ai 5.0.0-canary.20 → 5.0.0-canary.21

package/dist/index.js

@@ -50,8 +50,7 @@ __export(src_exports, {
   TypeValidationError: () => import_provider16.TypeValidationError,
   UnsupportedFunctionalityError: () => import_provider16.UnsupportedFunctionalityError,
   appendClientMessage: () => appendClientMessage,
-  appendResponseMessages: () => appendResponseMessages,
-  asSchema: () => import_provider_utils24.asSchema,
+  asSchema: () => import_provider_utils25.asSchema,
   assistantModelMessageSchema: () => assistantModelMessageSchema,
   callChatApi: () => callChatApi,
   callCompletionApi: () => callCompletionApi,
@@ -66,7 +65,7 @@ __export(src_exports, {
   cosineSimilarity: () => cosineSimilarity,
   createDataStream: () => createDataStream,
   createDataStreamResponse: () => createDataStreamResponse,
-  createIdGenerator: () => import_provider_utils24.createIdGenerator,
+  createIdGenerator: () => import_provider_utils25.createIdGenerator,
   createProviderRegistry: () => createProviderRegistry,
   createTextStreamResponse: () => createTextStreamResponse,
   customProvider: () => customProvider,
@@ -81,19 +80,18 @@ __export(src_exports, {
   experimental_transcribe: () => transcribe,
   extractMaxToolInvocationStep: () => extractMaxToolInvocationStep,
   extractReasoningMiddleware: () => extractReasoningMiddleware,
-  generateId: () => import_provider_utils24.generateId,
+  generateId: () => import_provider_utils25.generateId,
   generateObject: () => generateObject,
   generateText: () => generateText,
   getTextFromDataUrl: () => getTextFromDataUrl,
   getToolInvocations: () => getToolInvocations,
   isAssistantMessageWithCompletedToolCalls: () => isAssistantMessageWithCompletedToolCalls,
   isDeepEqualData: () => isDeepEqualData,
-  jsonSchema: () => import_provider_utils24.jsonSchema,
+  jsonSchema: () => import_provider_utils25.jsonSchema,
   modelMessageSchema: () => modelMessageSchema,
   parsePartialJson: () => parsePartialJson,
   pipeDataStreamToResponse: () => pipeDataStreamToResponse,
   pipeTextStreamToResponse: () => pipeTextStreamToResponse,
-  processDataStream: () => processDataStream,
   processTextStream: () => processTextStream,
   shouldResubmitMessages: () => shouldResubmitMessages,
   simulateReadableStream: () => simulateReadableStream,
@@ -109,7 +107,7 @@ __export(src_exports, {
   wrapLanguageModel: () => wrapLanguageModel
 });
 module.exports = __toCommonJS(src_exports);
-var import_provider_utils24 = require("@ai-sdk/provider-utils");
+var import_provider_utils25 = require("@ai-sdk/provider-utils");
 
 // src/data-stream/create-data-stream.ts
 function createDataStream({
@@ -277,237 +275,6 @@ function pipeDataStreamToResponse({
   });
 }
 
-// src/data-stream/process-data-stream.ts
-var import_provider_utils = require("@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
-var import_zod = require("zod");
-var languageModelUsageSchema = import_zod.z.object({
-  inputTokens: import_zod.z.number().optional(),
-  outputTokens: import_zod.z.number().optional(),
-  totalTokens: import_zod.z.number().optional(),
-  reasoningTokens: import_zod.z.number().optional(),
-  cachedInputTokens: import_zod.z.number().optional()
-});
-var finishReasonSchema = import_zod.z.enum([
-  "stop",
-  "length",
-  "tool-calls",
-  "content-filter",
-  "other",
-  "error",
-  "unknown"
-]);
-var toolCallSchema = import_zod.z.object({
-  toolCallId: import_zod.z.string(),
-  toolName: import_zod.z.string(),
-  args: import_zod.z.unknown()
-});
-var toolResultValueSchema = import_zod.z.object({
-  toolCallId: import_zod.z.string(),
-  result: import_zod.z.unknown(),
-  providerMetadata: import_zod.z.any().optional()
-});
-var sourceSchema = import_zod.z.object({
-  type: import_zod.z.literal("source"),
-  sourceType: import_zod.z.literal("url"),
-  id: import_zod.z.string(),
-  url: import_zod.z.string(),
-  title: import_zod.z.string().optional(),
-  providerMetadata: import_zod.z.any().optional()
-  // Use z.any() for generic metadata
-});
-var dataStreamPartSchema = import_zod.z.discriminatedUnion("type", [
-  import_zod.z.object({
-    type: import_zod.z.literal("text"),
-    value: import_zod.z.string()
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("data"),
-    value: import_zod.z.array(import_zod.z.any())
-    // TODO json validation
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("error"),
-    value: import_zod.z.string()
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("message-annotations"),
-    value: import_zod.z.array(import_zod.z.any())
-    // TODO json validation
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("tool-call"),
-    value: toolCallSchema
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("tool-result"),
-    value: toolResultValueSchema
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("tool-call-streaming-start"),
-    value: import_zod.z.object({ toolCallId: import_zod.z.string(), toolName: import_zod.z.string() })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("tool-call-delta"),
-    value: import_zod.z.object({ toolCallId: import_zod.z.string(), argsTextDelta: import_zod.z.string() })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("finish-message"),
-    value: import_zod.z.object({
-      finishReason: finishReasonSchema,
-      // TODO v5 remove usage from finish event (only on step-finish)
-      usage: languageModelUsageSchema.optional()
-    })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("finish-step"),
-    value: import_zod.z.object({
-      isContinued: import_zod.z.boolean(),
-      finishReason: finishReasonSchema,
-      usage: languageModelUsageSchema.optional()
-    })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("start-step"),
-    value: import_zod.z.object({
-      messageId: import_zod.z.string()
-    })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("reasoning"),
-    value: import_zod.z.object({
-      text: import_zod.z.string(),
-      providerMetadata: import_zod.z.record(import_zod.z.any()).optional()
-    })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("source"),
-    value: sourceSchema
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("file"),
-    value: import_zod.z.object({
-      url: import_zod.z.string(),
-      mediaType: import_zod.z.string()
-    })
-  }),
-  import_zod.z.object({
-    type: import_zod.z.literal("reasoning-part-finish"),
-    value: import_zod.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((0, import_provider_utils.createEventSourceParserStream)()).pipeThrough(
-      new TransformStream({
-        async transform({ data }, controller) {
-          if (data === "[DONE]") {
-            return;
-          }
-          controller.enqueue(
-            await (0, import_provider_utils.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
 var import_provider16 = require("@ai-sdk/provider");
 
@@ -906,267 +673,167 @@ function appendClientMessage({
   ];
 }
 
-// src/ui/append-response-messages.ts
-var import_provider18 = require("@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);
-}
+// src/ui/call-chat-api.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
 
-// core/prompt/data-content.ts
-var import_provider17 = require("@ai-sdk/provider");
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
-var import_zod2 = require("zod");
+// src/data-stream/data-stream-parts.ts
+var import_zod = require("zod");
+var toolCallSchema = import_zod.z.object({
+  toolCallId: import_zod.z.string(),
+  toolName: import_zod.z.string(),
+  args: import_zod.z.unknown()
+});
+var toolResultValueSchema = import_zod.z.object({
+  toolCallId: import_zod.z.string(),
+  result: import_zod.z.unknown(),
+  providerMetadata: import_zod.z.any().optional()
+});
+var sourceSchema = import_zod.z.object({
+  type: import_zod.z.literal("source"),
+  sourceType: import_zod.z.literal("url"),
+  id: import_zod.z.string(),
+  url: import_zod.z.string(),
+  title: import_zod.z.string().optional(),
+  providerMetadata: import_zod.z.any().optional()
+  // Use z.any() for generic metadata
+});
+var dataStreamPartSchema = import_zod.z.discriminatedUnion("type", [
+  import_zod.z.object({
+    type: import_zod.z.literal("text"),
+    value: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("error"),
+    value: import_zod.z.string()
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool-call"),
+    value: toolCallSchema
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool-result"),
+    value: toolResultValueSchema
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool-call-streaming-start"),
+    value: import_zod.z.object({ toolCallId: import_zod.z.string(), toolName: import_zod.z.string() })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("tool-call-delta"),
+    value: import_zod.z.object({ toolCallId: import_zod.z.string(), argsTextDelta: import_zod.z.string() })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("reasoning"),
+    value: import_zod.z.object({
+      text: import_zod.z.string(),
+      providerMetadata: import_zod.z.record(import_zod.z.any()).optional()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("source"),
+    value: sourceSchema
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("file"),
+    value: import_zod.z.object({
+      url: import_zod.z.string(),
+      mediaType: import_zod.z.string()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("metadata"),
+    value: import_zod.z.object({
+      metadata: import_zod.z.unknown()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("start-step"),
+    value: import_zod.z.object({
+      metadata: import_zod.z.unknown()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("finish-step"),
+    value: import_zod.z.object({
+      metadata: import_zod.z.unknown()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("start"),
+    value: import_zod.z.object({
+      messageId: import_zod.z.string().optional(),
+      metadata: import_zod.z.unknown()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("finish"),
+    value: import_zod.z.object({
+      metadata: import_zod.z.unknown()
+    })
+  }),
+  import_zod.z.object({
+    type: import_zod.z.literal("reasoning-part-finish"),
+    value: import_zod.z.null()
+  })
+]);
 
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
+// 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 = import_zod2.z.union([
-  import_zod2.z.string(),
-  import_zod2.z.instanceof(Uint8Array),
-  import_zod2.z.instanceof(ArrayBuffer),
-  import_zod2.z.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 import_provider17.AISDKError({
-        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 (0, import_provider_utils2.convertUint8ArrayToBase64)(new Uint8Array(content));
-  }
-  return (0, import_provider_utils2.convertUint8ArrayToBase64)(content);
-}
-function convertDataContentToUint8Array(content) {
-  if (content instanceof Uint8Array) {
-    return content;
+// src/ui/process-chat-response.ts
+var import_provider_utils2 = require("@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 (0, import_provider_utils2.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 import_provider18.AISDKError({
-                    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
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
-
 // src/util/parse-partial-json.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils = require("@ai-sdk/provider-utils");
 
 // src/util/fix-json.ts
 function fixJson(input) {
@@ -1491,33 +1158,48 @@ async function parsePartialJson(jsonText) {
   if (jsonText === void 0) {
     return { value: void 0, state: "undefined-input" };
   }
-  let result = await (0, import_provider_utils3.safeParseJSON)({ text: jsonText });
+  let result = await (0, import_provider_utils.safeParseJSON)({ text: jsonText });
   if (result.success) {
     return { value: result.value, state: "successful-parse" };
   }
-  result = await (0, import_provider_utils3.safeParseJSON)({ text: fixJson(jsonText) });
+  result = await (0, import_provider_utils.safeParseJSON)({ text: fixJson(jsonText) });
   if (result.success) {
     return { value: result.value, state: "repaired-parse" };
   }
   return { value: void 0, state: "failed-parse" };
 }
 
+// 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-chat-response.ts
-async function processChatResponse({
+function processChatResponse({
   stream,
-  update,
+  onUpdate,
   onToolCall,
   onFinish,
-  generateId: generateId3 = import_provider_utils4.generateId,
-  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: []
   };
@@ -1536,198 +1218,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 (0, import_provider_utils2.validateTypes)({
+          value: mergedMetadata,
+          schema: messageMetadataSchema
         });
-        if (result != null) {
-          updateToolInvocationPart(value.toolCallId, {
-            state: "result",
-            step,
-            ...value,
-            result
-          });
-          execUpdate();
+      }
+      message.metadata = mergedMetadata;
+    }
+  }
+  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 });
       }
-    },
-    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);
-    }
-  });
-  onFinish == null ? void 0 : onFinish({ message, finishReason, usage });
+    })
+  );
 }
 
 // src/ui/process-chat-text-response.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // src/ui/process-text-stream.ts
 async function processTextStream({
@@ -1749,13 +1447,11 @@ async function processChatTextResponse({
   stream,
   update,
   onFinish,
-  getCurrentDate = () => /* @__PURE__ */ new Date(),
-  generateId: generateId3 = import_provider_utils5.generateId
+  generateId: generateId3 = import_provider_utils3.generateId
 }) {
   const textPart = { type: "text", text: "" };
   const resultMessage = {
     id: generateId3(),
-    createdAt: getCurrentDate(),
     role: "assistant",
     parts: [textPart]
   };
@@ -1763,21 +1459,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
@@ -1796,8 +1481,8 @@ async function callChatApi({
   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}`, {
@@ -1835,24 +1520,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
+      await consumeStream({
+        stream: processChatResponse({
+          stream: (0, import_provider_utils4.parseJsonEventStream)({
+            stream: response.body,
+            schema: dataStreamPartSchema
+          }).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;
     }
@@ -1864,6 +1574,7 @@ async function callChatApi({
 }
 
 // src/ui/call-completion-api.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
 var getOriginalFetch2 = () => fetch;
 async function callCompletionApi({
   api,
@@ -1879,7 +1590,6 @@ async function callCompletionApi({
   onResponse,
   onFinish,
   onError,
-  onData,
   fetch: fetch2 = getOriginalFetch2()
 }) {
   var _a17;
@@ -1932,17 +1642,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: (0, import_provider_utils5.parseJsonEventStream)({
+            stream: response.body,
+            schema: dataStreamPartSchema
+          }).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;
@@ -2307,7 +2028,7 @@ function simulateReadableStream({
 }
 
 // src/util/retry-with-exponential-backoff.ts
-var import_provider19 = require("@ai-sdk/provider");
+var import_provider17 = require("@ai-sdk/provider");
 var import_provider_utils7 = require("@ai-sdk/provider-utils");
 var retryWithExponentialBackoff = ({
   maxRetries = 2,
@@ -2342,7 +2063,7 @@ async function _retryWithExponentialBackoff(f, {
         errors: newErrors
       });
     }
-    if (error instanceof Error && import_provider19.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+    if (error instanceof Error && import_provider17.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
       await (0, import_provider_utils7.delay)(delayInMs);
       return _retryWithExponentialBackoff(
         f,
@@ -3073,6 +2794,7 @@ async function generateImage({
   model,
   prompt,
   n = 1,
+  maxImagesPerCall,
   size,
   aspectRatio,
   seed,
@@ -3083,14 +2805,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(
@@ -3161,8 +2883,8 @@ var DefaultGenerateImageResult = class {
 };
 
 // core/generate-object/generate-object.ts
-var import_provider22 = require("@ai-sdk/provider");
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
+var import_provider21 = require("@ai-sdk/provider");
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
 
 // core/generate-text/extract-content-text.ts
 function extractContentText(content) {
@@ -3176,7 +2898,7 @@ function extractContentText(content) {
 }
 
 // core/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // src/util/download.ts
 async function download({ url }) {
@@ -3203,6 +2925,89 @@ async function download({ url }) {
   }
 }
 
+// core/prompt/data-content.ts
+var import_provider18 = require("@ai-sdk/provider");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
+var import_zod2 = require("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 = import_zod2.z.union([
+  import_zod2.z.string(),
+  import_zod2.z.instanceof(Uint8Array),
+  import_zod2.z.instanceof(ArrayBuffer),
+  import_zod2.z.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 import_provider18.AISDKError({
+        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 (0, import_provider_utils10.convertBase64ToUint8Array)(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,
@@ -3339,7 +3144,7 @@ async function downloadAssets(messages, downloadImplementation, supportedUrls) {
     }
     return { mediaType, data };
   }).filter(
-    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils10.isUrlSupported)({
+    (part) => part.data instanceof URL && part.mediaType != null && !(0, import_provider_utils11.isUrlSupported)({
       url: part.data.toString(),
       mediaType: part.mediaType,
       supportedUrls
@@ -3423,8 +3228,8 @@ function prepareCallSettings({
   topK,
   presencePenalty,
   frequencyPenalty,
-  stopSequences,
-  seed
+  seed,
+  stopSequences
 }) {
   if (maxOutputTokens != null) {
     if (!Number.isInteger(maxOutputTokens)) {
@@ -3498,19 +3303,19 @@ 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
   };
 }
 
 // core/prompt/standardize-prompt.ts
-var import_provider20 = require("@ai-sdk/provider");
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+var import_provider19 = require("@ai-sdk/provider");
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
 var import_zod8 = require("zod");
 
 // core/prompt/message.ts
@@ -3646,19 +3451,19 @@ var coreMessageSchema = modelMessageSchema;
 // core/prompt/standardize-prompt.ts
 async function standardizePrompt(prompt) {
   if (prompt.prompt == null && prompt.messages == null) {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
   if (prompt.prompt != null && prompt.messages != null) {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "prompt and messages cannot be defined at the same time"
     });
   }
   if (prompt.system != null && typeof prompt.system !== "string") {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "system must be a string"
     });
@@ -3671,23 +3476,23 @@ async function standardizePrompt(prompt) {
   } else if (prompt.messages != null) {
     messages = prompt.messages;
   } else {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
   if (messages.length === 0) {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "messages must not be empty"
     });
   }
-  const validationResult = await (0, import_provider_utils11.safeValidateTypes)({
+  const validationResult = await (0, import_provider_utils12.safeValidateTypes)({
     value: messages,
     schema: import_zod8.z.array(modelMessageSchema)
   });
   if (!validationResult.success) {
-    throw new import_provider20.InvalidPromptError({
+    throw new import_provider19.InvalidPromptError({
       prompt,
       message: "messages must be an array of ModelMessage",
       cause: validationResult.error
@@ -3700,8 +3505,25 @@ async function standardizePrompt(prompt) {
 }
 
 // core/generate-object/output-strategy.ts
-var import_provider21 = require("@ai-sdk/provider");
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
+var import_provider20 = require("@ai-sdk/provider");
+var import_provider_utils13 = require("@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,
@@ -3721,7 +3543,7 @@ var noSchemaOutputStrategy = {
     } : { success: true, value };
   },
   createElementStream() {
-    throw new import_provider21.UnsupportedFunctionalityError({
+    throw new import_provider20.UnsupportedFunctionalityError({
       functionality: "element streams in no-schema mode"
     });
   }
@@ -3740,10 +3562,10 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   async validateFinalResult(value) {
-    return (0, import_provider_utils12.safeValidateTypes)({ value, schema });
+    return (0, import_provider_utils13.safeValidateTypes)({ value, schema });
   },
   createElementStream() {
-    throw new import_provider21.UnsupportedFunctionalityError({
+    throw new import_provider20.UnsupportedFunctionalityError({
       functionality: "element streams in object mode"
     });
   }
@@ -3771,10 +3593,10 @@ var arrayOutputStrategy = (schema) => {
       isFinalDelta
     }) {
       var _a17;
-      if (!(0, import_provider21.isJSONObject)(value) || !(0, import_provider21.isJSONArray)(value.elements)) {
+      if (!(0, import_provider20.isJSONObject)(value) || !(0, import_provider20.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider21.TypeValidationError({
+          error: new import_provider20.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -3784,7 +3606,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = await (0, import_provider_utils12.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -3814,10 +3636,10 @@ var arrayOutputStrategy = (schema) => {
       };
     },
     async validateFinalResult(value) {
-      if (!(0, import_provider21.isJSONObject)(value) || !(0, import_provider21.isJSONArray)(value.elements)) {
+      if (!(0, import_provider20.isJSONObject)(value) || !(0, import_provider20.isJSONArray)(value.elements)) {
         return {
           success: false,
-          error: new import_provider21.TypeValidationError({
+          error: new import_provider20.TypeValidationError({
             value,
             cause: "value must be an object that contains an array of elements"
           })
@@ -3825,7 +3647,7 @@ var arrayOutputStrategy = (schema) => {
       }
       const inputArray = value.elements;
       for (const element of inputArray) {
-        const result = await (0, import_provider_utils12.safeValidateTypes)({ value: element, schema });
+        const result = await (0, import_provider_utils13.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -3880,10 +3702,10 @@ var enumOutputStrategy = (enumValues) => {
       additionalProperties: false
     },
     async validateFinalResult(value) {
-      if (!(0, import_provider21.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider20.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider21.TypeValidationError({
+          error: new import_provider20.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -3892,17 +3714,17 @@ var enumOutputStrategy = (enumValues) => {
       const result = value.result;
       return enumValues.includes(result) ? { success: true, value: result } : {
         success: false,
-        error: new import_provider21.TypeValidationError({
+        error: new import_provider20.TypeValidationError({
           value,
           cause: "value must be a string in the enum"
         })
       };
     },
     async validatePartialResult({ value, textDelta }) {
-      if (!(0, import_provider21.isJSONObject)(value) || typeof value.result !== "string") {
+      if (!(0, import_provider20.isJSONObject)(value) || typeof value.result !== "string") {
         return {
           success: false,
-          error: new import_provider21.TypeValidationError({
+          error: new import_provider20.TypeValidationError({
             value,
             cause: 'value must be an object that contains a string in the "result" property.'
           })
@@ -3915,7 +3737,7 @@ var enumOutputStrategy = (enumValues) => {
       if (value.result.length === 0 || possibleEnumValues.length === 0) {
         return {
           success: false,
-          error: new import_provider21.TypeValidationError({
+          error: new import_provider20.TypeValidationError({
             value,
             cause: "value must be a string in the enum"
           })
@@ -3930,7 +3752,7 @@ var enumOutputStrategy = (enumValues) => {
       };
     },
     createElementStream() {
-      throw new import_provider21.UnsupportedFunctionalityError({
+      throw new import_provider20.UnsupportedFunctionalityError({
         functionality: "element streams in enum mode"
       });
     }
@@ -3943,9 +3765,9 @@ function getOutputStrategy({
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy((0, import_provider_utils12.asSchema)(schema));
+      return objectOutputStrategy((0, import_provider_utils13.asSchema)(schema));
     case "array":
-      return arrayOutputStrategy((0, import_provider_utils12.asSchema)(schema));
+      return arrayOutputStrategy((0, import_provider_utils13.asSchema)(schema));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -4076,7 +3898,7 @@ function validateObjectGenerationInput({
 }
 
 // core/generate-object/generate-object.ts
-var originalGenerateId = (0, import_provider_utils13.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId = (0, import_provider_utils14.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject(options) {
   const {
     model,
@@ -4252,7 +4074,7 @@ async function generateObject(options) {
       request = (_a17 = generateResult.request) != null ? _a17 : {};
       response = generateResult.responseData;
       async function processResult(result2) {
-        const parseResult = await (0, import_provider_utils13.safeParseJSON)({ text: result2 });
+        const parseResult = await (0, import_provider_utils14.safeParseJSON)({ text: result2 });
         if (!parseResult.success) {
           throw new NoObjectGeneratedError({
             message: "No object generated: could not parse the response.",
@@ -4287,7 +4109,7 @@ async function generateObject(options) {
       try {
         object2 = await processResult(result);
       } catch (error) {
-        if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider22.JSONParseError.isInstance(error.cause) || import_provider22.TypeValidationError.isInstance(error.cause))) {
+        if (repairText != null && NoObjectGeneratedError.isInstance(error) && (import_provider21.JSONParseError.isInstance(error.cause) || import_provider21.TypeValidationError.isInstance(error.cause))) {
           const repairedText = await repairText({
             text: result,
             error: error.cause
@@ -4348,7 +4170,7 @@ var DefaultGenerateObjectResult = class {
 };
 
 // core/generate-object/stream-object.ts
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
 
 // src/util/create-resolvable-promise.ts
 function createResolvablePromise() {
@@ -4492,7 +4314,7 @@ function now() {
 }
 
 // core/generate-object/stream-object.ts
-var originalGenerateId2 = (0, import_provider_utils14.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId2 = (0, import_provider_utils15.createIdGenerator)({ prefix: "aiobj", size: 24 });
 function streamObject(options) {
   const {
     model,
@@ -4997,8 +4819,8 @@ var DefaultStreamObjectResult = class {
 };
 
 // src/error/no-speech-generated-error.ts
-var import_provider23 = require("@ai-sdk/provider");
-var NoSpeechGeneratedError = class extends import_provider23.AISDKError {
+var import_provider22 = require("@ai-sdk/provider");
+var NoSpeechGeneratedError = class extends import_provider22.AISDKError {
   constructor(options) {
     super({
       name: "AI_NoSpeechGeneratedError",
@@ -5087,23 +4909,10 @@ var DefaultSpeechResult = class {
 };
 
 // core/generate-text/generate-text.ts
-var import_provider_utils17 = require("@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;
-}
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
 
 // core/prompt/prepare-tools-and-tool-choice.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
 
 // src/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
@@ -5135,7 +4944,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: (0, import_provider_utils15.asSchema)(tool2.parameters).jsonSchema
+            parameters: (0, import_provider_utils16.asSchema)(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -5203,18 +5012,9 @@ 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
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
 async function parseToolCall({
   toolCall,
   tools,
@@ -5238,7 +5038,7 @@ async function parseToolCall({
         tools,
         parameterSchema: ({ toolName }) => {
           const { parameters } = tools[toolName];
-          return (0, import_provider_utils16.asSchema)(parameters).jsonSchema;
+          return (0, import_provider_utils17.asSchema)(parameters).jsonSchema;
         },
         system,
         messages,
@@ -5268,8 +5068,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = (0, import_provider_utils16.asSchema)(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils16.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils16.safeParseJSON)({ text: toolCall.args, schema });
+  const schema = (0, import_provider_utils17.asSchema)(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? await (0, import_provider_utils17.safeValidateTypes)({ value: {}, schema }) : await (0, import_provider_utils17.safeParseJSON)({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -5285,85 +5085,111 @@ async function doParseToolCall({
   };
 }
 
-// core/generate-text/reasoning.ts
-function asReasoningText(reasoningParts) {
-  const reasoningText = reasoningParts.map((part) => part.text).join("");
-  return reasoningText.length > 0 ? reasoningText : void 0;
-}
+// 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");
+  }
+  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;
 }
 
 // core/generate-text/generate-text.ts
-var originalGenerateId3 = (0, import_provider_utils17.createIdGenerator)({
+var originalGenerateId3 = (0, import_provider_utils18.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId = (0, import_provider_utils17.createIdGenerator)({
-  prefix: "msg",
-  size: 24
-});
 async function generateText({
   model,
   tools,
@@ -5375,9 +5201,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,
@@ -5433,22 +5257,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,
@@ -5514,7 +5330,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,
@@ -5528,7 +5344,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
                 };
@@ -5587,89 +5403,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,
@@ -5690,32 +5452,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
+          }
+        ))
       });
     }
   });
@@ -5797,35 +5544,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) {
@@ -5855,7 +5634,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-var import_provider_utils18 = require("@ai-sdk/provider-utils");
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
 var text = () => ({
   type: "text",
   responseFormat: { type: "text" },
@@ -5869,7 +5648,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = (0, import_provider_utils18.asSchema)(inputSchema);
+  const schema = (0, import_provider_utils19.asSchema)(inputSchema);
   return {
     type: "object",
     responseFormat: {
@@ -5895,7 +5674,7 @@ var object = ({
       }
     },
     async parseOutput({ text: text2 }, context) {
-      const parseResult = await (0, import_provider_utils18.safeParseJSON)({ text: text2 });
+      const parseResult = await (0, import_provider_utils19.safeParseJSON)({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -5906,7 +5685,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = await (0, import_provider_utils18.safeValidateTypes)({
+      const validationResult = await (0, import_provider_utils19.safeValidateTypes)({
         value: parseResult.value,
         schema
       });
@@ -5926,8 +5705,8 @@ var object = ({
 };
 
 // core/generate-text/smooth-stream.ts
-var import_provider_utils19 = require("@ai-sdk/provider-utils");
-var import_provider24 = require("@ai-sdk/provider");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider23 = require("@ai-sdk/provider");
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
   line: /\n+/m
@@ -5935,7 +5714,7 @@ var CHUNKING_REGEXPS = {
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
-  _internal: { delay: delay2 = import_provider_utils19.delay } = {}
+  _internal: { delay: delay2 = import_provider_utils20.delay } = {}
 } = {}) {
   let detectChunk;
   if (typeof chunking === "function") {
@@ -5957,7 +5736,7 @@ function smoothStream({
   } else {
     const chunkingRegex = typeof chunking === "string" ? CHUNKING_REGEXPS[chunking] : chunking;
     if (chunkingRegex == null) {
-      throw new import_provider24.InvalidArgumentError({
+      throw new import_provider23.InvalidArgumentError({
         argument: "chunking",
         message: `Chunking must be "word" or "line" or a RegExp. Received: ${chunking}`
       });
@@ -5995,34 +5774,15 @@ function smoothStream({
 }
 
 // core/generate-text/stream-text.ts
-var import_provider_utils21 = require("@ai-sdk/provider-utils");
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 
 // src/util/as-array.ts
 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
-var import_provider_utils20 = require("@ai-sdk/provider-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -6108,7 +5868,7 @@ function runToolsTransformation({
             controller.enqueue(toolCall);
             const tool2 = tools[toolCall.toolName];
             if (tool2.execute != null) {
-              const toolExecutionId = (0, import_provider_utils20.generateId)();
+              const toolExecutionId = (0, import_provider_utils21.generateId)();
               outstandingToolResults.add(toolExecutionId);
               recordSpan({
                 name: "ai.toolCall",
@@ -6217,14 +5977,10 @@ function runToolsTransformation({
 }
 
 // core/generate-text/stream-text.ts
-var originalGenerateId4 = (0, import_provider_utils21.createIdGenerator)({
+var originalGenerateId4 = (0, import_provider_utils22.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId2 = (0, import_provider_utils21.createIdGenerator)({
-  prefix: "msg",
-  size: 24
-});
 function streamText({
   model,
   tools,
@@ -6236,9 +5992,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,
@@ -6275,7 +6029,6 @@ function streamText({
     repairToolCall,
     maxSteps,
     output,
-    continueSteps,
     providerOptions,
     onChunk,
     onError,
@@ -6283,8 +6036,7 @@ function streamText({
     onStepFinish,
     now: now2,
     currentDate,
-    generateId: generateId3,
-    generateMessageId
+    generateId: generateId3
   });
 }
 function createOutputTransformStream(output) {
@@ -6310,7 +6062,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") {
@@ -6354,32 +6106,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",
@@ -6388,23 +6126,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({
@@ -6418,9 +6147,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;
@@ -6433,12 +6159,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) {
@@ -6449,129 +6175,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(
@@ -6579,18 +6252,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
               }
             })
           );
@@ -6649,11 +6322,7 @@ var DefaultStreamTextResult = class {
         async function streamStep({
           currentStep,
           responseMessages,
-          usage,
-          stepType: stepType2,
-          previousStepText,
-          hasLeadingWhitespace,
-          messageId
+          usage
         }) {
           const initialPrompt = await standardizePrompt({
             system,
@@ -6751,8 +6420,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 = {
@@ -6763,25 +6431,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(
@@ -6790,6 +6450,7 @@ var DefaultStreamTextResult = class {
                   var _a17, _b, _c, _d;
                   if (chunk.type === "stream-start") {
                     warnings = chunk.warnings;
+                    controller.enqueue({ type: "start" });
                     return;
                   }
                   if (stepFirstChunk) {
@@ -6802,8 +6463,7 @@ var DefaultStreamTextResult = class {
                       "ai.response.msToFirstChunk": msToFirstChunk
                     });
                     controller.enqueue({
-                      type: "step-start",
-                      messageId,
+                      type: "start-step",
                       request: stepRequest,
                       warnings: warnings != null ? warnings : []
                     });
@@ -6814,27 +6474,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": {
@@ -6843,12 +6483,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;
                     }
@@ -6860,11 +6500,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": {
@@ -6888,11 +6530,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);
@@ -6912,27 +6558,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({
@@ -6965,69 +6590,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()
-                      )
-                    });
                   }
                 }
               })
@@ -7041,11 +6634,7 @@ var DefaultStreamTextResult = class {
             inputTokens: void 0,
             outputTokens: void 0,
             totalTokens: void 0
-          },
-          previousStepText: "",
-          stepType: "initial",
-          hasLeadingWhitespace: false,
-          messageId: generateMessageId()
+          }
         });
       }
     }).catch((error) => {
@@ -7060,50 +6649,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.
@@ -7170,25 +6765,32 @@ var DefaultStreamTextResult = class {
     );
   }
   toDataStream({
-    onError = () => "An error occurred.",
-    // mask error messages for safety by default
-    sendUsage = true,
+    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;
             }
@@ -7205,15 +6807,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;
             }
@@ -7221,8 +6823,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;
@@ -7231,8 +6833,8 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-call-delta",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  argsTextDelta: chunk.argsTextDelta
+                  toolCallId: part.toolCallId,
+                  argsTextDelta: part.argsTextDelta
                 }
               });
               break;
@@ -7241,9 +6843,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;
@@ -7252,8 +6854,8 @@ var DefaultStreamTextResult = class {
               controller.enqueue({
                 type: "tool-result",
                 value: {
-                  toolCallId: chunk.toolCallId,
-                  result: chunk.result
+                  toolCallId: part.toolCallId,
+                  result: part.result
                 }
               });
               break;
@@ -7261,69 +6863,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 : processChatResponse({
+      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,
+    newMessageId,
+    originalMessages,
+    onFinish,
+    messageMetadata,
     sendReasoning,
     sendSources,
     experimental_sendFinish,
     experimental_sendStart,
+    onError,
     ...init
   } = {}) {
     pipeDataStreamToResponse({
       response,
       dataStream: this.toDataStream({
-        onError,
-        sendUsage,
+        newMessageId,
+        originalMessages,
+        onFinish,
+        messageMetadata,
         sendReasoning,
         sendSources,
         experimental_sendFinish,
-        experimental_sendStart
+        experimental_sendStart,
+        onError
       }),
       ...init
     });
@@ -7336,22 +6969,28 @@ var DefaultStreamTextResult = class {
     });
   }
   toDataStreamResponse({
-    onError,
-    sendUsage,
+    newMessageId,
+    originalMessages,
+    onFinish,
+    messageMetadata,
     sendReasoning,
     sendSources,
     experimental_sendFinish,
     experimental_sendStart,
+    onError,
     ...init
   } = {}) {
     return createDataStreamResponse({
       dataStream: this.toDataStream({
-        onError,
-        sendUsage,
+        newMessageId,
+        originalMessages,
+        onFinish,
+        messageMetadata,
         sendReasoning,
         sendSources,
         experimental_sendFinish,
-        experimental_sendStart
+        experimental_sendStart,
+        onError
       }),
       ...init
     });
@@ -7364,39 +7003,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
@@ -7404,33 +7010,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);
     }
   };
 }
@@ -7652,7 +7232,7 @@ var doWrap = ({
 };
 
 // core/registry/custom-provider.ts
-var import_provider25 = require("@ai-sdk/provider");
+var import_provider24 = require("@ai-sdk/provider");
 function customProvider({
   languageModels,
   textEmbeddingModels,
@@ -7667,7 +7247,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.languageModel(modelId);
       }
-      throw new import_provider25.NoSuchModelError({ modelId, modelType: "languageModel" });
+      throw new import_provider24.NoSuchModelError({ modelId, modelType: "languageModel" });
     },
     textEmbeddingModel(modelId) {
       if (textEmbeddingModels != null && modelId in textEmbeddingModels) {
@@ -7676,7 +7256,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.textEmbeddingModel(modelId);
       }
-      throw new import_provider25.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+      throw new import_provider24.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
     },
     imageModel(modelId) {
       if (imageModels != null && modelId in imageModels) {
@@ -7685,19 +7265,19 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.imageModel) {
         return fallbackProvider.imageModel(modelId);
       }
-      throw new import_provider25.NoSuchModelError({ modelId, modelType: "imageModel" });
+      throw new import_provider24.NoSuchModelError({ modelId, modelType: "imageModel" });
     }
   };
 }
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-var import_provider26 = require("@ai-sdk/provider");
+var import_provider25 = require("@ai-sdk/provider");
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
 var _a16;
-var NoSuchProviderError = class extends import_provider26.NoSuchModelError {
+var NoSuchProviderError = class extends import_provider25.NoSuchModelError {
   constructor({
     modelId,
     modelType,
@@ -7711,13 +7291,13 @@ var NoSuchProviderError = class extends import_provider26.NoSuchModelError {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return import_provider26.AISDKError.hasMarker(error, marker16);
+    return import_provider25.AISDKError.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
 
 // core/registry/provider-registry.ts
-var import_provider27 = require("@ai-sdk/provider");
+var import_provider26 = require("@ai-sdk/provider");
 function createProviderRegistry(providers, {
   separator = ":"
 } = {}) {
@@ -7756,7 +7336,7 @@ var DefaultProviderRegistry = class {
   splitId(id, modelType) {
     const index = id.indexOf(this.separator);
     if (index === -1) {
-      throw new import_provider27.NoSuchModelError({
+      throw new import_provider26.NoSuchModelError({
         modelId: id,
         modelType,
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
@@ -7769,7 +7349,7 @@ var DefaultProviderRegistry = class {
     const [providerId, modelId] = this.splitId(id, "languageModel");
     const model = (_b = (_a17 = this.getProvider(providerId)).languageModel) == null ? void 0 : _b.call(_a17, modelId);
     if (model == null) {
-      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "languageModel" });
+      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "languageModel" });
     }
     return model;
   }
@@ -7779,7 +7359,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.textEmbeddingModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider27.NoSuchModelError({
+      throw new import_provider26.NoSuchModelError({
         modelId: id,
         modelType: "textEmbeddingModel"
       });
@@ -7792,14 +7372,14 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.imageModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "imageModel" });
+      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "imageModel" });
     }
     return model;
   }
 };
 
 // core/tool/mcp/mcp-client.ts
-var import_provider_utils23 = require("@ai-sdk/provider-utils");
+var import_provider_utils24 = require("@ai-sdk/provider-utils");
 
 // core/tool/tool.ts
 function tool(tool2) {
@@ -7807,7 +7387,7 @@ function tool(tool2) {
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-var import_provider_utils22 = require("@ai-sdk/provider-utils");
+var import_provider_utils23 = require("@ai-sdk/provider-utils");
 
 // core/tool/mcp/json-rpc-message.ts
 var import_zod10 = require("zod");
@@ -7978,7 +7558,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((0, import_provider_utils22.createEventSourceParserStream)());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils23.createEventSourceParserStream)());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -8302,7 +7882,7 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? (0, import_provider_utils23.jsonSchema)({
+        const parameters = schemas === "automatic" ? (0, import_provider_utils24.jsonSchema)({
           ...inputSchema,
           properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
           additionalProperties: false
@@ -8366,8 +7946,8 @@ var MCPClient = class {
 };
 
 // src/error/no-transcript-generated-error.ts
-var import_provider28 = require("@ai-sdk/provider");
-var NoTranscriptGeneratedError = class extends import_provider28.AISDKError {
+var import_provider27 = require("@ai-sdk/provider");
+var NoTranscriptGeneratedError = class extends import_provider27.AISDKError {
   constructor(options) {
     super({
       name: "AI_NoTranscriptGeneratedError",
@@ -8460,7 +8040,6 @@ var DefaultTranscriptionResult = class {
   TypeValidationError,
   UnsupportedFunctionalityError,
   appendClientMessage,
-  appendResponseMessages,
   asSchema,
   assistantModelMessageSchema,
   callChatApi,
@@ -8503,7 +8082,6 @@ var DefaultTranscriptionResult = class {
   parsePartialJson,
   pipeDataStreamToResponse,
   pipeTextStreamToResponse,
-  processDataStream,
   processTextStream,
   shouldResubmitMessages,
   simulateReadableStream,