ai 5.0.0-canary.1 → 5.0.0-canary.10

package/dist/index.mjs

@@ -6,17 +6,1483 @@ var __export = (target, all) => {
 
 // core/index.ts
 import { createIdGenerator as createIdGenerator5, generateId as generateId2 } from "@ai-sdk/provider-utils";
-import {
-  formatDataStreamPart as formatDataStreamPart3,
-  jsonSchema as jsonSchema2,
-  parseDataStreamPart,
-  processDataStream,
-  processTextStream,
-  zodSchema
-} from "@ai-sdk/ui-utils";
+
+// core/util/index.ts
+import { generateId } from "@ai-sdk/provider-utils";
+
+// core/util/process-chat-response.ts
+import { generateId as generateIdFunction } from "@ai-sdk/provider-utils";
+
+// core/types/duplicated/usage.ts
+function calculateLanguageModelUsage({
+  promptTokens,
+  completionTokens
+}) {
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
+  };
+}
+
+// core/util/parse-partial-json.ts
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+
+// core/util/fix-json.ts
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// core/util/parse-partial-json.ts
+function parsePartialJson(jsonText) {
+  if (jsonText === void 0) {
+    return { value: void 0, state: "undefined-input" };
+  }
+  let result = safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+
+// core/util/data-stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var toolCallStreamPart = {
+  code: "9",
+  name: "tool_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
+      throw new Error(
+        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
+      );
+    }
+    return {
+      type: "tool_call",
+      value
+    };
+  }
+};
+var toolResultStreamPart = {
+  code: "a",
+  name: "tool_result",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
+      throw new Error(
+        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
+      );
+    }
+    return {
+      type: "tool_result",
+      value
+    };
+  }
+};
+var toolCallStreamingStartStreamPart = {
+  code: "b",
+  name: "tool_call_streaming_start",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
+      throw new Error(
+        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
+      );
+    }
+    return {
+      type: "tool_call_streaming_start",
+      value
+    };
+  }
+};
+var toolCallDeltaStreamPart = {
+  code: "c",
+  name: "tool_call_delta",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
+      throw new Error(
+        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
+      );
+    }
+    return {
+      type: "tool_call_delta",
+      value
+    };
+  }
+};
+var finishMessageStreamPart = {
+  code: "d",
+  name: "finish_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_message" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    return {
+      type: "finish_message",
+      value: result
+    };
+  }
+};
+var finishStepStreamPart = {
+  code: "e",
+  name: "finish_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_step" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason,
+      isContinued: false
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    if ("isContinued" in value && typeof value.isContinued === "boolean") {
+      result.isContinued = value.isContinued;
+    }
+    return {
+      type: "finish_step",
+      value: result
+    };
+  }
+};
+var startStepStreamPart = {
+  code: "f",
+  name: "start_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
+      throw new Error(
+        '"start_step" parts expect an object with an "id" property.'
+      );
+    }
+    return {
+      type: "start_step",
+      value: {
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var reasoningStreamPart = {
+  code: "g",
+  name: "reasoning",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"reasoning" parts expect a string value.');
+    }
+    return { type: "reasoning", value };
+  }
+};
+var sourcePart = {
+  code: "h",
+  name: "source",
+  parse: (value) => {
+    if (value == null || typeof value !== "object") {
+      throw new Error('"source" parts expect a Source object.');
+    }
+    return {
+      type: "source",
+      value
+    };
+  }
+};
+var redactedReasoningStreamPart = {
+  code: "i",
+  name: "redacted_reasoning",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string") {
+      throw new Error(
+        '"redacted_reasoning" parts expect an object with a "data" property.'
+      );
+    }
+    return { type: "redacted_reasoning", value: { data: value.data } };
+  }
+};
+var reasoningSignatureStreamPart = {
+  code: "j",
+  name: "reasoning_signature",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("signature" in value) || typeof value.signature !== "string") {
+      throw new Error(
+        '"reasoning_signature" parts expect an object with a "signature" property.'
+      );
+    }
+    return {
+      type: "reasoning_signature",
+      value: { signature: value.signature }
+    };
+  }
+};
+var fileStreamPart = {
+  code: "k",
+  name: "file",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") {
+      throw new Error(
+        '"file" parts expect an object with a "data" and "mimeType" property.'
+      );
+    }
+    return { type: "file", value };
+  }
+};
+var dataStreamParts = [
+  textStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  messageAnnotationsStreamPart,
+  toolCallStreamPart,
+  toolResultStreamPart,
+  toolCallStreamingStartStreamPart,
+  toolCallDeltaStreamPart,
+  finishMessageStreamPart,
+  finishStepStreamPart,
+  startStepStreamPart,
+  reasoningStreamPart,
+  sourcePart,
+  redactedReasoningStreamPart,
+  reasoningSignatureStreamPart,
+  fileStreamPart
+];
+var dataStreamPartsByCode = Object.fromEntries(
+  dataStreamParts.map((part) => [part.code, part])
+);
+var DataStreamStringPrefixes = Object.fromEntries(
+  dataStreamParts.map((part) => [part.name, part.code])
+);
+var validCodes = dataStreamParts.map((part) => part.code);
+var parseDataStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return dataStreamPartsByCode[code].parse(jsonValue);
+};
+function formatDataStreamPart(type, value) {
+  const streamPart = dataStreamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
+// core/util/process-data-stream.ts
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function processDataStream({
+  stream,
+  onTextPart,
+  onReasoningPart,
+  onReasoningSignaturePart,
+  onRedactedReasoningPart,
+  onSourcePart,
+  onFilePart,
+  onDataPart,
+  onErrorPart,
+  onToolCallStreamingStartPart,
+  onToolCallDeltaPart,
+  onToolCallPart,
+  onToolResultPart,
+  onMessageAnnotationsPart,
+  onFinishMessagePart,
+  onFinishStepPart,
+  onStartStepPart
+}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseDataStreamPart);
+    for (const { type, value: value2 } of streamParts) {
+      switch (type) {
+        case "text":
+          await (onTextPart == null ? void 0 : onTextPart(value2));
+          break;
+        case "reasoning":
+          await (onReasoningPart == null ? void 0 : onReasoningPart(value2));
+          break;
+        case "reasoning_signature":
+          await (onReasoningSignaturePart == null ? void 0 : onReasoningSignaturePart(value2));
+          break;
+        case "redacted_reasoning":
+          await (onRedactedReasoningPart == null ? void 0 : onRedactedReasoningPart(value2));
+          break;
+        case "file":
+          await (onFilePart == null ? void 0 : onFilePart(value2));
+          break;
+        case "source":
+          await (onSourcePart == null ? void 0 : onSourcePart(value2));
+          break;
+        case "data":
+          await (onDataPart == null ? void 0 : onDataPart(value2));
+          break;
+        case "error":
+          await (onErrorPart == null ? void 0 : onErrorPart(value2));
+          break;
+        case "message_annotations":
+          await (onMessageAnnotationsPart == null ? void 0 : onMessageAnnotationsPart(value2));
+          break;
+        case "tool_call_streaming_start":
+          await (onToolCallStreamingStartPart == null ? void 0 : onToolCallStreamingStartPart(value2));
+          break;
+        case "tool_call_delta":
+          await (onToolCallDeltaPart == null ? void 0 : onToolCallDeltaPart(value2));
+          break;
+        case "tool_call":
+          await (onToolCallPart == null ? void 0 : onToolCallPart(value2));
+          break;
+        case "tool_result":
+          await (onToolResultPart == null ? void 0 : onToolResultPart(value2));
+          break;
+        case "finish_message":
+          await (onFinishMessagePart == null ? void 0 : onFinishMessagePart(value2));
+          break;
+        case "finish_step":
+          await (onFinishStepPart == null ? void 0 : onFinishStepPart(value2));
+          break;
+        case "start_step":
+          await (onStartStepPart == null ? void 0 : onStartStepPart(value2));
+          break;
+        default: {
+          const exhaustiveCheck = type;
+          throw new Error(`Unknown stream part type: ${exhaustiveCheck}`);
+        }
+      }
+    }
+  }
+}
+
+// core/util/process-chat-response.ts
+async function processChatResponse({
+  stream,
+  update,
+  onToolCall,
+  onFinish,
+  generateId: generateId3 = generateIdFunction,
+  getCurrentDate = () => /* @__PURE__ */ new Date(),
+  lastMessage
+}) {
+  var _a17, _b;
+  const replaceLastMessage = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
+  let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
+  ((_b = (_a17 = lastMessage.toolInvocations) == null ? void 0 : _a17.reduce((max, toolInvocation) => {
+    var _a18;
+    return Math.max(max, (_a18 = toolInvocation.step) != null ? _a18 : 0);
+  }, 0)) != null ? _b : 0) : 0;
+  const message = replaceLastMessage ? structuredClone(lastMessage) : {
+    id: generateId3(),
+    createdAt: getCurrentDate(),
+    role: "assistant",
+    content: "",
+    parts: []
+  };
+  let currentTextPart = void 0;
+  let currentReasoningPart = void 0;
+  let currentReasoningTextDetail = void 0;
+  function updateToolInvocationPart(toolCallId, invocation) {
+    const part = message.parts.find(
+      (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+    );
+    if (part != null) {
+      part.toolInvocation = invocation;
+    } else {
+      message.parts.push({
+        type: "tool-invocation",
+        toolInvocation: invocation
+      });
+    }
+  }
+  const data = [];
+  let messageAnnotations = replaceLastMessage ? lastMessage == null ? void 0 : lastMessage.annotations : void 0;
+  const partialToolCalls = {};
+  let usage = {
+    completionTokens: NaN,
+    promptTokens: NaN,
+    totalTokens: NaN
+  };
+  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;
+      }
+      message.content += value;
+      execUpdate();
+    },
+    onReasoningPart(value) {
+      var _a18;
+      if (currentReasoningTextDetail == null) {
+        currentReasoningTextDetail = { type: "text", text: value };
+        if (currentReasoningPart != null) {
+          currentReasoningPart.details.push(currentReasoningTextDetail);
+        }
+      } else {
+        currentReasoningTextDetail.text += value;
+      }
+      if (currentReasoningPart == null) {
+        currentReasoningPart = {
+          type: "reasoning",
+          reasoning: value,
+          details: [currentReasoningTextDetail]
+        };
+        message.parts.push(currentReasoningPart);
+      } else {
+        currentReasoningPart.reasoning += value;
+      }
+      message.reasoning = ((_a18 = message.reasoning) != null ? _a18 : "") + value;
+      execUpdate();
+    },
+    onReasoningSignaturePart(value) {
+      if (currentReasoningTextDetail != null) {
+        currentReasoningTextDetail.signature = value.signature;
+      }
+    },
+    onRedactedReasoningPart(value) {
+      if (currentReasoningPart == null) {
+        currentReasoningPart = {
+          type: "reasoning",
+          reasoning: "",
+          details: []
+        };
+        message.parts.push(currentReasoningPart);
+      }
+      currentReasoningPart.details.push({
+        type: "redacted",
+        data: value.data
+      });
+      currentReasoningTextDetail = void 0;
+      execUpdate();
+    },
+    onFilePart(value) {
+      message.parts.push({
+        type: "file",
+        mediaType: value.mimeType,
+        data: value.data
+      });
+      execUpdate();
+    },
+    onSourcePart(value) {
+      message.parts.push({
+        type: "source",
+        source: value
+      });
+      execUpdate();
+    },
+    onToolCallStreamingStartPart(value) {
+      if (message.toolInvocations == null) {
+        message.toolInvocations = [];
+      }
+      partialToolCalls[value.toolCallId] = {
+        text: "",
+        step,
+        toolName: value.toolName,
+        index: message.toolInvocations.length
+      };
+      const invocation = {
+        state: "partial-call",
+        step,
+        toolCallId: value.toolCallId,
+        toolName: value.toolName,
+        args: void 0
+      };
+      message.toolInvocations.push(invocation);
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+    },
+    onToolCallDeltaPart(value) {
+      const partialToolCall = partialToolCalls[value.toolCallId];
+      partialToolCall.text += value.argsTextDelta;
+      const { value: partialArgs } = parsePartialJson(partialToolCall.text);
+      const invocation = {
+        state: "partial-call",
+        step: partialToolCall.step,
+        toolCallId: value.toolCallId,
+        toolName: partialToolCall.toolName,
+        args: partialArgs
+      };
+      message.toolInvocations[partialToolCall.index] = invocation;
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+    },
+    async onToolCallPart(value) {
+      const invocation = {
+        state: "call",
+        step,
+        ...value
+      };
+      if (partialToolCalls[value.toolCallId] != null) {
+        message.toolInvocations[partialToolCalls[value.toolCallId].index] = invocation;
+      } else {
+        if (message.toolInvocations == null) {
+          message.toolInvocations = [];
+        }
+        message.toolInvocations.push(invocation);
+      }
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+      if (onToolCall) {
+        const result = await onToolCall({ toolCall: value });
+        if (result != null) {
+          const invocation2 = {
+            state: "result",
+            step,
+            ...value,
+            result
+          };
+          message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
+          updateToolInvocationPart(value.toolCallId, invocation2);
+          execUpdate();
+        }
+      }
+    },
+    onToolResultPart(value) {
+      const toolInvocations = message.toolInvocations;
+      if (toolInvocations == null) {
+        throw new Error("tool_result must be preceded by a tool_call");
+      }
+      const toolInvocationIndex = toolInvocations.findIndex(
+        (invocation2) => invocation2.toolCallId === value.toolCallId
+      );
+      if (toolInvocationIndex === -1) {
+        throw new Error(
+          "tool_result must be preceded by a tool_call with the same toolCallId"
+        );
+      }
+      const invocation = {
+        ...toolInvocations[toolInvocationIndex],
+        state: "result",
+        ...value
+      };
+      toolInvocations[toolInvocationIndex] = invocation;
+      updateToolInvocationPart(value.toolCallId, invocation);
+      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;
+      currentReasoningTextDetail = 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 = calculateLanguageModelUsage(value.usage);
+      }
+    },
+    onErrorPart(error) {
+      throw new Error(error);
+    }
+  });
+  onFinish == null ? void 0 : onFinish({ message, finishReason, usage });
+}
+
+// core/util/process-chat-text-response.ts
+import { generateId as generateIdFunction2 } from "@ai-sdk/provider-utils";
+
+// core/util/process-text-stream.ts
+async function processTextStream({
+  stream,
+  onTextPart
+}) {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    await onTextPart(value);
+  }
+}
+
+// core/util/process-chat-text-response.ts
+async function processChatTextResponse({
+  stream,
+  update,
+  onFinish,
+  getCurrentDate = () => /* @__PURE__ */ new Date(),
+  generateId: generateId3 = generateIdFunction2
+}) {
+  const textPart = { type: "text", text: "" };
+  const resultMessage = {
+    id: generateId3(),
+    createdAt: getCurrentDate(),
+    role: "assistant",
+    content: "",
+    parts: [textPart]
+  };
+  await processTextStream({
+    stream,
+    onTextPart: (chunk) => {
+      resultMessage.content += chunk;
+      textPart.text += chunk;
+      update({
+        message: { ...resultMessage },
+        data: [],
+        replaceLastMessage: false
+      });
+    }
+  });
+  onFinish == null ? void 0 : onFinish(resultMessage, {
+    usage: { completionTokens: NaN, promptTokens: NaN, totalTokens: NaN },
+    finishReason: "unknown"
+  });
+}
+
+// core/util/call-chat-api.ts
+var getOriginalFetch = () => fetch;
+async function callChatApi({
+  api,
+  body,
+  streamProtocol = "data",
+  credentials,
+  headers,
+  abortController,
+  restoreMessagesOnFailure,
+  onResponse,
+  onUpdate,
+  onFinish,
+  onToolCall,
+  generateId: generateId3,
+  fetch: fetch2 = getOriginalFetch(),
+  lastMessage
+}) {
+  var _a17, _b;
+  const response = await fetch2(api, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
+    credentials
+  }).catch((err) => {
+    restoreMessagesOnFailure();
+    throw err;
+  });
+  if (onResponse) {
+    try {
+      await onResponse(response);
+    } catch (err) {
+      throw err;
+    }
+  }
+  if (!response.ok) {
+    restoreMessagesOnFailure();
+    throw new Error(
+      (_b = await response.text()) != null ? _b : "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  switch (streamProtocol) {
+    case "text": {
+      await processChatTextResponse({
+        stream: response.body,
+        update: onUpdate,
+        onFinish,
+        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
+      });
+      return;
+    }
+    default: {
+      const exhaustiveCheck = streamProtocol;
+      throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// core/util/call-completion-api.ts
+var getOriginalFetch2 = () => fetch;
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamProtocol = "data",
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onResponse,
+  onFinish,
+  onError,
+  onData,
+  fetch: fetch2 = getOriginalFetch2()
+}) {
+  var _a17;
+  try {
+    setLoading(true);
+    setError(void 0);
+    const abortController = new AbortController();
+    setAbortController(abortController);
+    setCompletion("");
+    const response = await fetch2(api, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...body
+      }),
+      credentials,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      signal: abortController.signal
+    }).catch((err) => {
+      throw err;
+    });
+    if (onResponse) {
+      try {
+        await onResponse(response);
+      } catch (err) {
+        throw err;
+      }
+    }
+    if (!response.ok) {
+      throw new Error(
+        (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    let result = "";
+    switch (streamProtocol) {
+      case "text": {
+        await processTextStream({
+          stream: response.body,
+          onTextPart: (chunk) => {
+            result += chunk;
+            setCompletion(result);
+          }
+        });
+        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);
+          }
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck = streamProtocol;
+        throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+      }
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// core/util/data-url.ts
+function getTextFromDataUrl(dataUrl) {
+  const [header, base64Content] = dataUrl.split(",");
+  const mediaType = header.split(";")[0].split(":")[1];
+  if (mediaType == null || base64Content == null) {
+    throw new Error("Invalid data URL format");
+  }
+  try {
+    return window.atob(base64Content);
+  } catch (error) {
+    throw new Error(`Error decoding data URL`);
+  }
+}
+
+// core/util/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);
+}
+
+// core/util/get-message-parts.ts
+function getMessageParts(message) {
+  var _a17;
+  return (_a17 = message.parts) != null ? _a17 : [
+    ...message.toolInvocations ? message.toolInvocations.map((toolInvocation) => ({
+      type: "tool-invocation",
+      toolInvocation
+    })) : [],
+    ...message.reasoning ? [
+      {
+        type: "reasoning",
+        reasoning: message.reasoning,
+        details: [{ type: "text", text: message.reasoning }]
+      }
+    ] : [],
+    ...message.content ? [{ type: "text", text: message.content }] : []
+  ];
+}
+
+// core/util/fill-message-parts.ts
+function fillMessageParts(messages) {
+  return messages.map((message) => ({
+    ...message,
+    parts: getMessageParts(message)
+  }));
+}
+
+// core/util/is-deep-equal-data.ts
+function isDeepEqualData(obj1, obj2) {
+  if (obj1 === obj2)
+    return true;
+  if (obj1 == null || obj2 == null)
+    return false;
+  if (typeof obj1 !== "object" && typeof obj2 !== "object")
+    return obj1 === obj2;
+  if (obj1.constructor !== obj2.constructor)
+    return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1)) {
+    if (obj1.length !== obj2.length)
+      return false;
+    for (let i = 0; i < obj1.length; i++) {
+      if (!isDeepEqualData(obj1[i], obj2[i]))
+        return false;
+    }
+    return true;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length)
+    return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key))
+      return false;
+    if (!isDeepEqualData(obj1[key], obj2[key]))
+      return false;
+  }
+  return true;
+}
+
+// core/util/prepare-attachments-for-request.ts
+async function prepareAttachmentsForRequest(attachmentsFromOptions) {
+  if (!attachmentsFromOptions) {
+    return [];
+  }
+  if (attachmentsFromOptions instanceof FileList) {
+    return Promise.all(
+      Array.from(attachmentsFromOptions).map(async (attachment) => {
+        const { name: name17, type } = attachment;
+        const dataUrl = await new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = (readerEvent) => {
+            var _a17;
+            resolve((_a17 = readerEvent.target) == null ? void 0 : _a17.result);
+          };
+          reader.onerror = (error) => reject(error);
+          reader.readAsDataURL(attachment);
+        });
+        return {
+          name: name17,
+          contentType: type,
+          url: dataUrl
+        };
+      })
+    );
+  }
+  if (Array.isArray(attachmentsFromOptions)) {
+    return attachmentsFromOptions;
+  }
+  throw new Error("Invalid attachments type");
+}
+
+// core/util/schema.ts
+import { validatorSymbol } from "@ai-sdk/provider-utils";
+
+// core/util/zod-schema.ts
+import zodToJsonSchema from "zod-to-json-schema";
+function zodSchema(zodSchema2, options) {
+  var _a17;
+  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
+  return jsonSchema(
+    zodToJsonSchema(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none",
+      target: "jsonSchema7"
+      // note: openai mode breaks various gemini conversions
+    }),
+    {
+      validate: (value) => {
+        const result = zodSchema2.safeParse(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+
+// core/util/schema.ts
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return schema == null ? jsonSchema({
+    properties: {},
+    additionalProperties: false
+  }) : isSchema(schema) ? schema : zodSchema(schema);
+}
+
+// core/util/should-resubmit-messages.ts
+function shouldResubmitMessages({
+  originalMaxToolInvocationStep,
+  originalMessageCount,
+  maxSteps,
+  messages
+}) {
+  var _a17;
+  const lastMessage = messages[messages.length - 1];
+  return (
+    // check if the feature is enabled:
+    maxSteps > 1 && // ensure there is a last message:
+    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
+    (messages.length > originalMessageCount || extractMaxToolInvocationStep(lastMessage.toolInvocations) !== originalMaxToolInvocationStep) && // check that next step is possible:
+    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
+    ((_a17 = extractMaxToolInvocationStep(lastMessage.toolInvocations)) != null ? _a17 : 0) < maxSteps
+  );
+}
+function isAssistantMessageWithCompletedToolCalls(message) {
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
+}
+
+// core/util/update-tool-call-result.ts
+function updateToolCallResult({
+  messages,
+  toolCallId,
+  toolResult: result
+}) {
+  var _a17;
+  const lastMessage = messages[messages.length - 1];
+  const invocationPart = lastMessage.parts.find(
+    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+  );
+  if (invocationPart == null) {
+    return;
+  }
+  const toolResult = {
+    ...invocationPart.toolInvocation,
+    state: "result",
+    result
+  };
+  invocationPart.toolInvocation = toolResult;
+  lastMessage.toolInvocations = (_a17 = lastMessage.toolInvocations) == null ? void 0 : _a17.map(
+    (toolInvocation) => toolInvocation.toolCallId === toolCallId ? toolResult : toolInvocation
+  );
+}
 
 // core/data-stream/create-data-stream.ts
-import { formatDataStreamPart } from "@ai-sdk/ui-utils";
 function createDataStream({
   execute,
   onError = () => "An error occurred."
@@ -527,6 +1993,7 @@ function selectTelemetryAttributes({
 async function embed({
   model,
   value,
+  providerOptions,
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
@@ -552,7 +2019,7 @@ async function embed({
     }),
     tracer,
     fn: async (span) => {
-      const { embedding, usage, rawResponse } = await retry(
+      const { embedding, usage, response } = await retry(
         () => (
           // nested spans to align with the embedMany telemetry data:
           recordSpan({
@@ -575,7 +2042,8 @@ async function embed({
               const modelResponse = await model.doEmbed({
                 values: [value],
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embedding2 = modelResponse.embeddings[0];
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -595,7 +2063,7 @@ async function embed({
               return {
                 embedding: embedding2,
                 usage: usage2,
-                rawResponse: modelResponse.rawResponse
+                response: modelResponse.response
               };
             }
           })
@@ -610,7 +2078,12 @@ async function embed({
           }
         })
       );
-      return new DefaultEmbedResult({ value, embedding, usage, rawResponse });
+      return new DefaultEmbedResult({
+        value,
+        embedding,
+        usage,
+        response
+      });
     }
   });
 }
@@ -619,7 +2092,7 @@ var DefaultEmbedResult = class {
     this.value = options.value;
     this.embedding = options.embedding;
     this.usage = options.usage;
-    this.rawResponse = options.rawResponse;
+    this.response = options.response;
   }
 };
 
@@ -642,6 +2115,7 @@ async function embedMany({
   maxRetries: maxRetriesArg,
   abortSignal,
   headers,
+  providerOptions,
   experimental_telemetry: telemetry
 }) {
   const { maxRetries, retry } = prepareRetries({ maxRetries: maxRetriesArg });
@@ -669,7 +2143,7 @@ async function embedMany({
     fn: async (span) => {
       const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall;
       if (maxEmbeddingsPerCall == null) {
-        const { embeddings: embeddings2, usage } = await retry(() => {
+        const { embeddings: embeddings2, usage, response } = await retry(() => {
           return recordSpan({
             name: "ai.embedMany.doEmbed",
             attributes: selectTelemetryAttributes({
@@ -692,7 +2166,8 @@ async function embedMany({
               const modelResponse = await model.doEmbed({
                 values,
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embeddings3 = modelResponse.embeddings;
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -707,7 +2182,11 @@ async function embedMany({
                   }
                 })
               );
-              return { embeddings: embeddings3, usage: usage2 };
+              return {
+                embeddings: embeddings3,
+                usage: usage2,
+                response: modelResponse.response
+              };
             }
           });
         });
@@ -722,13 +2201,23 @@ async function embedMany({
             }
           })
         );
-        return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage });
+        return new DefaultEmbedManyResult({
+          values,
+          embeddings: embeddings2,
+          usage,
+          responses: [response]
+        });
       }
       const valueChunks = splitArray(values, maxEmbeddingsPerCall);
       const embeddings = [];
+      const responses = [];
       let tokens = 0;
       for (const chunk of valueChunks) {
-        const { embeddings: responseEmbeddings, usage } = await retry(() => {
+        const {
+          embeddings: responseEmbeddings,
+          usage,
+          response
+        } = await retry(() => {
           return recordSpan({
             name: "ai.embedMany.doEmbed",
             attributes: selectTelemetryAttributes({
@@ -751,7 +2240,8 @@ async function embedMany({
               const modelResponse = await model.doEmbed({
                 values: chunk,
                 abortSignal,
-                headers
+                headers,
+                providerOptions
               });
               const embeddings2 = modelResponse.embeddings;
               const usage2 = (_a17 = modelResponse.usage) != null ? _a17 : { tokens: NaN };
@@ -766,11 +2256,16 @@ async function embedMany({
                   }
                 })
               );
-              return { embeddings: embeddings2, usage: usage2 };
+              return {
+                embeddings: embeddings2,
+                usage: usage2,
+                response: modelResponse.response
+              };
             }
           });
         });
         embeddings.push(...responseEmbeddings);
+        responses.push(response);
         tokens += usage.tokens;
       }
       span.setAttributes(
@@ -787,7 +2282,8 @@ async function embedMany({
       return new DefaultEmbedManyResult({
         values,
         embeddings,
-        usage: { tokens }
+        usage: { tokens },
+        responses
       });
     }
   });
@@ -797,6 +2293,7 @@ var DefaultEmbedManyResult = class {
     this.values = options.values;
     this.embeddings = options.embeddings;
     this.usage = options.usage;
+    this.responses = options.responses;
   }
 };
 
@@ -830,12 +2327,12 @@ import {
 var DefaultGeneratedFile = class {
   constructor({
     data,
-    mimeType
+    mediaType
   }) {
     const isUint8Array = data instanceof Uint8Array;
     this.base64Data = isUint8Array ? void 0 : data;
     this.uint8ArrayData = isUint8Array ? data : void 0;
-    this.mimeType = mimeType;
+    this.mediaType = mediaType;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
@@ -859,45 +2356,46 @@ var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
   }
 };
 
-// core/util/detect-image-mimetype.ts
-var mimeTypeSignatures = [
+// core/util/detect-media-type.ts
+import { convertBase64ToUint8Array as convertBase64ToUint8Array2 } from "@ai-sdk/provider-utils";
+var imageMediaTypeSignatures = [
   {
-    mimeType: "image/gif",
+    mediaType: "image/gif",
     bytesPrefix: [71, 73, 70],
     base64Prefix: "R0lG"
   },
   {
-    mimeType: "image/png",
+    mediaType: "image/png",
     bytesPrefix: [137, 80, 78, 71],
     base64Prefix: "iVBORw"
   },
   {
-    mimeType: "image/jpeg",
+    mediaType: "image/jpeg",
     bytesPrefix: [255, 216],
     base64Prefix: "/9j/"
   },
   {
-    mimeType: "image/webp",
+    mediaType: "image/webp",
     bytesPrefix: [82, 73, 70, 70],
     base64Prefix: "UklGRg"
   },
   {
-    mimeType: "image/bmp",
+    mediaType: "image/bmp",
     bytesPrefix: [66, 77],
     base64Prefix: "Qk"
   },
   {
-    mimeType: "image/tiff",
+    mediaType: "image/tiff",
     bytesPrefix: [73, 73, 42, 0],
     base64Prefix: "SUkqAA"
   },
   {
-    mimeType: "image/tiff",
+    mediaType: "image/tiff",
     bytesPrefix: [77, 77, 0, 42],
     base64Prefix: "TU0AKg"
   },
   {
-    mimeType: "image/avif",
+    mediaType: "image/avif",
     bytesPrefix: [
       0,
       0,
@@ -915,7 +2413,7 @@ var mimeTypeSignatures = [
     base64Prefix: "AAAAIGZ0eXBhdmlm"
   },
   {
-    mimeType: "image/heic",
+    mediaType: "image/heic",
     bytesPrefix: [
       0,
       0,
@@ -933,10 +2431,59 @@ var mimeTypeSignatures = [
     base64Prefix: "AAAAIGZ0eXBoZWlj"
   }
 ];
-function detectImageMimeType(image) {
-  for (const signature of mimeTypeSignatures) {
-    if (typeof image === "string" ? image.startsWith(signature.base64Prefix) : image.length >= signature.bytesPrefix.length && signature.bytesPrefix.every((byte, index) => image[index] === byte)) {
-      return signature.mimeType;
+var audioMediaTypeSignatures = [
+  {
+    mediaType: "audio/mpeg",
+    bytesPrefix: [255, 251],
+    base64Prefix: "//s="
+  },
+  {
+    mediaType: "audio/wav",
+    bytesPrefix: [82, 73, 70, 70],
+    base64Prefix: "UklGR"
+  },
+  {
+    mediaType: "audio/ogg",
+    bytesPrefix: [79, 103, 103, 83],
+    base64Prefix: "T2dnUw"
+  },
+  {
+    mediaType: "audio/flac",
+    bytesPrefix: [102, 76, 97, 67],
+    base64Prefix: "ZkxhQw"
+  },
+  {
+    mediaType: "audio/aac",
+    bytesPrefix: [64, 21, 0, 0],
+    base64Prefix: "QBUA"
+  },
+  {
+    mediaType: "audio/mp4",
+    bytesPrefix: [102, 116, 121, 112],
+    base64Prefix: "ZnR5cA"
+  }
+];
+var stripID3 = (data) => {
+  const bytes = typeof data === "string" ? convertBase64ToUint8Array2(data) : data;
+  const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
+  return bytes.slice(id3Size + 10);
+};
+function stripID3TagsIfPresent(data) {
+  const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
+  data[1] === 68 && // 'D'
+  data[2] === 51;
+  return hasId3 ? stripID3(data) : data;
+}
+function detectMediaType({
+  data,
+  signatures
+}) {
+  const processedData = stripID3TagsIfPresent(data);
+  for (const signature of signatures) {
+    if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
+      (byte, index) => processedData[index] === byte
+    )) {
+      return signature.mediaType;
     }
   }
   return void 0;
@@ -992,7 +2539,10 @@ async function generateImage({
           var _a18;
           return new DefaultGeneratedFile({
             data: image,
-            mimeType: (_a18 = detectImageMimeType(image)) != null ? _a18 : "image/png"
+            mediaType: (_a18 = detectMediaType({
+              data: image,
+              signatures: imageMediaTypeSignatures
+            })) != null ? _a18 : "image/png"
           });
         }
       )
@@ -1021,7 +2571,7 @@ import {
   JSONParseError,
   TypeValidationError as TypeValidationError2
 } from "@ai-sdk/provider";
-import { createIdGenerator, safeParseJSON } from "@ai-sdk/provider-utils";
+import { createIdGenerator, safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
 
 // errors/no-object-generated-error.ts
 import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
@@ -1092,7 +2642,7 @@ async function download({ url }) {
     }
     return {
       data: new Uint8Array(await response.arrayBuffer()),
-      mimeType: (_a17 = response.headers.get("content-type")) != null ? _a17 : void 0
+      mediaType: (_a17 = response.headers.get("content-type")) != null ? _a17 : void 0
     };
   } catch (error) {
     if (DownloadError.isInstance(error)) {
@@ -1103,10 +2653,12 @@ async function download({ url }) {
 }
 
 // core/prompt/data-content.ts
+import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
 import {
-  convertBase64ToUint8Array as convertBase64ToUint8Array2,
+  convertBase64ToUint8Array as convertBase64ToUint8Array3,
   convertUint8ArrayToBase64 as convertUint8ArrayToBase642
 } from "@ai-sdk/provider-utils";
+import { z } from "zod";
 
 // core/prompt/invalid-data-content-error.ts
 import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
@@ -1130,8 +2682,23 @@ var InvalidDataContentError = class extends AISDKError6 {
 };
 _a6 = symbol6;
 
+// 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
-import { z } from "zod";
 var dataContentSchema = z.union([
   z.string(),
   z.instanceof(Uint8Array),
@@ -1145,6 +2712,33 @@ var dataContentSchema = z.union([
     { 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 AISDKError7({
+        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;
@@ -1160,7 +2754,7 @@ function convertDataContentToUint8Array(content) {
   }
   if (typeof content === "string") {
     try {
-      return convertBase64ToUint8Array2(content);
+      return convertBase64ToUint8Array3(content);
     } catch (error) {
       throw new InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
@@ -1183,12 +2777,12 @@ function convertUint8ArrayToText(uint8Array) {
 }
 
 // core/prompt/invalid-message-role-error.ts
-import { AISDKError as AISDKError7 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError8 } from "@ai-sdk/provider";
 var name7 = "AI_InvalidMessageRoleError";
 var marker7 = `vercel.ai.error.${name7}`;
 var symbol7 = Symbol.for(marker7);
 var _a7;
-var InvalidMessageRoleError = class extends AISDKError7 {
+var InvalidMessageRoleError = class extends AISDKError8 {
   constructor({
     role,
     message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
@@ -1198,27 +2792,11 @@ var InvalidMessageRoleError = class extends AISDKError7 {
     this.role = role;
   }
   static isInstance(error) {
-    return AISDKError7.hasMarker(error, marker7);
+    return AISDKError8.hasMarker(error, marker7);
   }
 };
 _a7 = symbol7;
 
-// core/prompt/split-data-url.ts
-function splitDataUrl(dataUrl) {
-  try {
-    const [header, base64Content] = dataUrl.split(",");
-    return {
-      mimeType: header.split(";")[0].split(":")[1],
-      base64Content
-    };
-  } catch (error) {
-    return {
-      mimeType: void 0,
-      base64Content: void 0
-    };
-  }
-}
-
 // core/prompt/convert-to-language-model-prompt.ts
 async function convertToLanguageModelPrompt({
   prompt,
@@ -1240,14 +2818,13 @@ async function convertToLanguageModelPrompt({
   ];
 }
 function convertToLanguageModelMessage(message, downloadedAssets) {
-  var _a17, _b, _c, _d, _e, _f;
   const role = message.role;
   switch (role) {
     case "system": {
       return {
         role: "system",
         content: message.content,
-        providerMetadata: (_a17 = message.providerOptions) != null ? _a17 : message.experimental_providerMetadata
+        providerOptions: message.providerOptions
       };
     }
     case "user": {
@@ -1255,13 +2832,13 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
         return {
           role: "user",
           content: [{ type: "text", text: message.content }],
-          providerMetadata: (_b = message.providerOptions) != null ? _b : message.experimental_providerMetadata
+          providerOptions: message.providerOptions
         };
       }
       return {
         role: "user",
         content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
-        providerMetadata: (_c = message.providerOptions) != null ? _c : message.experimental_providerMetadata
+        providerOptions: message.providerOptions
       };
     }
     case "assistant": {
@@ -1269,7 +2846,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
         return {
           role: "assistant",
           content: [{ type: "text", text: message.content }],
-          providerMetadata: (_d = message.providerOptions) != null ? _d : message.experimental_providerMetadata
+          providerOptions: message.providerOptions
         };
       }
       return {
@@ -1278,16 +2855,19 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
           // remove empty text parts:
           (part) => part.type !== "text" || part.text !== ""
         ).map((part) => {
-          var _a18;
-          const providerOptions = (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata;
+          var _a17;
+          const providerOptions = part.providerOptions;
           switch (part.type) {
             case "file": {
+              const { data, mediaType } = convertToLanguageModelV2DataContent(
+                part.data
+              );
               return {
                 type: "file",
-                data: part.data instanceof URL ? part.data : convertDataContentToBase64String(part.data),
+                data,
                 filename: part.filename,
-                mimeType: part.mimeType,
-                providerMetadata: providerOptions
+                mediaType: (_a17 = mediaType != null ? mediaType : part.mediaType) != null ? _a17 : part.mimeType,
+                providerOptions
               };
             }
             case "reasoning": {
@@ -1295,21 +2875,21 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
                 type: "reasoning",
                 text: part.text,
                 signature: part.signature,
-                providerMetadata: providerOptions
+                providerOptions
               };
             }
             case "redacted-reasoning": {
               return {
                 type: "redacted-reasoning",
                 data: part.data,
-                providerMetadata: providerOptions
+                providerOptions
               };
             }
             case "text": {
               return {
                 type: "text",
                 text: part.text,
-                providerMetadata: providerOptions
+                providerOptions
               };
             }
             case "tool-call": {
@@ -1318,30 +2898,27 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
                 toolCallId: part.toolCallId,
                 toolName: part.toolName,
                 args: part.args,
-                providerMetadata: providerOptions
+                providerOptions
               };
             }
           }
         }),
-        providerMetadata: (_e = message.providerOptions) != null ? _e : message.experimental_providerMetadata
+        providerOptions: message.providerOptions
       };
     }
     case "tool": {
       return {
         role: "tool",
-        content: message.content.map((part) => {
-          var _a18;
-          return {
-            type: "tool-result",
-            toolCallId: part.toolCallId,
-            toolName: part.toolName,
-            result: part.result,
-            content: part.experimental_content,
-            isError: part.isError,
-            providerMetadata: (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata
-          };
-        }),
-        providerMetadata: (_f = message.providerOptions) != null ? _f : message.experimental_providerMetadata
+        content: message.content.map((part) => ({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          result: part.result,
+          content: part.experimental_content,
+          isError: part.isError,
+          providerOptions: part.providerOptions
+        })),
+        providerOptions: message.providerOptions
       };
     }
     default: {
@@ -1374,78 +2951,60 @@ async function downloadAssets(messages, downloadImplementation, modelSupportsIma
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a17, _b, _c, _d;
+  var _a17, _b, _c;
   if (part.type === "text") {
     return {
       type: "text",
       text: part.text,
-      providerMetadata: (_a17 = part.providerOptions) != null ? _a17 : part.experimental_providerMetadata
+      providerOptions: part.providerOptions
     };
   }
-  let mimeType = part.mimeType;
-  let data;
-  let content;
-  let normalizedData;
+  let originalData;
   const type = part.type;
   switch (type) {
     case "image":
-      data = part.image;
+      originalData = part.image;
       break;
     case "file":
-      data = part.data;
+      originalData = part.data;
       break;
     default:
       throw new Error(`Unsupported part type: ${type}`);
   }
-  try {
-    content = typeof data === "string" ? new URL(data) : data;
-  } catch (error) {
-    content = data;
-  }
-  if (content instanceof URL) {
-    if (content.protocol === "data:") {
-      const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl(
-        content.toString()
-      );
-      if (dataUrlMimeType == null || base64Content == null) {
-        throw new Error(`Invalid data URL format in part ${type}`);
-      }
-      mimeType = dataUrlMimeType;
-      normalizedData = convertDataContentToUint8Array(base64Content);
-    } else {
-      const downloadedFile = downloadedAssets[content.toString()];
-      if (downloadedFile) {
-        normalizedData = downloadedFile.data;
-        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType;
-      } else {
-        normalizedData = content;
-      }
+  const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV2DataContent(originalData);
+  let mediaType = (_a17 = convertedMediaType != null ? convertedMediaType : part.mediaType) != null ? _a17 : part.mimeType;
+  let data = convertedData;
+  if (data instanceof URL) {
+    const downloadedFile = downloadedAssets[data.toString()];
+    if (downloadedFile) {
+      data = downloadedFile.data;
+      mediaType = (_b = downloadedFile.mediaType) != null ? _b : mediaType;
     }
-  } else {
-    normalizedData = convertDataContentToUint8Array(content);
   }
   switch (type) {
     case "image": {
-      if (normalizedData instanceof Uint8Array) {
-        mimeType = (_b = detectImageMimeType(normalizedData)) != null ? _b : mimeType;
+      if (data instanceof Uint8Array || typeof data === "string") {
+        mediaType = (_c = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _c : mediaType;
       }
       return {
-        type: "image",
-        image: normalizedData,
-        mimeType,
-        providerMetadata: (_c = part.providerOptions) != null ? _c : part.experimental_providerMetadata
+        type: "file",
+        mediaType: mediaType != null ? mediaType : "image/*",
+        // any image
+        filename: void 0,
+        data,
+        providerOptions: part.providerOptions
       };
     }
     case "file": {
-      if (mimeType == null) {
-        throw new Error(`Mime type is missing for file part`);
+      if (mediaType == null) {
+        throw new Error(`Media type is missing for file part`);
       }
       return {
         type: "file",
-        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
+        mediaType,
         filename: part.filename,
-        mimeType,
-        providerMetadata: (_d = part.providerOptions) != null ? _d : part.experimental_providerMetadata
+        data,
+        providerOptions: part.providerOptions
       };
     }
   }
@@ -1453,7 +3012,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
 
 // core/prompt/prepare-call-settings.ts
 function prepareCallSettings({
-  maxTokens,
+  maxOutputTokens,
   temperature,
   topP,
   topK,
@@ -1462,19 +3021,19 @@ function prepareCallSettings({
   stopSequences,
   seed
 }) {
-  if (maxTokens != null) {
-    if (!Number.isInteger(maxTokens)) {
+  if (maxOutputTokens != null) {
+    if (!Number.isInteger(maxOutputTokens)) {
       throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be an integer"
+        parameter: "maxOutputTokens",
+        value: maxOutputTokens,
+        message: "maxOutputTokens must be an integer"
       });
     }
-    if (maxTokens < 1) {
+    if (maxOutputTokens < 1) {
       throw new InvalidArgumentError({
-        parameter: "maxTokens",
-        value: maxTokens,
-        message: "maxTokens must be >= 1"
+        parameter: "maxOutputTokens",
+        value: maxOutputTokens,
+        message: "maxOutputTokens must be >= 1"
       });
     }
   }
@@ -1533,7 +3092,7 @@ function prepareCallSettings({
     }
   }
   return {
-    maxTokens,
+    maxOutputTokens,
     // TODO v5 remove default 0 for temperature
     temperature: temperature != null ? temperature : 0,
     topP,
@@ -1575,7 +3134,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: url,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1583,14 +3142,14 @@ function attachmentsToParts(attachments) {
       case "data:": {
         let header;
         let base64Content;
-        let mimeType;
+        let mediaType;
         try {
           [header, base64Content] = attachment.url.split(",");
-          mimeType = header.split(";")[0].split(":")[1];
+          mediaType = header.split(";")[0].split(":")[1];
         } catch (error) {
           throw new Error(`Error processing data URL: ${attachment.url}`);
         }
-        if (mimeType == null || base64Content == null) {
+        if (mediaType == null || base64Content == null) {
           throw new Error(`Invalid data URL format: ${attachment.url}`);
         }
         if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) {
@@ -1614,7 +3173,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: base64Content,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1628,12 +3187,12 @@ function attachmentsToParts(attachments) {
 }
 
 // core/prompt/message-conversion-error.ts
-import { AISDKError as AISDKError8 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError9 } from "@ai-sdk/provider";
 var name8 = "AI_MessageConversionError";
 var marker8 = `vercel.ai.error.${name8}`;
 var symbol8 = Symbol.for(marker8);
 var _a8;
-var MessageConversionError = class extends AISDKError8 {
+var MessageConversionError = class extends AISDKError9 {
   constructor({
     originalMessage,
     message
@@ -1643,7 +3202,7 @@ var MessageConversionError = class extends AISDKError8 {
     this.originalMessage = originalMessage;
   }
   static isInstance(error) {
-    return AISDKError8.hasMarker(error, marker8);
+    return AISDKError9.hasMarker(error, marker8);
   }
 };
 _a8 = symbol8;
@@ -1689,14 +3248,23 @@ function convertToCoreMessages(messages, options) {
       case "assistant": {
         if (message.parts != null) {
           let processBlock2 = function() {
+            var _a18;
             const content2 = [];
             for (const part of block) {
               switch (part.type) {
-                case "file":
                 case "text": {
                   content2.push(part);
                   break;
                 }
+                case "file": {
+                  content2.push({
+                    type: "file",
+                    data: part.data,
+                    mediaType: (_a18 = part.mediaType) != null ? _a18 : part.mimeType
+                    // TODO migration, remove
+                  });
+                  break;
+                }
                 case "reasoning": {
                   for (const detail of part.details) {
                     switch (detail.type) {
@@ -1908,7 +3476,7 @@ function detectSingleMessageCharacteristics(message) {
   "experimental_attachments" in message)) {
     return "has-ui-specific-parts";
   } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
-  "experimental_providerMetadata" in message || "providerOptions" in message)) {
+  "providerOptions" in message)) {
     return "has-core-specific-parts";
   } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
     return "message";
@@ -1953,7 +3521,7 @@ var toolResultContentSchema = z4.array(
     z4.object({
       type: z4.literal("image"),
       data: z4.string(),
-      mimeType: z4.string().optional()
+      mediaType: z4.string().optional()
     })
   ])
 );
@@ -1962,43 +3530,39 @@ var toolResultContentSchema = z4.array(
 var textPartSchema = z5.object({
   type: z5.literal("text"),
   text: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var imagePartSchema = z5.object({
   type: z5.literal("image"),
   image: z5.union([dataContentSchema, z5.instanceof(URL)]),
+  mediaType: z5.string().optional(),
   mimeType: z5.string().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var filePartSchema = z5.object({
   type: z5.literal("file"),
   data: z5.union([dataContentSchema, z5.instanceof(URL)]),
   filename: z5.string().optional(),
-  mimeType: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  mediaType: z5.string(),
+  mimeType: z5.string().optional(),
+  providerOptions: providerMetadataSchema.optional()
 });
 var reasoningPartSchema = z5.object({
   type: z5.literal("reasoning"),
   text: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var redactedReasoningPartSchema = z5.object({
   type: z5.literal("redacted-reasoning"),
   data: z5.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var toolCallPartSchema = z5.object({
   type: z5.literal("tool-call"),
   toolCallId: z5.string(),
   toolName: z5.string(),
   args: z5.unknown(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var toolResultPartSchema = z5.object({
   type: z5.literal("tool-result"),
@@ -2007,16 +3571,14 @@ var toolResultPartSchema = z5.object({
   result: z5.unknown(),
   content: toolResultContentSchema.optional(),
   isError: z5.boolean().optional(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 
 // core/prompt/message.ts
 var coreSystemMessageSchema = z6.object({
   role: z6.literal("system"),
   content: z6.string(),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var coreUserMessageSchema = z6.object({
   role: z6.literal("user"),
@@ -2024,8 +3586,7 @@ var coreUserMessageSchema = z6.object({
     z6.string(),
     z6.array(z6.union([textPartSchema, imagePartSchema, filePartSchema]))
   ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var coreAssistantMessageSchema = z6.object({
   role: z6.literal("assistant"),
@@ -2041,14 +3602,12 @@ var coreAssistantMessageSchema = z6.object({
       ])
     )
   ]),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var coreToolMessageSchema = z6.object({
   role: z6.literal("tool"),
   content: z6.array(toolResultPartSchema),
-  providerOptions: providerMetadataSchema.optional(),
-  experimental_providerMetadata: providerMetadataSchema.optional()
+  providerOptions: providerMetadataSchema.optional()
 });
 var coreMessageSchema = z6.union([
   coreSystemMessageSchema,
@@ -2136,14 +3695,14 @@ function standardizePrompt({
 }
 
 // core/types/usage.ts
-function calculateLanguageModelUsage({
-  promptTokens,
-  completionTokens
+function calculateLanguageModelUsage2({
+  inputTokens,
+  outputTokens
 }) {
   return {
-    promptTokens,
-    completionTokens,
-    totalTokens: promptTokens + completionTokens
+    promptTokens: inputTokens != null ? inputTokens : NaN,
+    completionTokens: outputTokens != null ? outputTokens : NaN,
+    totalTokens: (inputTokens != null ? inputTokens : 0) + (outputTokens != null ? outputTokens : 0)
   };
 }
 function addLanguageModelUsage(usage1, usage2) {
@@ -2182,7 +3741,6 @@ import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import { safeValidateTypes as safeValidateTypes2 } from "@ai-sdk/provider-utils";
-import { asSchema } from "@ai-sdk/ui-utils";
 
 // core/util/async-iterable-stream.ts
 function createAsyncIterableStream(source) {
@@ -2550,6 +4108,17 @@ function validateObjectGenerationInput({
   }
 }
 
+// core/generate-text/extract-content-text.ts
+function extractContentText(content) {
+  const parts = content.filter(
+    (content2) => content2.type === "text"
+  );
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.map((content2) => content2.text).join("");
+}
+
 // core/generate-object/generate-object.ts
 var originalGenerateId = createIdGenerator({ prefix: "aiobj", size: 24 });
 async function generateObject({
@@ -2569,8 +4138,7 @@ async function generateObject({
   headers,
   experimental_repairText: repairText,
   experimental_telemetry: telemetry,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
+  providerOptions,
   _internal: {
     generateId: generateId3 = originalGenerateId,
     currentDate = () => /* @__PURE__ */ new Date()
@@ -2632,7 +4200,6 @@ async function generateObject({
       let finishReason;
       let usage;
       let warnings;
-      let rawResponse;
       let response;
       let request;
       let logprobs;
@@ -2678,7 +4245,7 @@ async function generateObject({
                   "gen_ai.system": model.provider,
                   "gen_ai.request.model": model.modelId,
                   "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxTokens,
+                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
                   "gen_ai.request.presence_penalty": settings.presencePenalty,
                   "gen_ai.request.temperature": settings.temperature,
                   "gen_ai.request.top_k": settings.topK,
@@ -2687,10 +4254,10 @@ async function generateObject({
               }),
               tracer,
               fn: async (span2) => {
-                var _a18, _b2, _c2, _d2, _e, _f;
+                var _a18, _b2, _c2, _d2, _e, _f, _g, _h;
                 const result2 = await model.doGenerate({
-                  mode: {
-                    type: "object-json",
+                  responseFormat: {
+                    type: "json",
                     schema: outputStrategy.jsonSchema,
                     name: schemaName,
                     description: schemaDescription
@@ -2698,20 +4265,23 @@ async function generateObject({
                   ...prepareCallSettings(settings),
                   inputFormat: standardizedPrompt.type,
                   prompt: promptMessages,
-                  providerMetadata: providerOptions,
+                  providerOptions,
                   abortSignal,
                   headers
                 });
                 const responseData = {
                   id: (_b2 = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b2 : generateId3(),
                   timestamp: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                  modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId
+                  modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                  headers: (_g = result2.response) == null ? void 0 : _g.headers,
+                  body: (_h = result2.response) == null ? void 0 : _h.body
                 };
-                if (result2.text === void 0) {
+                const text2 = extractContentText(result2.content);
+                if (text2 === void 0) {
                   throw new NoObjectGeneratedError({
                     message: "No object generated: the model did not return a response.",
                     response: responseData,
-                    usage: calculateLanguageModelUsage(result2.usage),
+                    usage: calculateLanguageModelUsage2(result2.usage),
                     finishReason: result2.finishReason
                   });
                 }
@@ -2720,22 +4290,23 @@ async function generateObject({
                     telemetry,
                     attributes: {
                       "ai.response.finishReason": result2.finishReason,
-                      "ai.response.object": { output: () => result2.text },
+                      "ai.response.object": { output: () => text2 },
                       "ai.response.id": responseData.id,
                       "ai.response.model": responseData.modelId,
                       "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      "ai.usage.promptTokens": result2.usage.promptTokens,
-                      "ai.usage.completionTokens": result2.usage.completionTokens,
+                      // TODO rename telemetry attributes to inputTokens and outputTokens
+                      "ai.usage.promptTokens": result2.usage.inputTokens,
+                      "ai.usage.completionTokens": result2.usage.outputTokens,
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [result2.finishReason],
                       "gen_ai.response.id": responseData.id,
                       "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.prompt_tokens": result2.usage.promptTokens,
-                      "gen_ai.usage.completion_tokens": result2.usage.completionTokens
+                      "gen_ai.usage.input_tokens": result2.usage.inputTokens,
+                      "gen_ai.usage.output_tokens": result2.usage.outputTokens
                     }
                   })
                 );
-                return { ...result2, objectText: result2.text, responseData };
+                return { ...result2, objectText: text2, responseData };
               }
             })
           );
@@ -2743,7 +4314,6 @@ async function generateObject({
           finishReason = generateResult.finishReason;
           usage = generateResult.usage;
           warnings = generateResult.warnings;
-          rawResponse = generateResult.rawResponse;
           logprobs = generateResult.logprobs;
           resultProviderMetadata = generateResult.providerMetadata;
           request = (_b = generateResult.request) != null ? _b : {};
@@ -2784,7 +4354,7 @@ async function generateObject({
                   "gen_ai.system": model.provider,
                   "gen_ai.request.model": model.modelId,
                   "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxTokens,
+                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
                   "gen_ai.request.presence_penalty": settings.presencePenalty,
                   "gen_ai.request.temperature": settings.temperature,
                   "gen_ai.request.top_k": settings.topK,
@@ -2795,33 +4365,38 @@ async function generateObject({
               fn: async (span2) => {
                 var _a18, _b2, _c2, _d2, _e, _f, _g, _h;
                 const result2 = await model.doGenerate({
-                  mode: {
-                    type: "object-tool",
-                    tool: {
+                  tools: [
+                    {
                       type: "function",
                       name: schemaName != null ? schemaName : "json",
                       description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
                       parameters: outputStrategy.jsonSchema
                     }
-                  },
+                  ],
+                  toolChoice: { type: "required" },
                   ...prepareCallSettings(settings),
                   inputFormat,
                   prompt: promptMessages,
-                  providerMetadata: providerOptions,
+                  providerOptions,
                   abortSignal,
                   headers
                 });
-                const objectText = (_b2 = (_a18 = result2.toolCalls) == null ? void 0 : _a18[0]) == null ? void 0 : _b2.args;
+                const firstToolCall = result2.content.find(
+                  (content) => content.type === "tool-call"
+                );
+                const objectText = firstToolCall == null ? void 0 : firstToolCall.args;
                 const responseData = {
-                  id: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.id) != null ? _d2 : generateId3(),
-                  timestamp: (_f = (_e = result2.response) == null ? void 0 : _e.timestamp) != null ? _f : currentDate(),
-                  modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId
+                  id: (_b2 = (_a18 = result2.response) == null ? void 0 : _a18.id) != null ? _b2 : generateId3(),
+                  timestamp: (_d2 = (_c2 = result2.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
+                  modelId: (_f = (_e = result2.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                  headers: (_g = result2.response) == null ? void 0 : _g.headers,
+                  body: (_h = result2.response) == null ? void 0 : _h.body
                 };
                 if (objectText === void 0) {
                   throw new NoObjectGeneratedError({
                     message: "No object generated: the tool was not called.",
                     response: responseData,
-                    usage: calculateLanguageModelUsage(result2.usage),
+                    usage: calculateLanguageModelUsage2(result2.usage),
                     finishReason: result2.finishReason
                   });
                 }
@@ -2834,14 +4409,15 @@ async function generateObject({
                       "ai.response.id": responseData.id,
                       "ai.response.model": responseData.modelId,
                       "ai.response.timestamp": responseData.timestamp.toISOString(),
-                      "ai.usage.promptTokens": result2.usage.promptTokens,
-                      "ai.usage.completionTokens": result2.usage.completionTokens,
+                      // TODO rename telemetry attributes to inputTokens and outputTokens
+                      "ai.usage.promptTokens": result2.usage.inputTokens,
+                      "ai.usage.completionTokens": result2.usage.outputTokens,
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [result2.finishReason],
                       "gen_ai.response.id": responseData.id,
                       "gen_ai.response.model": responseData.modelId,
-                      "gen_ai.usage.input_tokens": result2.usage.promptTokens,
-                      "gen_ai.usage.output_tokens": result2.usage.completionTokens
+                      "gen_ai.usage.input_tokens": result2.usage.inputTokens,
+                      "gen_ai.usage.output_tokens": result2.usage.outputTokens
                     }
                   })
                 );
@@ -2853,7 +4429,6 @@ async function generateObject({
           finishReason = generateResult.finishReason;
           usage = generateResult.usage;
           warnings = generateResult.warnings;
-          rawResponse = generateResult.rawResponse;
           logprobs = generateResult.logprobs;
           resultProviderMetadata = generateResult.providerMetadata;
           request = (_d = generateResult.request) != null ? _d : {};
@@ -2871,14 +4446,14 @@ async function generateObject({
         }
       }
       function processResult(result2) {
-        const parseResult = safeParseJSON({ text: result2 });
+        const parseResult = safeParseJSON2({ text: result2 });
         if (!parseResult.success) {
           throw new NoObjectGeneratedError({
             message: "No object generated: could not parse the response.",
             cause: parseResult.error,
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage),
+            usage: calculateLanguageModelUsage2(usage),
             finishReason
           });
         }
@@ -2887,7 +4462,7 @@ async function generateObject({
           {
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage)
+            usage: calculateLanguageModelUsage2(usage)
           }
         );
         if (!validationResult.success) {
@@ -2896,7 +4471,7 @@ async function generateObject({
             cause: validationResult.error,
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage),
+            usage: calculateLanguageModelUsage2(usage),
             finishReason
           });
         }
@@ -2927,22 +4502,19 @@ async function generateObject({
             "ai.response.object": {
               output: () => JSON.stringify(object2)
             },
-            "ai.usage.promptTokens": usage.promptTokens,
-            "ai.usage.completionTokens": usage.completionTokens
+            // TODO rename telemetry attributes to inputTokens and outputTokens
+            "ai.usage.promptTokens": usage.inputTokens,
+            "ai.usage.completionTokens": usage.outputTokens
           }
         })
       );
       return new DefaultGenerateObjectResult({
         object: object2,
         finishReason,
-        usage: calculateLanguageModelUsage(usage),
+        usage: calculateLanguageModelUsage2(usage),
         warnings,
         request,
-        response: {
-          ...response,
-          headers: rawResponse == null ? void 0 : rawResponse.headers,
-          body: rawResponse == null ? void 0 : rawResponse.body
-        },
+        response,
         logprobs,
         providerMetadata: resultProviderMetadata
       });
@@ -2956,7 +4528,6 @@ var DefaultGenerateObjectResult = class {
     this.usage = options.usage;
     this.warnings = options.warnings;
     this.providerMetadata = options.providerMetadata;
-    this.experimental_providerMetadata = options.providerMetadata;
     this.response = options.response;
     this.request = options.request;
     this.logprobs = options.logprobs;
@@ -2974,10 +4545,6 @@ var DefaultGenerateObjectResult = class {
 
 // core/generate-object/stream-object.ts
 import { createIdGenerator as createIdGenerator2 } from "@ai-sdk/provider-utils";
-import {
-  isDeepEqualData,
-  parsePartialJson
-} from "@ai-sdk/ui-utils";
 
 // util/delayed-promise.ts
 var DelayedPromise = class {
@@ -3136,8 +4703,7 @@ function streamObject({
   abortSignal,
   headers,
   experimental_telemetry: telemetry,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
+  providerOptions,
   onError,
   onFinish,
   _internal: {
@@ -3273,8 +4839,8 @@ var DefaultStreamObjectResult = class {
               tools: void 0
             });
             callOptions = {
-              mode: {
-                type: "object-json",
+              responseFormat: {
+                type: "json",
                 schema: outputStrategy.jsonSchema,
                 name: schemaName,
                 description: schemaDescription
@@ -3287,15 +4853,15 @@ var DefaultStreamObjectResult = class {
                 modelSupportsUrl: (_a17 = model.supportsUrl) == null ? void 0 : _a17.bind(model)
                 // support 'this' context
               }),
-              providerMetadata: providerOptions,
+              providerOptions,
               abortSignal,
               headers
             };
             transformer = {
               transform: (chunk, controller) => {
                 switch (chunk.type) {
-                  case "text-delta":
-                    controller.enqueue(chunk.textDelta);
+                  case "text":
+                    controller.enqueue(chunk.text);
                     break;
                   case "response-metadata":
                   case "finish":
@@ -3313,15 +4879,15 @@ var DefaultStreamObjectResult = class {
               tools: void 0
             });
             callOptions = {
-              mode: {
-                type: "object-tool",
-                tool: {
+              tools: [
+                {
                   type: "function",
                   name: schemaName != null ? schemaName : "json",
                   description: schemaDescription != null ? schemaDescription : "Respond with a JSON object.",
                   parameters: outputStrategy.jsonSchema
                 }
-              },
+              ],
+              toolChoice: { type: "required" },
               ...prepareCallSettings(settings),
               inputFormat: standardizedPrompt.type,
               prompt: await convertToLanguageModelPrompt({
@@ -3330,7 +4896,7 @@ var DefaultStreamObjectResult = class {
                 modelSupportsUrl: (_b = model.supportsUrl) == null ? void 0 : _b.bind(model)
                 // support 'this' context,
               }),
-              providerMetadata: providerOptions,
+              providerOptions,
               abortSignal,
               headers
             };
@@ -3361,7 +4927,7 @@ var DefaultStreamObjectResult = class {
           }
         }
         const {
-          result: { stream, warnings, rawResponse, request },
+          result: { stream, response, request },
           doStreamSpan,
           startTimestampMs
         } = await retry(
@@ -3386,7 +4952,7 @@ var DefaultStreamObjectResult = class {
                 "gen_ai.system": model.provider,
                 "gen_ai.request.model": model.modelId,
                 "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                "gen_ai.request.max_tokens": settings.maxTokens,
+                "gen_ai.request.max_tokens": settings.maxOutputTokens,
                 "gen_ai.request.presence_penalty": settings.presencePenalty,
                 "gen_ai.request.temperature": settings.temperature,
                 "gen_ai.request.top_k": settings.topK,
@@ -3403,6 +4969,7 @@ var DefaultStreamObjectResult = class {
           })
         );
         self.requestPromise.resolve(request != null ? request : {});
+        let warnings;
         let usage;
         let finishReason;
         let providerMetadata;
@@ -3410,7 +4977,7 @@ var DefaultStreamObjectResult = class {
         let error;
         let accumulatedText = "";
         let textDelta = "";
-        let response = {
+        let fullResponse = {
           id: generateId3(),
           timestamp: currentDate(),
           modelId: model.modelId
@@ -3423,6 +4990,10 @@ var DefaultStreamObjectResult = class {
           new TransformStream({
             async transform(chunk, controller) {
               var _a18, _b2, _c;
+              if (typeof chunk === "object" && chunk.type === "stream-start") {
+                warnings = chunk.warnings;
+                return;
+              }
               if (isFirstChunk) {
                 const msToFirstChunk = now2() - startTimestampMs;
                 isFirstChunk = false;
@@ -3467,10 +5038,10 @@ var DefaultStreamObjectResult = class {
               }
               switch (chunk.type) {
                 case "response-metadata": {
-                  response = {
-                    id: (_a18 = chunk.id) != null ? _a18 : response.id,
-                    timestamp: (_b2 = chunk.timestamp) != null ? _b2 : response.timestamp,
-                    modelId: (_c = chunk.modelId) != null ? _c : response.modelId
+                  fullResponse = {
+                    id: (_a18 = chunk.id) != null ? _a18 : fullResponse.id,
+                    timestamp: (_b2 = chunk.timestamp) != null ? _b2 : fullResponse.timestamp,
+                    modelId: (_c = chunk.modelId) != null ? _c : fullResponse.modelId
                   };
                   break;
                 }
@@ -3479,20 +5050,24 @@ var DefaultStreamObjectResult = class {
                     controller.enqueue({ type: "text-delta", textDelta });
                   }
                   finishReason = chunk.finishReason;
-                  usage = calculateLanguageModelUsage(chunk.usage);
+                  usage = calculateLanguageModelUsage2(chunk.usage);
                   providerMetadata = chunk.providerMetadata;
-                  controller.enqueue({ ...chunk, usage, response });
+                  controller.enqueue({
+                    ...chunk,
+                    usage,
+                    response: fullResponse
+                  });
                   self.usagePromise.resolve(usage);
                   self.providerMetadataPromise.resolve(providerMetadata);
                   self.responsePromise.resolve({
-                    ...response,
-                    headers: rawResponse == null ? void 0 : rawResponse.headers
+                    ...fullResponse,
+                    headers: response == null ? void 0 : response.headers
                   });
                   const validationResult = outputStrategy.validateFinalResult(
                     latestObjectJson,
                     {
                       text: accumulatedText,
-                      response,
+                      response: fullResponse,
                       usage
                     }
                   );
@@ -3504,7 +5079,7 @@ var DefaultStreamObjectResult = class {
                       message: "No object generated: response did not match schema.",
                       cause: validationResult.error,
                       text: accumulatedText,
-                      response,
+                      response: fullResponse,
                       usage,
                       finishReason
                     });
@@ -3534,15 +5109,15 @@ var DefaultStreamObjectResult = class {
                       "ai.response.object": {
                         output: () => JSON.stringify(object2)
                       },
-                      "ai.response.id": response.id,
-                      "ai.response.model": response.modelId,
-                      "ai.response.timestamp": response.timestamp.toISOString(),
+                      "ai.response.id": fullResponse.id,
+                      "ai.response.model": fullResponse.modelId,
+                      "ai.response.timestamp": fullResponse.timestamp.toISOString(),
                       "ai.usage.promptTokens": finalUsage.promptTokens,
                       "ai.usage.completionTokens": finalUsage.completionTokens,
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [finishReason],
-                      "gen_ai.response.id": response.id,
-                      "gen_ai.response.model": response.modelId,
+                      "gen_ai.response.id": fullResponse.id,
+                      "gen_ai.response.model": fullResponse.modelId,
                       "gen_ai.usage.input_tokens": finalUsage.promptTokens,
                       "gen_ai.usage.output_tokens": finalUsage.completionTokens
                     }
@@ -3566,12 +5141,11 @@ var DefaultStreamObjectResult = class {
                   object: object2,
                   error,
                   response: {
-                    ...response,
-                    headers: rawResponse == null ? void 0 : rawResponse.headers
+                    ...fullResponse,
+                    headers: response == null ? void 0 : response.headers
                   },
                   warnings,
-                  providerMetadata,
-                  experimental_providerMetadata: providerMetadata
+                  providerMetadata
                 }));
               } catch (error2) {
                 controller.enqueue({ type: "error", error: error2 });
@@ -3603,9 +5177,6 @@ var DefaultStreamObjectResult = class {
   get usage() {
     return this.usagePromise.value;
   }
-  get experimental_providerMetadata() {
-    return this.providerMetadataPromise.value;
-  }
   get providerMetadata() {
     return this.providerMetadataPromise.value;
   }
@@ -3696,30 +5267,30 @@ var DefaultStreamObjectResult = class {
 import { createIdGenerator as createIdGenerator3 } from "@ai-sdk/provider-utils";
 
 // errors/no-output-specified-error.ts
-import { AISDKError as AISDKError9 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError10 } from "@ai-sdk/provider";
 var name9 = "AI_NoOutputSpecifiedError";
 var marker9 = `vercel.ai.error.${name9}`;
 var symbol9 = Symbol.for(marker9);
 var _a9;
-var NoOutputSpecifiedError = class extends AISDKError9 {
+var NoOutputSpecifiedError = class extends AISDKError10 {
   // used in isInstance
   constructor({ message = "No output specified." } = {}) {
     super({ name: name9, message });
     this[_a9] = true;
   }
   static isInstance(error) {
-    return AISDKError9.hasMarker(error, marker9);
+    return AISDKError10.hasMarker(error, marker9);
   }
 };
 _a9 = symbol9;
 
 // errors/tool-execution-error.ts
-import { AISDKError as AISDKError10, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError11, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
 var name10 = "AI_ToolExecutionError";
 var marker10 = `vercel.ai.error.${name10}`;
 var symbol10 = Symbol.for(marker10);
 var _a10;
-var ToolExecutionError = class extends AISDKError10 {
+var ToolExecutionError = class extends AISDKError11 {
   constructor({
     toolArgs,
     toolName,
@@ -3734,14 +5305,11 @@ var ToolExecutionError = class extends AISDKError10 {
     this.toolCallId = toolCallId;
   }
   static isInstance(error) {
-    return AISDKError10.hasMarker(error, marker10);
+    return AISDKError11.hasMarker(error, marker10);
   }
 };
 _a10 = symbol10;
 
-// core/prompt/prepare-tools-and-tool-choice.ts
-import { asSchema as asSchema2 } from "@ai-sdk/ui-utils";
-
 // core/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
   return object2 != null && Object.keys(object2).length > 0;
@@ -3772,7 +5340,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: asSchema2(tool2.parameters).jsonSchema
+            parameters: asSchema(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -3805,16 +5373,15 @@ function removeTextAfterLastWhitespace(text2) {
 }
 
 // core/generate-text/parse-tool-call.ts
-import { safeParseJSON as safeParseJSON2, safeValidateTypes as safeValidateTypes3 } from "@ai-sdk/provider-utils";
-import { asSchema as asSchema3 } from "@ai-sdk/ui-utils";
+import { safeParseJSON as safeParseJSON3, safeValidateTypes as safeValidateTypes3 } from "@ai-sdk/provider-utils";
 
 // errors/invalid-tool-arguments-error.ts
-import { AISDKError as AISDKError11, getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError12, getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
 var name11 = "AI_InvalidToolArgumentsError";
 var marker11 = `vercel.ai.error.${name11}`;
 var symbol11 = Symbol.for(marker11);
 var _a11;
-var InvalidToolArgumentsError = class extends AISDKError11 {
+var InvalidToolArgumentsError = class extends AISDKError12 {
   constructor({
     toolArgs,
     toolName,
@@ -3829,18 +5396,18 @@ var InvalidToolArgumentsError = class extends AISDKError11 {
     this.toolName = toolName;
   }
   static isInstance(error) {
-    return AISDKError11.hasMarker(error, marker11);
+    return AISDKError12.hasMarker(error, marker11);
   }
 };
 _a11 = symbol11;
 
 // errors/no-such-tool-error.ts
-import { AISDKError as AISDKError12 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError13 } from "@ai-sdk/provider";
 var name12 = "AI_NoSuchToolError";
 var marker12 = `vercel.ai.error.${name12}`;
 var symbol12 = Symbol.for(marker12);
 var _a12;
-var NoSuchToolError = class extends AISDKError12 {
+var NoSuchToolError = class extends AISDKError13 {
   constructor({
     toolName,
     availableTools = void 0,
@@ -3852,18 +5419,18 @@ var NoSuchToolError = class extends AISDKError12 {
     this.availableTools = availableTools;
   }
   static isInstance(error) {
-    return AISDKError12.hasMarker(error, marker12);
+    return AISDKError13.hasMarker(error, marker12);
   }
 };
 _a12 = symbol12;
 
 // errors/tool-call-repair-error.ts
-import { AISDKError as AISDKError13, getErrorMessage as getErrorMessage4 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError14, getErrorMessage as getErrorMessage4 } from "@ai-sdk/provider";
 var name13 = "AI_ToolCallRepairError";
 var marker13 = `vercel.ai.error.${name13}`;
 var symbol13 = Symbol.for(marker13);
 var _a13;
-var ToolCallRepairError = class extends AISDKError13 {
+var ToolCallRepairError = class extends AISDKError14 {
   constructor({
     cause,
     originalError,
@@ -3874,7 +5441,7 @@ var ToolCallRepairError = class extends AISDKError13 {
     this.originalError = originalError;
   }
   static isInstance(error) {
-    return AISDKError13.hasMarker(error, marker13);
+    return AISDKError14.hasMarker(error, marker13);
   }
 };
 _a13 = symbol13;
@@ -3901,7 +5468,10 @@ async function parseToolCall({
       repairedToolCall = await repairToolCall({
         toolCall,
         tools,
-        parameterSchema: ({ toolName }) => asSchema3(tools[toolName].parameters).jsonSchema,
+        parameterSchema: ({ toolName }) => {
+          const { parameters } = tools[toolName];
+          return asSchema(parameters).jsonSchema;
+        },
         system,
         messages,
         error
@@ -3930,8 +5500,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = asSchema3(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? safeValidateTypes3({ value: {}, schema }) : safeParseJSON2({ text: toolCall.args, schema });
+  const schema = asSchema(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? safeValidateTypes3({ value: {}, schema }) : safeParseJSON3({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -3943,11 +5513,11 @@ async function doParseToolCall({
     type: "tool-call",
     toolCallId: toolCall.toolCallId,
     toolName,
-    args: parseResult.value
+    args: parseResult == null ? void 0 : parseResult.value
   };
 }
 
-// core/generate-text/reasoning-detail.ts
+// core/generate-text/reasoning.ts
 function asReasoningText(reasoning) {
   const reasoningText = reasoning.filter((part) => part.type === "text").map((part) => part.text).join("");
   return reasoningText.length > 0 ? reasoningText : void 0;
@@ -3965,23 +5535,36 @@ function toResponseMessages({
   generateMessageId
 }) {
   const responseMessages = [];
-  responseMessages.push({
-    role: "assistant",
-    content: [
+  const content = [];
+  if (reasoning.length > 0) {
+    content.push(
       ...reasoning.map(
         (part) => part.type === "text" ? { ...part, type: "reasoning" } : { ...part, type: "redacted-reasoning" }
-      ),
-      // TODO language model v2: switch to order response content (instead of type-based ordering)
+      )
+    );
+  }
+  if (files.length > 0) {
+    content.push(
       ...files.map((file) => ({
         type: "file",
         data: file.base64,
-        mimeType: file.mimeType
-      })),
-      { type: "text", text: text2 },
-      ...toolCalls
-    ],
-    id: messageId
-  });
+        mediaType: file.mediaType
+      }))
+    );
+  }
+  if (text2.length > 0) {
+    content.push({ type: "text", text: text2 });
+  }
+  if (toolCalls.length > 0) {
+    content.push(...toolCalls);
+  }
+  if (content.length > 0) {
+    responseMessages.push({
+      role: "assistant",
+      content,
+      id: messageId
+    });
+  }
   if (toolResults.length > 0) {
     responseMessages.push({
       role: "tool",
@@ -4032,8 +5615,7 @@ async function generateText({
   experimental_output: output,
   experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
+  providerOptions,
   experimental_activeTools: activeTools,
   experimental_repairToolCall: repairToolCall,
   _internal: {
@@ -4086,9 +5668,8 @@ async function generateText({
     }),
     tracer,
     fn: async (span) => {
-      var _a18, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
-      const mode = {
-        type: "regular",
+      var _a18, _b, _c, _d;
+      const toolsAndToolChoice = {
         ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
       };
       const callSettings = prepareCallSettings(settings);
@@ -4142,17 +5723,17 @@ async function generateText({
                   // convert the language model level tools:
                   input: () => {
                     var _a19;
-                    return (_a19 = mode.tools) == null ? void 0 : _a19.map((tool2) => JSON.stringify(tool2));
+                    return (_a19 = toolsAndToolChoice.tools) == null ? void 0 : _a19.map((tool2) => JSON.stringify(tool2));
                   }
                 },
                 "ai.prompt.toolChoice": {
-                  input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
+                  input: () => toolsAndToolChoice.toolChoice != null ? JSON.stringify(toolsAndToolChoice.toolChoice) : void 0
                 },
                 // standardized gen-ai llm span attributes:
                 "gen_ai.system": model.provider,
                 "gen_ai.request.model": model.modelId,
                 "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                "gen_ai.request.max_tokens": settings.maxTokens,
+                "gen_ai.request.max_tokens": settings.maxOutputTokens,
                 "gen_ai.request.presence_penalty": settings.presencePenalty,
                 "gen_ai.request.stop_sequences": settings.stopSequences,
                 "gen_ai.request.temperature": settings.temperature,
@@ -4162,21 +5743,23 @@ async function generateText({
             }),
             tracer,
             fn: async (span2) => {
-              var _a19, _b2, _c2, _d2, _e2, _f2;
+              var _a19, _b2, _c2, _d2, _e, _f, _g, _h;
               const result = await model.doGenerate({
-                mode,
                 ...callSettings,
+                ...toolsAndToolChoice,
                 inputFormat: promptFormat,
                 responseFormat: output == null ? void 0 : output.responseFormat({ model }),
                 prompt: promptMessages,
-                providerMetadata: providerOptions,
+                providerOptions,
                 abortSignal,
                 headers
               });
               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 : model.modelId
+                modelId: (_f = (_e = result.response) == null ? void 0 : _e.modelId) != null ? _f : model.modelId,
+                headers: (_g = result.response) == null ? void 0 : _g.headers,
+                body: (_h = result.response) == null ? void 0 : _h.body
               };
               span2.setAttributes(
                 selectTelemetryAttributes({
@@ -4184,22 +5767,26 @@ async function generateText({
                   attributes: {
                     "ai.response.finishReason": result.finishReason,
                     "ai.response.text": {
-                      output: () => result.text
+                      output: () => extractContentText(result.content)
                     },
                     "ai.response.toolCalls": {
-                      output: () => JSON.stringify(result.toolCalls)
+                      output: () => {
+                        const toolCalls = asToolCalls(result.content);
+                        return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+                      }
                     },
                     "ai.response.id": responseData.id,
                     "ai.response.model": responseData.modelId,
                     "ai.response.timestamp": responseData.timestamp.toISOString(),
-                    "ai.usage.promptTokens": result.usage.promptTokens,
-                    "ai.usage.completionTokens": result.usage.completionTokens,
+                    // TODO rename telemetry attributes to inputTokens and outputTokens
+                    "ai.usage.promptTokens": result.usage.inputTokens,
+                    "ai.usage.completionTokens": result.usage.outputTokens,
                     // standardized gen-ai llm span attributes:
                     "gen_ai.response.finish_reasons": [result.finishReason],
                     "gen_ai.response.id": responseData.id,
                     "gen_ai.response.model": responseData.modelId,
-                    "gen_ai.usage.input_tokens": result.usage.promptTokens,
-                    "gen_ai.usage.output_tokens": result.usage.completionTokens
+                    "gen_ai.usage.input_tokens": result.usage.inputTokens,
+                    "gen_ai.usage.output_tokens": result.usage.outputTokens
                   }
                 })
               );
@@ -4208,7 +5795,9 @@ async function generateText({
           })
         );
         currentToolCalls = await Promise.all(
-          ((_b = currentModelResponse.toolCalls) != null ? _b : []).map(
+          currentModelResponse.content.filter(
+            (part) => part.type === "tool-call"
+          ).map(
             (toolCall) => parseToolCall({
               toolCall,
               tools,
@@ -4226,7 +5815,7 @@ async function generateText({
           messages: stepInputMessages,
           abortSignal
         });
-        const currentUsage = calculateLanguageModelUsage(
+        const currentUsage = calculateLanguageModelUsage2(
           currentModelResponse.usage
         );
         usage = addLanguageModelUsage(usage, currentUsage);
@@ -4243,15 +5832,19 @@ async function generateText({
             nextStepType = "tool-result";
           }
         }
-        const originalText = (_c = currentModelResponse.text) != null ? _c : "";
+        const originalText = (_b = extractContentText(currentModelResponse.content)) != null ? _b : "";
         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;
         currentReasoningDetails = asReasoningDetails(
-          currentModelResponse.reasoning
+          currentModelResponse.content
+        );
+        sources.push(
+          ...currentModelResponse.content.filter(
+            (part) => part.type === "source"
+          )
         );
-        sources.push(...(_d = currentModelResponse.sources) != null ? _d : []);
         if (stepType === "continue") {
           const lastMessage = responseMessages[responseMessages.length - 1];
           if (typeof lastMessage.content === "string") {
@@ -4266,8 +5859,8 @@ async function generateText({
           responseMessages.push(
             ...toResponseMessages({
               text: text2,
-              files: asFiles(currentModelResponse.files),
-              reasoning: asReasoningDetails(currentModelResponse.reasoning),
+              files: asFiles(currentModelResponse.content),
+              reasoning: asReasoningDetails(currentModelResponse.content),
               tools: tools != null ? tools : {},
               toolCalls: currentToolCalls,
               toolResults: currentToolResults,
@@ -4279,27 +5872,25 @@ async function generateText({
         const currentStepResult = {
           stepType,
           text: stepText,
-          // TODO v5: rename reasoning to reasoningText (and use reasoning for composite array)
-          reasoning: asReasoningText(currentReasoningDetails),
-          reasoningDetails: currentReasoningDetails,
-          files: asFiles(currentModelResponse.files),
-          sources: (_e = currentModelResponse.sources) != null ? _e : [],
+          reasoningText: asReasoningText(currentReasoningDetails),
+          reasoning: currentReasoningDetails,
+          files: asFiles(currentModelResponse.content),
+          sources: currentModelResponse.content.filter(
+            (part) => part.type === "source"
+          ),
           toolCalls: currentToolCalls,
           toolResults: currentToolResults,
           finishReason: currentModelResponse.finishReason,
           usage: currentUsage,
           warnings: currentModelResponse.warnings,
           logprobs: currentModelResponse.logprobs,
-          request: (_f = currentModelResponse.request) != null ? _f : {},
+          request: (_c = currentModelResponse.request) != null ? _c : {},
           response: {
             ...currentModelResponse.response,
-            headers: (_g = currentModelResponse.rawResponse) == null ? void 0 : _g.headers,
-            body: (_h = currentModelResponse.rawResponse) == null ? void 0 : _h.body,
             // deep clone msgs to avoid mutating past messages in multi-step:
             messages: structuredClone(responseMessages)
           },
           providerMetadata: currentModelResponse.providerMetadata,
-          experimental_providerMetadata: currentModelResponse.providerMetadata,
           isContinued: nextStepType === "continue"
         };
         steps.push(currentStepResult);
@@ -4312,19 +5903,23 @@ async function generateText({
           attributes: {
             "ai.response.finishReason": currentModelResponse.finishReason,
             "ai.response.text": {
-              output: () => currentModelResponse.text
+              output: () => extractContentText(currentModelResponse.content)
             },
             "ai.response.toolCalls": {
-              output: () => JSON.stringify(currentModelResponse.toolCalls)
+              output: () => {
+                const toolCalls = asToolCalls(currentModelResponse.content);
+                return toolCalls == null ? void 0 : JSON.stringify(toolCalls);
+              }
             },
-            "ai.usage.promptTokens": currentModelResponse.usage.promptTokens,
-            "ai.usage.completionTokens": currentModelResponse.usage.completionTokens
+            // TODO rename telemetry attributes to inputTokens and outputTokens
+            "ai.usage.promptTokens": currentModelResponse.usage.inputTokens,
+            "ai.usage.completionTokens": currentModelResponse.usage.outputTokens
           }
         })
       );
       return new DefaultGenerateTextResult({
         text: text2,
-        files: asFiles(currentModelResponse.files),
+        files: asFiles(currentModelResponse.content),
         reasoning: asReasoningText(currentReasoningDetails),
         reasoningDetails: currentReasoningDetails,
         sources,
@@ -4346,11 +5941,9 @@ async function generateText({
         finishReason: currentModelResponse.finishReason,
         usage,
         warnings: currentModelResponse.warnings,
-        request: (_i = currentModelResponse.request) != null ? _i : {},
+        request: (_d = currentModelResponse.request) != null ? _d : {},
         response: {
           ...currentModelResponse.response,
-          headers: (_j = currentModelResponse.rawResponse) == null ? void 0 : _j.headers,
-          body: (_k = currentModelResponse.rawResponse) == null ? void 0 : _k.body,
           messages: responseMessages
         },
         logprobs: currentModelResponse.logprobs,
@@ -4439,8 +6032,8 @@ var DefaultGenerateTextResult = class {
   constructor(options) {
     this.text = options.text;
     this.files = options.files;
-    this.reasoning = options.reasoning;
-    this.reasoningDetails = options.reasoningDetails;
+    this.reasoningText = options.reasoning;
+    this.reasoning = options.reasoningDetails;
     this.toolCalls = options.toolCalls;
     this.toolResults = options.toolResults;
     this.finishReason = options.finishReason;
@@ -4449,7 +6042,6 @@ var DefaultGenerateTextResult = class {
     this.request = options.request;
     this.response = options.response;
     this.steps = options.steps;
-    this.experimental_providerMetadata = options.providerMetadata;
     this.providerMetadata = options.providerMetadata;
     this.logprobs = options.logprobs;
     this.outputResolver = options.outputResolver;
@@ -4459,18 +6051,50 @@ var DefaultGenerateTextResult = class {
     return this.outputResolver();
   }
 };
-function asReasoningDetails(reasoning) {
-  if (reasoning == null) {
+function asReasoningDetails(content) {
+  const reasoning = content.filter((part) => part.type === "reasoning");
+  if (reasoning.length === 0) {
     return [];
   }
-  if (typeof reasoning === "string") {
-    return [{ type: "text", text: reasoning }];
+  const result = [];
+  let activeReasoningText;
+  for (const part of reasoning) {
+    if (part.reasoningType === "text") {
+      if (activeReasoningText == null) {
+        activeReasoningText = { type: "text", text: part.text };
+        result.push(activeReasoningText);
+      } else {
+        activeReasoningText.text += part.text;
+      }
+    } else if (part.reasoningType === "signature") {
+      if (activeReasoningText == null) {
+        activeReasoningText = { type: "text", text: "" };
+        result.push(activeReasoningText);
+      }
+      activeReasoningText.signature = part.signature;
+      activeReasoningText = void 0;
+    } else if (part.reasoningType === "redacted") {
+      result.push({ type: "redacted", data: part.data });
+    }
   }
-  return reasoning;
+  return result;
 }
-function asFiles(files) {
-  var _a17;
-  return (_a17 = files == null ? void 0 : files.map((file) => new DefaultGeneratedFile(file))) != null ? _a17 : [];
+function asFiles(content) {
+  return content.filter((part) => part.type === "file").map((part) => new DefaultGeneratedFile(part));
+}
+function asToolCalls(content) {
+  const parts = content.filter(
+    (part) => part.type === "tool-call"
+  );
+  if (parts.length === 0) {
+    return void 0;
+  }
+  return parts.map((toolCall) => ({
+    toolCallType: toolCall.toolCallType,
+    toolCallId: toolCall.toolCallId,
+    toolName: toolCall.toolName,
+    args: toolCall.args
+  }));
 }
 
 // core/generate-text/output.ts
@@ -4479,15 +6103,11 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-import { safeParseJSON as safeParseJSON3, safeValidateTypes as safeValidateTypes4 } from "@ai-sdk/provider-utils";
-import {
-  asSchema as asSchema4,
-  parsePartialJson as parsePartialJson2
-} from "@ai-sdk/ui-utils";
+import { safeParseJSON as safeParseJSON4, safeValidateTypes as safeValidateTypes4 } from "@ai-sdk/provider-utils";
 
 // errors/index.ts
 import {
-  AISDKError as AISDKError16,
+  AISDKError as AISDKError17,
   APICallError as APICallError2,
   EmptyResponseBodyError,
   InvalidPromptError as InvalidPromptError2,
@@ -4501,12 +6121,12 @@ import {
 } from "@ai-sdk/provider";
 
 // errors/invalid-stream-part-error.ts
-import { AISDKError as AISDKError14 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError15 } from "@ai-sdk/provider";
 var name14 = "AI_InvalidStreamPartError";
 var marker14 = `vercel.ai.error.${name14}`;
 var symbol14 = Symbol.for(marker14);
 var _a14;
-var InvalidStreamPartError = class extends AISDKError14 {
+var InvalidStreamPartError = class extends AISDKError15 {
   constructor({
     chunk,
     message
@@ -4516,18 +6136,18 @@ var InvalidStreamPartError = class extends AISDKError14 {
     this.chunk = chunk;
   }
   static isInstance(error) {
-    return AISDKError14.hasMarker(error, marker14);
+    return AISDKError15.hasMarker(error, marker14);
   }
 };
 _a14 = symbol14;
 
 // errors/mcp-client-error.ts
-import { AISDKError as AISDKError15 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError16 } from "@ai-sdk/provider";
 var name15 = "AI_MCPClientError";
 var marker15 = `vercel.ai.error.${name15}`;
 var symbol15 = Symbol.for(marker15);
 var _a15;
-var MCPClientError = class extends AISDKError15 {
+var MCPClientError = class extends AISDKError16 {
   constructor({
     name: name17 = "MCPClientError",
     message,
@@ -4537,7 +6157,7 @@ var MCPClientError = class extends AISDKError15 {
     this[_a15] = true;
   }
   static isInstance(error) {
-    return AISDKError15.hasMarker(error, marker15);
+    return AISDKError16.hasMarker(error, marker15);
   }
 };
 _a15 = symbol15;
@@ -4559,7 +6179,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = asSchema4(inputSchema);
+  const schema = asSchema(inputSchema);
   return {
     type: "object",
     responseFormat: ({ model }) => ({
@@ -4573,7 +6193,7 @@ var object = ({
       });
     },
     parsePartial({ text: text2 }) {
-      const result = parsePartialJson2(text2);
+      const result = parsePartialJson(text2);
       switch (result.state) {
         case "failed-parse":
         case "undefined-input":
@@ -4591,7 +6211,7 @@ var object = ({
       }
     },
     parseOutput({ text: text2 }, context) {
-      const parseResult = safeParseJSON3({ text: text2 });
+      const parseResult = safeParseJSON4({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -4670,18 +6290,18 @@ function smoothStream({
     let buffer = "";
     return new TransformStream({
       async transform(chunk, controller) {
-        if (chunk.type !== "text-delta") {
+        if (chunk.type !== "text") {
           if (buffer.length > 0) {
-            controller.enqueue({ type: "text-delta", textDelta: buffer });
+            controller.enqueue({ type: "text", text: buffer });
             buffer = "";
           }
           controller.enqueue(chunk);
           return;
         }
-        buffer += chunk.textDelta;
+        buffer += chunk.text;
         let match;
         while ((match = detectChunk(buffer)) != null) {
-          controller.enqueue({ type: "text-delta", textDelta: match });
+          controller.enqueue({ type: "text", text: match });
           buffer = buffer.slice(match.length);
           await delay2(delayInMs);
         }
@@ -4691,15 +6311,35 @@ function smoothStream({
 }
 
 // core/generate-text/stream-text.ts
-import { AISDKError as AISDKError17 } from "@ai-sdk/provider";
+import {
+  AISDKError as AISDKError18
+} from "@ai-sdk/provider";
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
-import { formatDataStreamPart as formatDataStreamPart2 } from "@ai-sdk/ui-utils";
 
 // util/as-array.ts
 function asArray(value) {
   return value === void 0 ? [] : Array.isArray(value) ? value : [value];
 }
 
+// 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/util/merge-streams.ts
 function mergeStreams(stream1, stream2) {
   const reader1 = stream1.getReader();
@@ -4789,7 +6429,6 @@ function mergeStreams(stream1, stream2) {
 }
 
 // core/generate-text/run-tools-transformation.ts
-import { generateId } from "@ai-sdk/ui-utils";
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -4823,10 +6462,9 @@ function runToolsTransformation({
     async transform(chunk, controller) {
       const chunkType = chunk.type;
       switch (chunkType) {
-        case "text-delta":
+        case "stream-start":
+        case "text":
         case "reasoning":
-        case "reasoning-signature":
-        case "redacted-reasoning":
         case "source":
         case "response-metadata":
         case "error": {
@@ -4834,12 +6472,13 @@ function runToolsTransformation({
           break;
         }
         case "file": {
-          controller.enqueue(
-            new DefaultGeneratedFileWithType({
+          controller.enqueue({
+            type: "file",
+            file: new DefaultGeneratedFileWithType({
               data: chunk.data,
-              mimeType: chunk.mimeType
+              mediaType: chunk.mediaType
             })
-          );
+          });
           break;
         }
         case "tool-call-delta": {
@@ -4948,8 +6587,8 @@ function runToolsTransformation({
             type: "finish",
             finishReason: chunk.finishReason,
             logprobs: chunk.logprobs,
-            usage: calculateLanguageModelUsage(chunk.usage),
-            experimental_providerMetadata: chunk.providerMetadata
+            usage: calculateLanguageModelUsage2(chunk.usage),
+            providerMetadata: chunk.providerMetadata
           };
           break;
         }
@@ -5015,8 +6654,7 @@ function streamText({
   experimental_output: output,
   experimental_continueSteps: continueSteps = false,
   experimental_telemetry: telemetry,
-  experimental_providerMetadata,
-  providerOptions = experimental_providerMetadata,
+  providerOptions,
   experimental_toolCallStreaming = false,
   toolCallStreaming = experimental_toolCallStreaming,
   experimental_activeTools: activeTools,
@@ -5079,7 +6717,7 @@ function createOutputTransformStream(output) {
     partialOutput = void 0
   }) {
     controller.enqueue({
-      part: { type: "text-delta", textDelta: textChunk },
+      part: { type: "text", text: textChunk },
       partialOutput
     });
     textChunk = "";
@@ -5089,12 +6727,12 @@ function createOutputTransformStream(output) {
       if (chunk.type === "step-finish") {
         publishTextChunk({ controller });
       }
-      if (chunk.type !== "text-delta") {
+      if (chunk.type !== "text") {
         controller.enqueue({ part: chunk, partialOutput: void 0 });
         return;
       }
-      text2 += chunk.textDelta;
-      textChunk += chunk.textDelta;
+      text2 += chunk.text;
+      textChunk += chunk.text;
       const result = output.parsePartial({ text: text2 });
       if (result != null) {
         const currentJson = JSON.stringify(result.partial);
@@ -5189,44 +6827,44 @@ var DefaultStreamTextResult = class {
       async transform(chunk, controller) {
         controller.enqueue(chunk);
         const { part } = chunk;
-        if (part.type === "text-delta" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") {
+        if (part.type === "text" || part.type === "reasoning" || part.type === "source" || part.type === "tool-call" || part.type === "tool-result" || part.type === "tool-call-streaming-start" || part.type === "tool-call-delta") {
           await (onChunk == null ? void 0 : onChunk({ chunk: part }));
         }
         if (part.type === "error") {
           await (onError == null ? void 0 : onError({ error: part.error }));
         }
-        if (part.type === "text-delta") {
-          recordedStepText += part.textDelta;
-          recordedContinuationText += part.textDelta;
-          recordedFullText += part.textDelta;
+        if (part.type === "text") {
+          recordedStepText += part.text;
+          recordedContinuationText += part.text;
+          recordedFullText += part.text;
         }
         if (part.type === "reasoning") {
-          if (activeReasoningText == null) {
-            activeReasoningText = { type: "text", text: part.textDelta };
-            stepReasoning.push(activeReasoningText);
-          } else {
-            activeReasoningText.text += part.textDelta;
-          }
-        }
-        if (part.type === "reasoning-signature") {
-          if (activeReasoningText == null) {
-            throw new AISDKError17({
-              name: "InvalidStreamPart",
-              message: "reasoning-signature without reasoning"
-            });
+          if (part.reasoningType === "text") {
+            if (activeReasoningText == null) {
+              activeReasoningText = { type: "text", text: part.text };
+              stepReasoning.push(activeReasoningText);
+            } else {
+              activeReasoningText.text += part.text;
+            }
+          } else if (part.reasoningType === "signature") {
+            if (activeReasoningText == null) {
+              throw new AISDKError18({
+                name: "InvalidStreamPart",
+                message: "reasoning-signature without reasoning"
+              });
+            }
+            activeReasoningText.signature = part.signature;
+            activeReasoningText = void 0;
+          } else if (part.reasoningType === "redacted") {
+            stepReasoning.push({ type: "redacted", data: part.data });
           }
-          activeReasoningText.signature = part.signature;
-          activeReasoningText = void 0;
-        }
-        if (part.type === "redacted-reasoning") {
-          stepReasoning.push({ type: "redacted", data: part.data });
         }
         if (part.type === "file") {
-          stepFiles.push(part);
+          stepFiles.push(part.file);
         }
         if (part.type === "source") {
-          recordedSources.push(part.source);
-          recordedStepSources.push(part.source);
+          recordedSources.push(part);
+          recordedStepSources.push(part);
         }
         if (part.type === "tool-call") {
           recordedToolCalls.push(part);
@@ -5262,8 +6900,8 @@ var DefaultStreamTextResult = class {
           const currentStepResult = {
             stepType,
             text: recordedStepText,
-            reasoning: asReasoningText(stepReasoning),
-            reasoningDetails: stepReasoning,
+            reasoningText: asReasoningText(stepReasoning),
+            reasoning: stepReasoning,
             files: stepFiles,
             sources: recordedStepSources,
             toolCalls: recordedToolCalls,
@@ -5277,8 +6915,7 @@ var DefaultStreamTextResult = class {
               ...part.response,
               messages: [...recordedResponse.messages, ...stepMessages]
             },
-            providerMetadata: part.experimental_providerMetadata,
-            experimental_providerMetadata: part.experimental_providerMetadata,
+            providerMetadata: part.providerMetadata,
             isContinued: part.isContinued
           };
           await (onStepFinish == null ? void 0 : onStepFinish(currentStepResult));
@@ -5319,11 +6956,9 @@ var DefaultStreamTextResult = class {
           self.responsePromise.resolve(lastStep.response);
           self.toolCallsPromise.resolve(lastStep.toolCalls);
           self.toolResultsPromise.resolve(lastStep.toolResults);
-          self.providerMetadataPromise.resolve(
-            lastStep.experimental_providerMetadata
-          );
-          self.reasoningPromise.resolve(lastStep.reasoning);
-          self.reasoningDetailsPromise.resolve(lastStep.reasoningDetails);
+          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 : {
             completionTokens: NaN,
@@ -5341,8 +6976,8 @@ var DefaultStreamTextResult = class {
             logprobs: void 0,
             usage,
             text: recordedFullText,
+            reasoningText: lastStep.reasoningText,
             reasoning: lastStep.reasoning,
-            reasoningDetails: lastStep.reasoningDetails,
             files: lastStep.files,
             sources: lastStep.sources,
             toolCalls: lastStep.toolCalls,
@@ -5351,7 +6986,6 @@ var DefaultStreamTextResult = class {
             response: lastStep.response,
             warnings: lastStep.warnings,
             providerMetadata: lastStep.providerMetadata,
-            experimental_providerMetadata: lastStep.experimental_providerMetadata,
             steps: recordedSteps
           }));
           rootSpan.setAttributes(
@@ -5455,12 +7089,11 @@ var DefaultStreamTextResult = class {
             modelSupportsUrl: (_a18 = model.supportsUrl) == null ? void 0 : _a18.bind(model)
             // support 'this' context
           });
-          const mode = {
-            type: "regular",
+          const toolsAndToolChoice = {
             ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
           };
           const {
-            result: { stream: stream2, warnings, rawResponse, request },
+            result: { stream: stream2, response, request },
             doStreamSpan,
             startTimestampMs
           } = await retry(
@@ -5484,17 +7117,19 @@ var DefaultStreamTextResult = class {
                     // convert the language model level tools:
                     input: () => {
                       var _a19;
-                      return (_a19 = mode.tools) == null ? void 0 : _a19.map((tool2) => JSON.stringify(tool2));
+                      return (_a19 = toolsAndToolChoice.tools) == null ? void 0 : _a19.map(
+                        (tool2) => JSON.stringify(tool2)
+                      );
                     }
                   },
                   "ai.prompt.toolChoice": {
-                    input: () => mode.toolChoice != null ? JSON.stringify(mode.toolChoice) : void 0
+                    input: () => toolsAndToolChoice.toolChoice != null ? JSON.stringify(toolsAndToolChoice.toolChoice) : void 0
                   },
                   // standardized gen-ai llm span attributes:
                   "gen_ai.system": model.provider,
                   "gen_ai.request.model": model.modelId,
                   "gen_ai.request.frequency_penalty": settings.frequencyPenalty,
-                  "gen_ai.request.max_tokens": settings.maxTokens,
+                  "gen_ai.request.max_tokens": settings.maxOutputTokens,
                   "gen_ai.request.presence_penalty": settings.presencePenalty,
                   "gen_ai.request.stop_sequences": settings.stopSequences,
                   "gen_ai.request.temperature": settings.temperature,
@@ -5509,12 +7144,12 @@ var DefaultStreamTextResult = class {
                 // get before the call
                 doStreamSpan: doStreamSpan2,
                 result: await model.doStream({
-                  mode,
                   ...prepareCallSettings(settings),
+                  ...toolsAndToolChoice,
                   inputFormat: promptFormat,
                   responseFormat: output == null ? void 0 : output.responseFormat({ model }),
                   prompt: promptMessages,
-                  providerMetadata: providerOptions,
+                  providerOptions,
                   abortSignal,
                   headers
                 })
@@ -5535,6 +7170,7 @@ var DefaultStreamTextResult = class {
           const stepRequest = request != null ? request : {};
           const stepToolCalls = [];
           const stepToolResults = [];
+          let warnings;
           const stepReasoning2 = [];
           const stepFiles2 = [];
           let activeReasoningText2 = void 0;
@@ -5563,16 +7199,20 @@ var DefaultStreamTextResult = class {
             chunk
           }) {
             controller.enqueue(chunk);
-            stepText += chunk.textDelta;
-            fullStepText += chunk.textDelta;
+            stepText += chunk.text;
+            fullStepText += chunk.text;
             chunkTextPublished = true;
-            hasWhitespaceSuffix = chunk.textDelta.trimEnd() !== chunk.textDelta;
+            hasWhitespaceSuffix = chunk.text.trimEnd() !== chunk.text;
           }
           self.addStream(
             transformedStream.pipeThrough(
               new TransformStream({
                 async transform(chunk, controller) {
                   var _a19, _b, _c;
+                  if (chunk.type === "stream-start") {
+                    warnings = chunk.warnings;
+                    return;
+                  }
                   if (stepFirstChunk) {
                     const msToFirstChunk = now2() - startTimestampMs;
                     stepFirstChunk = false;
@@ -5589,14 +7229,14 @@ var DefaultStreamTextResult = class {
                       warnings: warnings != null ? warnings : []
                     });
                   }
-                  if (chunk.type === "text-delta" && chunk.textDelta.length === 0) {
+                  if (chunk.type === "text" && chunk.text.length === 0) {
                     return;
                   }
                   const chunkType = chunk.type;
                   switch (chunkType) {
-                    case "text-delta": {
+                    case "text": {
                       if (continueSteps) {
-                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.textDelta.trimStart() : chunk.textDelta;
+                        const trimmedChunkText = inWhitespacePrefix && hasLeadingWhitespace ? chunk.text.trimStart() : chunk.text;
                         if (trimmedChunkText.length === 0) {
                           break;
                         }
@@ -5608,8 +7248,8 @@ var DefaultStreamTextResult = class {
                           await publishTextChunk({
                             controller,
                             chunk: {
-                              type: "text-delta",
-                              textDelta: split.prefix + split.whitespace
+                              type: "text",
+                              text: split.prefix + split.whitespace
                             }
                           });
                         }
@@ -5620,35 +7260,31 @@ var DefaultStreamTextResult = class {
                     }
                     case "reasoning": {
                       controller.enqueue(chunk);
-                      if (activeReasoningText2 == null) {
-                        activeReasoningText2 = {
-                          type: "text",
-                          text: chunk.textDelta
-                        };
-                        stepReasoning2.push(activeReasoningText2);
-                      } else {
-                        activeReasoningText2.text += chunk.textDelta;
-                      }
-                      break;
-                    }
-                    case "reasoning-signature": {
-                      controller.enqueue(chunk);
-                      if (activeReasoningText2 == null) {
-                        throw new InvalidStreamPartError({
-                          chunk,
-                          message: "reasoning-signature without reasoning"
+                      if (chunk.reasoningType === "text") {
+                        if (activeReasoningText2 == null) {
+                          activeReasoningText2 = {
+                            type: "text",
+                            text: chunk.text
+                          };
+                          stepReasoning2.push(activeReasoningText2);
+                        } else {
+                          activeReasoningText2.text += chunk.text;
+                        }
+                      } else if (chunk.reasoningType === "signature") {
+                        if (activeReasoningText2 == null) {
+                          throw new InvalidStreamPartError({
+                            chunk,
+                            message: "reasoning-signature without reasoning"
+                          });
+                        }
+                        activeReasoningText2.signature = chunk.signature;
+                        activeReasoningText2 = void 0;
+                      } else if (chunk.reasoningType === "redacted") {
+                        stepReasoning2.push({
+                          type: "redacted",
+                          data: chunk.data
                         });
                       }
-                      activeReasoningText2.signature = chunk.signature;
-                      activeReasoningText2 = void 0;
-                      break;
-                    }
-                    case "redacted-reasoning": {
-                      controller.enqueue(chunk);
-                      stepReasoning2.push({
-                        type: "redacted",
-                        data: chunk.data
-                      });
                       break;
                     }
                     case "tool-call": {
@@ -5672,7 +7308,7 @@ var DefaultStreamTextResult = class {
                     case "finish": {
                       stepUsage = chunk.usage;
                       stepFinishReason = chunk.finishReason;
-                      stepProviderMetadata = chunk.experimental_providerMetadata;
+                      stepProviderMetadata = chunk.providerMetadata;
                       stepLogProbs = chunk.logprobs;
                       const msToFinish = now2() - startTimestampMs;
                       doStreamSpan.addEvent("ai.stream.finish");
@@ -5683,7 +7319,7 @@ var DefaultStreamTextResult = class {
                       break;
                     }
                     case "file": {
-                      stepFiles2.push(chunk);
+                      stepFiles2.push(chunk.file);
                       controller.enqueue(chunk);
                       break;
                     }
@@ -5724,10 +7360,7 @@ var DefaultStreamTextResult = class {
                   stepType2 === "continue" && !chunkTextPublished)) {
                     await publishTextChunk({
                       controller,
-                      chunk: {
-                        type: "text-delta",
-                        textDelta: chunkBuffer
-                      }
+                      chunk: { type: "text", text: chunkBuffer }
                     });
                     chunkBuffer = "";
                   }
@@ -5764,12 +7397,11 @@ var DefaultStreamTextResult = class {
                     finishReason: stepFinishReason,
                     usage: stepUsage,
                     providerMetadata: stepProviderMetadata,
-                    experimental_providerMetadata: stepProviderMetadata,
                     logprobs: stepLogProbs,
                     request: stepRequest,
                     response: {
                       ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers
+                      headers: response == null ? void 0 : response.headers
                     },
                     warnings,
                     isContinued: nextStepType === "continue",
@@ -5782,11 +7414,10 @@ var DefaultStreamTextResult = class {
                       finishReason: stepFinishReason,
                       usage: combinedUsage,
                       providerMetadata: stepProviderMetadata,
-                      experimental_providerMetadata: stepProviderMetadata,
                       logprobs: stepLogProbs,
                       response: {
                         ...stepResponse,
-                        headers: rawResponse == null ? void 0 : rawResponse.headers
+                        headers: response == null ? void 0 : response.headers
                       }
                     });
                     self.closeStream();
@@ -5868,19 +7499,16 @@ var DefaultStreamTextResult = class {
   get finishReason() {
     return this.finishReasonPromise.value;
   }
-  get experimental_providerMetadata() {
-    return this.providerMetadataPromise.value;
-  }
   get providerMetadata() {
     return this.providerMetadataPromise.value;
   }
   get text() {
     return this.textPromise.value;
   }
-  get reasoning() {
+  get reasoningText() {
     return this.reasoningPromise.value;
   }
-  get reasoningDetails() {
+  get reasoning() {
     return this.reasoningDetailsPromise.value;
   }
   get sources() {
@@ -5922,8 +7550,8 @@ var DefaultStreamTextResult = class {
       this.teeStream().pipeThrough(
         new TransformStream({
           transform({ part }, controller) {
-            if (part.type === "text-delta") {
-              controller.enqueue(part.textDelta);
+            if (part.type === "text") {
+              controller.enqueue(part.text);
             }
           }
         })
@@ -5941,9 +7569,15 @@ var DefaultStreamTextResult = class {
       )
     );
   }
-  async consumeStream() {
-    const stream = this.fullStream;
-    for await (const part of stream) {
+  async consumeStream(options) {
+    var _a17;
+    try {
+      await consumeStream({
+        stream: this.fullStream,
+        onError: options == null ? void 0 : options.onError
+      });
+    } catch (error) {
+      (_a17 = options == null ? void 0 : options.onError) == null ? void 0 : _a17.call(options, error);
     }
   }
   get experimental_partialOutputStream() {
@@ -5975,58 +7609,51 @@ var DefaultStreamTextResult = class {
         transform: async (chunk, controller) => {
           const chunkType = chunk.type;
           switch (chunkType) {
-            case "text-delta": {
-              controller.enqueue(formatDataStreamPart2("text", chunk.textDelta));
+            case "text": {
+              controller.enqueue(formatDataStreamPart("text", chunk.text));
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart2("reasoning", chunk.textDelta)
-                );
-              }
-              break;
-            }
-            case "redacted-reasoning": {
-              if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart2("redacted_reasoning", {
-                    data: chunk.data
-                  })
-                );
-              }
-              break;
-            }
-            case "reasoning-signature": {
-              if (sendReasoning) {
-                controller.enqueue(
-                  formatDataStreamPart2("reasoning_signature", {
-                    signature: chunk.signature
-                  })
-                );
+                if (chunk.reasoningType === "text") {
+                  controller.enqueue(
+                    formatDataStreamPart("reasoning", chunk.text)
+                  );
+                } else if (chunk.reasoningType === "signature") {
+                  controller.enqueue(
+                    formatDataStreamPart("reasoning_signature", {
+                      signature: chunk.signature
+                    })
+                  );
+                } else if (chunk.reasoningType === "redacted") {
+                  controller.enqueue(
+                    formatDataStreamPart("redacted_reasoning", {
+                      data: chunk.data
+                    })
+                  );
+                }
               }
               break;
             }
             case "file": {
               controller.enqueue(
-                formatDataStreamPart2("file", {
-                  mimeType: chunk.mimeType,
-                  data: chunk.base64
+                // TODO update protocol to v2 or replace with event stream
+                formatDataStreamPart("file", {
+                  mimeType: chunk.file.mediaType,
+                  data: chunk.file.base64
                 })
               );
               break;
             }
             case "source": {
               if (sendSources) {
-                controller.enqueue(
-                  formatDataStreamPart2("source", chunk.source)
-                );
+                controller.enqueue(formatDataStreamPart("source", chunk));
               }
               break;
             }
             case "tool-call-streaming-start": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call_streaming_start", {
+                formatDataStreamPart("tool_call_streaming_start", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName
                 })
@@ -6035,7 +7662,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call-delta": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call_delta", {
+                formatDataStreamPart("tool_call_delta", {
                   toolCallId: chunk.toolCallId,
                   argsTextDelta: chunk.argsTextDelta
                 })
@@ -6044,7 +7671,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call", {
+                formatDataStreamPart("tool_call", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName,
                   args: chunk.args
@@ -6054,7 +7681,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-result": {
               controller.enqueue(
-                formatDataStreamPart2("tool_result", {
+                formatDataStreamPart("tool_result", {
                   toolCallId: chunk.toolCallId,
                   result: chunk.result
                 })
@@ -6063,13 +7690,13 @@ var DefaultStreamTextResult = class {
             }
             case "error": {
               controller.enqueue(
-                formatDataStreamPart2("error", getErrorMessage5(chunk.error))
+                formatDataStreamPart("error", getErrorMessage5(chunk.error))
               );
               break;
             }
             case "step-start": {
               controller.enqueue(
-                formatDataStreamPart2("start_step", {
+                formatDataStreamPart("start_step", {
                   messageId: chunk.messageId
                 })
               );
@@ -6077,7 +7704,7 @@ var DefaultStreamTextResult = class {
             }
             case "step-finish": {
               controller.enqueue(
-                formatDataStreamPart2("finish_step", {
+                formatDataStreamPart("finish_step", {
                   finishReason: chunk.finishReason,
                   usage: sendUsage ? {
                     promptTokens: chunk.usage.promptTokens,
@@ -6091,7 +7718,7 @@ var DefaultStreamTextResult = class {
             case "finish": {
               if (experimental_sendFinish) {
                 controller.enqueue(
-                  formatDataStreamPart2("finish_message", {
+                  formatDataStreamPart("finish_message", {
                     finishReason: chunk.finishReason,
                     usage: sendUsage ? {
                       promptTokens: chunk.usage.promptTokens,
@@ -6214,6 +7841,160 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// errors/no-speech-generated-error.ts
+import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
+var NoSpeechGeneratedError = class extends AISDKError19 {
+  constructor(options) {
+    super({
+      name: "AI_NoSpeechGeneratedError",
+      message: "No speech audio generated."
+    });
+    this.responses = options.responses;
+  }
+};
+
+// core/generate-speech/generated-audio-file.ts
+var DefaultGeneratedAudioFile = class extends DefaultGeneratedFile {
+  constructor({
+    data,
+    mediaType
+  }) {
+    super({ data, mediaType });
+    let format = "mp3";
+    if (mediaType) {
+      const mimeTypeParts = mediaType.split("/");
+      if (mimeTypeParts.length === 2) {
+        if (mediaType !== "audio/mpeg") {
+          format = mimeTypeParts[1];
+        }
+      }
+    }
+    if (!format) {
+      throw new Error(
+        "Audio format must be provided or determinable from mimeType"
+      );
+    }
+    this.format = format;
+  }
+};
+
+// core/generate-speech/generate-speech.ts
+async function generateSpeech({
+  model,
+  text: text2,
+  voice,
+  outputFormat,
+  instructions,
+  speed,
+  providerOptions = {},
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers
+}) {
+  var _a17;
+  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const result = await retry(
+    () => model.doGenerate({
+      text: text2,
+      voice,
+      outputFormat,
+      instructions,
+      speed,
+      abortSignal,
+      headers,
+      providerOptions
+    })
+  );
+  if (!result.audio || result.audio.length === 0) {
+    throw new NoSpeechGeneratedError({ responses: [result.response] });
+  }
+  return new DefaultSpeechResult({
+    audio: new DefaultGeneratedAudioFile({
+      data: result.audio,
+      mediaType: (_a17 = detectMediaType({
+        data: result.audio,
+        signatures: audioMediaTypeSignatures
+      })) != null ? _a17 : "audio/mp3"
+    }),
+    warnings: result.warnings,
+    responses: [result.response],
+    providerMetadata: result.providerMetadata
+  });
+}
+var DefaultSpeechResult = class {
+  constructor(options) {
+    var _a17;
+    this.audio = options.audio;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = (_a17 = options.providerMetadata) != null ? _a17 : {};
+  }
+};
+
+// errors/no-transcript-generated-error.ts
+import { AISDKError as AISDKError20 } from "@ai-sdk/provider";
+var NoTranscriptGeneratedError = class extends AISDKError20 {
+  constructor(options) {
+    super({
+      name: "AI_NoTranscriptGeneratedError",
+      message: "No transcript generated."
+    });
+    this.responses = options.responses;
+  }
+};
+
+// core/transcribe/transcribe.ts
+async function transcribe({
+  model,
+  audio,
+  providerOptions = {},
+  maxRetries: maxRetriesArg,
+  abortSignal,
+  headers
+}) {
+  const { retry } = prepareRetries({ maxRetries: maxRetriesArg });
+  const audioData = audio instanceof URL ? (await download({ url: audio })).data : convertDataContentToUint8Array(audio);
+  const result = await retry(
+    () => {
+      var _a17;
+      return model.doGenerate({
+        audio: audioData,
+        abortSignal,
+        headers,
+        providerOptions,
+        mediaType: (_a17 = detectMediaType({
+          data: audioData,
+          signatures: audioMediaTypeSignatures
+        })) != null ? _a17 : "audio/wav"
+      });
+    }
+  );
+  if (!result.text) {
+    throw new NoTranscriptGeneratedError({ responses: [result.response] });
+  }
+  return new DefaultTranscriptionResult({
+    text: result.text,
+    segments: result.segments,
+    language: result.language,
+    durationInSeconds: result.durationInSeconds,
+    warnings: result.warnings,
+    responses: [result.response],
+    providerMetadata: result.providerMetadata
+  });
+}
+var DefaultTranscriptionResult = class {
+  constructor(options) {
+    var _a17;
+    this.text = options.text;
+    this.segments = options.segments;
+    this.language = options.language;
+    this.durationInSeconds = options.durationInSeconds;
+    this.warnings = options.warnings;
+    this.responses = options.responses;
+    this.providerMetadata = (_a17 = options.providerMetadata) != null ? _a17 : {};
+  }
+};
+
 // core/util/merge-objects.ts
 function mergeObjects(target, source) {
   if (target === void 0 && source === void 0) {
@@ -6258,9 +8039,9 @@ function defaultSettingsMiddleware({
       return {
         ...settings,
         ...params,
-        providerMetadata: mergeObjects(
-          settings.providerMetadata,
-          params.providerMetadata
+        providerOptions: mergeObjects(
+          settings.providerOptions,
+          params.providerOptions
         ),
         // special case for temperature 0
         // TODO remove when temperature defaults to undefined
@@ -6299,27 +8080,41 @@ function extractReasoningMiddleware({
   return {
     middlewareVersion: "v2",
     wrapGenerate: async ({ doGenerate }) => {
-      const { text: rawText, ...rest } = await doGenerate();
-      if (rawText == null) {
-        return { text: rawText, ...rest };
-      }
-      const text2 = startWithReasoning ? openingTag + rawText : rawText;
-      const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, "gs");
-      const matches = Array.from(text2.matchAll(regexp));
-      if (!matches.length) {
-        return { text: text2, ...rest };
-      }
-      const reasoning = matches.map((match) => match[1]).join(separator);
-      let textWithoutReasoning = text2;
-      for (let i = matches.length - 1; i >= 0; i--) {
-        const match = matches[i];
-        const beforeMatch = textWithoutReasoning.slice(0, match.index);
-        const afterMatch = textWithoutReasoning.slice(
-          match.index + match[0].length
-        );
-        textWithoutReasoning = beforeMatch + (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : "") + afterMatch;
+      const { content, ...rest } = await doGenerate();
+      const transformedContent = [];
+      for (const part of content) {
+        if (part.type !== "text") {
+          transformedContent.push(part);
+          continue;
+        }
+        const text2 = startWithReasoning ? openingTag + part.text : part.text;
+        const regexp = new RegExp(`${openingTag}(.*?)${closingTag}`, "gs");
+        const matches = Array.from(text2.matchAll(regexp));
+        if (!matches.length) {
+          transformedContent.push(part);
+          continue;
+        }
+        const reasoningText = matches.map((match) => match[1]).join(separator);
+        let textWithoutReasoning = text2;
+        for (let i = matches.length - 1; i >= 0; i--) {
+          const match = matches[i];
+          const beforeMatch = textWithoutReasoning.slice(0, match.index);
+          const afterMatch = textWithoutReasoning.slice(
+            match.index + match[0].length
+          );
+          textWithoutReasoning = beforeMatch + (beforeMatch.length > 0 && afterMatch.length > 0 ? separator : "") + afterMatch;
+        }
+        transformedContent.push({
+          type: "reasoning",
+          reasoningType: "text",
+          text: reasoningText
+        });
+        transformedContent.push({
+          type: "text",
+          text: textWithoutReasoning
+        });
       }
-      return { ...rest, text: textWithoutReasoning, reasoning };
+      return { content: transformedContent, ...rest };
     },
     wrapStream: async ({ doStream }) => {
       const { stream, ...rest } = await doStream();
@@ -6332,18 +8127,24 @@ function extractReasoningMiddleware({
         stream: stream.pipeThrough(
           new TransformStream({
             transform: (chunk, controller) => {
-              if (chunk.type !== "text-delta") {
+              if (chunk.type !== "text") {
                 controller.enqueue(chunk);
                 return;
               }
-              buffer += chunk.textDelta;
+              buffer += chunk.text;
               function publish(text2) {
                 if (text2.length > 0) {
                   const prefix = afterSwitch && (isReasoning ? !isFirstReasoning : !isFirstText) ? separator : "";
-                  controller.enqueue({
-                    type: isReasoning ? "reasoning" : "text-delta",
-                    textDelta: prefix + text2
-                  });
+                  controller.enqueue(
+                    isReasoning ? {
+                      type: "reasoning",
+                      reasoningType: "text",
+                      text: prefix + text2
+                    } : {
+                      type: "text",
+                      text: prefix + text2
+                    }
+                  );
                   afterSwitch = false;
                   if (isReasoning) {
                     isFirstReasoning = false;
@@ -6388,60 +8189,13 @@ function simulateStreamingMiddleware() {
       const result = await doGenerate();
       const simulatedStream = new ReadableStream({
         start(controller) {
+          controller.enqueue({
+            type: "stream-start",
+            warnings: result.warnings
+          });
           controller.enqueue({ type: "response-metadata", ...result.response });
-          if (result.reasoning) {
-            if (typeof result.reasoning === "string") {
-              controller.enqueue({
-                type: "reasoning",
-                textDelta: result.reasoning
-              });
-            } else {
-              for (const reasoning of result.reasoning) {
-                switch (reasoning.type) {
-                  case "text": {
-                    controller.enqueue({
-                      type: "reasoning",
-                      textDelta: reasoning.text
-                    });
-                    if (reasoning.signature != null) {
-                      controller.enqueue({
-                        type: "reasoning-signature",
-                        signature: reasoning.signature
-                      });
-                    }
-                    break;
-                  }
-                  case "redacted": {
-                    controller.enqueue({
-                      type: "redacted-reasoning",
-                      data: reasoning.data
-                    });
-                    break;
-                  }
-                }
-              }
-            }
-          }
-          if (result.text) {
-            controller.enqueue({
-              type: "text-delta",
-              textDelta: result.text
-            });
-          }
-          if (result.toolCalls) {
-            for (const toolCall of result.toolCalls) {
-              controller.enqueue({
-                type: "tool-call-delta",
-                toolCallType: "function",
-                toolCallId: toolCall.toolCallId,
-                toolName: toolCall.toolName,
-                argsTextDelta: toolCall.args
-              });
-              controller.enqueue({
-                type: "tool-call",
-                ...toolCall
-              });
-            }
+          for (const part of result.content) {
+            controller.enqueue(part);
           }
           controller.enqueue({
             type: "finish",
@@ -6455,9 +8209,8 @@ function simulateStreamingMiddleware() {
       });
       return {
         stream: simulatedStream,
-        rawCall: result.rawCall,
-        rawResponse: result.rawResponse,
-        warnings: result.warnings
+        request: result.request,
+        response: result.response
       };
     }
   };
@@ -6514,7 +8267,6 @@ var doWrap = ({
     }
   };
 };
-var experimental_wrapLanguageModel = wrapLanguageModel;
 
 // core/prompt/append-client-message.ts
 function appendClientMessage({
@@ -6528,16 +8280,13 @@ function appendClientMessage({
 }
 
 // core/prompt/append-response-messages.ts
-import {
-  extractMaxToolInvocationStep
-} from "@ai-sdk/ui-utils";
-import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError21 } from "@ai-sdk/provider";
 function appendResponseMessages({
   messages,
   responseMessages,
   _internal: { currentDate = () => /* @__PURE__ */ new Date() } = {}
 }) {
-  var _a17, _b, _c, _d;
+  var _a17, _b, _c, _d, _e;
   const clonedMessages = structuredClone(messages);
   for (const message of responseMessages) {
     const role = message.role;
@@ -6614,14 +8363,14 @@ function appendResponseMessages({
                 break;
               case "file":
                 if (part.data instanceof URL) {
-                  throw new AISDKError18({
+                  throw new AISDKError21({
                     name: "InvalidAssistantFileData",
                     message: "File data cannot be a URL"
                   });
                 }
                 parts.push({
                   type: "file",
-                  mimeType: part.mimeType,
+                  mediaType: (_a17 = part.mediaType) != null ? _a17 : part.mimeType,
                   data: convertDataContentToBase64String(part.data)
                 });
                 break;
@@ -6632,12 +8381,12 @@ function appendResponseMessages({
           const maxStep = extractMaxToolInvocationStep(
             lastMessage.toolInvocations
           );
-          (_a17 = lastMessage.parts) != null ? _a17 : lastMessage.parts = [];
+          (_b = lastMessage.parts) != null ? _b : lastMessage.parts = [];
           lastMessage.content = textContent;
           lastMessage.reasoning = reasoningTextContent;
           lastMessage.parts.push(...parts);
           lastMessage.toolInvocations = [
-            ...(_b = lastMessage.toolInvocations) != null ? _b : [],
+            ...(_c = lastMessage.toolInvocations) != null ? _c : [],
             ...getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1)
           ];
           getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1).map((call) => ({
@@ -6667,13 +8416,13 @@ function appendResponseMessages({
         break;
       }
       case "tool": {
-        (_c = lastMessage.toolInvocations) != null ? _c : lastMessage.toolInvocations = [];
+        (_d = lastMessage.toolInvocations) != null ? _d : lastMessage.toolInvocations = [];
         if (lastMessage.role !== "assistant") {
           throw new Error(
             `Tool result must follow an assistant message: ${lastMessage.role}`
           );
         }
-        (_d = lastMessage.parts) != null ? _d : lastMessage.parts = [];
+        (_e = lastMessage.parts) != null ? _e : lastMessage.parts = [];
         for (const contentPart of message.content) {
           const toolCall = lastMessage.toolInvocations.find(
             (call) => call.toolCallId === contentPart.toolCallId
@@ -6748,7 +8497,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError19, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError22, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -6767,7 +8516,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError19.hasMarker(error, marker16);
+    return AISDKError22.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
@@ -6818,7 +8567,7 @@ var DefaultProviderRegistry = class {
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
       });
     }
-    return [id.slice(0, index), id.slice(index + 1)];
+    return [id.slice(0, index), id.slice(index + this.separator.length)];
   }
   languageModel(id) {
     var _a17, _b;
@@ -6854,9 +8603,6 @@ var DefaultProviderRegistry = class {
   }
 };
 
-// core/tool/mcp/mcp-client.ts
-import { jsonSchema } from "@ai-sdk/ui-utils";
-
 // core/tool/tool.ts
 function tool(tool2) {
   return tool2;
@@ -7341,6 +9087,7 @@ var MCPClient = class {
   async tools({
     schemas = "automatic"
   } = {}) {
+    var _a17;
     const tools = {};
     try {
       const listToolsResult = await this.listTools();
@@ -7348,14 +9095,18 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? jsonSchema(inputSchema) : schemas[name17].parameters;
+        const parameters = schemas === "automatic" ? jsonSchema({
+          ...inputSchema,
+          properties: (_a17 = inputSchema.properties) != null ? _a17 : {},
+          additionalProperties: false
+        }) : schemas[name17].parameters;
         const self = this;
         const toolWithExecute = tool({
           description,
           parameters,
           execute: async (args, options) => {
-            var _a17;
-            (_a17 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a17.throwIfAborted();
+            var _a18;
+            (_a18 = options == null ? void 0 : options.abortSignal) == null ? void 0 : _a18.throwIfAborted();
             return self.callTool({
               name: name17,
               args,
@@ -7408,7 +9159,7 @@ var MCPClient = class {
 };
 
 // core/util/cosine-similarity.ts
-function cosineSimilarity(vector1, vector2, options) {
+function cosineSimilarity(vector1, vector2) {
   if (vector1.length !== vector2.length) {
     throw new InvalidArgumentError({
       parameter: "vector1,vector2",
@@ -7418,13 +9169,6 @@ function cosineSimilarity(vector1, vector2, options) {
   }
   const n = vector1.length;
   if (n === 0) {
-    if (options == null ? void 0 : options.throwErrorForEmptyVectors) {
-      throw new InvalidArgumentError({
-        parameter: "vector1",
-        value: vector1,
-        message: "Vectors cannot be empty"
-      });
-    }
     return 0;
   }
   let magnitudeSquared1 = 0;
@@ -7470,7 +9214,6 @@ __export(langchain_adapter_exports, {
   toDataStream: () => toDataStream,
   toDataStreamResponse: () => toDataStreamResponse
 });
-import { formatDataStreamPart as formatDataStreamPart4 } from "@ai-sdk/ui-utils";
 
 // streams/stream-callbacks.ts
 function createCallbacksTransformer(callbacks = {}) {
@@ -7526,7 +9269,7 @@ function toDataStreamInternal(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart4("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7578,7 +9321,6 @@ __export(llamaindex_adapter_exports, {
   toDataStreamResponse: () => toDataStreamResponse2
 });
 import { convertAsyncIteratorToReadableStream } from "@ai-sdk/provider-utils";
-import { formatDataStreamPart as formatDataStreamPart5 } from "@ai-sdk/ui-utils";
 function toDataStreamInternal2(stream, callbacks) {
   const trimStart = trimStartOfStream();
   return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
@@ -7590,7 +9332,7 @@ function toDataStreamInternal2(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart5("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7631,9 +9373,6 @@ function trimStartOfStream() {
   };
 }
 
-// streams/stream-data.ts
-import { formatDataStreamPart as formatDataStreamPart6 } from "@ai-sdk/ui-utils";
-
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
@@ -7684,7 +9423,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart6("data", [value]))
+      this.encoder.encode(formatDataStreamPart("data", [value]))
     );
   }
   appendMessageAnnotation(value) {
@@ -7695,12 +9434,12 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart6("message_annotations", [value]))
+      this.encoder.encode(formatDataStreamPart("message_annotations", [value]))
     );
   }
 };
 export {
-  AISDKError16 as AISDKError,
+  AISDKError17 as AISDKError,
   APICallError2 as APICallError,
   DownloadError,
   EmptyResponseBodyError,
@@ -7733,6 +9472,9 @@ export {
   UnsupportedFunctionalityError2 as UnsupportedFunctionalityError,
   appendClientMessage,
   appendResponseMessages,
+  asSchema,
+  callChatApi,
+  callCompletionApi,
   convertToCoreMessages,
   coreAssistantMessageSchema,
   coreMessageSchema,
@@ -7752,23 +9494,34 @@ export {
   experimental_createProviderRegistry,
   experimental_customProvider,
   generateImage as experimental_generateImage,
-  experimental_wrapLanguageModel,
+  generateSpeech as experimental_generateSpeech,
+  transcribe as experimental_transcribe,
+  extractMaxToolInvocationStep,
   extractReasoningMiddleware,
-  formatDataStreamPart3 as formatDataStreamPart,
+  fillMessageParts,
+  formatDataStreamPart,
   generateId2 as generateId,
   generateObject,
   generateText,
-  jsonSchema2 as jsonSchema,
+  getMessageParts,
+  getTextFromDataUrl,
+  isAssistantMessageWithCompletedToolCalls,
+  isDeepEqualData,
+  jsonSchema,
   parseDataStreamPart,
+  parsePartialJson,
   pipeDataStreamToResponse,
+  prepareAttachmentsForRequest,
   processDataStream,
   processTextStream,
+  shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,
   smoothStream,
   streamObject,
   streamText,
   tool,
+  updateToolCallResult,
   wrapLanguageModel,
   zodSchema
 };