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

package/dist/index.mjs

@@ -6,17 +6,1480 @@ var __export = (target, all) => {
 
 // core/index.ts
 import { createIdGenerator as createIdGenerator5, generateId as generateId2 } from "@ai-sdk/provider-utils";
-import {
-  formatDataStreamPart as formatDataStreamPart3,
-  jsonSchema as jsonSchema2,
-  parseDataStreamPart,
-  processDataStream,
-  processTextStream,
-  zodSchema
-} from "@ai-sdk/ui-utils";
+
+// core/util/index.ts
+import { generateId } from "@ai-sdk/provider-utils";
+
+// core/util/process-chat-response.ts
+import { generateId as generateIdFunction } from "@ai-sdk/provider-utils";
+
+// core/types/duplicated/usage.ts
+function calculateLanguageModelUsage({
+  promptTokens,
+  completionTokens
+}) {
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
+  };
+}
+
+// core/util/parse-partial-json.ts
+import { safeParseJSON } from "@ai-sdk/provider-utils";
+
+// core/util/fix-json.ts
+function fixJson(input) {
+  const stack = ["ROOT"];
+  let lastValidIndex = -1;
+  let literalStart = null;
+  function processValueStart(char, i, swapState) {
+    {
+      switch (char) {
+        case '"': {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_STRING");
+          break;
+        }
+        case "f":
+        case "t":
+        case "n": {
+          lastValidIndex = i;
+          literalStart = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_LITERAL");
+          break;
+        }
+        case "-": {
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "0":
+        case "1":
+        case "2":
+        case "3":
+        case "4":
+        case "5":
+        case "6":
+        case "7":
+        case "8":
+        case "9": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_NUMBER");
+          break;
+        }
+        case "{": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_OBJECT_START");
+          break;
+        }
+        case "[": {
+          lastValidIndex = i;
+          stack.pop();
+          stack.push(swapState);
+          stack.push("INSIDE_ARRAY_START");
+          break;
+        }
+      }
+    }
+  }
+  function processAfterObjectValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_OBJECT_AFTER_COMMA");
+        break;
+      }
+      case "}": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  function processAfterArrayValue(char, i) {
+    switch (char) {
+      case ",": {
+        stack.pop();
+        stack.push("INSIDE_ARRAY_AFTER_COMMA");
+        break;
+      }
+      case "]": {
+        lastValidIndex = i;
+        stack.pop();
+        break;
+      }
+    }
+  }
+  for (let i = 0; i < input.length; i++) {
+    const char = input[i];
+    const currentState = stack[stack.length - 1];
+    switch (currentState) {
+      case "ROOT":
+        processValueStart(char, i, "FINISH");
+        break;
+      case "INSIDE_OBJECT_START": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+          case "}": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_COMMA": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_KEY": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_AFTER_KEY");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_KEY": {
+        switch (char) {
+          case ":": {
+            stack.pop();
+            stack.push("INSIDE_OBJECT_BEFORE_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_OBJECT_BEFORE_VALUE": {
+        processValueStart(char, i, "INSIDE_OBJECT_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        processAfterObjectValue(char, i);
+        break;
+      }
+      case "INSIDE_STRING": {
+        switch (char) {
+          case '"': {
+            stack.pop();
+            lastValidIndex = i;
+            break;
+          }
+          case "\\": {
+            stack.push("INSIDE_STRING_ESCAPE");
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_START": {
+        switch (char) {
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        switch (char) {
+          case ",": {
+            stack.pop();
+            stack.push("INSIDE_ARRAY_AFTER_COMMA");
+            break;
+          }
+          case "]": {
+            lastValidIndex = i;
+            stack.pop();
+            break;
+          }
+          default: {
+            lastValidIndex = i;
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_ARRAY_AFTER_COMMA": {
+        processValueStart(char, i, "INSIDE_ARRAY_AFTER_VALUE");
+        break;
+      }
+      case "INSIDE_STRING_ESCAPE": {
+        stack.pop();
+        lastValidIndex = i;
+        break;
+      }
+      case "INSIDE_NUMBER": {
+        switch (char) {
+          case "0":
+          case "1":
+          case "2":
+          case "3":
+          case "4":
+          case "5":
+          case "6":
+          case "7":
+          case "8":
+          case "9": {
+            lastValidIndex = i;
+            break;
+          }
+          case "e":
+          case "E":
+          case "-":
+          case ".": {
+            break;
+          }
+          case ",": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "}": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+              processAfterObjectValue(char, i);
+            }
+            break;
+          }
+          case "]": {
+            stack.pop();
+            if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+              processAfterArrayValue(char, i);
+            }
+            break;
+          }
+          default: {
+            stack.pop();
+            break;
+          }
+        }
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, i + 1);
+        if (!"false".startsWith(partialLiteral) && !"true".startsWith(partialLiteral) && !"null".startsWith(partialLiteral)) {
+          stack.pop();
+          if (stack[stack.length - 1] === "INSIDE_OBJECT_AFTER_VALUE") {
+            processAfterObjectValue(char, i);
+          } else if (stack[stack.length - 1] === "INSIDE_ARRAY_AFTER_VALUE") {
+            processAfterArrayValue(char, i);
+          }
+        } else {
+          lastValidIndex = i;
+        }
+        break;
+      }
+    }
+  }
+  let result = input.slice(0, lastValidIndex + 1);
+  for (let i = stack.length - 1; i >= 0; i--) {
+    const state = stack[i];
+    switch (state) {
+      case "INSIDE_STRING": {
+        result += '"';
+        break;
+      }
+      case "INSIDE_OBJECT_KEY":
+      case "INSIDE_OBJECT_AFTER_KEY":
+      case "INSIDE_OBJECT_AFTER_COMMA":
+      case "INSIDE_OBJECT_START":
+      case "INSIDE_OBJECT_BEFORE_VALUE":
+      case "INSIDE_OBJECT_AFTER_VALUE": {
+        result += "}";
+        break;
+      }
+      case "INSIDE_ARRAY_START":
+      case "INSIDE_ARRAY_AFTER_COMMA":
+      case "INSIDE_ARRAY_AFTER_VALUE": {
+        result += "]";
+        break;
+      }
+      case "INSIDE_LITERAL": {
+        const partialLiteral = input.substring(literalStart, input.length);
+        if ("true".startsWith(partialLiteral)) {
+          result += "true".slice(partialLiteral.length);
+        } else if ("false".startsWith(partialLiteral)) {
+          result += "false".slice(partialLiteral.length);
+        } else if ("null".startsWith(partialLiteral)) {
+          result += "null".slice(partialLiteral.length);
+        }
+      }
+    }
+  }
+  return result;
+}
+
+// core/util/parse-partial-json.ts
+function parsePartialJson(jsonText) {
+  if (jsonText === void 0) {
+    return { value: void 0, state: "undefined-input" };
+  }
+  let result = safeParseJSON({ text: jsonText });
+  if (result.success) {
+    return { value: result.value, state: "successful-parse" };
+  }
+  result = safeParseJSON({ text: fixJson(jsonText) });
+  if (result.success) {
+    return { value: result.value, state: "repaired-parse" };
+  }
+  return { value: void 0, state: "failed-parse" };
+}
+
+// core/util/data-stream-parts.ts
+var textStreamPart = {
+  code: "0",
+  name: "text",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"text" parts expect a string value.');
+    }
+    return { type: "text", value };
+  }
+};
+var dataStreamPart = {
+  code: "2",
+  name: "data",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"data" parts expect an array value.');
+    }
+    return { type: "data", value };
+  }
+};
+var errorStreamPart = {
+  code: "3",
+  name: "error",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"error" parts expect a string value.');
+    }
+    return { type: "error", value };
+  }
+};
+var messageAnnotationsStreamPart = {
+  code: "8",
+  name: "message_annotations",
+  parse: (value) => {
+    if (!Array.isArray(value)) {
+      throw new Error('"message_annotations" parts expect an array value.');
+    }
+    return { type: "message_annotations", value };
+  }
+};
+var toolCallStreamPart = {
+  code: "9",
+  name: "tool_call",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string" || !("args" in value) || typeof value.args !== "object") {
+      throw new Error(
+        '"tool_call" parts expect an object with a "toolCallId", "toolName", and "args" property.'
+      );
+    }
+    return {
+      type: "tool_call",
+      value
+    };
+  }
+};
+var toolResultStreamPart = {
+  code: "a",
+  name: "tool_result",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("result" in value)) {
+      throw new Error(
+        '"tool_result" parts expect an object with a "toolCallId" and a "result" property.'
+      );
+    }
+    return {
+      type: "tool_result",
+      value
+    };
+  }
+};
+var toolCallStreamingStartStreamPart = {
+  code: "b",
+  name: "tool_call_streaming_start",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("toolName" in value) || typeof value.toolName !== "string") {
+      throw new Error(
+        '"tool_call_streaming_start" parts expect an object with a "toolCallId" and "toolName" property.'
+      );
+    }
+    return {
+      type: "tool_call_streaming_start",
+      value
+    };
+  }
+};
+var toolCallDeltaStreamPart = {
+  code: "c",
+  name: "tool_call_delta",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("toolCallId" in value) || typeof value.toolCallId !== "string" || !("argsTextDelta" in value) || typeof value.argsTextDelta !== "string") {
+      throw new Error(
+        '"tool_call_delta" parts expect an object with a "toolCallId" and "argsTextDelta" property.'
+      );
+    }
+    return {
+      type: "tool_call_delta",
+      value
+    };
+  }
+};
+var finishMessageStreamPart = {
+  code: "d",
+  name: "finish_message",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_message" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    return {
+      type: "finish_message",
+      value: result
+    };
+  }
+};
+var finishStepStreamPart = {
+  code: "e",
+  name: "finish_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("finishReason" in value) || typeof value.finishReason !== "string") {
+      throw new Error(
+        '"finish_step" parts expect an object with a "finishReason" property.'
+      );
+    }
+    const result = {
+      finishReason: value.finishReason,
+      isContinued: false
+    };
+    if ("usage" in value && value.usage != null && typeof value.usage === "object" && "promptTokens" in value.usage && "completionTokens" in value.usage) {
+      result.usage = {
+        promptTokens: typeof value.usage.promptTokens === "number" ? value.usage.promptTokens : Number.NaN,
+        completionTokens: typeof value.usage.completionTokens === "number" ? value.usage.completionTokens : Number.NaN
+      };
+    }
+    if ("isContinued" in value && typeof value.isContinued === "boolean") {
+      result.isContinued = value.isContinued;
+    }
+    return {
+      type: "finish_step",
+      value: result
+    };
+  }
+};
+var startStepStreamPart = {
+  code: "f",
+  name: "start_step",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("messageId" in value) || typeof value.messageId !== "string") {
+      throw new Error(
+        '"start_step" parts expect an object with an "id" property.'
+      );
+    }
+    return {
+      type: "start_step",
+      value: {
+        messageId: value.messageId
+      }
+    };
+  }
+};
+var reasoningStreamPart = {
+  code: "g",
+  name: "reasoning",
+  parse: (value) => {
+    if (typeof value !== "string") {
+      throw new Error('"reasoning" parts expect a string value.');
+    }
+    return { type: "reasoning", value };
+  }
+};
+var sourcePart = {
+  code: "h",
+  name: "source",
+  parse: (value) => {
+    if (value == null || typeof value !== "object") {
+      throw new Error('"source" parts expect a Source object.');
+    }
+    return {
+      type: "source",
+      value
+    };
+  }
+};
+var redactedReasoningStreamPart = {
+  code: "i",
+  name: "redacted_reasoning",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string") {
+      throw new Error(
+        '"redacted_reasoning" parts expect an object with a "data" property.'
+      );
+    }
+    return { type: "redacted_reasoning", value: { data: value.data } };
+  }
+};
+var reasoningSignatureStreamPart = {
+  code: "j",
+  name: "reasoning_signature",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("signature" in value) || typeof value.signature !== "string") {
+      throw new Error(
+        '"reasoning_signature" parts expect an object with a "signature" property.'
+      );
+    }
+    return {
+      type: "reasoning_signature",
+      value: { signature: value.signature }
+    };
+  }
+};
+var fileStreamPart = {
+  code: "k",
+  name: "file",
+  parse: (value) => {
+    if (value == null || typeof value !== "object" || !("data" in value) || typeof value.data !== "string" || !("mimeType" in value) || typeof value.mimeType !== "string") {
+      throw new Error(
+        '"file" parts expect an object with a "data" and "mimeType" property.'
+      );
+    }
+    return { type: "file", value };
+  }
+};
+var dataStreamParts = [
+  textStreamPart,
+  dataStreamPart,
+  errorStreamPart,
+  messageAnnotationsStreamPart,
+  toolCallStreamPart,
+  toolResultStreamPart,
+  toolCallStreamingStartStreamPart,
+  toolCallDeltaStreamPart,
+  finishMessageStreamPart,
+  finishStepStreamPart,
+  startStepStreamPart,
+  reasoningStreamPart,
+  sourcePart,
+  redactedReasoningStreamPart,
+  reasoningSignatureStreamPart,
+  fileStreamPart
+];
+var dataStreamPartsByCode = Object.fromEntries(
+  dataStreamParts.map((part) => [part.code, part])
+);
+var DataStreamStringPrefixes = Object.fromEntries(
+  dataStreamParts.map((part) => [part.name, part.code])
+);
+var validCodes = dataStreamParts.map((part) => part.code);
+var parseDataStreamPart = (line) => {
+  const firstSeparatorIndex = line.indexOf(":");
+  if (firstSeparatorIndex === -1) {
+    throw new Error("Failed to parse stream string. No separator found.");
+  }
+  const prefix = line.slice(0, firstSeparatorIndex);
+  if (!validCodes.includes(prefix)) {
+    throw new Error(`Failed to parse stream string. Invalid code ${prefix}.`);
+  }
+  const code = prefix;
+  const textValue = line.slice(firstSeparatorIndex + 1);
+  const jsonValue = JSON.parse(textValue);
+  return dataStreamPartsByCode[code].parse(jsonValue);
+};
+function formatDataStreamPart(type, value) {
+  const streamPart = dataStreamParts.find((part) => part.name === type);
+  if (!streamPart) {
+    throw new Error(`Invalid stream part type: ${type}`);
+  }
+  return `${streamPart.code}:${JSON.stringify(value)}
+`;
+}
+
+// core/util/process-data-stream.ts
+var NEWLINE = "\n".charCodeAt(0);
+function concatChunks(chunks, totalLength) {
+  const concatenatedChunks = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    concatenatedChunks.set(chunk, offset);
+    offset += chunk.length;
+  }
+  chunks.length = 0;
+  return concatenatedChunks;
+}
+async function processDataStream({
+  stream,
+  onTextPart,
+  onReasoningPart,
+  onReasoningSignaturePart,
+  onRedactedReasoningPart,
+  onSourcePart,
+  onFilePart,
+  onDataPart,
+  onErrorPart,
+  onToolCallStreamingStartPart,
+  onToolCallDeltaPart,
+  onToolCallPart,
+  onToolResultPart,
+  onMessageAnnotationsPart,
+  onFinishMessagePart,
+  onFinishStepPart,
+  onStartStepPart
+}) {
+  const reader = stream.getReader();
+  const decoder = new TextDecoder();
+  const chunks = [];
+  let totalLength = 0;
+  while (true) {
+    const { value } = await reader.read();
+    if (value) {
+      chunks.push(value);
+      totalLength += value.length;
+      if (value[value.length - 1] !== NEWLINE) {
+        continue;
+      }
+    }
+    if (chunks.length === 0) {
+      break;
+    }
+    const concatenatedChunks = concatChunks(chunks, totalLength);
+    totalLength = 0;
+    const streamParts = decoder.decode(concatenatedChunks, { stream: true }).split("\n").filter((line) => line !== "").map(parseDataStreamPart);
+    for (const { type, value: value2 } of streamParts) {
+      switch (type) {
+        case "text":
+          await (onTextPart == null ? void 0 : onTextPart(value2));
+          break;
+        case "reasoning":
+          await (onReasoningPart == null ? void 0 : onReasoningPart(value2));
+          break;
+        case "reasoning_signature":
+          await (onReasoningSignaturePart == null ? void 0 : onReasoningSignaturePart(value2));
+          break;
+        case "redacted_reasoning":
+          await (onRedactedReasoningPart == null ? void 0 : onRedactedReasoningPart(value2));
+          break;
+        case "file":
+          await (onFilePart == null ? void 0 : onFilePart(value2));
+          break;
+        case "source":
+          await (onSourcePart == null ? void 0 : onSourcePart(value2));
+          break;
+        case "data":
+          await (onDataPart == null ? void 0 : onDataPart(value2));
+          break;
+        case "error":
+          await (onErrorPart == null ? void 0 : onErrorPart(value2));
+          break;
+        case "message_annotations":
+          await (onMessageAnnotationsPart == null ? void 0 : onMessageAnnotationsPart(value2));
+          break;
+        case "tool_call_streaming_start":
+          await (onToolCallStreamingStartPart == null ? void 0 : onToolCallStreamingStartPart(value2));
+          break;
+        case "tool_call_delta":
+          await (onToolCallDeltaPart == null ? void 0 : onToolCallDeltaPart(value2));
+          break;
+        case "tool_call":
+          await (onToolCallPart == null ? void 0 : onToolCallPart(value2));
+          break;
+        case "tool_result":
+          await (onToolResultPart == null ? void 0 : onToolResultPart(value2));
+          break;
+        case "finish_message":
+          await (onFinishMessagePart == null ? void 0 : onFinishMessagePart(value2));
+          break;
+        case "finish_step":
+          await (onFinishStepPart == null ? void 0 : onFinishStepPart(value2));
+          break;
+        case "start_step":
+          await (onStartStepPart == null ? void 0 : onStartStepPart(value2));
+          break;
+        default: {
+          const exhaustiveCheck = type;
+          throw new Error(`Unknown stream part type: ${exhaustiveCheck}`);
+        }
+      }
+    }
+  }
+}
+
+// core/util/process-chat-response.ts
+async function processChatResponse({
+  stream,
+  update,
+  onToolCall,
+  onFinish,
+  generateId: generateId3 = generateIdFunction,
+  getCurrentDate = () => /* @__PURE__ */ new Date(),
+  lastMessage
+}) {
+  var _a17, _b;
+  const replaceLastMessage = (lastMessage == null ? void 0 : lastMessage.role) === "assistant";
+  let step = replaceLastMessage ? 1 + // find max step in existing tool invocations:
+  ((_b = (_a17 = lastMessage.toolInvocations) == null ? void 0 : _a17.reduce((max, toolInvocation) => {
+    var _a18;
+    return Math.max(max, (_a18 = toolInvocation.step) != null ? _a18 : 0);
+  }, 0)) != null ? _b : 0) : 0;
+  const message = replaceLastMessage ? structuredClone(lastMessage) : {
+    id: generateId3(),
+    createdAt: getCurrentDate(),
+    role: "assistant",
+    content: "",
+    parts: []
+  };
+  let currentTextPart = void 0;
+  let currentReasoningPart = void 0;
+  let currentReasoningTextDetail = void 0;
+  function updateToolInvocationPart(toolCallId, invocation) {
+    const part = message.parts.find(
+      (part2) => part2.type === "tool-invocation" && part2.toolInvocation.toolCallId === toolCallId
+    );
+    if (part != null) {
+      part.toolInvocation = invocation;
+    } else {
+      message.parts.push({
+        type: "tool-invocation",
+        toolInvocation: invocation
+      });
+    }
+  }
+  const data = [];
+  let messageAnnotations = replaceLastMessage ? lastMessage == null ? void 0 : lastMessage.annotations : void 0;
+  const partialToolCalls = {};
+  let usage = {
+    completionTokens: NaN,
+    promptTokens: NaN,
+    totalTokens: NaN
+  };
+  let finishReason = "unknown";
+  function execUpdate() {
+    const copiedData = [...data];
+    if (messageAnnotations == null ? void 0 : messageAnnotations.length) {
+      message.annotations = messageAnnotations;
+    }
+    const copiedMessage = {
+      // deep copy the message to ensure that deep changes (msg attachments) are updated
+      // with SolidJS. SolidJS uses referential integration of sub-objects to detect changes.
+      ...structuredClone(message),
+      // add a revision id to ensure that the message is updated with SWR. SWR uses a
+      // hashing approach by default to detect changes, but it only works for shallow
+      // changes. This is why we need to add a revision id to ensure that the message
+      // is updated with SWR (without it, the changes get stuck in SWR and are not
+      // forwarded to rendering):
+      revisionId: generateId3()
+    };
+    update({
+      message: copiedMessage,
+      data: copiedData,
+      replaceLastMessage
+    });
+  }
+  await processDataStream({
+    stream,
+    onTextPart(value) {
+      if (currentTextPart == null) {
+        currentTextPart = {
+          type: "text",
+          text: value
+        };
+        message.parts.push(currentTextPart);
+      } else {
+        currentTextPart.text += value;
+      }
+      message.content += value;
+      execUpdate();
+    },
+    onReasoningPart(value) {
+      var _a18;
+      if (currentReasoningTextDetail == null) {
+        currentReasoningTextDetail = { type: "text", text: value };
+        if (currentReasoningPart != null) {
+          currentReasoningPart.details.push(currentReasoningTextDetail);
+        }
+      } else {
+        currentReasoningTextDetail.text += value;
+      }
+      if (currentReasoningPart == null) {
+        currentReasoningPart = {
+          type: "reasoning",
+          reasoning: value,
+          details: [currentReasoningTextDetail]
+        };
+        message.parts.push(currentReasoningPart);
+      } else {
+        currentReasoningPart.reasoning += value;
+      }
+      message.reasoning = ((_a18 = message.reasoning) != null ? _a18 : "") + value;
+      execUpdate();
+    },
+    onReasoningSignaturePart(value) {
+      if (currentReasoningTextDetail != null) {
+        currentReasoningTextDetail.signature = value.signature;
+      }
+    },
+    onRedactedReasoningPart(value) {
+      if (currentReasoningPart == null) {
+        currentReasoningPart = {
+          type: "reasoning",
+          reasoning: "",
+          details: []
+        };
+        message.parts.push(currentReasoningPart);
+      }
+      currentReasoningPart.details.push({
+        type: "redacted",
+        data: value.data
+      });
+      currentReasoningTextDetail = void 0;
+      execUpdate();
+    },
+    onFilePart(value) {
+      message.parts.push({
+        type: "file",
+        mediaType: value.mimeType,
+        data: value.data
+      });
+      execUpdate();
+    },
+    onSourcePart(value) {
+      message.parts.push({
+        type: "source",
+        source: value
+      });
+      execUpdate();
+    },
+    onToolCallStreamingStartPart(value) {
+      if (message.toolInvocations == null) {
+        message.toolInvocations = [];
+      }
+      partialToolCalls[value.toolCallId] = {
+        text: "",
+        step,
+        toolName: value.toolName,
+        index: message.toolInvocations.length
+      };
+      const invocation = {
+        state: "partial-call",
+        step,
+        toolCallId: value.toolCallId,
+        toolName: value.toolName,
+        args: void 0
+      };
+      message.toolInvocations.push(invocation);
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+    },
+    onToolCallDeltaPart(value) {
+      const partialToolCall = partialToolCalls[value.toolCallId];
+      partialToolCall.text += value.argsTextDelta;
+      const { value: partialArgs } = parsePartialJson(partialToolCall.text);
+      const invocation = {
+        state: "partial-call",
+        step: partialToolCall.step,
+        toolCallId: value.toolCallId,
+        toolName: partialToolCall.toolName,
+        args: partialArgs
+      };
+      message.toolInvocations[partialToolCall.index] = invocation;
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+    },
+    async onToolCallPart(value) {
+      const invocation = {
+        state: "call",
+        step,
+        ...value
+      };
+      if (partialToolCalls[value.toolCallId] != null) {
+        message.toolInvocations[partialToolCalls[value.toolCallId].index] = invocation;
+      } else {
+        if (message.toolInvocations == null) {
+          message.toolInvocations = [];
+        }
+        message.toolInvocations.push(invocation);
+      }
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+      if (onToolCall) {
+        const result = await onToolCall({ toolCall: value });
+        if (result != null) {
+          const invocation2 = {
+            state: "result",
+            step,
+            ...value,
+            result
+          };
+          message.toolInvocations[message.toolInvocations.length - 1] = invocation2;
+          updateToolInvocationPart(value.toolCallId, invocation2);
+          execUpdate();
+        }
+      }
+    },
+    onToolResultPart(value) {
+      const toolInvocations = message.toolInvocations;
+      if (toolInvocations == null) {
+        throw new Error("tool_result must be preceded by a tool_call");
+      }
+      const toolInvocationIndex = toolInvocations.findIndex(
+        (invocation2) => invocation2.toolCallId === value.toolCallId
+      );
+      if (toolInvocationIndex === -1) {
+        throw new Error(
+          "tool_result must be preceded by a tool_call with the same toolCallId"
+        );
+      }
+      const invocation = {
+        ...toolInvocations[toolInvocationIndex],
+        state: "result",
+        ...value
+      };
+      toolInvocations[toolInvocationIndex] = invocation;
+      updateToolInvocationPart(value.toolCallId, invocation);
+      execUpdate();
+    },
+    onDataPart(value) {
+      data.push(...value);
+      execUpdate();
+    },
+    onMessageAnnotationsPart(value) {
+      if (messageAnnotations == null) {
+        messageAnnotations = [...value];
+      } else {
+        messageAnnotations.push(...value);
+      }
+      execUpdate();
+    },
+    onFinishStepPart(value) {
+      step += 1;
+      currentTextPart = value.isContinued ? currentTextPart : void 0;
+      currentReasoningPart = void 0;
+      currentReasoningTextDetail = void 0;
+    },
+    onStartStepPart(value) {
+      if (!replaceLastMessage) {
+        message.id = value.messageId;
+      }
+      message.parts.push({ type: "step-start" });
+      execUpdate();
+    },
+    onFinishMessagePart(value) {
+      finishReason = value.finishReason;
+      if (value.usage != null) {
+        usage = calculateLanguageModelUsage(value.usage);
+      }
+    },
+    onErrorPart(error) {
+      throw new Error(error);
+    }
+  });
+  onFinish == null ? void 0 : onFinish({ message, finishReason, usage });
+}
+
+// core/util/process-chat-text-response.ts
+import { generateId as generateIdFunction2 } from "@ai-sdk/provider-utils";
+
+// core/util/process-text-stream.ts
+async function processTextStream({
+  stream,
+  onTextPart
+}) {
+  const reader = stream.pipeThrough(new TextDecoderStream()).getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) {
+      break;
+    }
+    await onTextPart(value);
+  }
+}
+
+// core/util/process-chat-text-response.ts
+async function processChatTextResponse({
+  stream,
+  update,
+  onFinish,
+  getCurrentDate = () => /* @__PURE__ */ new Date(),
+  generateId: generateId3 = generateIdFunction2
+}) {
+  const textPart = { type: "text", text: "" };
+  const resultMessage = {
+    id: generateId3(),
+    createdAt: getCurrentDate(),
+    role: "assistant",
+    content: "",
+    parts: [textPart]
+  };
+  await processTextStream({
+    stream,
+    onTextPart: (chunk) => {
+      resultMessage.content += chunk;
+      textPart.text += chunk;
+      update({
+        message: { ...resultMessage },
+        data: [],
+        replaceLastMessage: false
+      });
+    }
+  });
+  onFinish == null ? void 0 : onFinish(resultMessage, {
+    usage: { completionTokens: NaN, promptTokens: NaN, totalTokens: NaN },
+    finishReason: "unknown"
+  });
+}
+
+// core/util/call-chat-api.ts
+var getOriginalFetch = () => fetch;
+async function callChatApi({
+  api,
+  body,
+  streamProtocol = "data",
+  credentials,
+  headers,
+  abortController,
+  restoreMessagesOnFailure,
+  onResponse,
+  onUpdate,
+  onFinish,
+  onToolCall,
+  generateId: generateId3,
+  fetch: fetch2 = getOriginalFetch(),
+  lastMessage
+}) {
+  var _a17, _b;
+  const response = await fetch2(api, {
+    method: "POST",
+    body: JSON.stringify(body),
+    headers: {
+      "Content-Type": "application/json",
+      ...headers
+    },
+    signal: (_a17 = abortController == null ? void 0 : abortController()) == null ? void 0 : _a17.signal,
+    credentials
+  }).catch((err) => {
+    restoreMessagesOnFailure();
+    throw err;
+  });
+  if (onResponse) {
+    try {
+      await onResponse(response);
+    } catch (err) {
+      throw err;
+    }
+  }
+  if (!response.ok) {
+    restoreMessagesOnFailure();
+    throw new Error(
+      (_b = await response.text()) != null ? _b : "Failed to fetch the chat response."
+    );
+  }
+  if (!response.body) {
+    throw new Error("The response body is empty.");
+  }
+  switch (streamProtocol) {
+    case "text": {
+      await processChatTextResponse({
+        stream: response.body,
+        update: onUpdate,
+        onFinish,
+        generateId: generateId3
+      });
+      return;
+    }
+    case "data": {
+      await processChatResponse({
+        stream: response.body,
+        update: onUpdate,
+        lastMessage,
+        onToolCall,
+        onFinish({ message, finishReason, usage }) {
+          if (onFinish && message != null) {
+            onFinish(message, { usage, finishReason });
+          }
+        },
+        generateId: generateId3
+      });
+      return;
+    }
+    default: {
+      const exhaustiveCheck = streamProtocol;
+      throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+    }
+  }
+}
+
+// core/util/call-completion-api.ts
+var getOriginalFetch2 = () => fetch;
+async function callCompletionApi({
+  api,
+  prompt,
+  credentials,
+  headers,
+  body,
+  streamProtocol = "data",
+  setCompletion,
+  setLoading,
+  setError,
+  setAbortController,
+  onResponse,
+  onFinish,
+  onError,
+  onData,
+  fetch: fetch2 = getOriginalFetch2()
+}) {
+  var _a17;
+  try {
+    setLoading(true);
+    setError(void 0);
+    const abortController = new AbortController();
+    setAbortController(abortController);
+    setCompletion("");
+    const response = await fetch2(api, {
+      method: "POST",
+      body: JSON.stringify({
+        prompt,
+        ...body
+      }),
+      credentials,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers
+      },
+      signal: abortController.signal
+    }).catch((err) => {
+      throw err;
+    });
+    if (onResponse) {
+      try {
+        await onResponse(response);
+      } catch (err) {
+        throw err;
+      }
+    }
+    if (!response.ok) {
+      throw new Error(
+        (_a17 = await response.text()) != null ? _a17 : "Failed to fetch the chat response."
+      );
+    }
+    if (!response.body) {
+      throw new Error("The response body is empty.");
+    }
+    let result = "";
+    switch (streamProtocol) {
+      case "text": {
+        await processTextStream({
+          stream: response.body,
+          onTextPart: (chunk) => {
+            result += chunk;
+            setCompletion(result);
+          }
+        });
+        break;
+      }
+      case "data": {
+        await processDataStream({
+          stream: response.body,
+          onTextPart(value) {
+            result += value;
+            setCompletion(result);
+          },
+          onDataPart(value) {
+            onData == null ? void 0 : onData(value);
+          },
+          onErrorPart(value) {
+            throw new Error(value);
+          }
+        });
+        break;
+      }
+      default: {
+        const exhaustiveCheck = streamProtocol;
+        throw new Error(`Unknown stream protocol: ${exhaustiveCheck}`);
+      }
+    }
+    if (onFinish) {
+      onFinish(prompt, result);
+    }
+    setAbortController(null);
+    return result;
+  } catch (err) {
+    if (err.name === "AbortError") {
+      setAbortController(null);
+      return null;
+    }
+    if (err instanceof Error) {
+      if (onError) {
+        onError(err);
+      }
+    }
+    setError(err);
+  } finally {
+    setLoading(false);
+  }
+}
+
+// core/util/data-url.ts
+function getTextFromDataUrl(dataUrl) {
+  const [header, base64Content] = dataUrl.split(",");
+  const mediaType = header.split(";")[0].split(":")[1];
+  if (mediaType == null || base64Content == null) {
+    throw new Error("Invalid data URL format");
+  }
+  try {
+    return window.atob(base64Content);
+  } catch (error) {
+    throw new Error(`Error decoding data URL`);
+  }
+}
+
+// core/util/extract-max-tool-invocation-step.ts
+function extractMaxToolInvocationStep(toolInvocations) {
+  return toolInvocations == null ? void 0 : toolInvocations.reduce((max, toolInvocation) => {
+    var _a17;
+    return Math.max(max, (_a17 = toolInvocation.step) != null ? _a17 : 0);
+  }, 0);
+}
+
+// core/util/get-message-parts.ts
+function getMessageParts(message) {
+  var _a17;
+  return (_a17 = message.parts) != null ? _a17 : [
+    ...message.toolInvocations ? message.toolInvocations.map((toolInvocation) => ({
+      type: "tool-invocation",
+      toolInvocation
+    })) : [],
+    ...message.reasoning ? [
+      {
+        type: "reasoning",
+        reasoning: message.reasoning,
+        details: [{ type: "text", text: message.reasoning }]
+      }
+    ] : [],
+    ...message.content ? [{ type: "text", text: message.content }] : []
+  ];
+}
+
+// core/util/fill-message-parts.ts
+function fillMessageParts(messages) {
+  return messages.map((message) => ({
+    ...message,
+    parts: getMessageParts(message)
+  }));
+}
+
+// core/util/is-deep-equal-data.ts
+function isDeepEqualData(obj1, obj2) {
+  if (obj1 === obj2)
+    return true;
+  if (obj1 == null || obj2 == null)
+    return false;
+  if (typeof obj1 !== "object" && typeof obj2 !== "object")
+    return obj1 === obj2;
+  if (obj1.constructor !== obj2.constructor)
+    return false;
+  if (obj1 instanceof Date && obj2 instanceof Date) {
+    return obj1.getTime() === obj2.getTime();
+  }
+  if (Array.isArray(obj1)) {
+    if (obj1.length !== obj2.length)
+      return false;
+    for (let i = 0; i < obj1.length; i++) {
+      if (!isDeepEqualData(obj1[i], obj2[i]))
+        return false;
+    }
+    return true;
+  }
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length)
+    return false;
+  for (const key of keys1) {
+    if (!keys2.includes(key))
+      return false;
+    if (!isDeepEqualData(obj1[key], obj2[key]))
+      return false;
+  }
+  return true;
+}
+
+// core/util/prepare-attachments-for-request.ts
+async function prepareAttachmentsForRequest(attachmentsFromOptions) {
+  if (!attachmentsFromOptions) {
+    return [];
+  }
+  if (attachmentsFromOptions instanceof FileList) {
+    return Promise.all(
+      Array.from(attachmentsFromOptions).map(async (attachment) => {
+        const { name: name17, type } = attachment;
+        const dataUrl = await new Promise((resolve, reject) => {
+          const reader = new FileReader();
+          reader.onload = (readerEvent) => {
+            var _a17;
+            resolve((_a17 = readerEvent.target) == null ? void 0 : _a17.result);
+          };
+          reader.onerror = (error) => reject(error);
+          reader.readAsDataURL(attachment);
+        });
+        return {
+          name: name17,
+          contentType: type,
+          url: dataUrl
+        };
+      })
+    );
+  }
+  if (Array.isArray(attachmentsFromOptions)) {
+    return attachmentsFromOptions;
+  }
+  throw new Error("Invalid attachments type");
+}
+
+// core/util/schema.ts
+import { validatorSymbol } from "@ai-sdk/provider-utils";
+
+// core/util/zod-schema.ts
+import zodToJsonSchema from "zod-to-json-schema";
+function zodSchema(zodSchema2, options) {
+  var _a17;
+  const useReferences = (_a17 = options == null ? void 0 : options.useReferences) != null ? _a17 : false;
+  return jsonSchema(
+    zodToJsonSchema(zodSchema2, {
+      $refStrategy: useReferences ? "root" : "none",
+      target: "jsonSchema7"
+      // note: openai mode breaks various gemini conversions
+    }),
+    {
+      validate: (value) => {
+        const result = zodSchema2.safeParse(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+
+// core/util/schema.ts
+var schemaSymbol = Symbol.for("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return isSchema(schema) ? schema : zodSchema(schema);
+}
+
+// core/util/should-resubmit-messages.ts
+function shouldResubmitMessages({
+  originalMaxToolInvocationStep,
+  originalMessageCount,
+  maxSteps,
+  messages
+}) {
+  var _a17;
+  const lastMessage = messages[messages.length - 1];
+  return (
+    // check if the feature is enabled:
+    maxSteps > 1 && // ensure there is a last message:
+    lastMessage != null && // ensure we actually have new steps (to prevent infinite loops in case of errors):
+    (messages.length > originalMessageCount || extractMaxToolInvocationStep(lastMessage.toolInvocations) !== originalMaxToolInvocationStep) && // check that next step is possible:
+    isAssistantMessageWithCompletedToolCalls(lastMessage) && // limit the number of automatic steps:
+    ((_a17 = extractMaxToolInvocationStep(lastMessage.toolInvocations)) != null ? _a17 : 0) < maxSteps
+  );
+}
+function isAssistantMessageWithCompletedToolCalls(message) {
+  if (message.role !== "assistant") {
+    return false;
+  }
+  const lastStepStartIndex = message.parts.reduce((lastIndex, part, index) => {
+    return part.type === "step-start" ? index : lastIndex;
+  }, -1);
+  const lastStepToolInvocations = message.parts.slice(lastStepStartIndex + 1).filter((part) => part.type === "tool-invocation");
+  return lastStepToolInvocations.length > 0 && lastStepToolInvocations.every((part) => "result" in part.toolInvocation);
+}
+
+// core/util/update-tool-call-result.ts
+function updateToolCallResult({
+  messages,
+  toolCallId,
+  toolResult: result
+}) {
+  var _a17;
+  const lastMessage = messages[messages.length - 1];
+  const invocationPart = lastMessage.parts.find(
+    (part) => part.type === "tool-invocation" && part.toolInvocation.toolCallId === toolCallId
+  );
+  if (invocationPart == null) {
+    return;
+  }
+  const toolResult = {
+    ...invocationPart.toolInvocation,
+    state: "result",
+    result
+  };
+  invocationPart.toolInvocation = toolResult;
+  lastMessage.toolInvocations = (_a17 = lastMessage.toolInvocations) == null ? void 0 : _a17.map(
+    (toolInvocation) => toolInvocation.toolCallId === toolCallId ? toolResult : toolInvocation
+  );
+}
 
 // core/data-stream/create-data-stream.ts
-import { formatDataStreamPart } from "@ai-sdk/ui-utils";
 function createDataStream({
   execute,
   onError = () => "An error occurred."
@@ -830,12 +2293,12 @@ import {
 var DefaultGeneratedFile = class {
   constructor({
     data,
-    mimeType
+    mediaType
   }) {
     const isUint8Array = data instanceof Uint8Array;
     this.base64Data = isUint8Array ? void 0 : data;
     this.uint8ArrayData = isUint8Array ? data : void 0;
-    this.mimeType = mimeType;
+    this.mediaType = mediaType;
   }
   // lazy conversion with caching to avoid unnecessary conversion overhead:
   get base64() {
@@ -859,45 +2322,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,
@@ -915,7 +2378,7 @@ var mimeTypeSignatures = [
     base64Prefix: "AAAAIGZ0eXBhdmlm"
   },
   {
-    mimeType: "image/heic",
+    mediaType: "image/heic",
     bytesPrefix: [
       0,
       0,
@@ -933,10 +2396,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;
@@ -992,7 +2490,10 @@ async function generateImage({
           var _a18;
           return new DefaultGeneratedFile({
             data: image,
-            mimeType: (_a18 = detectImageMimeType(image)) != null ? _a18 : "image/png"
+            mediaType: (_a18 = detectMediaType({
+              data: image,
+              signatures: imageMediaTypeSignatures
+            })) != null ? _a18 : "image/png"
           });
         }
       )
@@ -1021,7 +2522,7 @@ import {
   JSONParseError,
   TypeValidationError as TypeValidationError2
 } from "@ai-sdk/provider";
-import { createIdGenerator, safeParseJSON } from "@ai-sdk/provider-utils";
+import { createIdGenerator, safeParseJSON as safeParseJSON2 } from "@ai-sdk/provider-utils";
 
 // errors/no-object-generated-error.ts
 import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
@@ -1051,6 +2552,9 @@ var NoObjectGeneratedError = class extends AISDKError4 {
 };
 _a4 = symbol4;
 
+// core/prompt/convert-to-language-model-prompt.ts
+import { convertUint8ArrayToBase64 as convertUint8ArrayToBase643 } from "@ai-sdk/provider-utils";
+
 // util/download-error.ts
 import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
 var name5 = "AI_DownloadError";
@@ -1092,7 +2596,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)) {
@@ -1208,12 +2712,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
     };
   }
@@ -1278,7 +2782,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": {
@@ -1286,7 +2790,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
               };
             }
@@ -1374,7 +2878,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",
@@ -1382,7 +2886,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;
@@ -1404,19 +2908,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;
       }
@@ -1427,25 +2931,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 ? convertUint8ArrayToBase643(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
       };
     }
   }
@@ -1575,7 +3084,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: url,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1583,14 +3092,14 @@ function attachmentsToParts(attachments) {
       case "data:": {
         let header;
         let base64Content;
-        let mimeType;
+        let mediaType;
         try {
           [header, base64Content] = attachment.url.split(",");
-          mimeType = header.split(";")[0].split(":")[1];
+          mediaType = header.split(";")[0].split(":")[1];
         } catch (error) {
           throw new Error(`Error processing data URL: ${attachment.url}`);
         }
-        if (mimeType == null || base64Content == null) {
+        if (mediaType == null || base64Content == null) {
           throw new Error(`Invalid data URL format: ${attachment.url}`);
         }
         if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) {
@@ -1614,7 +3123,7 @@ function attachmentsToParts(attachments) {
           parts.push({
             type: "file",
             data: base64Content,
-            mimeType: attachment.contentType
+            mediaType: attachment.contentType
           });
         }
         break;
@@ -1689,14 +3198,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) {
@@ -1953,7 +3471,7 @@ var toolResultContentSchema = z4.array(
     z4.object({
       type: z4.literal("image"),
       data: z4.string(),
-      mimeType: z4.string().optional()
+      mediaType: z4.string().optional()
     })
   ])
 );
@@ -1968,6 +3486,7 @@ var textPartSchema = z5.object({
 var imagePartSchema = z5.object({
   type: z5.literal("image"),
   image: z5.union([dataContentSchema, z5.instanceof(URL)]),
+  mediaType: z5.string().optional(),
   mimeType: z5.string().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
@@ -1976,7 +3495,8 @@ var filePartSchema = z5.object({
   type: z5.literal("file"),
   data: z5.union([dataContentSchema, z5.instanceof(URL)]),
   filename: z5.string().optional(),
-  mimeType: z5.string(),
+  mediaType: z5.string(),
+  mimeType: z5.string().optional(),
   providerOptions: providerMetadataSchema.optional(),
   experimental_providerMetadata: providerMetadataSchema.optional()
 });
@@ -2136,7 +3656,7 @@ function standardizePrompt({
 }
 
 // core/types/usage.ts
-function calculateLanguageModelUsage({
+function calculateLanguageModelUsage2({
   promptTokens,
   completionTokens
 }) {
@@ -2182,7 +3702,6 @@ import {
   UnsupportedFunctionalityError
 } from "@ai-sdk/provider";
 import { safeValidateTypes as safeValidateTypes2 } from "@ai-sdk/provider-utils";
-import { asSchema } from "@ai-sdk/ui-utils";
 
 // core/util/async-iterable-stream.ts
 function createAsyncIterableStream(source) {
@@ -2632,7 +4151,6 @@ async function generateObject({
       let finishReason;
       let usage;
       let warnings;
-      let rawResponse;
       let response;
       let request;
       let logprobs;
@@ -2687,7 +4205,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",
@@ -2705,13 +4223,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
                   });
                 }
@@ -2743,7 +4263,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 : {};
@@ -2793,7 +4312,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: [
                     {
@@ -2815,13 +4334,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
                   });
                 }
@@ -2853,7 +4374,6 @@ async function generateObject({
           finishReason = generateResult.finishReason;
           usage = generateResult.usage;
           warnings = generateResult.warnings;
-          rawResponse = generateResult.rawResponse;
           logprobs = generateResult.logprobs;
           resultProviderMetadata = generateResult.providerMetadata;
           request = (_d = generateResult.request) != null ? _d : {};
@@ -2871,14 +4391,14 @@ async function generateObject({
         }
       }
       function processResult(result2) {
-        const parseResult = safeParseJSON({ text: result2 });
+        const parseResult = safeParseJSON2({ text: result2 });
         if (!parseResult.success) {
           throw new NoObjectGeneratedError({
             message: "No object generated: could not parse the response.",
             cause: parseResult.error,
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage),
+            usage: calculateLanguageModelUsage2(usage),
             finishReason
           });
         }
@@ -2887,7 +4407,7 @@ async function generateObject({
           {
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage)
+            usage: calculateLanguageModelUsage2(usage)
           }
         );
         if (!validationResult.success) {
@@ -2896,7 +4416,7 @@ async function generateObject({
             cause: validationResult.error,
             text: result2,
             response,
-            usage: calculateLanguageModelUsage(usage),
+            usage: calculateLanguageModelUsage2(usage),
             finishReason
           });
         }
@@ -2935,14 +4455,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
       });
@@ -2974,10 +4490,6 @@ var DefaultGenerateObjectResult = class {
 
 // core/generate-object/stream-object.ts
 import { createIdGenerator as createIdGenerator2 } from "@ai-sdk/provider-utils";
-import {
-  isDeepEqualData,
-  parsePartialJson
-} from "@ai-sdk/ui-utils";
 
 // util/delayed-promise.ts
 var DelayedPromise = class {
@@ -3361,7 +4873,7 @@ var DefaultStreamObjectResult = class {
           }
         }
         const {
-          result: { stream, warnings, rawResponse, request },
+          result: { stream, warnings, response, request },
           doStreamSpan,
           startTimestampMs
         } = await retry(
@@ -3410,7 +4922,7 @@ var DefaultStreamObjectResult = class {
         let error;
         let accumulatedText = "";
         let textDelta = "";
-        let response = {
+        let fullResponse = {
           id: generateId3(),
           timestamp: currentDate(),
           modelId: model.modelId
@@ -3467,10 +4979,10 @@ var DefaultStreamObjectResult = class {
               }
               switch (chunk.type) {
                 case "response-metadata": {
-                  response = {
-                    id: (_a18 = chunk.id) != null ? _a18 : response.id,
-                    timestamp: (_b2 = chunk.timestamp) != null ? _b2 : response.timestamp,
-                    modelId: (_c = chunk.modelId) != null ? _c : response.modelId
+                  fullResponse = {
+                    id: (_a18 = chunk.id) != null ? _a18 : fullResponse.id,
+                    timestamp: (_b2 = chunk.timestamp) != null ? _b2 : fullResponse.timestamp,
+                    modelId: (_c = chunk.modelId) != null ? _c : fullResponse.modelId
                   };
                   break;
                 }
@@ -3479,20 +4991,24 @@ var DefaultStreamObjectResult = class {
                     controller.enqueue({ type: "text-delta", textDelta });
                   }
                   finishReason = chunk.finishReason;
-                  usage = calculateLanguageModelUsage(chunk.usage);
+                  usage = calculateLanguageModelUsage2(chunk.usage);
                   providerMetadata = chunk.providerMetadata;
-                  controller.enqueue({ ...chunk, usage, response });
+                  controller.enqueue({
+                    ...chunk,
+                    usage,
+                    response: fullResponse
+                  });
                   self.usagePromise.resolve(usage);
                   self.providerMetadataPromise.resolve(providerMetadata);
                   self.responsePromise.resolve({
-                    ...response,
-                    headers: rawResponse == null ? void 0 : rawResponse.headers
+                    ...fullResponse,
+                    headers: response == null ? void 0 : response.headers
                   });
                   const validationResult = outputStrategy.validateFinalResult(
                     latestObjectJson,
                     {
                       text: accumulatedText,
-                      response,
+                      response: fullResponse,
                       usage
                     }
                   );
@@ -3504,7 +5020,7 @@ var DefaultStreamObjectResult = class {
                       message: "No object generated: response did not match schema.",
                       cause: validationResult.error,
                       text: accumulatedText,
-                      response,
+                      response: fullResponse,
                       usage,
                       finishReason
                     });
@@ -3534,15 +5050,15 @@ var DefaultStreamObjectResult = class {
                       "ai.response.object": {
                         output: () => JSON.stringify(object2)
                       },
-                      "ai.response.id": response.id,
-                      "ai.response.model": response.modelId,
-                      "ai.response.timestamp": response.timestamp.toISOString(),
+                      "ai.response.id": fullResponse.id,
+                      "ai.response.model": fullResponse.modelId,
+                      "ai.response.timestamp": fullResponse.timestamp.toISOString(),
                       "ai.usage.promptTokens": finalUsage.promptTokens,
                       "ai.usage.completionTokens": finalUsage.completionTokens,
                       // standardized gen-ai llm span attributes:
                       "gen_ai.response.finish_reasons": [finishReason],
-                      "gen_ai.response.id": response.id,
-                      "gen_ai.response.model": response.modelId,
+                      "gen_ai.response.id": fullResponse.id,
+                      "gen_ai.response.model": fullResponse.modelId,
                       "gen_ai.usage.input_tokens": finalUsage.promptTokens,
                       "gen_ai.usage.output_tokens": finalUsage.completionTokens
                     }
@@ -3566,8 +5082,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,
@@ -3739,9 +5255,6 @@ var ToolExecutionError = class extends AISDKError10 {
 };
 _a10 = symbol10;
 
-// core/prompt/prepare-tools-and-tool-choice.ts
-import { asSchema as asSchema2 } from "@ai-sdk/ui-utils";
-
 // core/util/is-non-empty-object.ts
 function isNonEmptyObject(object2) {
   return object2 != null && Object.keys(object2).length > 0;
@@ -3772,7 +5285,7 @@ function prepareToolsAndToolChoice({
             type: "function",
             name: name17,
             description: tool2.description,
-            parameters: asSchema2(tool2.parameters).jsonSchema
+            parameters: asSchema(tool2.parameters).jsonSchema
           };
         case "provider-defined":
           return {
@@ -3805,8 +5318,7 @@ function removeTextAfterLastWhitespace(text2) {
 }
 
 // core/generate-text/parse-tool-call.ts
-import { safeParseJSON as safeParseJSON2, safeValidateTypes as safeValidateTypes3 } from "@ai-sdk/provider-utils";
-import { asSchema as asSchema3 } from "@ai-sdk/ui-utils";
+import { safeParseJSON as safeParseJSON3, safeValidateTypes as safeValidateTypes3 } from "@ai-sdk/provider-utils";
 
 // errors/invalid-tool-arguments-error.ts
 import { AISDKError as AISDKError11, getErrorMessage as getErrorMessage3 } from "@ai-sdk/provider";
@@ -3901,7 +5413,7 @@ async function parseToolCall({
       repairedToolCall = await repairToolCall({
         toolCall,
         tools,
-        parameterSchema: ({ toolName }) => asSchema3(tools[toolName].parameters).jsonSchema,
+        parameterSchema: ({ toolName }) => asSchema(tools[toolName].parameters).jsonSchema,
         system,
         messages,
         error
@@ -3930,8 +5442,8 @@ async function doParseToolCall({
       availableTools: Object.keys(tools)
     });
   }
-  const schema = asSchema3(tool2.parameters);
-  const parseResult = toolCall.args.trim() === "" ? safeValidateTypes3({ value: {}, schema }) : safeParseJSON2({ text: toolCall.args, schema });
+  const schema = asSchema(tool2.parameters);
+  const parseResult = toolCall.args.trim() === "" ? safeValidateTypes3({ value: {}, schema }) : safeParseJSON3({ text: toolCall.args, schema });
   if (parseResult.success === false) {
     throw new InvalidToolArgumentsError({
       toolName,
@@ -3975,7 +5487,7 @@ function toResponseMessages({
       ...files.map((file) => ({
         type: "file",
         data: file.base64,
-        mimeType: file.mimeType
+        mediaType: file.mediaType
       })),
       { type: "text", text: text2 },
       ...toolCalls
@@ -4086,7 +5598,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 })
       };
@@ -4161,7 +5673,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,
@@ -4175,7 +5687,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({
@@ -4225,7 +5739,7 @@ async function generateText({
           messages: stepInputMessages,
           abortSignal
         });
-        const currentUsage = calculateLanguageModelUsage(
+        const currentUsage = calculateLanguageModelUsage2(
           currentModelResponse.usage
         );
         usage = addLanguageModelUsage(usage, currentUsage);
@@ -4292,8 +5806,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)
           },
@@ -4345,11 +5857,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,
@@ -4478,11 +5988,7 @@ __export(output_exports, {
   object: () => object,
   text: () => text
 });
-import { safeParseJSON as safeParseJSON3, safeValidateTypes as safeValidateTypes4 } from "@ai-sdk/provider-utils";
-import {
-  asSchema as asSchema4,
-  parsePartialJson as parsePartialJson2
-} from "@ai-sdk/ui-utils";
+import { safeParseJSON as safeParseJSON4, safeValidateTypes as safeValidateTypes4 } from "@ai-sdk/provider-utils";
 
 // errors/index.ts
 import {
@@ -4558,7 +6064,7 @@ var text = () => ({
 var object = ({
   schema: inputSchema
 }) => {
-  const schema = asSchema4(inputSchema);
+  const schema = asSchema(inputSchema);
   return {
     type: "object",
     responseFormat: ({ model }) => ({
@@ -4572,7 +6078,7 @@ var object = ({
       });
     },
     parsePartial({ text: text2 }) {
-      const result = parsePartialJson2(text2);
+      const result = parsePartialJson(text2);
       switch (result.state) {
         case "failed-parse":
         case "undefined-input":
@@ -4590,7 +6096,7 @@ var object = ({
       }
     },
     parseOutput({ text: text2 }, context) {
-      const parseResult = safeParseJSON3({ text: text2 });
+      const parseResult = safeParseJSON4({ text: text2 });
       if (!parseResult.success) {
         throw new NoObjectGeneratedError({
           message: "No object generated: could not parse the response.",
@@ -4692,7 +6198,6 @@ function smoothStream({
 // core/generate-text/stream-text.ts
 import { AISDKError as AISDKError17 } from "@ai-sdk/provider";
 import { createIdGenerator as createIdGenerator4 } from "@ai-sdk/provider-utils";
-import { formatDataStreamPart as formatDataStreamPart2 } from "@ai-sdk/ui-utils";
 
 // util/as-array.ts
 function asArray(value) {
@@ -4807,7 +6312,6 @@ function mergeStreams(stream1, stream2) {
 }
 
 // core/generate-text/run-tools-transformation.ts
-import { generateId } from "@ai-sdk/ui-utils";
 function runToolsTransformation({
   tools,
   generatorStream,
@@ -4855,7 +6359,7 @@ function runToolsTransformation({
           controller.enqueue(
             new DefaultGeneratedFileWithType({
               data: chunk.data,
-              mimeType: chunk.mimeType
+              mediaType: chunk.mediaType
             })
           );
           break;
@@ -4966,7 +6470,7 @@ function runToolsTransformation({
             type: "finish",
             finishReason: chunk.finishReason,
             logprobs: chunk.logprobs,
-            usage: calculateLanguageModelUsage(chunk.usage),
+            usage: calculateLanguageModelUsage2(chunk.usage),
             experimental_providerMetadata: chunk.providerMetadata
           };
           break;
@@ -5477,7 +6981,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(
@@ -5788,7 +7292,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",
@@ -5805,7 +7309,7 @@ var DefaultStreamTextResult = class {
                       logprobs: stepLogProbs,
                       response: {
                         ...stepResponse,
-                        headers: rawResponse == null ? void 0 : rawResponse.headers
+                        headers: response == null ? void 0 : response.headers
                       }
                     });
                     self.closeStream();
@@ -6001,13 +7505,13 @@ var DefaultStreamTextResult = class {
           const chunkType = chunk.type;
           switch (chunkType) {
             case "text-delta": {
-              controller.enqueue(formatDataStreamPart2("text", chunk.textDelta));
+              controller.enqueue(formatDataStreamPart("text", chunk.textDelta));
               break;
             }
             case "reasoning": {
               if (sendReasoning) {
                 controller.enqueue(
-                  formatDataStreamPart2("reasoning", chunk.textDelta)
+                  formatDataStreamPart("reasoning", chunk.textDelta)
                 );
               }
               break;
@@ -6015,7 +7519,7 @@ var DefaultStreamTextResult = class {
             case "redacted-reasoning": {
               if (sendReasoning) {
                 controller.enqueue(
-                  formatDataStreamPart2("redacted_reasoning", {
+                  formatDataStreamPart("redacted_reasoning", {
                     data: chunk.data
                   })
                 );
@@ -6025,7 +7529,7 @@ var DefaultStreamTextResult = class {
             case "reasoning-signature": {
               if (sendReasoning) {
                 controller.enqueue(
-                  formatDataStreamPart2("reasoning_signature", {
+                  formatDataStreamPart("reasoning_signature", {
                     signature: chunk.signature
                   })
                 );
@@ -6034,8 +7538,8 @@ var DefaultStreamTextResult = class {
             }
             case "file": {
               controller.enqueue(
-                formatDataStreamPart2("file", {
-                  mimeType: chunk.mimeType,
+                formatDataStreamPart("file", {
+                  mimeType: chunk.mediaType,
                   data: chunk.base64
                 })
               );
@@ -6044,14 +7548,14 @@ var DefaultStreamTextResult = class {
             case "source": {
               if (sendSources) {
                 controller.enqueue(
-                  formatDataStreamPart2("source", chunk.source)
+                  formatDataStreamPart("source", chunk.source)
                 );
               }
               break;
             }
             case "tool-call-streaming-start": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call_streaming_start", {
+                formatDataStreamPart("tool_call_streaming_start", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName
                 })
@@ -6060,7 +7564,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call-delta": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call_delta", {
+                formatDataStreamPart("tool_call_delta", {
                   toolCallId: chunk.toolCallId,
                   argsTextDelta: chunk.argsTextDelta
                 })
@@ -6069,7 +7573,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-call": {
               controller.enqueue(
-                formatDataStreamPart2("tool_call", {
+                formatDataStreamPart("tool_call", {
                   toolCallId: chunk.toolCallId,
                   toolName: chunk.toolName,
                   args: chunk.args
@@ -6079,7 +7583,7 @@ var DefaultStreamTextResult = class {
             }
             case "tool-result": {
               controller.enqueue(
-                formatDataStreamPart2("tool_result", {
+                formatDataStreamPart("tool_result", {
                   toolCallId: chunk.toolCallId,
                   result: chunk.result
                 })
@@ -6088,13 +7592,13 @@ var DefaultStreamTextResult = class {
             }
             case "error": {
               controller.enqueue(
-                formatDataStreamPart2("error", getErrorMessage5(chunk.error))
+                formatDataStreamPart("error", getErrorMessage5(chunk.error))
               );
               break;
             }
             case "step-start": {
               controller.enqueue(
-                formatDataStreamPart2("start_step", {
+                formatDataStreamPart("start_step", {
                   messageId: chunk.messageId
                 })
               );
@@ -6102,7 +7606,7 @@ var DefaultStreamTextResult = class {
             }
             case "step-finish": {
               controller.enqueue(
-                formatDataStreamPart2("finish_step", {
+                formatDataStreamPart("finish_step", {
                   finishReason: chunk.finishReason,
                   usage: sendUsage ? {
                     promptTokens: chunk.usage.promptTokens,
@@ -6116,7 +7620,7 @@ var DefaultStreamTextResult = class {
             case "finish": {
               if (experimental_sendFinish) {
                 controller.enqueue(
-                  formatDataStreamPart2("finish_message", {
+                  formatDataStreamPart("finish_message", {
                     finishReason: chunk.finishReason,
                     usage: sendUsage ? {
                       promptTokens: chunk.usage.promptTokens,
@@ -6239,6 +7743,70 @@ var DefaultStreamTextResult = class {
   }
 };
 
+// errors/no-transcript-generated-error.ts
+import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+var NoTranscriptGeneratedError = class extends AISDKError18 {
+  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) {
@@ -6481,7 +8049,7 @@ function simulateStreamingMiddleware() {
       return {
         stream: simulatedStream,
         rawCall: result.rawCall,
-        rawResponse: result.rawResponse,
+        rawResponse: result.response,
         warnings: result.warnings
       };
     }
@@ -6553,16 +8121,13 @@ function appendClientMessage({
 }
 
 // core/prompt/append-response-messages.ts
-import {
-  extractMaxToolInvocationStep
-} from "@ai-sdk/ui-utils";
-import { AISDKError as AISDKError18 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError19 } from "@ai-sdk/provider";
 function appendResponseMessages({
   messages,
   responseMessages,
   _internal: { currentDate = () => /* @__PURE__ */ new Date() } = {}
 }) {
-  var _a17, _b, _c, _d;
+  var _a17, _b, _c, _d, _e;
   const clonedMessages = structuredClone(messages);
   for (const message of responseMessages) {
     const role = message.role;
@@ -6639,14 +8204,14 @@ function appendResponseMessages({
                 break;
               case "file":
                 if (part.data instanceof URL) {
-                  throw new AISDKError18({
+                  throw new AISDKError19({
                     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;
@@ -6657,12 +8222,12 @@ function appendResponseMessages({
           const maxStep = extractMaxToolInvocationStep(
             lastMessage.toolInvocations
           );
-          (_a17 = lastMessage.parts) != null ? _a17 : lastMessage.parts = [];
+          (_b = lastMessage.parts) != null ? _b : lastMessage.parts = [];
           lastMessage.content = textContent;
           lastMessage.reasoning = reasoningTextContent;
           lastMessage.parts.push(...parts);
           lastMessage.toolInvocations = [
-            ...(_b = lastMessage.toolInvocations) != null ? _b : [],
+            ...(_c = lastMessage.toolInvocations) != null ? _c : [],
             ...getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1)
           ];
           getToolInvocations2(maxStep === void 0 ? 0 : maxStep + 1).map((call) => ({
@@ -6692,13 +8257,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
@@ -6773,7 +8338,7 @@ function customProvider({
 var experimental_customProvider = customProvider;
 
 // core/registry/no-such-provider-error.ts
-import { AISDKError as AISDKError19, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
+import { AISDKError as AISDKError20, NoSuchModelError as NoSuchModelError3 } from "@ai-sdk/provider";
 var name16 = "AI_NoSuchProviderError";
 var marker16 = `vercel.ai.error.${name16}`;
 var symbol16 = Symbol.for(marker16);
@@ -6792,7 +8357,7 @@ var NoSuchProviderError = class extends NoSuchModelError3 {
     this.availableProviders = availableProviders;
   }
   static isInstance(error) {
-    return AISDKError19.hasMarker(error, marker16);
+    return AISDKError20.hasMarker(error, marker16);
   }
 };
 _a16 = symbol16;
@@ -6879,9 +8444,6 @@ var DefaultProviderRegistry = class {
   }
 };
 
-// core/tool/mcp/mcp-client.ts
-import { jsonSchema } from "@ai-sdk/ui-utils";
-
 // core/tool/tool.ts
 function tool(tool2) {
   return tool2;
@@ -7495,7 +9057,6 @@ __export(langchain_adapter_exports, {
   toDataStream: () => toDataStream,
   toDataStreamResponse: () => toDataStreamResponse
 });
-import { formatDataStreamPart as formatDataStreamPart4 } from "@ai-sdk/ui-utils";
 
 // streams/stream-callbacks.ts
 function createCallbacksTransformer(callbacks = {}) {
@@ -7551,7 +9112,7 @@ function toDataStreamInternal(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart4("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7603,7 +9164,6 @@ __export(llamaindex_adapter_exports, {
   toDataStreamResponse: () => toDataStreamResponse2
 });
 import { convertAsyncIteratorToReadableStream } from "@ai-sdk/provider-utils";
-import { formatDataStreamPart as formatDataStreamPart5 } from "@ai-sdk/ui-utils";
 function toDataStreamInternal2(stream, callbacks) {
   const trimStart = trimStartOfStream();
   return convertAsyncIteratorToReadableStream(stream[Symbol.asyncIterator]()).pipeThrough(
@@ -7615,7 +9175,7 @@ function toDataStreamInternal2(stream, callbacks) {
   ).pipeThrough(createCallbacksTransformer(callbacks)).pipeThrough(new TextDecoderStream()).pipeThrough(
     new TransformStream({
       transform: async (chunk, controller) => {
-        controller.enqueue(formatDataStreamPart5("text", chunk));
+        controller.enqueue(formatDataStreamPart("text", chunk));
       }
     })
   );
@@ -7656,9 +9216,6 @@ function trimStartOfStream() {
   };
 }
 
-// streams/stream-data.ts
-import { formatDataStreamPart as formatDataStreamPart6 } from "@ai-sdk/ui-utils";
-
 // util/constants.ts
 var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
@@ -7709,7 +9266,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart6("data", [value]))
+      this.encoder.encode(formatDataStreamPart("data", [value]))
     );
   }
   appendMessageAnnotation(value) {
@@ -7720,7 +9277,7 @@ var StreamData = class {
       throw new Error("Stream controller is not initialized.");
     }
     this.controller.enqueue(
-      this.encoder.encode(formatDataStreamPart6("message_annotations", [value]))
+      this.encoder.encode(formatDataStreamPart("message_annotations", [value]))
     );
   }
 };
@@ -7758,6 +9315,9 @@ export {
   UnsupportedFunctionalityError2 as UnsupportedFunctionalityError,
   appendClientMessage,
   appendResponseMessages,
+  asSchema,
+  callChatApi,
+  callCompletionApi,
   convertToCoreMessages,
   coreAssistantMessageSchema,
   coreMessageSchema,
@@ -7777,23 +9337,34 @@ export {
   experimental_createProviderRegistry,
   experimental_customProvider,
   generateImage as experimental_generateImage,
+  transcribe as experimental_transcribe,
   experimental_wrapLanguageModel,
+  extractMaxToolInvocationStep,
   extractReasoningMiddleware,
-  formatDataStreamPart3 as formatDataStreamPart,
+  fillMessageParts,
+  formatDataStreamPart,
   generateId2 as generateId,
   generateObject,
   generateText,
-  jsonSchema2 as jsonSchema,
+  getMessageParts,
+  getTextFromDataUrl,
+  isAssistantMessageWithCompletedToolCalls,
+  isDeepEqualData,
+  jsonSchema,
   parseDataStreamPart,
+  parsePartialJson,
   pipeDataStreamToResponse,
+  prepareAttachmentsForRequest,
   processDataStream,
   processTextStream,
+  shouldResubmitMessages,
   simulateReadableStream,
   simulateStreamingMiddleware,
   smoothStream,
   streamObject,
   streamText,
   tool,
+  updateToolCallResult,
   wrapLanguageModel,
   zodSchema
 };