ai 5.0.0-canary.3 → 5.0.0-canary.5

package/dist/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name17 in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // streams/index.ts
@@ -53,6 +63,9 @@ __export(streams_exports, {
   UnsupportedFunctionalityError: () => import_provider20.UnsupportedFunctionalityError,
   appendClientMessage: () => appendClientMessage,
   appendResponseMessages: () => appendResponseMessages,
+  asSchema: () => asSchema,
+  callChatApi: () => callChatApi,
+  callCompletionApi: () => callCompletionApi,
   convertToCoreMessages: () => convertToCoreMessages,
   coreAssistantMessageSchema: () => coreAssistantMessageSchema,
   coreMessageSchema: () => coreMessageSchema,
@@ -62,7 +75,7 @@ __export(streams_exports, {
   cosineSimilarity: () => cosineSimilarity,
   createDataStream: () => createDataStream,
   createDataStreamResponse: () => createDataStreamResponse,
-  createIdGenerator: () => import_provider_utils15.createIdGenerator,
+  createIdGenerator: () => import_provider_utils21.createIdGenerator,
   createProviderRegistry: () => createProviderRegistry,
   customProvider: () => customProvider,
   defaultSettingsMiddleware: () => defaultSettingsMiddleware,
@@ -72,34 +85,1515 @@ __export(streams_exports, {
   experimental_createProviderRegistry: () => experimental_createProviderRegistry,
   experimental_customProvider: () => experimental_customProvider,
   experimental_generateImage: () => generateImage,
+  experimental_transcribe: () => transcribe,
   experimental_wrapLanguageModel: () => experimental_wrapLanguageModel,
+  extractMaxToolInvocationStep: () => extractMaxToolInvocationStep,
   extractReasoningMiddleware: () => extractReasoningMiddleware,
-  formatDataStreamPart: () => import_ui_utils11.formatDataStreamPart,
-  generateId: () => import_provider_utils15.generateId,
+  fillMessageParts: () => fillMessageParts,
+  formatDataStreamPart: () => formatDataStreamPart,
+  generateId: () => import_provider_utils21.generateId,
   generateObject: () => generateObject,
   generateText: () => generateText,
-  jsonSchema: () => import_ui_utils11.jsonSchema,
-  parseDataStreamPart: () => import_ui_utils11.parseDataStreamPart,
+  getMessageParts: () => getMessageParts,
+  getTextFromDataUrl: () => getTextFromDataUrl,
+  isAssistantMessageWithCompletedToolCalls: () => isAssistantMessageWithCompletedToolCalls,
+  isDeepEqualData: () => isDeepEqualData,
+  jsonSchema: () => jsonSchema,
+  parseDataStreamPart: () => parseDataStreamPart,
+  parsePartialJson: () => parsePartialJson,
   pipeDataStreamToResponse: () => pipeDataStreamToResponse,
-  processDataStream: () => import_ui_utils11.processDataStream,
-  processTextStream: () => import_ui_utils11.processTextStream,
+  prepareAttachmentsForRequest: () => prepareAttachmentsForRequest,
+  processDataStream: () => processDataStream,
+  processTextStream: () => processTextStream,
+  shouldResubmitMessages: () => shouldResubmitMessages,
   simulateReadableStream: () => simulateReadableStream,
   simulateStreamingMiddleware: () => simulateStreamingMiddleware,
   smoothStream: () => smoothStream,
   streamObject: () => streamObject,
   streamText: () => streamText,
   tool: () => tool,
+  updateToolCallResult: () => updateToolCallResult,
   wrapLanguageModel: () => wrapLanguageModel,
-  zodSchema: () => import_ui_utils11.zodSchema
+  zodSchema: () => zodSchema
 });
 module.exports = __toCommonJS(streams_exports);
 
 // core/index.ts
-var import_provider_utils15 = require("@ai-sdk/provider-utils");
-var import_ui_utils11 = require("@ai-sdk/ui-utils");
+var import_provider_utils21 = require("@ai-sdk/provider-utils");
+
+// core/util/index.ts
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// core/util/process-chat-response.ts
+var import_provider_utils2 = require("@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
+var import_provider_utils = require("@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 = (0, import_provider_utils.safeParseJSON)({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = (0, import_provider_utils.safeParseJSON)({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+
+// 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 = import_provider_utils2.generateId,
+  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
+var import_provider_utils3 = require("@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 = import_provider_utils3.generateId
+}) {
+  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
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+
+// core/util/zod-schema.ts
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+function zodSchema(zodSchema2, options) {
+  var _a17;
+  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
+  return jsonSchema(
+    (0, import_zod_to_json_schema.default)(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
+    [import_provider_utils4.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 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
-var import_ui_utils = require("@ai-sdk/ui-utils");
 function createDataStream({
   execute,
   onError = () => "An error occurred."
@@ -124,13 +1618,13 @@ function createDataStream({
         safeEnqueue(data);
       },
       writeData(data) {
-        safeEnqueue((0, import_ui_utils.formatDataStreamPart)("data", [data]));
+        safeEnqueue(formatDataStreamPart("data", [data]));
       },
       writeMessageAnnotation(annotation) {
-        safeEnqueue((0, import_ui_utils.formatDataStreamPart)("message_annotations", [annotation]));
+        safeEnqueue(formatDataStreamPart("message_annotations", [annotation]));
       },
       writeSource(source) {
-        safeEnqueue((0, import_ui_utils.formatDataStreamPart)("source", source));
+        safeEnqueue(formatDataStreamPart("source", source));
       },
       merge(streamArg) {
         ongoingStreamPromises.push(
@@ -143,7 +1637,7 @@ function createDataStream({
               safeEnqueue(value);
             }
           })().catch((error) => {
-            safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error)));
+            safeEnqueue(formatDataStreamPart("error", onError(error)));
           })
         );
       },
@@ -152,12 +1646,12 @@ function createDataStream({
     if (result) {
       ongoingStreamPromises.push(
         result.catch((error) => {
-          safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error)));
+          safeEnqueue(formatDataStreamPart("error", onError(error)));
         })
       );
     }
   } catch (error) {
-    safeEnqueue((0, import_ui_utils.formatDataStreamPart)("error", onError(error)));
+    safeEnqueue(formatDataStreamPart("error", onError(error)));
   }
   const waitForStreams = new Promise(async (resolve) => {
     while (ongoingStreamPromises.length > 0) {
@@ -307,7 +1801,7 @@ _a = symbol;
 
 // util/retry-with-exponential-backoff.ts
 var import_provider3 = require("@ai-sdk/provider");
-var import_provider_utils = require("@ai-sdk/provider-utils");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 
 // util/retry-error.ts
 var import_provider2 = require("@ai-sdk/provider");
@@ -351,13 +1845,13 @@ async function _retryWithExponentialBackoff(f, {
   try {
     return await f();
   } catch (error) {
-    if ((0, import_provider_utils.isAbortError)(error)) {
+    if ((0, import_provider_utils6.isAbortError)(error)) {
       throw error;
     }
     if (maxRetries === 0) {
       throw error;
     }
-    const errorMessage = (0, import_provider_utils.getErrorMessage)(error);
+    const errorMessage = (0, import_provider_utils6.getErrorMessage)(error);
     const newErrors = [...errors, error];
     const tryNumber = newErrors.length;
     if (tryNumber > maxRetries) {
@@ -368,7 +1862,7 @@ async function _retryWithExponentialBackoff(f, {
       });
     }
     if (error instanceof Error && import_provider3.APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await (0, import_provider_utils.delay)(delayInMs);
+      await (0, import_provider_utils6.delay)(delayInMs);
       return _retryWithExponentialBackoff(
         f,
         { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
@@ -906,28 +2400,28 @@ var NoImageGeneratedError = class extends import_provider4.AISDKError {
 _a3 = symbol3;
 
 // core/generate-text/generated-file.ts
-var import_provider_utils2 = require("@ai-sdk/provider-utils");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 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() {
     if (this.base64Data == null) {
-      this.base64Data = (0, import_provider_utils2.convertUint8ArrayToBase64)(this.uint8ArrayData);
+      this.base64Data = (0, import_provider_utils7.convertUint8ArrayToBase64)(this.uint8ArrayData);
     }
     return this.base64Data;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get uint8Array() {
     if (this.uint8ArrayData == null) {
-      this.uint8ArrayData = (0, import_provider_utils2.convertBase64ToUint8Array)(this.base64Data);
+      this.uint8ArrayData = (0, import_provider_utils7.convertBase64ToUint8Array)(this.base64Data);
     }
     return this.uint8ArrayData;
   }
@@ -939,45 +2433,45 @@ var DefaultGeneratedFileWithType = class extends DefaultGeneratedFile {
   }
 };
 
-// core/util/detect-image-mimetype.ts
-var mimeTypeSignatures = [
+// core/util/detect-media-type.ts
+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,
@@ -995,7 +2489,7 @@ var mimeTypeSignatures = [
     base64Prefix: "AAAAIGZ0eXBhdmlm"
   },
   {
-    mimeType: "image/heic",
+    mediaType: "image/heic",
     bytesPrefix: [
       0,
       0,
@@ -1013,10 +2507,45 @@ 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"
+  }
+];
+function detectMediaType({
+  data,
+  signatures
+}) {
+  for (const signature of signatures) {
+    if (typeof data === "string" ? data.startsWith(signature.base64Prefix) : data.length >= signature.bytesPrefix.length && signature.bytesPrefix.every((byte, index) => data[index] === byte)) {
+      return signature.mediaType;
     }
   }
   return void 0;
@@ -1072,7 +2601,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"
           });
         }
       )
@@ -1098,7 +2630,7 @@ var DefaultGenerateImageResult = class {
 
 // core/generate-object/generate-object.ts
 var import_provider12 = require("@ai-sdk/provider");
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_provider_utils12 = require("@ai-sdk/provider-utils");
 
 // errors/no-object-generated-error.ts
 var import_provider5 = require("@ai-sdk/provider");
@@ -1128,6 +2660,9 @@ var NoObjectGeneratedError = class extends import_provider5.AISDKError {
 };
 _a4 = symbol4;
 
+// core/prompt/convert-to-language-model-prompt.ts
+var import_provider_utils9 = require("@ai-sdk/provider-utils");
+
 // util/download-error.ts
 var import_provider6 = require("@ai-sdk/provider");
 var name5 = "AI_DownloadError";
@@ -1169,7 +2704,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)) {
@@ -1180,7 +2715,7 @@ async function download({ url }) {
 }
 
 // core/prompt/data-content.ts
-var import_provider_utils3 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
 
 // core/prompt/invalid-data-content-error.ts
 var import_provider7 = require("@ai-sdk/provider");
@@ -1224,9 +2759,9 @@ function convertDataContentToBase64String(content) {
     return content;
   }
   if (content instanceof ArrayBuffer) {
-    return (0, import_provider_utils3.convertUint8ArrayToBase64)(new Uint8Array(content));
+    return (0, import_provider_utils8.convertUint8ArrayToBase64)(new Uint8Array(content));
   }
-  return (0, import_provider_utils3.convertUint8ArrayToBase64)(content);
+  return (0, import_provider_utils8.convertUint8ArrayToBase64)(content);
 }
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
@@ -1234,7 +2769,7 @@ function convertDataContentToUint8Array(content) {
   }
   if (typeof content === "string") {
     try {
-      return (0, import_provider_utils3.convertBase64ToUint8Array)(content);
+      return (0, import_provider_utils8.convertBase64ToUint8Array)(content);
     } catch (error) {
       throw new InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
@@ -1282,12 +2817,12 @@ function splitDataUrl(dataUrl) {
   try {
     const [header, base64Content] = dataUrl.split(",");
     return {
-      mimeType: header.split(";")[0].split(":")[1],
+      mediaType: header.split(";")[0].split(":")[1],
       base64Content
     };
   } catch (error) {
     return {
-      mimeType: void 0,
+      mediaType: void 0,
       base64Content: void 0
     };
   }
@@ -1352,7 +2887,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
           // remove empty text parts:
           (part) => part.type !== "text" || part.text !== ""
         ).map((part) => {
-          var _a18;
+          var _a18, _b2;
           const providerOptions = (_a18 = part.providerOptions) != null ? _a18 : part.experimental_providerMetadata;
           switch (part.type) {
             case "file": {
@@ -1360,7 +2895,7 @@ function convertToLanguageModelMessage(message, downloadedAssets) {
                 type: "file",
                 data: part.data instanceof URL ? part.data : convertDataContentToBase64String(part.data),
                 filename: part.filename,
-                mimeType: part.mimeType,
+                mediaType: (_b2 = part.mediaType) != null ? _b2 : part.mimeType,
                 providerOptions
               };
             }
@@ -1448,7 +2983,7 @@ async function downloadAssets(messages, downloadImplementation, modelSupportsIma
   );
 }
 function convertPartToLanguageModelPart(part, downloadedAssets) {
-  var _a17, _b, _c, _d;
+  var _a17, _b, _c, _d, _e;
   if (part.type === "text") {
     return {
       type: "text",
@@ -1456,7 +2991,7 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
       providerOptions: (_a17 = part.providerOptions) != null ? _a17 : part.experimental_providerMetadata
     };
   }
-  let mimeType = part.mimeType;
+  let mediaType = (_b = part.mediaType) != null ? _b : part.mimeType;
   let data;
   let content;
   let normalizedData;
@@ -1478,19 +3013,19 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
   }
   if (content instanceof URL) {
     if (content.protocol === "data:") {
-      const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl(
+      const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
         content.toString()
       );
-      if (dataUrlMimeType == null || base64Content == null) {
+      if (dataUrlMediaType == null || base64Content == null) {
         throw new Error(`Invalid data URL format in part ${type}`);
       }
-      mimeType = dataUrlMimeType;
+      mediaType = dataUrlMediaType;
       normalizedData = convertDataContentToUint8Array(base64Content);
     } else {
       const downloadedFile = downloadedAssets[content.toString()];
       if (downloadedFile) {
         normalizedData = downloadedFile.data;
-        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType;
+        mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
       } else {
         normalizedData = content;
       }
@@ -1501,25 +3036,30 @@ function convertPartToLanguageModelPart(part, downloadedAssets) {
   switch (type) {
     case "image": {
       if (normalizedData instanceof Uint8Array) {
-        mimeType = (_b = detectImageMimeType(normalizedData)) != null ? _b : mimeType;
+        mediaType = (_c = detectMediaType({
+          data: normalizedData,
+          signatures: imageMediaTypeSignatures
+        })) != null ? _c : mediaType;
       }
       return {
-        type: "image",
-        image: normalizedData,
-        mimeType,
-        providerOptions: (_c = part.providerOptions) != null ? _c : part.experimental_providerMetadata
+        type: "file",
+        mediaType: mediaType != null ? mediaType : "image/*",
+        // any image
+        filename: void 0,
+        data: normalizedData instanceof Uint8Array ? (0, import_provider_utils9.convertUint8ArrayToBase64)(normalizedData) : normalizedData,
+        providerOptions: (_d = part.providerOptions) != null ? _d : part.experimental_providerMetadata
       };
     }
     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,
-        providerOptions: (_d = part.providerOptions) != null ? _d : part.experimental_providerMetadata
+        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
+        providerOptions: (_e = part.providerOptions) != null ? _e : part.experimental_providerMetadata
       };
     }
   }
@@ -1621,7 +3161,7 @@ function prepareCallSettings({
 
 // core/prompt/standardize-prompt.ts
 var import_provider10 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider_utils10 = require("@ai-sdk/provider-utils");
 var import_zod7 = require("zod");
 
 // core/prompt/attachments-to-parts.ts
@@ -1649,7 +3189,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: url,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1657,14 +3197,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/")) {
@@ -1688,7 +3228,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: base64Content,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1763,14 +3303,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) {
@@ -2027,7 +3576,7 @@ var toolResultContentSchema = import_zod4.z.array(
     import_zod4.z.object({
       type: import_zod4.z.literal("image"),
       data: import_zod4.z.string(),
-      mimeType: import_zod4.z.string().optional()
+      mediaType: import_zod4.z.string().optional()
     })
   ])
 );
@@ -2042,6 +3591,7 @@ var textPartSchema = import_zod5.z.object({
 var imagePartSchema = import_zod5.z.object({
   type: import_zod5.z.literal("image"),
   image: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
+  mediaType: import_zod5.z.string().optional(),
   mimeType: import_zod5.z.string().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
@@ -2050,7 +3600,8 @@ var filePartSchema = import_zod5.z.object({
   type: import_zod5.z.literal("file"),
   data: import_zod5.z.union([dataContentSchema, import_zod5.z.instanceof(URL)]),
   filename: import_zod5.z.string().optional(),
-  mimeType: import_zod5.z.string(),
+  mediaType: import_zod5.z.string(),
+  mimeType: import_zod5.z.string().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
@@ -2189,7 +3740,7 @@ function standardizePrompt({
         message: "messages must not be empty"
       });
     }
-    const validationResult = (0, import_provider_utils4.safeValidateTypes)({
+    const validationResult = (0, import_provider_utils10.safeValidateTypes)({
       value: messages,
       schema: import_zod7.z.array(coreMessageSchema)
     });
@@ -2210,7 +3761,7 @@ function standardizePrompt({
 }
 
 // core/types/usage.ts
-function calculateLanguageModelUsage({
+function calculateLanguageModelUsage2({
   promptTokens,
   completionTokens
 }) {
@@ -2250,8 +3801,7 @@ function injectJsonInstruction({
 
 // core/generate-object/output-strategy.ts
 var import_provider11 = require("@ai-sdk/provider");
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
-var import_ui_utils2 = require("@ai-sdk/ui-utils");
+var import_provider_utils11 = require("@ai-sdk/provider-utils");
 
 // core/util/async-iterable-stream.ts
 function createAsyncIterableStream(source) {
@@ -2307,7 +3857,7 @@ var objectOutputStrategy = (schema) => ({
     };
   },
   validateFinalResult(value) {
-    return (0, import_provider_utils5.safeValidateTypes)({ value, schema });
+    return (0, import_provider_utils11.safeValidateTypes)({ value, schema });
   },
   createElementStream() {
     throw new import_provider11.UnsupportedFunctionalityError({
@@ -2346,7 +3896,7 @@ var arrayOutputStrategy = (schema) => {
       const resultArray = [];
       for (let i = 0; i < inputArray.length; i++) {
         const element = inputArray[i];
-        const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema });
+        const result = (0, import_provider_utils11.safeValidateTypes)({ value: element, schema });
         if (i === inputArray.length - 1 && !isFinalDelta) {
           continue;
         }
@@ -2387,7 +3937,7 @@ var arrayOutputStrategy = (schema) => {
       }
       const inputArray = value.elements;
       for (const element of inputArray) {
-        const result = (0, import_provider_utils5.safeValidateTypes)({ value: element, schema });
+        const result = (0, import_provider_utils11.safeValidateTypes)({ value: element, schema });
         if (!result.success) {
           return result;
         }
@@ -2479,9 +4029,9 @@ function getOutputStrategy({
 }) {
   switch (output) {
     case "object":
-      return objectOutputStrategy((0, import_ui_utils2.asSchema)(schema));
+      return objectOutputStrategy(asSchema(schema));
     case "array":
-      return arrayOutputStrategy((0, import_ui_utils2.asSchema)(schema));
+      return arrayOutputStrategy(asSchema(schema));
     case "enum":
       return enumOutputStrategy(enumValues);
     case "no-schema":
@@ -2620,7 +4170,7 @@ function validateObjectGenerationInput({
 }
 
 // core/generate-object/generate-object.ts
-var originalGenerateId = (0, import_provider_utils6.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId = (0, import_provider_utils12.createIdGenerator)({ prefix: "aiobj", size: 24 });
 async function generateObject({
   model,
   enum: enumValues,
@@ -2701,7 +4251,6 @@ async function generateObject({
       let finishReason;
       let usage;
       let warnings;
-      let rawResponse;
       let response;
       let request;
       let logprobs;
@@ -2756,7 +4305,7 @@ 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({
                   responseFormat: {
                     type: "json",
@@ -2774,13 +4323,15 @@ async function generateObject({
                 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) {
                   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
                   });
                 }
@@ -2812,7 +4363,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 : {};
@@ -2862,7 +4412,7 @@ async function generateObject({
               }),
               tracer,
               fn: async (span2) => {
-                var _a18, _b2, _c2, _d2, _e, _f, _g, _h;
+                var _a18, _b2, _c2, _d2, _e, _f, _g, _h, _i, _j;
                 const result2 = await model.doGenerate({
                   tools: [
                     {
@@ -2884,13 +4434,15 @@ async function generateObject({
                 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
+                  modelId: (_h = (_g = result2.response) == null ? void 0 : _g.modelId) != null ? _h : model.modelId,
+                  headers: (_i = result2.response) == null ? void 0 : _i.headers,
+                  body: (_j = result2.response) == null ? void 0 : _j.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
                   });
                 }
@@ -2922,7 +4474,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 : {};
@@ -2940,14 +4491,14 @@ async function generateObject({
         }
       }
       function processResult(result2) {
-        const parseResult = (0, import_provider_utils6.safeParseJSON)({ text: result2 });
+        const parseResult = (0, import_provider_utils12.safeParseJSON)({ 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
           });
         }
@@ -2956,7 +4507,7 @@ async function generateObject({
           {
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage)
+            usage: calculateLanguageModelUsage2(usage)
           }
         );
         if (!validationResult.success) {
@@ -2965,7 +4516,7 @@ async function generateObject({
             cause: validationResult.error,
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage),
+            usage: calculateLanguageModelUsage2(usage),
             finishReason
           });
         }
@@ -3004,14 +4555,10 @@ async function generateObject({
       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
       });
@@ -3042,8 +4589,7 @@ var DefaultGenerateObjectResult = class {
 };
 
 // core/generate-object/stream-object.ts
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
-var import_ui_utils3 = require("@ai-sdk/ui-utils");
+var import_provider_utils13 = require("@ai-sdk/provider-utils");
 
 // util/delayed-promise.ts
 var DelayedPromise = class {
@@ -3187,7 +4733,7 @@ function now() {
 }
 
 // core/generate-object/stream-object.ts
-var originalGenerateId2 = (0, import_provider_utils7.createIdGenerator)({ prefix: "aiobj", size: 24 });
+var originalGenerateId2 = (0, import_provider_utils13.createIdGenerator)({ prefix: "aiobj", size: 24 });
 function streamObject({
   model,
   schema: inputSchema,
@@ -3427,7 +4973,7 @@ var DefaultStreamObjectResult = class {
           }
         }
         const {
-          result: { stream, warnings, rawResponse, request },
+          result: { stream, warnings, response, request },
           doStreamSpan,
           startTimestampMs
         } = await retry(
@@ -3476,7 +5022,7 @@ var DefaultStreamObjectResult = class {
         let error;
         let accumulatedText = "";
         let textDelta = "";
-        let response = {
+        let fullResponse = {
           id: generateId3(),
           timestamp: currentDate(),
           modelId: model.modelId
@@ -3502,8 +5048,8 @@ var DefaultStreamObjectResult = class {
               if (typeof chunk === "string") {
                 accumulatedText += chunk;
                 textDelta += chunk;
-                const { value: currentObjectJson, state: parseState } = (0, import_ui_utils3.parsePartialJson)(accumulatedText);
-                if (currentObjectJson !== void 0 && !(0, import_ui_utils3.isDeepEqualData)(latestObjectJson, currentObjectJson)) {
+                const { value: currentObjectJson, state: parseState } = parsePartialJson(accumulatedText);
+                if (currentObjectJson !== void 0 && !isDeepEqualData(latestObjectJson, currentObjectJson)) {
                   const validationResult = outputStrategy.validatePartialResult({
                     value: currentObjectJson,
                     textDelta,
@@ -3511,7 +5057,7 @@ var DefaultStreamObjectResult = class {
                     isFirstDelta,
                     isFinalDelta: parseState === "successful-parse"
                   });
-                  if (validationResult.success && !(0, import_ui_utils3.isDeepEqualData)(
+                  if (validationResult.success && !isDeepEqualData(
                     latestObject,
                     validationResult.value.partial
                   )) {
@@ -3533,10 +5079,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;
                 }
@@ -3545,20 +5091,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
                     }
                   );
@@ -3570,7 +5120,7 @@ var DefaultStreamObjectResult = class {
                       message: "No object generated: response did not match schema.",
                       cause: validationResult.error,
                       text: accumulatedText,
-                      response,
+                      response: fullResponse,
                       usage,
                       finishReason
                     });
@@ -3600,15 +5150,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
                     }
@@ -3632,8 +5182,8 @@ 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,
@@ -3759,7 +5309,7 @@ var DefaultStreamObjectResult = class {
 };
 
 // core/generate-text/generate-text.ts
-var import_provider_utils9 = require("@ai-sdk/provider-utils");
+var import_provider_utils15 = require("@ai-sdk/provider-utils");
 
 // errors/no-output-specified-error.ts
 var import_provider13 = require("@ai-sdk/provider");
@@ -3805,9 +5355,6 @@ var ToolExecutionError = class extends import_provider14.AISDKError {
 };
 _a10 = symbol10;
 
-// core/prompt/prepare-tools-and-tool-choice.ts
-var import_ui_utils4 = require("@ai-sdk/ui-utils");
-
 // core/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
   return object2 != null && Object.keys(object2).length > 0;
@@ -3838,7 +5385,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: (0, import_ui_utils4.asSchema)(tool2.parameters).jsonSchema
+            parameters: asSchema(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -3871,8 +5418,7 @@ function removeTextAfterLastWhitespace(text2) {
 }
 
 // core/generate-text/parse-tool-call.ts
-var import_provider_utils8 = require("@ai-sdk/provider-utils");
-var import_ui_utils5 = require("@ai-sdk/ui-utils");
+var import_provider_utils14 = require("@ai-sdk/provider-utils");
 
 // errors/invalid-tool-arguments-error.ts
 var import_provider15 = require("@ai-sdk/provider");
@@ -3967,7 +5513,7 @@ async function parseToolCall({
       repairedToolCall = await repairToolCall({
         toolCall,
         tools,
-        parameterSchema: ({ toolName }) => (0, import_ui_utils5.asSchema)(tools[toolName].parameters).jsonSchema,
+        parameterSchema: ({ toolName }) => asSchema(tools[toolName].parameters).jsonSchema,
         system,
         messages,
         error
@@ -3996,8 +5542,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = (0, import_ui_utils5.asSchema)(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? (0, import_provider_utils8.safeValidateTypes)({ value: {}, schema }) : (0, import_provider_utils8.safeParseJSON)({ text: toolCall.args, schema });
+  const schema = asSchema(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? (0, import_provider_utils14.safeValidateTypes)({ value: {}, schema }) : (0, import_provider_utils14.safeParseJSON)({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -4041,7 +5587,7 @@ function toResponseMessages({
       ...files.map((file) => ({
         type: "file",
         data: file.base64,
-        mimeType: file.mimeType
+        mediaType: file.mediaType
       })),
       { type: "text", text: text2 },
       ...toolCalls
@@ -4075,11 +5621,11 @@ function toResponseMessages({
 }
 
 // core/generate-text/generate-text.ts
-var originalGenerateId3 = (0, import_provider_utils9.createIdGenerator)({
+var originalGenerateId3 = (0, import_provider_utils15.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId = (0, import_provider_utils9.createIdGenerator)({
+var originalGenerateMessageId = (0, import_provider_utils15.createIdGenerator)({
   prefix: "msg",
   size: 24
 });
@@ -4152,7 +5698,7 @@ async function generateText({
     }),
     tracer,
     fn: async (span) => {
-      var _a18, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k;
+      var _a18, _b, _c, _d, _e, _f, _g;
       const toolsAndToolChoice = {
         ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
       };
@@ -4227,7 +5773,7 @@ async function generateText({
             }),
             tracer,
             fn: async (span2) => {
-              var _a19, _b2, _c2, _d2, _e2, _f2;
+              var _a19, _b2, _c2, _d2, _e2, _f2, _g2, _h;
               const result = await model.doGenerate({
                 ...callSettings,
                 ...toolsAndToolChoice,
@@ -4241,7 +5787,9 @@ async function generateText({
               const responseData = {
                 id: (_b2 = (_a19 = result.response) == null ? void 0 : _a19.id) != null ? _b2 : generateId3(),
                 timestamp: (_d2 = (_c2 = result.response) == null ? void 0 : _c2.timestamp) != null ? _d2 : currentDate(),
-                modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : model.modelId
+                modelId: (_f2 = (_e2 = result.response) == null ? void 0 : _e2.modelId) != null ? _f2 : model.modelId,
+                headers: (_g2 = result.response) == null ? void 0 : _g2.headers,
+                body: (_h = result.response) == null ? void 0 : _h.body
               };
               span2.setAttributes(
                 selectTelemetryAttributes({
@@ -4291,7 +5839,7 @@ async function generateText({
           messages: stepInputMessages,
           abortSignal
         });
-        const currentUsage = calculateLanguageModelUsage(
+        const currentUsage = calculateLanguageModelUsage2(
           currentModelResponse.usage
         );
         usage = addLanguageModelUsage(usage, currentUsage);
@@ -4358,8 +5906,6 @@ async function generateText({
           request: (_f = currentModelResponse.request) != null ? _f : {},
           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)
           },
@@ -4411,11 +5957,9 @@ async function generateText({
         finishReason: currentModelResponse.finishReason,
         usage,
         warnings: currentModelResponse.warnings,
-        request: (_i = currentModelResponse.request) != null ? _i : {},
+        request: (_g = currentModelResponse.request) != null ? _g : {},
         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,
@@ -4544,8 +6088,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-var import_provider_utils10 = require("@ai-sdk/provider-utils");
-var import_ui_utils6 = require("@ai-sdk/ui-utils");
+var import_provider_utils16 = require("@ai-sdk/provider-utils");
 
 // errors/index.ts
 var import_provider20 = require("@ai-sdk/provider");
@@ -4609,7 +6152,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = (0, import_ui_utils6.asSchema)(inputSchema);
+  const schema = asSchema(inputSchema);
   return {
     type: "object",
     responseFormat: ({ model }) => ({
@@ -4623,7 +6166,7 @@ var object = ({
       });
     },
     parsePartial({ text: text2 }) {
-      const result = (0, import_ui_utils6.parsePartialJson)(text2);
+      const result = parsePartialJson(text2);
       switch (result.state) {
         case "failed-parse":
         case "undefined-input":
@@ -4641,7 +6184,7 @@ var object = ({
       }
     },
     parseOutput({ text: text2 }, context) {
-      const parseResult = (0, import_provider_utils10.safeParseJSON)({ text: text2 });
+      const parseResult = (0, import_provider_utils16.safeParseJSON)({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -4652,7 +6195,7 @@ var object = ({
           finishReason: context.finishReason
         });
       }
-      const validationResult = (0, import_provider_utils10.safeValidateTypes)({
+      const validationResult = (0, import_provider_utils16.safeValidateTypes)({
         value: parseResult.value,
         schema
       });
@@ -4672,7 +6215,7 @@ var object = ({
 };
 
 // core/generate-text/smooth-stream.ts
-var import_provider_utils11 = require("@ai-sdk/provider-utils");
+var import_provider_utils17 = require("@ai-sdk/provider-utils");
 var import_provider21 = require("@ai-sdk/provider");
 var CHUNKING_REGEXPS = {
   word: /\S+\s+/m,
@@ -4681,7 +6224,7 @@ var CHUNKING_REGEXPS = {
 function smoothStream({
   delayInMs = 10,
   chunking = "word",
-  _internal: { delay: delay2 = import_provider_utils11.delay } = {}
+  _internal: { delay: delay2 = import_provider_utils17.delay } = {}
 } = {}) {
   let detectChunk;
   if (typeof chunking === "function") {
@@ -4742,8 +6285,7 @@ function smoothStream({
 
 // core/generate-text/stream-text.ts
 var import_provider22 = require("@ai-sdk/provider");
-var import_provider_utils12 = require("@ai-sdk/provider-utils");
-var import_ui_utils8 = require("@ai-sdk/ui-utils");
+var import_provider_utils18 = require("@ai-sdk/provider-utils");
 
 // util/as-array.ts
 function asArray(value) {
@@ -4858,7 +6400,6 @@ function mergeStreams(stream1, stream2) {
 }
 
 // core/generate-text/run-tools-transformation.ts
-var import_ui_utils7 = require("@ai-sdk/ui-utils");
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -4906,7 +6447,7 @@ function runToolsTransformation({
           controller.enqueue(
             new DefaultGeneratedFileWithType({
               data: chunk.data,
-              mimeType: chunk.mimeType
+              mediaType: chunk.mediaType
             })
           );
           break;
@@ -4942,7 +6483,7 @@ function runToolsTransformation({
             controller.enqueue(toolCall);
             const tool2 = tools[toolCall.toolName];
             if (tool2.execute != null) {
-              const toolExecutionId = (0, import_ui_utils7.generateId)();
+              const toolExecutionId = (0, import_provider_utils5.generateId)();
               outstandingToolResults.add(toolExecutionId);
               recordSpan({
                 name: "ai.toolCall",
@@ -5017,7 +6558,7 @@ function runToolsTransformation({
             type: "finish",
             finishReason: chunk.finishReason,
             logprobs: chunk.logprobs,
-            usage: calculateLanguageModelUsage(chunk.usage),
+            usage: calculateLanguageModelUsage2(chunk.usage),
             experimental_providerMetadata: chunk.providerMetadata
           };
           break;
@@ -5061,11 +6602,11 @@ function runToolsTransformation({
 }
 
 // core/generate-text/stream-text.ts
-var originalGenerateId4 = (0, import_provider_utils12.createIdGenerator)({
+var originalGenerateId4 = (0, import_provider_utils18.createIdGenerator)({
   prefix: "aitxt",
   size: 24
 });
-var originalGenerateMessageId2 = (0, import_provider_utils12.createIdGenerator)({
+var originalGenerateMessageId2 = (0, import_provider_utils18.createIdGenerator)({
   prefix: "msg",
   size: 24
 });
@@ -5528,7 +7069,7 @@ var DefaultStreamTextResult = class {
             ...prepareToolsAndToolChoice({ tools, toolChoice, activeTools })
           };
           const {
-            result: { stream: stream2, warnings, rawResponse, request },
+            result: { stream: stream2, warnings, response, request },
             doStreamSpan,
             startTimestampMs
           } = await retry(
@@ -5839,7 +7380,7 @@ var DefaultStreamTextResult = class {
                     request: stepRequest,
                     response: {
                       ...stepResponse,
-                      headers: rawResponse == null ? void 0 : rawResponse.headers
+                      headers: response == null ? void 0 : response.headers
                     },
                     warnings,
                     isContinued: nextStepType === "continue",
@@ -5856,7 +7397,7 @@ var DefaultStreamTextResult = class {
                       logprobs: stepLogProbs,
                       response: {
                         ...stepResponse,
-                        headers: rawResponse == null ? void 0 : rawResponse.headers
+                        headers: response == null ? void 0 : response.headers
                       }
                     });
                     self.closeStream();
@@ -6052,13 +7593,13 @@ var DefaultStreamTextResult = class {
           const chunkType = chunk.type;
           switch (chunkType) {
             case "text-delta": {
-              controller.enqueue((0, import_ui_utils8.formatDataStreamPart)("text", chunk.textDelta));
+              controller.enqueue(formatDataStreamPart("text", chunk.textDelta));
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
                 controller.enqueue(
-                  (0, import_ui_utils8.formatDataStreamPart)("reasoning", chunk.textDelta)
+                  formatDataStreamPart("reasoning", chunk.textDelta)
                 );
               }
               break;
@@ -6066,7 +7607,7 @@ var DefaultStreamTextResult = class {
             case "redacted-reasoning": {
               if (sendReasoning) {
                 controller.enqueue(
-                  (0, import_ui_utils8.formatDataStreamPart)("redacted_reasoning", {
+                  formatDataStreamPart("redacted_reasoning", {
                     data: chunk.data
                   })
                 );
@@ -6076,7 +7617,7 @@ var DefaultStreamTextResult = class {
             case "reasoning-signature": {
               if (sendReasoning) {
                 controller.enqueue(
-                  (0, import_ui_utils8.formatDataStreamPart)("reasoning_signature", {
+                  formatDataStreamPart("reasoning_signature", {
                     signature: chunk.signature
                   })
                 );
@@ -6085,8 +7626,8 @@ var DefaultStreamTextResult = class {
             }
             case "file": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("file", {
-                  mimeType: chunk.mimeType,
+                formatDataStreamPart("file", {
+                  mimeType: chunk.mediaType,
                   data: chunk.base64
                 })
               );
@@ -6095,14 +7636,14 @@ var DefaultStreamTextResult = class {
             case "source": {
               if (sendSources) {
                 controller.enqueue(
-                  (0, import_ui_utils8.formatDataStreamPart)("source", chunk.source)
+                  formatDataStreamPart("source", chunk.source)
                 );
               }
               break;
             }
             case "tool-call-streaming-start": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("tool_call_streaming_start", {
+                formatDataStreamPart("tool_call_streaming_start", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName
                 })
@@ -6111,7 +7652,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call-delta": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("tool_call_delta", {
+                formatDataStreamPart("tool_call_delta", {
                   toolCallId: chunk.toolCallId,
                   argsTextDelta: chunk.argsTextDelta
                 })
@@ -6120,7 +7661,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("tool_call", {
+                formatDataStreamPart("tool_call", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName,
                   args: chunk.args
@@ -6130,7 +7671,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-result": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("tool_result", {
+                formatDataStreamPart("tool_result", {
                   toolCallId: chunk.toolCallId,
                   result: chunk.result
                 })
@@ -6139,13 +7680,13 @@ var DefaultStreamTextResult = class {
             }
             case "error": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("error", getErrorMessage5(chunk.error))
+                formatDataStreamPart("error", getErrorMessage5(chunk.error))
               );
               break;
             }
             case "step-start": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("start_step", {
+                formatDataStreamPart("start_step", {
                   messageId: chunk.messageId
                 })
               );
@@ -6153,7 +7694,7 @@ var DefaultStreamTextResult = class {
             }
             case "step-finish": {
               controller.enqueue(
-                (0, import_ui_utils8.formatDataStreamPart)("finish_step", {
+                formatDataStreamPart("finish_step", {
                   finishReason: chunk.finishReason,
                   usage: sendUsage ? {
                     promptTokens: chunk.usage.promptTokens,
@@ -6167,7 +7708,7 @@ var DefaultStreamTextResult = class {
             case "finish": {
               if (experimental_sendFinish) {
                 controller.enqueue(
-                  (0, import_ui_utils8.formatDataStreamPart)("finish_message", {
+                  formatDataStreamPart("finish_message", {
                     finishReason: chunk.finishReason,
                     usage: sendUsage ? {
                       promptTokens: chunk.usage.promptTokens,
@@ -6290,6 +7831,70 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// errors/no-transcript-generated-error.ts
+var import_provider23 = require("@ai-sdk/provider");
+var NoTranscriptGeneratedError = class extends import_provider23.AISDKError {
+  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) {
@@ -6532,7 +8137,7 @@ function simulateStreamingMiddleware() {
       return {
         stream: simulatedStream,
         rawCall: result.rawCall,
-        rawResponse: result.rawResponse,
+        rawResponse: result.response,
         warnings: result.warnings
       };
     }
@@ -6604,14 +8209,13 @@ function appendClientMessage({
 }
 
 // core/prompt/append-response-messages.ts
-var import_ui_utils9 = require("@ai-sdk/ui-utils");
-var import_provider23 = require("@ai-sdk/provider");
+var import_provider24 = require("@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;
@@ -6688,14 +8292,14 @@ function appendResponseMessages({
                 break;
               case "file":
                 if (part.data instanceof URL) {
-                  throw new import_provider23.AISDKError({
+                  throw new import_provider24.AISDKError({
                     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;
@@ -6703,15 +8307,15 @@ function appendResponseMessages({
           }
         }
         if (isLastMessageAssistant) {
-          const maxStep = (0, import_ui_utils9.extractMaxToolInvocationStep)(
+          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) => ({
@@ -6741,13 +8345,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
@@ -6782,7 +8386,7 @@ function appendResponseMessages({
 }
 
 // core/registry/custom-provider.ts
-var import_provider24 = require("@ai-sdk/provider");
+var import_provider25 = require("@ai-sdk/provider");
 function customProvider({
   languageModels,
   textEmbeddingModels,
@@ -6797,7 +8401,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.languageModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "languageModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "languageModel" });
     },
     textEmbeddingModel(modelId) {
       if (textEmbeddingModels != null && modelId in textEmbeddingModels) {
@@ -6806,7 +8410,7 @@ function customProvider({
       if (fallbackProvider) {
         return fallbackProvider.textEmbeddingModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "textEmbeddingModel" });
     },
     imageModel(modelId) {
       if (imageModels != null && modelId in imageModels) {
@@ -6815,19 +8419,19 @@ function customProvider({
       if (fallbackProvider == null ? void 0 : fallbackProvider.imageModel) {
         return fallbackProvider.imageModel(modelId);
       }
-      throw new import_provider24.NoSuchModelError({ modelId, modelType: "imageModel" });
+      throw new import_provider25.NoSuchModelError({ modelId, modelType: "imageModel" });
     }
   };
 }
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-var import_provider25 = require("@ai-sdk/provider");
+var import_provider26 = require("@ai-sdk/provider");
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
 var _a16;
-var NoSuchProviderError = class extends import_provider25.NoSuchModelError {
+var NoSuchProviderError = class extends import_provider26.NoSuchModelError {
   constructor({
     modelId,
     modelType,
@@ -6841,13 +8445,13 @@ var NoSuchProviderError = class extends import_provider25.NoSuchModelError {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return import_provider25.AISDKError.hasMarker(error, marker16);
+    return import_provider26.AISDKError.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
 
 // core/registry/provider-registry.ts
-var import_provider26 = require("@ai-sdk/provider");
+var import_provider27 = require("@ai-sdk/provider");
 function createProviderRegistry(providers, {
   separator = ":"
 } = {}) {
@@ -6886,7 +8490,7 @@ var DefaultProviderRegistry = class {
   splitId(id, modelType) {
     const index = id.indexOf(this.separator);
     if (index === -1) {
-      throw new import_provider26.NoSuchModelError({
+      throw new import_provider27.NoSuchModelError({
         modelId: id,
         modelType,
         message: `Invalid ${modelType} id for registry: ${id} (must be in the format "providerId${this.separator}modelId")`
@@ -6899,7 +8503,7 @@ var DefaultProviderRegistry = class {
     const [providerId, modelId] = this.splitId(id, "languageModel");
     const model = (_b = (_a17 = this.getProvider(providerId)).languageModel) == null ? void 0 : _b.call(_a17, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "languageModel" });
+      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "languageModel" });
     }
     return model;
   }
@@ -6909,7 +8513,7 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.textEmbeddingModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({
+      throw new import_provider27.NoSuchModelError({
         modelId: id,
         modelType: "textEmbeddingModel"
       });
@@ -6922,22 +8526,19 @@ var DefaultProviderRegistry = class {
     const provider = this.getProvider(providerId);
     const model = (_a17 = provider.imageModel) == null ? void 0 : _a17.call(provider, modelId);
     if (model == null) {
-      throw new import_provider26.NoSuchModelError({ modelId: id, modelType: "imageModel" });
+      throw new import_provider27.NoSuchModelError({ modelId: id, modelType: "imageModel" });
     }
     return model;
   }
 };
 
-// core/tool/mcp/mcp-client.ts
-var import_ui_utils10 = require("@ai-sdk/ui-utils");
-
 // core/tool/tool.ts
 function tool(tool2) {
   return tool2;
 }
 
 // core/tool/mcp/mcp-sse-transport.ts
-var import_provider_utils13 = require("@ai-sdk/provider-utils");
+var import_provider_utils19 = require("@ai-sdk/provider-utils");
 
 // core/tool/mcp/json-rpc-message.ts
 var import_zod9 = require("zod");
@@ -7108,7 +8709,7 @@ var SseMCPTransport = class {
             (_b = this.onerror) == null ? void 0 : _b.call(this, error);
             return reject(error);
           }
-          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils13.createEventSourceParserStream)());
+          const stream = response.body.pipeThrough(new TextDecoderStream()).pipeThrough((0, import_provider_utils19.createEventSourceParserStream)());
           const reader = stream.getReader();
           const processEvents = async () => {
             var _a18, _b2, _c2;
@@ -7422,7 +9023,7 @@ var MCPClient = class {
         if (schemas !== "automatic" && !(name17 in schemas)) {
           continue;
         }
-        const parameters = schemas === "automatic" ? (0, import_ui_utils10.jsonSchema)(inputSchema) : schemas[name17].parameters;
+        const parameters = schemas === "automatic" ? jsonSchema(inputSchema) : schemas[name17].parameters;
         const self = this;
         const toolWithExecute = tool({
           description,
@@ -7515,7 +9116,7 @@ function cosineSimilarity(vector1, vector2, options) {
 }
 
 // core/util/simulate-readable-stream.ts
-var import_provider_utils14 = require("@ai-sdk/provider-utils");
+var import_provider_utils20 = require("@ai-sdk/provider-utils");
 function simulateReadableStream({
   chunks,
   initialDelayInMs = 0,
@@ -7523,7 +9124,7 @@ function simulateReadableStream({
   _internal
 }) {
   var _a17;
-  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils14.delay;
+  const delay2 = (_a17 = _internal == null ? void 0 : _internal.delay) != null ? _a17 : import_provider_utils20.delay;
   let index = 0;
   return new ReadableStream({
     async pull(controller) {
@@ -7544,7 +9145,6 @@ __export(langchain_adapter_exports, {
   toDataStream: () => toDataStream,
   toDataStreamResponse: () => toDataStreamResponse
 });
-var import_ui_utils12 = require("@ai-sdk/ui-utils");
 
 // streams/stream-callbacks.ts
 function createCallbacksTransformer(callbacks = {}) {
@@ -7600,7 +9200,7 @@ function toDataStreamInternal(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue((0, import_ui_utils12.formatDataStreamPart)("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7651,11 +9251,10 @@ __export(llamaindex_adapter_exports, {
   toDataStream: () => toDataStream2,
   toDataStreamResponse: () => toDataStreamResponse2
 });
-var import_provider_utils16 = require("@ai-sdk/provider-utils");
-var import_ui_utils13 = require("@ai-sdk/ui-utils");
+var import_provider_utils22 = require("@ai-sdk/provider-utils");
 function toDataStreamInternal2(stream, callbacks) {
   const trimStart = trimStartOfStream();
-  return (0, import_provider_utils16.convertAsyncIteratorToReadableStream)(stream[Symbol.asyncIterator]()).pipeThrough(
+  return (0, import_provider_utils22.convertAsyncIteratorToReadableStream)(stream[Symbol.asyncIterator]()).pipeThrough(
     new TransformStream({
       async transform(message, controller) {
         controller.enqueue(trimStart(message.delta));
@@ -7664,7 +9263,7 @@ function toDataStreamInternal2(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue((0, import_ui_utils13.formatDataStreamPart)("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7705,9 +9304,6 @@ function trimStartOfStream() {
   };
 }
 
-// streams/stream-data.ts
-var import_ui_utils14 = require("@ai-sdk/ui-utils");
-
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
@@ -7758,7 +9354,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode((0, import_ui_utils14.formatDataStreamPart)("data", [value]))
+      this.encoder.encode(formatDataStreamPart("data", [value]))
     );
   }
   appendMessageAnnotation(value) {
@@ -7769,7 +9365,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode((0, import_ui_utils14.formatDataStreamPart)("message_annotations", [value]))
+      this.encoder.encode(formatDataStreamPart("message_annotations", [value]))
     );
   }
 };
@@ -7808,6 +9404,9 @@ var StreamData = class {
   UnsupportedFunctionalityError,
   appendClientMessage,
   appendResponseMessages,
+  asSchema,
+  callChatApi,
+  callCompletionApi,
   convertToCoreMessages,
   coreAssistantMessageSchema,
   coreMessageSchema,
@@ -7827,23 +9426,34 @@ var StreamData = class {
   experimental_createProviderRegistry,
   experimental_customProvider,
   experimental_generateImage,
+  experimental_transcribe,
   experimental_wrapLanguageModel,
+  extractMaxToolInvocationStep,
   extractReasoningMiddleware,
+  fillMessageParts,
   formatDataStreamPart,
   generateId,
   generateObject,
   generateText,
+  getMessageParts,
+  getTextFromDataUrl,
+  isAssistantMessageWithCompletedToolCalls,
+  isDeepEqualData,
   jsonSchema,
   parseDataStreamPart,
+  parsePartialJson,
   pipeDataStreamToResponse,
+  prepareAttachmentsForRequest,
   processDataStream,
   processTextStream,
+  shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,
   smoothStream,
   streamObject,
   streamText,
   tool,
+  updateToolCallResult,
   wrapLanguageModel,
   zodSchema
 });