ai 0.0.0-85f9a635-20240518005312 → 0.0.0-8777c42a-20250115032312

package/rsc/dist/rsc-server.mjs

@@ -1,12 +1,11 @@
 // rsc/ai-state.tsx
-import { AsyncLocalStorage } from "async_hooks";
 import * as jsondiffpatch from "jsondiffpatch";
+import { AsyncLocalStorage } from "async_hooks";
 
-// rsc/utils.tsx
-import { Suspense } from "react";
-import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+// util/create-resolvable-promise.ts
 function createResolvablePromise() {
-  let resolve, reject;
+  let resolve;
+  let reject;
   const promise = new Promise((res, rej) => {
     resolve = res;
     reject = rej;
@@ -17,43 +16,9 @@ function createResolvablePromise() {
     reject
   };
 }
-var R = [
-  async ({
-    c,
-    // current
-    n
-    // next
-  }) => {
-    const chunk = await n;
-    if (chunk.done) {
-      return chunk.value;
-    }
-    if (chunk.append) {
-      return /* @__PURE__ */ jsxs(Fragment, { children: [
-        c,
-        /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(R, { c: chunk.value, n: chunk.next }) })
-      ] });
-    }
-    return /* @__PURE__ */ jsx(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx(R, { c: chunk.value, n: chunk.next }) });
-  }
-][0];
-function createSuspensedChunk(initialValue) {
-  const { promise, resolve, reject } = createResolvablePromise();
-  return {
-    row: /* @__PURE__ */ jsx(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx(R, { c: initialValue, n: promise }) }),
-    resolve,
-    reject
-  };
-}
-var isFunction = (x) => typeof x === "function";
-var consumeStream = async (stream) => {
-  const reader = stream.getReader();
-  while (true) {
-    const { done } = await reader.read();
-    if (done)
-      break;
-  }
-};
+
+// util/is-function.ts
+var isFunction = (value) => typeof value === "function";
 
 // rsc/ai-state.tsx
 var asyncAIStateStorage = new AsyncLocalStorage();
@@ -67,7 +32,8 @@ function getAIStateStoreOrThrow(message) {
 function withAIState({ state, options }, fn) {
   return asyncAIStateStorage.run(
     {
-      currentState: state,
+      currentState: JSON.parse(JSON.stringify(state)),
+      // deep clone object
       originalState: state,
       sealed: false,
       options
@@ -115,7 +81,7 @@ function getMutableAIState(...args) {
     store.mutationDeltaResolve = resolve;
   }
   function doUpdate(newState, done) {
-    var _a, _b;
+    var _a9, _b;
     if (args.length > 0) {
       if (typeof store.currentState !== "object") {
         const key = args[0];
@@ -139,7 +105,7 @@ function getMutableAIState(...args) {
         store.currentState = newState;
       }
     }
-    (_b = (_a = store.options).onSetAIState) == null ? void 0 : _b.call(_a, {
+    (_b = (_a9 = store.options).onSetAIState) == null ? void 0 : _b.call(_a9, {
       key: args.length > 0 ? args[0] : void 0,
       state: store.currentState,
       done
@@ -174,68 +140,130 @@ function getMutableAIState(...args) {
   return mutableState;
 }
 
-// rsc/streamable.tsx
-import zodToJsonSchema2 from "zod-to-json-schema";
+// rsc/provider.tsx
+import * as React from "react";
+import { InternalAIProvider } from "./rsc-shared.mjs";
+import { jsx } from "react/jsx-runtime";
+async function innerAction({
+  action,
+  options
+}, state, ...args) {
+  "use server";
+  return await withAIState(
+    {
+      state,
+      options
+    },
+    async () => {
+      const result = await action(...args);
+      sealMutableAIState();
+      return [getAIStateDeltaPromise(), result];
+    }
+  );
+}
+function wrapAction(action, options) {
+  return innerAction.bind(null, { action, options });
+}
+function createAI({
+  actions,
+  initialAIState,
+  initialUIState,
+  onSetAIState,
+  onGetUIState
+}) {
+  const wrappedActions = {};
+  for (const name9 in actions) {
+    wrappedActions[name9] = wrapAction(actions[name9], {
+      onSetAIState
+    });
+  }
+  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
+  const AI = async (props) => {
+    var _a9, _b;
+    if ("useState" in React) {
+      throw new Error(
+        "This component can only be used inside Server Components."
+      );
+    }
+    let uiState = (_a9 = props.initialUIState) != null ? _a9 : initialUIState;
+    let aiState = (_b = props.initialAIState) != null ? _b : initialAIState;
+    let aiStateDelta = void 0;
+    if (wrappedSyncUIState) {
+      const [newAIStateDelta, newUIState] = await wrappedSyncUIState(aiState);
+      if (newUIState !== void 0) {
+        aiStateDelta = newAIStateDelta;
+        uiState = newUIState;
+      }
+    }
+    return /* @__PURE__ */ jsx(
+      InternalAIProvider,
+      {
+        wrappedActions,
+        wrappedSyncUIState,
+        initialUIState: uiState,
+        initialAIState: aiState,
+        initialAIStatePatch: aiStateDelta,
+        children: props.children
+      }
+    );
+  };
+  return AI;
+}
 
-// core/util/retry-with-exponential-backoff.ts
-import { APICallError, RetryError } from "@ai-sdk/provider";
-import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
+// rsc/stream-ui/stream-ui.tsx
+import { safeParseJSON } from "@ai-sdk/provider-utils";
 
-// core/util/delay.ts
-async function delay(delayInMs) {
-  return new Promise((resolve) => setTimeout(resolve, delayInMs));
-}
+// util/download-error.ts
+import { AISDKError } from "@ai-sdk/provider";
+var name = "AI_DownloadError";
+var marker = `vercel.ai.error.${name}`;
+var symbol = Symbol.for(marker);
+var _a;
+var DownloadError = class extends AISDKError {
+  constructor({
+    url,
+    statusCode,
+    statusText,
+    cause,
+    message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
+  }) {
+    super({ name, message, cause });
+    this[_a] = true;
+    this.url = url;
+    this.statusCode = statusCode;
+    this.statusText = statusText;
+  }
+  static isInstance(error) {
+    return AISDKError.hasMarker(error, marker);
+  }
+};
+_a = symbol;
 
-// core/util/retry-with-exponential-backoff.ts
-var retryWithExponentialBackoff = ({
-  maxRetries = 2,
-  initialDelayInMs = 2e3,
-  backoffFactor = 2
-} = {}) => async (f) => _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs: initialDelayInMs,
-  backoffFactor
-});
-async function _retryWithExponentialBackoff(f, {
-  maxRetries,
-  delayInMs,
-  backoffFactor
-}, errors = []) {
+// util/download.ts
+async function download({
+  url,
+  fetchImplementation = fetch
+}) {
+  var _a9;
+  const urlText = url.toString();
   try {
-    return await f();
-  } catch (error) {
-    if (isAbortError(error)) {
-      throw error;
-    }
-    if (maxRetries === 0) {
-      throw error;
-    }
-    const errorMessage = getErrorMessage(error);
-    const newErrors = [...errors, error];
-    const tryNumber = newErrors.length;
-    if (tryNumber > maxRetries) {
-      throw new RetryError({
-        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
-        reason: "maxRetriesExceeded",
-        errors: newErrors
+    const response = await fetchImplementation(urlText);
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
       });
     }
-    if (error instanceof Error && APICallError.isAPICallError(error) && error.isRetryable === true && tryNumber <= maxRetries) {
-      await delay(delayInMs);
-      return _retryWithExponentialBackoff(
-        f,
-        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
-        newErrors
-      );
-    }
-    if (tryNumber === 1) {
+    return {
+      data: new Uint8Array(await response.arrayBuffer()),
+      mimeType: (_a9 = response.headers.get("content-type")) != null ? _a9 : void 0
+    };
+  } catch (error) {
+    if (DownloadError.isInstance(error)) {
       throw error;
     }
-    throw new RetryError({
-      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
-      reason: "errorNotRetryable",
-      errors: newErrors
-    });
+    throw new DownloadError({ url: urlText, cause: error });
   }
 }
 
@@ -256,11 +284,57 @@ function detectImageMimeType(image) {
 }
 
 // core/prompt/data-content.ts
-import { InvalidDataContentError } from "@ai-sdk/provider";
 import {
   convertBase64ToUint8Array,
   convertUint8ArrayToBase64
 } from "@ai-sdk/provider-utils";
+
+// core/prompt/invalid-data-content-error.ts
+import { AISDKError as AISDKError2 } from "@ai-sdk/provider";
+var name2 = "AI_InvalidDataContentError";
+var marker2 = `vercel.ai.error.${name2}`;
+var symbol2 = Symbol.for(marker2);
+var _a2;
+var InvalidDataContentError = class extends AISDKError2 {
+  constructor({
+    content,
+    cause,
+    message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
+  }) {
+    super({ name: name2, message, cause });
+    this[_a2] = true;
+    this.content = content;
+  }
+  static isInstance(error) {
+    return AISDKError2.hasMarker(error, marker2);
+  }
+};
+_a2 = symbol2;
+
+// core/prompt/data-content.ts
+import { z } from "zod";
+var dataContentSchema = z.union([
+  z.string(),
+  z.instanceof(Uint8Array),
+  z.instanceof(ArrayBuffer),
+  z.custom(
+    // Buffer might not be available in some environments such as CloudFlare:
+    (value) => {
+      var _a9, _b;
+      return (_b = (_a9 = globalThis.Buffer) == null ? void 0 : _a9.isBuffer(value)) != null ? _b : false;
+    },
+    { message: "Must be a Buffer" }
+  )
+]);
+function convertDataContentToBase64String(content) {
+  if (typeof content === "string") {
+    return content;
+  }
+  if (content instanceof ArrayBuffer) {
+    return convertUint8ArrayToBase64(new Uint8Array(content));
+  }
+  return convertUint8ArrayToBase64(content);
+}
 function convertDataContentToUint8Array(content) {
   if (content instanceof Uint8Array) {
     return content;
@@ -270,7 +344,7 @@ function convertDataContentToUint8Array(content) {
       return convertBase64ToUint8Array(content);
     } catch (error) {
       throw new InvalidDataContentError({
-        message: "Invalid data content. Content string is not a base64-encoded image.",
+        message: "Invalid data content. Content string is not a base64-encoded media.",
         content,
         cause: error
       });
@@ -281,130 +355,275 @@ function convertDataContentToUint8Array(content) {
   }
   throw new InvalidDataContentError({ content });
 }
+function convertUint8ArrayToText(uint8Array) {
+  try {
+    return new TextDecoder().decode(uint8Array);
+  } catch (error) {
+    throw new Error("Error decoding Uint8Array to text");
+  }
+}
+
+// core/prompt/invalid-message-role-error.ts
+import { AISDKError as AISDKError3 } from "@ai-sdk/provider";
+var name3 = "AI_InvalidMessageRoleError";
+var marker3 = `vercel.ai.error.${name3}`;
+var symbol3 = Symbol.for(marker3);
+var _a3;
+var InvalidMessageRoleError = class extends AISDKError3 {
+  constructor({
+    role,
+    message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
+  }) {
+    super({ name: name3, message });
+    this[_a3] = true;
+    this.role = role;
+  }
+  static isInstance(error) {
+    return AISDKError3.hasMarker(error, marker3);
+  }
+};
+_a3 = symbol3;
+
+// core/prompt/split-data-url.ts
+function splitDataUrl(dataUrl) {
+  try {
+    const [header, base64Content] = dataUrl.split(",");
+    return {
+      mimeType: header.split(";")[0].split(":")[1],
+      base64Content
+    };
+  } catch (error) {
+    return {
+      mimeType: void 0,
+      base64Content: void 0
+    };
+  }
+}
 
 // core/prompt/convert-to-language-model-prompt.ts
-function convertToLanguageModelPrompt(prompt) {
-  const languageModelMessages = [];
-  if (prompt.system != null) {
-    languageModelMessages.push({ role: "system", content: prompt.system });
-  }
-  switch (prompt.type) {
-    case "prompt": {
-      languageModelMessages.push({
+async function convertToLanguageModelPrompt({
+  prompt,
+  modelSupportsImageUrls = true,
+  modelSupportsUrl = () => false,
+  downloadImplementation = download
+}) {
+  const downloadedAssets = await downloadAssets(
+    prompt.messages,
+    downloadImplementation,
+    modelSupportsImageUrls,
+    modelSupportsUrl
+  );
+  return [
+    ...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
+    ...prompt.messages.map(
+      (message) => convertToLanguageModelMessage(message, downloadedAssets)
+    )
+  ];
+}
+function convertToLanguageModelMessage(message, downloadedAssets) {
+  const role = message.role;
+  switch (role) {
+    case "system": {
+      return {
+        role: "system",
+        content: message.content,
+        providerMetadata: message.experimental_providerMetadata
+      };
+    }
+    case "user": {
+      if (typeof message.content === "string") {
+        return {
+          role: "user",
+          content: [{ type: "text", text: message.content }],
+          providerMetadata: message.experimental_providerMetadata
+        };
+      }
+      return {
         role: "user",
-        content: [{ type: "text", text: prompt.prompt }]
-      });
-      break;
+        content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
+        providerMetadata: message.experimental_providerMetadata
+      };
     }
-    case "messages": {
-      languageModelMessages.push(
-        ...prompt.messages.map((message) => {
-          switch (message.role) {
-            case "system": {
-              return { role: "system", content: message.content };
-            }
-            case "user": {
-              if (typeof message.content === "string") {
-                return {
-                  role: "user",
-                  content: [{ type: "text", text: message.content }]
-                };
-              }
-              return {
-                role: "user",
-                content: message.content.map(
-                  (part) => {
-                    var _a;
-                    switch (part.type) {
-                      case "text": {
-                        return part;
-                      }
-                      case "image": {
-                        if (part.image instanceof URL) {
-                          return {
-                            type: "image",
-                            image: part.image,
-                            mimeType: part.mimeType
-                          };
-                        }
-                        const imageUint8 = convertDataContentToUint8Array(
-                          part.image
-                        );
-                        return {
-                          type: "image",
-                          image: imageUint8,
-                          mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
-                        };
-                      }
-                    }
-                  }
-                )
-              };
-            }
-            case "assistant": {
-              if (typeof message.content === "string") {
-                return {
-                  role: "assistant",
-                  content: [{ type: "text", text: message.content }]
-                };
-              }
-              return { role: "assistant", content: message.content };
-            }
-            case "tool": {
-              return message;
-            }
-          }
-        })
-      );
-      break;
+    case "assistant": {
+      if (typeof message.content === "string") {
+        return {
+          role: "assistant",
+          content: [{ type: "text", text: message.content }],
+          providerMetadata: message.experimental_providerMetadata
+        };
+      }
+      return {
+        role: "assistant",
+        content: message.content.filter(
+          // remove empty text parts:
+          (part) => part.type !== "text" || part.text !== ""
+        ).map((part) => {
+          const { experimental_providerMetadata, ...rest } = part;
+          return {
+            ...rest,
+            providerMetadata: experimental_providerMetadata
+          };
+        }),
+        providerMetadata: message.experimental_providerMetadata
+      };
+    }
+    case "tool": {
+      return {
+        role: "tool",
+        content: message.content.map((part) => ({
+          type: "tool-result",
+          toolCallId: part.toolCallId,
+          toolName: part.toolName,
+          result: part.result,
+          content: part.experimental_content,
+          isError: part.isError,
+          providerMetadata: part.experimental_providerMetadata
+        })),
+        providerMetadata: message.experimental_providerMetadata
+      };
     }
     default: {
-      const _exhaustiveCheck = prompt;
-      throw new Error(`Unsupported prompt type: ${_exhaustiveCheck}`);
+      const _exhaustiveCheck = role;
+      throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
+    }
+  }
+}
+async function downloadAssets(messages, downloadImplementation, modelSupportsImageUrls, modelSupportsUrl) {
+  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
+    (content) => Array.isArray(content)
+  ).flat().filter(
+    (part) => part.type === "image" || part.type === "file"
+  ).filter(
+    (part) => !(part.type === "image" && modelSupportsImageUrls === true)
+  ).map((part) => part.type === "image" ? part.image : part.data).map(
+    (part) => (
+      // support string urls:
+      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
+    )
+  ).filter((image) => image instanceof URL).filter((url) => !modelSupportsUrl(url));
+  const downloadedImages = await Promise.all(
+    urls.map(async (url) => ({
+      url,
+      data: await downloadImplementation({ url })
+    }))
+  );
+  return Object.fromEntries(
+    downloadedImages.map(({ url, data }) => [url.toString(), data])
+  );
+}
+function convertPartToLanguageModelPart(part, downloadedAssets) {
+  var _a9;
+  if (part.type === "text") {
+    return {
+      type: "text",
+      text: part.text,
+      providerMetadata: part.experimental_providerMetadata
+    };
+  }
+  let mimeType = part.mimeType;
+  let data;
+  let content;
+  let normalizedData;
+  const type = part.type;
+  switch (type) {
+    case "image":
+      data = part.image;
+      break;
+    case "file":
+      data = part.data;
+      break;
+    default:
+      throw new Error(`Unsupported part type: ${type}`);
+  }
+  try {
+    content = typeof data === "string" ? new URL(data) : data;
+  } catch (error) {
+    content = data;
+  }
+  if (content instanceof URL) {
+    if (content.protocol === "data:") {
+      const { mimeType: dataUrlMimeType, base64Content } = splitDataUrl(
+        content.toString()
+      );
+      if (dataUrlMimeType == null || base64Content == null) {
+        throw new Error(`Invalid data URL format in part ${type}`);
+      }
+      mimeType = dataUrlMimeType;
+      normalizedData = convertDataContentToUint8Array(base64Content);
+    } else {
+      const downloadedFile = downloadedAssets[content.toString()];
+      if (downloadedFile) {
+        normalizedData = downloadedFile.data;
+        mimeType != null ? mimeType : mimeType = downloadedFile.mimeType;
+      } else {
+        normalizedData = content;
+      }
+    }
+  } else {
+    normalizedData = convertDataContentToUint8Array(content);
+  }
+  switch (type) {
+    case "image": {
+      if (normalizedData instanceof Uint8Array) {
+        mimeType = (_a9 = detectImageMimeType(normalizedData)) != null ? _a9 : mimeType;
+      }
+      return {
+        type: "image",
+        image: normalizedData,
+        mimeType,
+        providerMetadata: part.experimental_providerMetadata
+      };
+    }
+    case "file": {
+      if (mimeType == null) {
+        throw new Error(`Mime type is missing for file part`);
+      }
+      return {
+        type: "file",
+        data: normalizedData instanceof Uint8Array ? convertDataContentToBase64String(normalizedData) : normalizedData,
+        mimeType,
+        providerMetadata: part.experimental_providerMetadata
+      };
     }
   }
-  return languageModelMessages;
 }
 
-// core/prompt/get-validated-prompt.ts
-import { InvalidPromptError } from "@ai-sdk/provider";
-function getValidatedPrompt(prompt) {
-  if (prompt.prompt == null && prompt.messages == null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: "prompt or messages must be defined"
+// errors/invalid-argument-error.ts
+import { AISDKError as AISDKError4 } from "@ai-sdk/provider";
+var name4 = "AI_InvalidArgumentError";
+var marker4 = `vercel.ai.error.${name4}`;
+var symbol4 = Symbol.for(marker4);
+var _a4;
+var InvalidArgumentError = class extends AISDKError4 {
+  constructor({
+    parameter,
+    value,
+    message
+  }) {
+    super({
+      name: name4,
+      message: `Invalid argument for parameter ${parameter}: ${message}`
     });
+    this[_a4] = true;
+    this.parameter = parameter;
+    this.value = value;
   }
-  if (prompt.prompt != null && prompt.messages != null) {
-    throw new InvalidPromptError({
-      prompt,
-      message: "prompt and messages cannot be defined at the same time"
-    });
+  static isInstance(error) {
+    return AISDKError4.hasMarker(error, marker4);
   }
-  return prompt.prompt != null ? {
-    type: "prompt",
-    prompt: prompt.prompt,
-    messages: void 0,
-    system: prompt.system
-  } : {
-    type: "messages",
-    prompt: void 0,
-    messages: prompt.messages,
-    // only possible case bc of checks above
-    system: prompt.system
-  };
-}
+};
+_a4 = symbol4;
 
 // core/prompt/prepare-call-settings.ts
-import { InvalidArgumentError } from "@ai-sdk/provider";
 function prepareCallSettings({
   maxTokens,
   temperature,
   topP,
+  topK,
   presencePenalty,
   frequencyPenalty,
-  seed,
-  maxRetries
+  stopSequences,
+  seed
 }) {
   if (maxTokens != null) {
     if (!Number.isInteger(maxTokens)) {
@@ -440,6 +659,15 @@ function prepareCallSettings({
       });
     }
   }
+  if (topK != null) {
+    if (typeof topK !== "number") {
+      throw new InvalidArgumentError({
+        parameter: "topK",
+        value: topK,
+        message: "topK must be a number"
+      });
+    }
+  }
   if (presencePenalty != null) {
     if (typeof presencePenalty !== "number") {
       throw new InvalidArgumentError({
@@ -467,734 +695,697 @@ function prepareCallSettings({
       });
     }
   }
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
   return {
     maxTokens,
     temperature: temperature != null ? temperature : 0,
     topP,
+    topK,
     presencePenalty,
     frequencyPenalty,
-    seed,
-    maxRetries: maxRetries != null ? maxRetries : 2
+    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
+    seed
   };
 }
 
-// core/util/convert-zod-to-json-schema.ts
-import zodToJsonSchema from "zod-to-json-schema";
-function convertZodToJSONSchema(zodSchema) {
-  return zodToJsonSchema(zodSchema);
+// util/retry-with-exponential-backoff.ts
+import { APICallError } from "@ai-sdk/provider";
+import { getErrorMessage, isAbortError } from "@ai-sdk/provider-utils";
+
+// util/delay.ts
+async function delay(delayInMs) {
+  return delayInMs == null ? Promise.resolve() : new Promise((resolve) => setTimeout(resolve, delayInMs));
 }
 
-// shared/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 };
+// util/retry-error.ts
+import { AISDKError as AISDKError5 } from "@ai-sdk/provider";
+var name5 = "AI_RetryError";
+var marker5 = `vercel.ai.error.${name5}`;
+var symbol5 = Symbol.for(marker5);
+var _a5;
+var RetryError = class extends AISDKError5 {
+  constructor({
+    message,
+    reason,
+    errors
+  }) {
+    super({ name: name5, message });
+    this[_a5] = true;
+    this.reason = reason;
+    this.errors = errors;
+    this.lastError = errors[errors.length - 1];
   }
-};
-var functionCallStreamPart = {
-  code: "1",
-  name: "function_call",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("function_call" in value) || typeof value.function_call !== "object" || value.function_call == null || !("name" in value.function_call) || !("arguments" in value.function_call) || typeof value.function_call.name !== "string" || typeof value.function_call.arguments !== "string") {
-      throw new Error(
-        '"function_call" parts expect an object with a "function_call" property.'
-      );
-    }
-    return {
-      type: "function_call",
-      value
-    };
+  static isInstance(error) {
+    return AISDKError5.hasMarker(error, marker5);
   }
 };
-var dataStreamPart = {
-  code: "2",
-  name: "data",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"data" parts expect an array value.');
+_a5 = symbol5;
+
+// util/retry-with-exponential-backoff.ts
+var retryWithExponentialBackoff = ({
+  maxRetries = 2,
+  initialDelayInMs = 2e3,
+  backoffFactor = 2
+} = {}) => async (f) => _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs: initialDelayInMs,
+  backoffFactor
+});
+async function _retryWithExponentialBackoff(f, {
+  maxRetries,
+  delayInMs,
+  backoffFactor
+}, errors = []) {
+  try {
+    return await f();
+  } catch (error) {
+    if (isAbortError(error)) {
+      throw error;
     }
-    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.');
+    if (maxRetries === 0) {
+      throw error;
     }
-    return { type: "error", value };
-  }
-};
-var assistantMessageStreamPart = {
-  code: "4",
-  name: "assistant_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("id" in value) || !("role" in value) || !("content" in value) || typeof value.id !== "string" || typeof value.role !== "string" || value.role !== "assistant" || !Array.isArray(value.content) || !value.content.every(
-      (item) => item != null && typeof item === "object" && "type" in item && item.type === "text" && "text" in item && item.text != null && typeof item.text === "object" && "value" in item.text && typeof item.text.value === "string"
-    )) {
-      throw new Error(
-        '"assistant_message" parts expect an object with an "id", "role", and "content" property.'
-      );
+    const errorMessage = getErrorMessage(error);
+    const newErrors = [...errors, error];
+    const tryNumber = newErrors.length;
+    if (tryNumber > maxRetries) {
+      throw new RetryError({
+        message: `Failed after ${tryNumber} attempts. Last error: ${errorMessage}`,
+        reason: "maxRetriesExceeded",
+        errors: newErrors
+      });
     }
-    return {
-      type: "assistant_message",
-      value
-    };
-  }
-};
-var assistantControlDataStreamPart = {
-  code: "5",
-  name: "assistant_control_data",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("threadId" in value) || !("messageId" in value) || typeof value.threadId !== "string" || typeof value.messageId !== "string") {
-      throw new Error(
-        '"assistant_control_data" parts expect an object with a "threadId" and "messageId" property.'
+    if (error instanceof Error && APICallError.isInstance(error) && error.isRetryable === true && tryNumber <= maxRetries) {
+      await delay(delayInMs);
+      return _retryWithExponentialBackoff(
+        f,
+        { maxRetries, delayInMs: backoffFactor * delayInMs, backoffFactor },
+        newErrors
       );
     }
-    return {
-      type: "assistant_control_data",
-      value: {
-        threadId: value.threadId,
-        messageId: value.messageId
-      }
-    };
-  }
-};
-var dataMessageStreamPart = {
-  code: "6",
-  name: "data_message",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("role" in value) || !("data" in value) || typeof value.role !== "string" || value.role !== "data") {
-      throw new Error(
-        '"data_message" parts expect an object with a "role" and "data" property.'
-      );
+    if (tryNumber === 1) {
+      throw error;
     }
-    return {
-      type: "data_message",
-      value
-    };
+    throw new RetryError({
+      message: `Failed after ${tryNumber} attempts with non-retryable error: '${errorMessage}'`,
+      reason: "errorNotRetryable",
+      errors: newErrors
+    });
   }
-};
-var toolCallsStreamPart = {
-  code: "7",
-  name: "tool_calls",
-  parse: (value) => {
-    if (value == null || typeof value !== "object" || !("tool_calls" in value) || typeof value.tool_calls !== "object" || value.tool_calls == null || !Array.isArray(value.tool_calls) || value.tool_calls.some(
-      (tc) => tc == null || typeof tc !== "object" || !("id" in tc) || typeof tc.id !== "string" || !("type" in tc) || typeof tc.type !== "string" || !("function" in tc) || tc.function == null || typeof tc.function !== "object" || !("arguments" in tc.function) || typeof tc.function.name !== "string" || typeof tc.function.arguments !== "string"
-    )) {
-      throw new Error(
-        '"tool_calls" parts expect an object with a ToolCallPayload.'
-      );
+}
+
+// core/prompt/prepare-retries.ts
+function prepareRetries({
+  maxRetries
+}) {
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
     }
-    return {
-      type: "tool_calls",
-      value
-    };
-  }
-};
-var messageAnnotationsStreamPart = {
-  code: "8",
-  name: "message_annotations",
-  parse: (value) => {
-    if (!Array.isArray(value)) {
-      throw new Error('"message_annotations" parts expect an array value.');
+    if (maxRetries < 0) {
+      throw new InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
     }
-    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.'
-      );
-    }
+  const maxRetriesResult = maxRetries != null ? maxRetries : 2;
+  return {
+    maxRetries: maxRetriesResult,
+    retry: retryWithExponentialBackoff({ maxRetries: maxRetriesResult })
+  };
+}
+
+// core/prompt/prepare-tools-and-tool-choice.ts
+import { asSchema } from "@ai-sdk/ui-utils";
+
+// core/util/is-non-empty-object.ts
+function isNonEmptyObject(object) {
+  return object != null && Object.keys(object).length > 0;
+}
+
+// core/prompt/prepare-tools-and-tool-choice.ts
+function prepareToolsAndToolChoice({
+  tools,
+  toolChoice,
+  activeTools
+}) {
+  if (!isNonEmptyObject(tools)) {
     return {
-      type: "tool_call",
-      value
+      tools: void 0,
+      toolChoice: void 0
     };
   }
-};
-var toolResultStreamPart = {
-  code: "a",
-  name: "tool_result",
-  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" || !("result" in value)) {
-      throw new Error(
-        '"tool_result" parts expect an object with a "toolCallId", "toolName", "args", and "result" property.'
-      );
-    }
-    return {
-      type: "tool_result",
-      value
-    };
+  const filteredTools = activeTools != null ? Object.entries(tools).filter(
+    ([name9]) => activeTools.includes(name9)
+  ) : Object.entries(tools);
+  return {
+    tools: filteredTools.map(([name9, tool]) => {
+      const toolType = tool.type;
+      switch (toolType) {
+        case void 0:
+        case "function":
+          return {
+            type: "function",
+            name: name9,
+            description: tool.description,
+            parameters: asSchema(tool.parameters).jsonSchema
+          };
+        case "provider-defined":
+          return {
+            type: "provider-defined",
+            name: name9,
+            id: tool.id,
+            args: tool.args
+          };
+        default: {
+          const exhaustiveCheck = toolType;
+          throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
+        }
+      }
+    }),
+    toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
+  };
+}
+
+// core/prompt/standardize-prompt.ts
+import { InvalidPromptError } from "@ai-sdk/provider";
+import { safeValidateTypes } from "@ai-sdk/provider-utils";
+import { z as z7 } from "zod";
+
+// core/prompt/message.ts
+import { z as z6 } from "zod";
+
+// core/types/provider-metadata.ts
+import { z as z3 } from "zod";
+
+// core/types/json-value.ts
+import { z as z2 } from "zod";
+var jsonValueSchema = z2.lazy(
+  () => z2.union([
+    z2.null(),
+    z2.string(),
+    z2.number(),
+    z2.boolean(),
+    z2.record(z2.string(), jsonValueSchema),
+    z2.array(jsonValueSchema)
+  ])
+);
+
+// core/types/provider-metadata.ts
+var providerMetadataSchema = z3.record(
+  z3.string(),
+  z3.record(z3.string(), jsonValueSchema)
+);
+
+// core/prompt/content-part.ts
+import { z as z5 } from "zod";
+
+// core/prompt/tool-result-content.ts
+import { z as z4 } from "zod";
+var toolResultContentSchema = z4.array(
+  z4.union([
+    z4.object({ type: z4.literal("text"), text: z4.string() }),
+    z4.object({
+      type: z4.literal("image"),
+      data: z4.string(),
+      mimeType: z4.string().optional()
+    })
+  ])
+);
+
+// core/prompt/content-part.ts
+var textPartSchema = z5.object({
+  type: z5.literal("text"),
+  text: z5.string(),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var imagePartSchema = z5.object({
+  type: z5.literal("image"),
+  image: z5.union([dataContentSchema, z5.instanceof(URL)]),
+  mimeType: z5.string().optional(),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var filePartSchema = z5.object({
+  type: z5.literal("file"),
+  data: z5.union([dataContentSchema, z5.instanceof(URL)]),
+  mimeType: z5.string(),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var toolCallPartSchema = z5.object({
+  type: z5.literal("tool-call"),
+  toolCallId: z5.string(),
+  toolName: z5.string(),
+  args: z5.unknown()
+});
+var toolResultPartSchema = z5.object({
+  type: z5.literal("tool-result"),
+  toolCallId: z5.string(),
+  toolName: z5.string(),
+  result: z5.unknown(),
+  content: toolResultContentSchema.optional(),
+  isError: z5.boolean().optional(),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+
+// core/prompt/message.ts
+var coreSystemMessageSchema = z6.object({
+  role: z6.literal("system"),
+  content: z6.string(),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var coreUserMessageSchema = z6.object({
+  role: z6.literal("user"),
+  content: z6.union([
+    z6.string(),
+    z6.array(z6.union([textPartSchema, imagePartSchema, filePartSchema]))
+  ]),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var coreAssistantMessageSchema = z6.object({
+  role: z6.literal("assistant"),
+  content: z6.union([
+    z6.string(),
+    z6.array(z6.union([textPartSchema, toolCallPartSchema]))
+  ]),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var coreToolMessageSchema = z6.object({
+  role: z6.literal("tool"),
+  content: z6.array(toolResultPartSchema),
+  experimental_providerMetadata: providerMetadataSchema.optional()
+});
+var coreMessageSchema = z6.union([
+  coreSystemMessageSchema,
+  coreUserMessageSchema,
+  coreAssistantMessageSchema,
+  coreToolMessageSchema
+]);
+
+// core/prompt/detect-prompt-type.ts
+function detectPromptType(prompt) {
+  if (!Array.isArray(prompt)) {
+    return "other";
   }
-};
-var streamParts = [
-  textStreamPart,
-  functionCallStreamPart,
-  dataStreamPart,
-  errorStreamPart,
-  assistantMessageStreamPart,
-  assistantControlDataStreamPart,
-  dataMessageStreamPart,
-  toolCallsStreamPart,
-  messageAnnotationsStreamPart,
-  toolCallStreamPart,
-  toolResultStreamPart
-];
-var streamPartsByCode = {
-  [textStreamPart.code]: textStreamPart,
-  [functionCallStreamPart.code]: functionCallStreamPart,
-  [dataStreamPart.code]: dataStreamPart,
-  [errorStreamPart.code]: errorStreamPart,
-  [assistantMessageStreamPart.code]: assistantMessageStreamPart,
-  [assistantControlDataStreamPart.code]: assistantControlDataStreamPart,
-  [dataMessageStreamPart.code]: dataMessageStreamPart,
-  [toolCallsStreamPart.code]: toolCallsStreamPart,
-  [messageAnnotationsStreamPart.code]: messageAnnotationsStreamPart,
-  [toolCallStreamPart.code]: toolCallStreamPart,
-  [toolResultStreamPart.code]: toolResultStreamPart
-};
-var StreamStringPrefixes = {
-  [textStreamPart.name]: textStreamPart.code,
-  [functionCallStreamPart.name]: functionCallStreamPart.code,
-  [dataStreamPart.name]: dataStreamPart.code,
-  [errorStreamPart.name]: errorStreamPart.code,
-  [assistantMessageStreamPart.name]: assistantMessageStreamPart.code,
-  [assistantControlDataStreamPart.name]: assistantControlDataStreamPart.code,
-  [dataMessageStreamPart.name]: dataMessageStreamPart.code,
-  [toolCallsStreamPart.name]: toolCallsStreamPart.code,
-  [messageAnnotationsStreamPart.name]: messageAnnotationsStreamPart.code,
-  [toolCallStreamPart.name]: toolCallStreamPart.code,
-  [toolResultStreamPart.name]: toolResultStreamPart.code
-};
-var validCodes = streamParts.map((part) => part.code);
-var parseStreamPart = (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 streamPartsByCode[code].parse(jsonValue);
-};
-function formatStreamPart(type, value) {
-  const streamPart = streamParts.find((part) => part.name === type);
-  if (!streamPart) {
-    throw new Error(`Invalid stream part type: ${type}`);
+  if (prompt.length === 0) {
+    return "messages";
+  }
+  const characteristics = prompt.map(detectSingleMessageCharacteristics);
+  if (characteristics.some((c) => c === "has-ui-specific-parts")) {
+    return "ui-messages";
+  } else if (characteristics.every(
+    (c) => c === "has-core-specific-parts" || c === "message"
+  )) {
+    return "messages";
+  } else {
+    return "other";
   }
-  return `${streamPart.code}:${JSON.stringify(value)}
-`;
 }
-
-// shared/utils.ts
-function createChunkDecoder(complex) {
-  const decoder = new TextDecoder();
-  if (!complex) {
-    return function(chunk) {
-      if (!chunk)
-        return "";
-      return decoder.decode(chunk, { stream: true });
-    };
+function detectSingleMessageCharacteristics(message) {
+  if (typeof message === "object" && message !== null && (message.role === "function" || // UI-only role
+  message.role === "data" || // UI-only role
+  "toolInvocations" in message || // UI-specific field
+  "experimental_attachments" in message)) {
+    return "has-ui-specific-parts";
+  } else if (typeof message === "object" && message !== null && "content" in message && (Array.isArray(message.content) || // Core messages can have array content
+  "experimental_providerMetadata" in message)) {
+    return "has-core-specific-parts";
+  } else if (typeof message === "object" && message !== null && "role" in message && "content" in message && typeof message.content === "string" && ["system", "user", "assistant", "tool"].includes(message.role)) {
+    return "message";
+  } else {
+    return "other";
   }
-  return function(chunk) {
-    const decoded = decoder.decode(chunk, { stream: true }).split("\n").filter((line) => line !== "");
-    return decoded.map(parseStreamPart).filter(Boolean);
-  };
 }
 
-// streams/ai-stream.ts
-import {
-  createParser
-} from "eventsource-parser";
-function createEventStreamTransformer(customParser) {
-  const textDecoder = new TextDecoder();
-  let eventSourceParser;
-  return new TransformStream({
-    async start(controller) {
-      eventSourceParser = createParser(
-        (event) => {
-          if ("data" in event && event.type === "event" && event.data === "[DONE]" || // Replicate doesn't send [DONE] but does send a 'done' event
-          // @see https://replicate.com/docs/streaming
-          event.event === "done") {
-            controller.terminate();
-            return;
+// core/prompt/attachments-to-parts.ts
+function attachmentsToParts(attachments) {
+  var _a9, _b, _c;
+  const parts = [];
+  for (const attachment of attachments) {
+    let url;
+    try {
+      url = new URL(attachment.url);
+    } catch (error) {
+      throw new Error(`Invalid URL: ${attachment.url}`);
+    }
+    switch (url.protocol) {
+      case "http:":
+      case "https:": {
+        if ((_a9 = attachment.contentType) == null ? void 0 : _a9.startsWith("image/")) {
+          parts.push({ type: "image", image: url });
+        } else {
+          if (!attachment.contentType) {
+            throw new Error(
+              "If the attachment is not an image, it must specify a content type"
+            );
           }
-          if ("data" in event) {
-            const parsedMessage = customParser ? customParser(event.data, {
-              event: event.event
-            }) : event.data;
-            if (parsedMessage)
-              controller.enqueue(parsedMessage);
+          parts.push({
+            type: "file",
+            data: url,
+            mimeType: attachment.contentType
+          });
+        }
+        break;
+      }
+      case "data:": {
+        let header;
+        let base64Content;
+        let mimeType;
+        try {
+          [header, base64Content] = attachment.url.split(",");
+          mimeType = header.split(";")[0].split(":")[1];
+        } catch (error) {
+          throw new Error(`Error processing data URL: ${attachment.url}`);
+        }
+        if (mimeType == null || base64Content == null) {
+          throw new Error(`Invalid data URL format: ${attachment.url}`);
+        }
+        if ((_b = attachment.contentType) == null ? void 0 : _b.startsWith("image/")) {
+          parts.push({
+            type: "image",
+            image: convertDataContentToUint8Array(base64Content)
+          });
+        } else if ((_c = attachment.contentType) == null ? void 0 : _c.startsWith("text/")) {
+          parts.push({
+            type: "text",
+            text: convertUint8ArrayToText(
+              convertDataContentToUint8Array(base64Content)
+            )
+          });
+        } else {
+          if (!attachment.contentType) {
+            throw new Error(
+              "If the attachment is not an image or text, it must specify a content type"
+            );
           }
+          parts.push({
+            type: "file",
+            data: base64Content,
+            mimeType: attachment.contentType
+          });
         }
-      );
-    },
-    transform(chunk) {
-      eventSourceParser.feed(textDecoder.decode(chunk));
+        break;
+      }
+      default: {
+        throw new Error(`Unsupported URL protocol: ${url.protocol}`);
+      }
     }
-  });
+  }
+  return parts;
 }
-function createCallbacksTransformer(cb) {
-  const textEncoder = new TextEncoder();
-  let aggregatedResponse = "";
-  const callbacks = cb || {};
-  return new TransformStream({
-    async start() {
-      if (callbacks.onStart)
-        await callbacks.onStart();
-    },
-    async transform(message, controller) {
-      const content = typeof message === "string" ? message : message.content;
-      controller.enqueue(textEncoder.encode(content));
-      aggregatedResponse += content;
-      if (callbacks.onToken)
-        await callbacks.onToken(content);
-      if (callbacks.onText && typeof message === "string") {
-        await callbacks.onText(message);
+
+// core/prompt/message-conversion-error.ts
+import { AISDKError as AISDKError6 } from "@ai-sdk/provider";
+var name6 = "AI_MessageConversionError";
+var marker6 = `vercel.ai.error.${name6}`;
+var symbol6 = Symbol.for(marker6);
+var _a6;
+var MessageConversionError = class extends AISDKError6 {
+  constructor({
+    originalMessage,
+    message
+  }) {
+    super({ name: name6, message });
+    this[_a6] = true;
+    this.originalMessage = originalMessage;
+  }
+  static isInstance(error) {
+    return AISDKError6.hasMarker(error, marker6);
+  }
+};
+_a6 = symbol6;
+
+// core/prompt/convert-to-core-messages.ts
+function convertToCoreMessages(messages, options) {
+  var _a9;
+  const tools = (_a9 = options == null ? void 0 : options.tools) != null ? _a9 : {};
+  const coreMessages = [];
+  for (const message of messages) {
+    const { role, content, toolInvocations, experimental_attachments } = message;
+    switch (role) {
+      case "system": {
+        coreMessages.push({
+          role: "system",
+          content
+        });
+        break;
       }
-    },
-    async flush() {
-      const isOpenAICallbacks = isOfTypeOpenAIStreamCallbacks(callbacks);
-      if (callbacks.onCompletion) {
-        await callbacks.onCompletion(aggregatedResponse);
+      case "user": {
+        coreMessages.push({
+          role: "user",
+          content: experimental_attachments ? [
+            { type: "text", text: content },
+            ...attachmentsToParts(experimental_attachments)
+          ] : content
+        });
+        break;
+      }
+      case "assistant": {
+        if (toolInvocations == null) {
+          coreMessages.push({ role: "assistant", content });
+          break;
+        }
+        coreMessages.push({
+          role: "assistant",
+          content: [
+            { type: "text", text: content },
+            ...toolInvocations.map(
+              ({ toolCallId, toolName, args }) => ({
+                type: "tool-call",
+                toolCallId,
+                toolName,
+                args
+              })
+            )
+          ]
+        });
+        coreMessages.push({
+          role: "tool",
+          content: toolInvocations.map((toolInvocation) => {
+            if (!("result" in toolInvocation)) {
+              throw new MessageConversionError({
+                originalMessage: message,
+                message: "ToolInvocation must have a result: " + JSON.stringify(toolInvocation)
+              });
+            }
+            const { toolCallId, toolName, result } = toolInvocation;
+            const tool = tools[toolName];
+            return (tool == null ? void 0 : tool.experimental_toToolResultContent) != null ? {
+              type: "tool-result",
+              toolCallId,
+              toolName,
+              result: tool.experimental_toToolResultContent(result),
+              experimental_content: tool.experimental_toToolResultContent(result)
+            } : {
+              type: "tool-result",
+              toolCallId,
+              toolName,
+              result
+            };
+          })
+        });
+        break;
+      }
+      case "data": {
+        break;
       }
-      if (callbacks.onFinal && !isOpenAICallbacks) {
-        await callbacks.onFinal(aggregatedResponse);
+      default: {
+        const _exhaustiveCheck = role;
+        throw new MessageConversionError({
+          originalMessage: message,
+          message: `Unsupported role: ${_exhaustiveCheck}`
+        });
       }
     }
-  });
-}
-function isOfTypeOpenAIStreamCallbacks(callbacks) {
-  return "experimental_onFunctionCall" in callbacks;
+  }
+  return coreMessages;
 }
-function trimStartOfStreamHelper() {
-  let isStreamStart = true;
-  return (text) => {
-    if (isStreamStart) {
-      text = text.trimStart();
-      if (text)
-        isStreamStart = false;
+
+// core/prompt/standardize-prompt.ts
+function standardizePrompt({
+  prompt,
+  tools
+}) {
+  if (prompt.prompt == null && prompt.messages == null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt or messages must be defined"
+    });
+  }
+  if (prompt.prompt != null && prompt.messages != null) {
+    throw new InvalidPromptError({
+      prompt,
+      message: "prompt and messages cannot be defined at the same time"
+    });
+  }
+  if (prompt.system != null && typeof prompt.system !== "string") {
+    throw new InvalidPromptError({
+      prompt,
+      message: "system must be a string"
+    });
+  }
+  if (prompt.prompt != null) {
+    if (typeof prompt.prompt !== "string") {
+      throw new InvalidPromptError({
+        prompt,
+        message: "prompt must be a string"
+      });
     }
-    return text;
-  };
-}
-function AIStream(response, customParser, callbacks) {
-  if (!response.ok) {
-    if (response.body) {
-      const reader = response.body.getReader();
-      return new ReadableStream({
-        async start(controller) {
-          const { done, value } = await reader.read();
-          if (!done) {
-            const errorText = new TextDecoder().decode(value);
-            controller.error(new Error(`Response error: ${errorText}`));
-          }
+    return {
+      type: "prompt",
+      system: prompt.system,
+      messages: [
+        {
+          role: "user",
+          content: prompt.prompt
         }
+      ]
+    };
+  }
+  if (prompt.messages != null) {
+    const promptType = detectPromptType(prompt.messages);
+    if (promptType === "other") {
+      throw new InvalidPromptError({
+        prompt,
+        message: "messages must be an array of CoreMessage or UIMessage"
       });
-    } else {
-      return new ReadableStream({
-        start(controller) {
-          controller.error(new Error("Response error: No response body"));
-        }
+    }
+    const messages = promptType === "ui-messages" ? convertToCoreMessages(prompt.messages, {
+      tools
+    }) : prompt.messages;
+    const validationResult = safeValidateTypes({
+      value: messages,
+      schema: z7.array(coreMessageSchema)
+    });
+    if (!validationResult.success) {
+      throw new InvalidPromptError({
+        prompt,
+        message: "messages must be an array of CoreMessage or UIMessage",
+        cause: validationResult.error
       });
     }
+    return {
+      type: "messages",
+      messages,
+      system: prompt.system
+    };
   }
-  const responseBodyStream = response.body || createEmptyReadableStream();
-  return responseBodyStream.pipeThrough(createEventStreamTransformer(customParser)).pipeThrough(createCallbacksTransformer(callbacks));
-}
-function createEmptyReadableStream() {
-  return new ReadableStream({
-    start(controller) {
-      controller.close();
-    }
-  });
-}
-function readableFromAsyncIterable(iterable) {
-  let it = iterable[Symbol.asyncIterator]();
-  return new ReadableStream({
-    async pull(controller) {
-      const { done, value } = await it.next();
-      if (done)
-        controller.close();
-      else
-        controller.enqueue(value);
-    },
-    async cancel(reason) {
-      var _a;
-      await ((_a = it.return) == null ? void 0 : _a.call(it, reason));
-    }
-  });
+  throw new Error("unreachable");
 }
 
-// streams/stream-data.ts
-function createStreamDataTransformer() {
-  const encoder = new TextEncoder();
-  const decoder = new TextDecoder();
-  return new TransformStream({
-    transform: async (chunk, controller) => {
-      const message = decoder.decode(chunk);
-      controller.enqueue(encoder.encode(formatStreamPart("text", message)));
-    }
-  });
+// core/types/usage.ts
+function calculateLanguageModelUsage({
+  promptTokens,
+  completionTokens
+}) {
+  return {
+    promptTokens,
+    completionTokens,
+    totalTokens: promptTokens + completionTokens
+  };
 }
 
-// streams/openai-stream.ts
-function parseOpenAIStream() {
-  const extract = chunkToText();
-  return (data) => extract(JSON.parse(data));
-}
-async function* streamable(stream) {
-  const extract = chunkToText();
-  for await (let chunk of stream) {
-    if ("promptFilterResults" in chunk) {
-      chunk = {
-        id: chunk.id,
-        created: chunk.created.getDate(),
-        object: chunk.object,
-        // not exposed by Azure API
-        model: chunk.model,
-        // not exposed by Azure API
-        choices: chunk.choices.map((choice) => {
-          var _a, _b, _c, _d, _e, _f, _g;
-          return {
-            delta: {
-              content: (_a = choice.delta) == null ? void 0 : _a.content,
-              function_call: (_b = choice.delta) == null ? void 0 : _b.functionCall,
-              role: (_c = choice.delta) == null ? void 0 : _c.role,
-              tool_calls: ((_e = (_d = choice.delta) == null ? void 0 : _d.toolCalls) == null ? void 0 : _e.length) ? (_g = (_f = choice.delta) == null ? void 0 : _f.toolCalls) == null ? void 0 : _g.map((toolCall, index) => ({
-                index,
-                id: toolCall.id,
-                function: toolCall.function,
-                type: toolCall.type
-              })) : void 0
-            },
-            finish_reason: choice.finishReason,
-            index: choice.index
-          };
-        })
-      };
-    }
-    const text = extract(chunk);
-    if (text)
-      yield text;
+// errors/invalid-tool-arguments-error.ts
+import { AISDKError as AISDKError7, getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider";
+var name7 = "AI_InvalidToolArgumentsError";
+var marker7 = `vercel.ai.error.${name7}`;
+var symbol7 = Symbol.for(marker7);
+var _a7;
+var InvalidToolArgumentsError = class extends AISDKError7 {
+  constructor({
+    toolArgs,
+    toolName,
+    cause,
+    message = `Invalid arguments for tool ${toolName}: ${getErrorMessage2(
+      cause
+    )}`
+  }) {
+    super({ name: name7, message, cause });
+    this[_a7] = true;
+    this.toolArgs = toolArgs;
+    this.toolName = toolName;
   }
-}
-function chunkToText() {
-  const trimStartOfStream = trimStartOfStreamHelper();
-  let isFunctionStreamingIn;
-  return (json) => {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
-    if (isChatCompletionChunk(json)) {
-      const delta = (_a = json.choices[0]) == null ? void 0 : _a.delta;
-      if ((_b = delta.function_call) == null ? void 0 : _b.name) {
-        isFunctionStreamingIn = true;
-        return {
-          isText: false,
-          content: `{"function_call": {"name": "${delta.function_call.name}", "arguments": "`
-        };
-      } else if ((_e = (_d = (_c = delta.tool_calls) == null ? void 0 : _c[0]) == null ? void 0 : _d.function) == null ? void 0 : _e.name) {
-        isFunctionStreamingIn = true;
-        const toolCall = delta.tool_calls[0];
-        if (toolCall.index === 0) {
-          return {
-            isText: false,
-            content: `{"tool_calls":[ {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_f = toolCall.function) == null ? void 0 : _f.name}", "arguments": "`
-          };
-        } else {
-          return {
-            isText: false,
-            content: `"}}, {"id": "${toolCall.id}", "type": "function", "function": {"name": "${(_g = toolCall.function) == null ? void 0 : _g.name}", "arguments": "`
-          };
-        }
-      } else if ((_h = delta.function_call) == null ? void 0 : _h.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_i = delta.function_call) == null ? void 0 : _i.arguments)
-        };
-      } else if ((_l = (_k = (_j = delta.tool_calls) == null ? void 0 : _j[0]) == null ? void 0 : _k.function) == null ? void 0 : _l.arguments) {
-        return {
-          isText: false,
-          content: cleanupArguments((_o = (_n = (_m = delta.tool_calls) == null ? void 0 : _m[0]) == null ? void 0 : _n.function) == null ? void 0 : _o.arguments)
-        };
-      } else if (isFunctionStreamingIn && (((_p = json.choices[0]) == null ? void 0 : _p.finish_reason) === "function_call" || ((_q = json.choices[0]) == null ? void 0 : _q.finish_reason) === "stop")) {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}'
-        };
-      } else if (isFunctionStreamingIn && ((_r = json.choices[0]) == null ? void 0 : _r.finish_reason) === "tool_calls") {
-        isFunctionStreamingIn = false;
-        return {
-          isText: false,
-          content: '"}}]}'
-        };
-      }
-    }
-    const text = trimStartOfStream(
-      isChatCompletionChunk(json) && json.choices[0].delta.content ? json.choices[0].delta.content : isCompletion(json) ? json.choices[0].text : ""
-    );
-    return text;
-  };
-  function cleanupArguments(argumentChunk) {
-    let escapedPartialJson = argumentChunk.replace(/\\/g, "\\\\").replace(/\//g, "\\/").replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r").replace(/\t/g, "\\t").replace(/\f/g, "\\f");
-    return `${escapedPartialJson}`;
+  static isInstance(error) {
+    return AISDKError7.hasMarker(error, marker7);
   }
-}
-var __internal__OpenAIFnMessagesSymbol = Symbol(
-  "internal_openai_fn_messages"
-);
-function isChatCompletionChunk(data) {
-  return "choices" in data && data.choices && data.choices[0] && "delta" in data.choices[0];
-}
-function isCompletion(data) {
-  return "choices" in data && data.choices && data.choices[0] && "text" in data.choices[0];
-}
-function OpenAIStream(res, callbacks) {
-  const cb = callbacks;
-  let stream;
-  if (Symbol.asyncIterator in res) {
-    stream = readableFromAsyncIterable(streamable(res)).pipeThrough(
-      createCallbacksTransformer(
-        (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-          ...cb,
-          onFinal: void 0
-        } : {
-          ...cb
-        }
-      )
-    );
-  } else {
-    stream = AIStream(
-      res,
-      parseOpenAIStream(),
-      (cb == null ? void 0 : cb.experimental_onFunctionCall) || (cb == null ? void 0 : cb.experimental_onToolCall) ? {
-        ...cb,
-        onFinal: void 0
-      } : {
-        ...cb
-      }
-    );
+};
+_a7 = symbol7;
+
+// errors/no-such-tool-error.ts
+import { AISDKError as AISDKError8 } from "@ai-sdk/provider";
+var name8 = "AI_NoSuchToolError";
+var marker8 = `vercel.ai.error.${name8}`;
+var symbol8 = Symbol.for(marker8);
+var _a8;
+var NoSuchToolError = class extends AISDKError8 {
+  constructor({
+    toolName,
+    availableTools = void 0,
+    message = `Model tried to call unavailable tool '${toolName}'. ${availableTools === void 0 ? "No tools are available." : `Available tools: ${availableTools.join(", ")}.`}`
+  }) {
+    super({ name: name8, message });
+    this[_a8] = true;
+    this.toolName = toolName;
+    this.availableTools = availableTools;
   }
-  if (cb && (cb.experimental_onFunctionCall || cb.experimental_onToolCall)) {
-    const functionCallTransformer = createFunctionCallTransformer(cb);
-    return stream.pipeThrough(functionCallTransformer);
-  } else {
-    return stream.pipeThrough(createStreamDataTransformer());
+  static isInstance(error) {
+    return AISDKError8.hasMarker(error, marker8);
   }
+};
+_a8 = symbol8;
+
+// util/is-async-generator.ts
+function isAsyncGenerator(value) {
+  return value != null && typeof value === "object" && Symbol.asyncIterator in value;
 }
-function createFunctionCallTransformer(callbacks) {
-  const textEncoder = new TextEncoder();
-  let isFirstChunk = true;
-  let aggregatedResponse = "";
-  let aggregatedFinalCompletionResponse = "";
-  let isFunctionStreamingIn = false;
-  let functionCallMessages = callbacks[__internal__OpenAIFnMessagesSymbol] || [];
-  const decode = createChunkDecoder();
-  return new TransformStream({
-    async transform(chunk, controller) {
-      const message = decode(chunk);
-      aggregatedFinalCompletionResponse += message;
-      const shouldHandleAsFunction = isFirstChunk && (message.startsWith('{"function_call":') || message.startsWith('{"tool_calls":'));
-      if (shouldHandleAsFunction) {
-        isFunctionStreamingIn = true;
-        aggregatedResponse += message;
-        isFirstChunk = false;
-        return;
-      }
-      if (!isFunctionStreamingIn) {
-        controller.enqueue(
-          textEncoder.encode(formatStreamPart("text", message))
-        );
-        return;
-      } else {
-        aggregatedResponse += message;
-      }
-    },
-    async flush(controller) {
-      try {
-        if (!isFirstChunk && isFunctionStreamingIn && (callbacks.experimental_onFunctionCall || callbacks.experimental_onToolCall)) {
-          isFunctionStreamingIn = false;
-          const payload = JSON.parse(aggregatedResponse);
-          let newFunctionCallMessages = [
-            ...functionCallMessages
-          ];
-          let functionResponse = void 0;
-          if (callbacks.experimental_onFunctionCall) {
-            if (payload.function_call === void 0) {
-              console.warn(
-                "experimental_onFunctionCall should not be defined when using tools"
-              );
-            }
-            const argumentsPayload = JSON.parse(
-              payload.function_call.arguments
-            );
-            functionResponse = await callbacks.experimental_onFunctionCall(
-              {
-                name: payload.function_call.name,
-                arguments: argumentsPayload
-              },
-              (result) => {
-                newFunctionCallMessages = [
-                  ...functionCallMessages,
-                  {
-                    role: "assistant",
-                    content: "",
-                    function_call: payload.function_call
-                  },
-                  {
-                    role: "function",
-                    name: payload.function_call.name,
-                    content: JSON.stringify(result)
-                  }
-                ];
-                return newFunctionCallMessages;
-              }
-            );
-          }
-          if (callbacks.experimental_onToolCall) {
-            const toolCalls = {
-              tools: []
-            };
-            for (const tool of payload.tool_calls) {
-              toolCalls.tools.push({
-                id: tool.id,
-                type: "function",
-                func: {
-                  name: tool.function.name,
-                  arguments: JSON.parse(tool.function.arguments)
-                }
-              });
-            }
-            let responseIndex = 0;
-            try {
-              functionResponse = await callbacks.experimental_onToolCall(
-                toolCalls,
-                (result) => {
-                  if (result) {
-                    const { tool_call_id, function_name, tool_call_result } = result;
-                    newFunctionCallMessages = [
-                      ...newFunctionCallMessages,
-                      // Only append the assistant message if it's the first response
-                      ...responseIndex === 0 ? [
-                        {
-                          role: "assistant",
-                          content: "",
-                          tool_calls: payload.tool_calls.map(
-                            (tc) => ({
-                              id: tc.id,
-                              type: "function",
-                              function: {
-                                name: tc.function.name,
-                                // we send the arguments an object to the user, but as the API expects a string, we need to stringify it
-                                arguments: JSON.stringify(
-                                  tc.function.arguments
-                                )
-                              }
-                            })
-                          )
-                        }
-                      ] : [],
-                      // Append the function call result message
-                      {
-                        role: "tool",
-                        tool_call_id,
-                        name: function_name,
-                        content: JSON.stringify(tool_call_result)
-                      }
-                    ];
-                    responseIndex++;
-                  }
-                  return newFunctionCallMessages;
-                }
-              );
-            } catch (e) {
-              console.error("Error calling experimental_onToolCall:", e);
-            }
-          }
-          if (!functionResponse) {
-            controller.enqueue(
-              textEncoder.encode(
-                formatStreamPart(
-                  payload.function_call ? "function_call" : "tool_calls",
-                  // parse to prevent double-encoding:
-                  JSON.parse(aggregatedResponse)
-                )
-              )
-            );
-            return;
-          } else if (typeof functionResponse === "string") {
-            controller.enqueue(
-              textEncoder.encode(formatStreamPart("text", functionResponse))
-            );
-            aggregatedFinalCompletionResponse = functionResponse;
-            return;
-          }
-          const filteredCallbacks = {
-            ...callbacks,
-            onStart: void 0
-          };
-          callbacks.onFinal = void 0;
-          const openAIStream = OpenAIStream(functionResponse, {
-            ...filteredCallbacks,
-            [__internal__OpenAIFnMessagesSymbol]: newFunctionCallMessages
-          });
-          const reader = openAIStream.getReader();
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) {
-              break;
-            }
-            controller.enqueue(value);
-          }
-        }
-      } finally {
-        if (callbacks.onFinal && aggregatedFinalCompletionResponse) {
-          await callbacks.onFinal(aggregatedFinalCompletionResponse);
-        }
-      }
-    }
-  });
+
+// util/is-generator.ts
+function isGenerator(value) {
+  return value != null && typeof value === "object" && Symbol.iterator in value;
 }
 
-// rsc/constants.ts
-var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
-var DEV_DEFAULT_STREAMABLE_WARNING_TIME = 15 * 1e3;
+// util/constants.ts
+var HANGING_STREAM_WARNING_TIME_MS = 15 * 1e3;
 
-// rsc/streamable.tsx
+// rsc/streamable-ui/create-suspended-chunk.tsx
+import { Suspense } from "react";
+import { Fragment, jsx as jsx2, jsxs } from "react/jsx-runtime";
+var R = [
+  async ({
+    c: current,
+    n: next
+  }) => {
+    const chunk = await next;
+    if (chunk.done) {
+      return chunk.value;
+    }
+    if (chunk.append) {
+      return /* @__PURE__ */ jsxs(Fragment, { children: [
+        current,
+        /* @__PURE__ */ jsx2(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx2(R, { c: chunk.value, n: chunk.next }) })
+      ] });
+    }
+    return /* @__PURE__ */ jsx2(Suspense, { fallback: chunk.value, children: /* @__PURE__ */ jsx2(R, { c: chunk.value, n: chunk.next }) });
+  }
+][0];
+function createSuspendedChunk(initialValue) {
+  const { promise, resolve, reject } = createResolvablePromise();
+  return {
+    row: /* @__PURE__ */ jsx2(Suspense, { fallback: initialValue, children: /* @__PURE__ */ jsx2(R, { c: initialValue, n: promise }) }),
+    resolve,
+    reject
+  };
+}
+
+// rsc/streamable-ui/create-streamable-ui.tsx
 function createStreamableUI(initialValue) {
   let currentValue = initialValue;
   let closed = false;
-  let { row, resolve, reject } = createSuspensedChunk(initialValue);
+  let { row, resolve, reject } = createSuspendedChunk(initialValue);
   function assertStream(method) {
     if (closed) {
       throw new Error(method + ": UI stream is already closed.");
@@ -1210,23 +1401,17 @@ function createStreamableUI(initialValue) {
         console.warn(
           "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
         );
-      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
+      }, HANGING_STREAM_WARNING_TIME_MS);
     }
   }
   warnUnclosedStream();
-  const streamable2 = {
-    /**
-     * The value of the streamable UI. This can be returned from a Server Action and received by the client.
-     */
+  const streamable = {
     value: row,
-    /**
-     * This method updates the current UI node. It takes a new UI node and replaces the old one.
-     */
     update(value) {
       assertStream(".update()");
       if (value === currentValue) {
         warnUnclosedStream();
-        return streamable2;
+        return streamable;
       }
       const resolvable = createResolvablePromise();
       currentValue = value;
@@ -1234,24 +1419,8 @@ function createStreamableUI(initialValue) {
       resolve = resolvable.resolve;
       reject = resolvable.reject;
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method is used to append a new UI node to the end of the old one.
-     * Once appended a new UI node, the previous UI node cannot be updated anymore.
-     *
-     * @example
-     * ```jsx
-     * const ui = createStreamableUI(<div>hello</div>)
-     * ui.append(<div>world</div>)
-     *
-     * // The UI node will be:
-     * // <>
-     * //   <div>hello</div>
-     * //   <div>world</div>
-     * // </>
-     * ```
-     */
     append(value) {
       assertStream(".append()");
       const resolvable = createResolvablePromise();
@@ -1260,12 +1429,8 @@ function createStreamableUI(initialValue) {
       resolve = resolvable.resolve;
       reject = resolvable.reject;
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method is used to signal that there is an error in the UI stream.
-     * It will be thrown on the client side and caught by the nearest error boundary component.
-     */
     error(error) {
       assertStream(".error()");
       if (warningTimeout) {
@@ -1273,30 +1438,238 @@ function createStreamableUI(initialValue) {
       }
       closed = true;
       reject(error);
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method marks the UI node as finalized. You can either call it without any parameters or with a new UI node as the final state.
-     * Once called, the UI node cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response will be stuck in a loading state.
-     */
     done(...args) {
       assertStream(".done()");
       if (warningTimeout) {
         clearTimeout(warningTimeout);
       }
-      closed = true;
-      if (args.length) {
-        resolve({ value: args[0], done: true });
-        return streamable2;
+      closed = true;
+      if (args.length) {
+        resolve({ value: args[0], done: true });
+        return streamable;
+      }
+      resolve({ value: currentValue, done: true });
+      return streamable;
+    }
+  };
+  return streamable;
+}
+
+// rsc/stream-ui/stream-ui.tsx
+var defaultTextRenderer = ({ content }) => content;
+async function streamUI({
+  model,
+  tools,
+  toolChoice,
+  system,
+  prompt,
+  messages,
+  maxRetries,
+  abortSignal,
+  headers,
+  initial,
+  text,
+  experimental_providerMetadata: providerMetadata,
+  onFinish,
+  ...settings
+}) {
+  if (typeof model === "string") {
+    throw new Error(
+      "`model` cannot be a string in `streamUI`. Use the actual model instance instead."
+    );
+  }
+  if ("functions" in settings) {
+    throw new Error(
+      "`functions` is not supported in `streamUI`, use `tools` instead."
+    );
+  }
+  if ("provider" in settings) {
+    throw new Error(
+      "`provider` is no longer needed in `streamUI`. Use `model` instead."
+    );
+  }
+  if (tools) {
+    for (const [name9, tool] of Object.entries(tools)) {
+      if ("render" in tool) {
+        throw new Error(
+          "Tool definition in `streamUI` should not have `render` property. Use `generate` instead. Found in tool: " + name9
+        );
+      }
+    }
+  }
+  const ui = createStreamableUI(initial);
+  const textRender = text || defaultTextRenderer;
+  let finished;
+  let finishEvent = null;
+  async function render({
+    args,
+    renderer,
+    streamableUI,
+    isLastCall = false
+  }) {
+    if (!renderer)
+      return;
+    const renderFinished = createResolvablePromise();
+    finished = finished ? finished.then(() => renderFinished.promise) : renderFinished.promise;
+    const rendererResult = renderer(...args);
+    if (isAsyncGenerator(rendererResult) || isGenerator(rendererResult)) {
+      while (true) {
+        const { done, value } = await rendererResult.next();
+        const node = await value;
+        if (isLastCall && done) {
+          streamableUI.done(node);
+        } else {
+          streamableUI.update(node);
+        }
+        if (done)
+          break;
+      }
+    } else {
+      const node = await rendererResult;
+      if (isLastCall) {
+        streamableUI.done(node);
+      } else {
+        streamableUI.update(node);
+      }
+    }
+    renderFinished.resolve(void 0);
+  }
+  const { retry } = prepareRetries({ maxRetries });
+  const validatedPrompt = standardizePrompt({
+    prompt: { system, prompt, messages },
+    tools: void 0
+    // streamUI tools don't support multi-modal tool result conversion
+  });
+  const result = await retry(
+    async () => model.doStream({
+      mode: {
+        type: "regular",
+        ...prepareToolsAndToolChoice({
+          tools,
+          toolChoice,
+          activeTools: void 0
+        })
+      },
+      ...prepareCallSettings(settings),
+      inputFormat: validatedPrompt.type,
+      prompt: await convertToLanguageModelPrompt({
+        prompt: validatedPrompt,
+        modelSupportsImageUrls: model.supportsImageUrls,
+        modelSupportsUrl: model.supportsUrl
+      }),
+      providerMetadata,
+      abortSignal,
+      headers
+    })
+  );
+  const [stream, forkedStream] = result.stream.tee();
+  (async () => {
+    try {
+      let content = "";
+      let hasToolCall = false;
+      const reader = forkedStream.getReader();
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+          break;
+        switch (value.type) {
+          case "text-delta": {
+            content += value.textDelta;
+            render({
+              renderer: textRender,
+              args: [{ content, done: false, delta: value.textDelta }],
+              streamableUI: ui
+            });
+            break;
+          }
+          case "tool-call-delta": {
+            hasToolCall = true;
+            break;
+          }
+          case "tool-call": {
+            const toolName = value.toolName;
+            if (!tools) {
+              throw new NoSuchToolError({ toolName });
+            }
+            const tool = tools[toolName];
+            if (!tool) {
+              throw new NoSuchToolError({
+                toolName,
+                availableTools: Object.keys(tools)
+              });
+            }
+            hasToolCall = true;
+            const parseResult = safeParseJSON({
+              text: value.args,
+              schema: tool.parameters
+            });
+            if (parseResult.success === false) {
+              throw new InvalidToolArgumentsError({
+                toolName,
+                toolArgs: value.args,
+                cause: parseResult.error
+              });
+            }
+            render({
+              renderer: tool.generate,
+              args: [
+                parseResult.value,
+                {
+                  toolName,
+                  toolCallId: value.toolCallId
+                }
+              ],
+              streamableUI: ui,
+              isLastCall: true
+            });
+            break;
+          }
+          case "error": {
+            throw value.error;
+          }
+          case "finish": {
+            finishEvent = {
+              finishReason: value.finishReason,
+              usage: calculateLanguageModelUsage(value.usage),
+              warnings: result.warnings,
+              rawResponse: result.rawResponse
+            };
+            break;
+          }
+        }
+      }
+      if (!hasToolCall) {
+        render({
+          renderer: textRender,
+          args: [{ content, done: true }],
+          streamableUI: ui,
+          isLastCall: true
+        });
       }
-      resolve({ value: currentValue, done: true });
-      return streamable2;
+      await finished;
+      if (finishEvent && onFinish) {
+        await onFinish({
+          ...finishEvent,
+          value: ui.value
+        });
+      }
+    } catch (error) {
+      ui.error(error);
     }
+  })();
+  return {
+    ...result,
+    stream,
+    value: ui.value
   };
-  return streamable2;
 }
+
+// rsc/streamable-value/streamable-value.ts
+var STREAMABLE_VALUE_TYPE = Symbol.for("ui.streamable.value");
+
+// rsc/streamable-value/create-streamable-value.ts
 var STREAMABLE_VALUE_INTERNAL_LOCK = Symbol("streamable.value.lock");
 function createStreamableValue(initialValue) {
   const isReadableStream = initialValue instanceof ReadableStream || typeof initialValue === "object" && initialValue !== null && "getReader" in initialValue && typeof initialValue.getReader === "function" && "locked" in initialValue && typeof initialValue.locked === "boolean";
@@ -1356,9 +1729,9 @@ function createStreamableValueImpl(initialValue) {
       }
       warningTimeout = setTimeout(() => {
         console.warn(
-          "The streamable UI has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
+          "The streamable value has been slow to update. This may be a bug or a performance issue or you forgot to call `.done()`."
         );
-      }, DEV_DEFAULT_STREAMABLE_WARNING_TIME);
+      }, HANGING_STREAM_WARNING_TIME_MS);
     }
   }
   warnUnclosedStream();
@@ -1392,25 +1765,13 @@ function createStreamableValueImpl(initialValue) {
     }
     currentValue = value;
   }
-  const streamable2 = {
-    /**
-     * @internal This is an internal lock to prevent the value from being
-     * updated by the user.
-     */
+  const streamable = {
     set [STREAMABLE_VALUE_INTERNAL_LOCK](state) {
       locked = state;
     },
-    /**
-     * The value of the streamable. This can be returned from a Server Action and
-     * received by the client. To read the streamed values, use the
-     * `readStreamableValue` or `useStreamableValue` APIs.
-     */
     get value() {
       return createWrapped(true);
     },
-    /**
-     * This method updates the current value with a new one.
-     */
     update(value) {
       assertStream(".update()");
       const resolvePrevious = resolvable.resolve;
@@ -1419,20 +1780,8 @@ function createStreamableValueImpl(initialValue) {
       currentPromise = resolvable.promise;
       resolvePrevious(createWrapped());
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method is used to append a delta string to the current value. It
-     * requires the current value of the streamable to be a string.
-     *
-     * @example
-     * ```jsx
-     * const streamable = createStreamableValue('hello');
-     * streamable.append(' world');
-     *
-     * // The value will be 'hello world'
-     * ```
-     */
     append(value) {
       assertStream(".append()");
       if (typeof currentValue !== "string" && typeof currentValue !== "undefined") {
@@ -1457,13 +1806,8 @@ function createStreamableValueImpl(initialValue) {
       currentPromise = resolvable.promise;
       resolvePrevious(createWrapped());
       warnUnclosedStream();
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method is used to signal that there is an error in the value stream.
-     * It will be thrown on the client side when consumed via
-     * `readStreamableValue` or `useStreamableValue`.
-     */
     error(error) {
       assertStream(".error()");
       if (warningTimeout) {
@@ -1473,16 +1817,8 @@ function createStreamableValueImpl(initialValue) {
       currentError = error;
       currentPromise = void 0;
       resolvable.resolve({ error });
-      return streamable2;
+      return streamable;
     },
-    /**
-     * This method marks the value as finalized. You can either call it without
-     * any parameters or with a new value as the final state.
-     * Once called, the value cannot be updated or appended anymore.
-     *
-     * This method is always **required** to be called, otherwise the response
-     * will be stuck in a loading state.
-     */
     done(...args) {
       assertStream(".done()");
       if (warningTimeout) {
@@ -1493,400 +1829,13 @@ function createStreamableValueImpl(initialValue) {
       if (args.length) {
         updateValueStates(args[0]);
         resolvable.resolve(createWrapped());
-        return streamable2;
+        return streamable;
       }
       resolvable.resolve({});
-      return streamable2;
-    }
-  };
-  return streamable2;
-}
-function render(options) {
-  const ui = createStreamableUI(options.initial);
-  const text = options.text ? options.text : ({ content }) => content;
-  const functions = options.functions ? Object.entries(options.functions).map(
-    ([name, { description, parameters }]) => {
-      return {
-        name,
-        description,
-        parameters: zodToJsonSchema2(parameters)
-      };
-    }
-  ) : void 0;
-  const tools = options.tools ? Object.entries(options.tools).map(
-    ([name, { description, parameters }]) => {
-      return {
-        type: "function",
-        function: {
-          name,
-          description,
-          parameters: zodToJsonSchema2(parameters)
-        }
-      };
-    }
-  ) : void 0;
-  if (functions && tools) {
-    throw new Error(
-      "You can't have both functions and tools defined. Please choose one or the other."
-    );
-  }
-  let finished;
-  async function handleRender(args, renderer, res) {
-    if (!renderer)
-      return;
-    const resolvable = createResolvablePromise();
-    if (finished) {
-      finished = finished.then(() => resolvable.promise);
-    } else {
-      finished = resolvable.promise;
-    }
-    const value = renderer(args);
-    if (value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function") {
-      const node = await value;
-      res.update(node);
-      resolvable.resolve(void 0);
-    } else if (value && typeof value === "object" && Symbol.asyncIterator in value) {
-      const it = value;
-      while (true) {
-        const { done, value: value2 } = await it.next();
-        res.update(value2);
-        if (done)
-          break;
-      }
-      resolvable.resolve(void 0);
-    } else if (value && typeof value === "object" && Symbol.iterator in value) {
-      const it = value;
-      while (true) {
-        const { done, value: value2 } = it.next();
-        res.update(value2);
-        if (done)
-          break;
-      }
-      resolvable.resolve(void 0);
-    } else {
-      res.update(value);
-      resolvable.resolve(void 0);
-    }
-  }
-  (async () => {
-    let hasFunction = false;
-    let content = "";
-    consumeStream(
-      OpenAIStream(
-        await options.provider.chat.completions.create({
-          model: options.model,
-          messages: options.messages,
-          temperature: options.temperature,
-          stream: true,
-          ...functions ? {
-            functions
-          } : {},
-          ...tools ? {
-            tools
-          } : {}
-        }),
-        {
-          ...functions ? {
-            async experimental_onFunctionCall(functionCallPayload) {
-              var _a, _b;
-              hasFunction = true;
-              handleRender(
-                functionCallPayload.arguments,
-                (_b = (_a = options.functions) == null ? void 0 : _a[functionCallPayload.name]) == null ? void 0 : _b.render,
-                ui
-              );
-            }
-          } : {},
-          ...tools ? {
-            async experimental_onToolCall(toolCallPayload) {
-              var _a, _b;
-              hasFunction = true;
-              for (const tool of toolCallPayload.tools) {
-                handleRender(
-                  tool.func.arguments,
-                  (_b = (_a = options.tools) == null ? void 0 : _a[tool.func.name]) == null ? void 0 : _b.render,
-                  ui
-                );
-              }
-            }
-          } : {},
-          onText(chunk) {
-            content += chunk;
-            handleRender({ content, done: false, delta: chunk }, text, ui);
-          },
-          async onFinal() {
-            if (hasFunction) {
-              await finished;
-              ui.done();
-              return;
-            }
-            handleRender({ content, done: true }, text, ui);
-            await finished;
-            ui.done();
-          }
-        }
-      )
-    );
-  })();
-  return ui.value;
-}
-
-// rsc/stream-ui/stream-ui.tsx
-import {
-  InvalidToolArgumentsError,
-  NoSuchToolError
-} from "@ai-sdk/provider";
-import { safeParseJSON } from "@ai-sdk/provider-utils";
-var defaultTextRenderer = ({ content }) => content;
-async function streamUI({
-  model,
-  tools,
-  system,
-  prompt,
-  messages,
-  maxRetries,
-  abortSignal,
-  initial,
-  text,
-  ...settings
-}) {
-  if (typeof model === "string") {
-    throw new Error(
-      "`model` cannot be a string in `streamUI`. Use the actual model instance instead."
-    );
-  }
-  if ("functions" in settings) {
-    throw new Error(
-      "`functions` is not supported in `streamUI`, use `tools` instead."
-    );
-  }
-  if ("provider" in settings) {
-    throw new Error(
-      "`provider` is no longer needed in `streamUI`. Use `model` instead."
-    );
-  }
-  if (tools) {
-    for (const [name, tool] of Object.entries(tools)) {
-      if ("render" in tool) {
-        throw new Error(
-          "Tool definition in `streamUI` should not have `render` property. Use `generate` instead. Found in tool: " + name
-        );
-      }
-    }
-  }
-  const ui = createStreamableUI(initial);
-  const textRender = text || defaultTextRenderer;
-  let finished;
-  async function handleRender(args, renderer, res) {
-    if (!renderer)
-      return;
-    const resolvable = createResolvablePromise();
-    if (finished) {
-      finished = finished.then(() => resolvable.promise);
-    } else {
-      finished = resolvable.promise;
-    }
-    const value = renderer(...args);
-    if (value instanceof Promise || value && typeof value === "object" && "then" in value && typeof value.then === "function") {
-      const node = await value;
-      res.update(node);
-      resolvable.resolve(void 0);
-    } else if (value && typeof value === "object" && Symbol.asyncIterator in value) {
-      const it = value;
-      while (true) {
-        const { done, value: value2 } = await it.next();
-        res.update(value2);
-        if (done)
-          break;
-      }
-      resolvable.resolve(void 0);
-    } else if (value && typeof value === "object" && Symbol.iterator in value) {
-      const it = value;
-      while (true) {
-        const { done, value: value2 } = it.next();
-        res.update(value2);
-        if (done)
-          break;
-      }
-      resolvable.resolve(void 0);
-    } else {
-      res.update(value);
-      resolvable.resolve(void 0);
-    }
-  }
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-  const result = await retry(
-    () => model.doStream({
-      mode: {
-        type: "regular",
-        tools: tools == null ? void 0 : Object.entries(tools).map(([name, tool]) => ({
-          type: "function",
-          name,
-          description: tool.description,
-          parameters: convertZodToJSONSchema(tool.parameters)
-        }))
-      },
-      ...prepareCallSettings(settings),
-      inputFormat: validatedPrompt.type,
-      prompt: convertToLanguageModelPrompt(validatedPrompt),
-      abortSignal
-    })
-  );
-  const [stream, forkedStream] = result.stream.tee();
-  (async () => {
-    try {
-      let content = "";
-      let hasToolCall = false;
-      const reader = forkedStream.getReader();
-      while (true) {
-        const { done, value } = await reader.read();
-        if (done)
-          break;
-        switch (value.type) {
-          case "text-delta": {
-            content += value.textDelta;
-            handleRender(
-              [{ content, done: false, delta: value.textDelta }],
-              textRender,
-              ui
-            );
-            break;
-          }
-          case "tool-call-delta": {
-            hasToolCall = true;
-            break;
-          }
-          case "tool-call": {
-            const toolName = value.toolName;
-            if (!tools) {
-              throw new NoSuchToolError({ toolName });
-            }
-            const tool = tools[toolName];
-            if (!tool) {
-              throw new NoSuchToolError({
-                toolName,
-                availableTools: Object.keys(tools)
-              });
-            }
-            const parseResult = safeParseJSON({
-              text: value.args,
-              schema: tool.parameters
-            });
-            if (parseResult.success === false) {
-              throw new InvalidToolArgumentsError({
-                toolName,
-                toolArgs: value.args,
-                cause: parseResult.error
-              });
-            }
-            handleRender(
-              [
-                parseResult.value,
-                {
-                  toolName,
-                  toolCallId: value.toolCallId
-                }
-              ],
-              tool.generate,
-              ui
-            );
-            break;
-          }
-          case "error": {
-            throw value.error;
-          }
-          case "finish": {
-          }
-        }
-      }
-      if (hasToolCall) {
-        await finished;
-        ui.done();
-      } else {
-        handleRender([{ content, done: true }], textRender, ui);
-        await finished;
-        ui.done();
-      }
-    } catch (error) {
-      ui.error(error);
-    }
-  })();
-  return {
-    ...result,
-    stream,
-    value: ui.value
-  };
-}
-
-// rsc/provider.tsx
-import * as React2 from "react";
-import { InternalAIProvider } from "./rsc-shared.mjs";
-import { jsx as jsx2 } from "react/jsx-runtime";
-async function innerAction({
-  action,
-  options
-}, state, ...args) {
-  "use server";
-  return await withAIState(
-    {
-      state,
-      options
-    },
-    async () => {
-      const result = await action(...args);
-      sealMutableAIState();
-      return [getAIStateDeltaPromise(), result];
-    }
-  );
-}
-function wrapAction(action, options) {
-  return innerAction.bind(null, { action, options });
-}
-function createAI({
-  actions,
-  initialAIState,
-  initialUIState,
-  onSetAIState,
-  onGetUIState
-}) {
-  const wrappedActions = {};
-  for (const name in actions) {
-    wrappedActions[name] = wrapAction(actions[name], {
-      onSetAIState
-    });
-  }
-  const wrappedSyncUIState = onGetUIState ? wrapAction(onGetUIState, {}) : void 0;
-  const AI = async (props) => {
-    var _a, _b;
-    if ("useState" in React2) {
-      throw new Error(
-        "This component can only be used inside Server Components."
-      );
-    }
-    let uiState = (_a = props.initialUIState) != null ? _a : initialUIState;
-    let aiState = (_b = props.initialAIState) != null ? _b : initialAIState;
-    let aiStateDelta = void 0;
-    if (wrappedSyncUIState) {
-      const [newAIStateDelta, newUIState] = await wrappedSyncUIState(aiState);
-      if (newUIState !== void 0) {
-        aiStateDelta = newAIStateDelta;
-        uiState = newUIState;
-      }
+      return streamable;
     }
-    return /* @__PURE__ */ jsx2(
-      InternalAIProvider,
-      {
-        wrappedActions,
-        wrappedSyncUIState,
-        initialUIState: uiState,
-        initialAIState: aiState,
-        initialAIStatePatch: aiStateDelta,
-        children: props.children
-      }
-    );
   };
-  return AI;
+  return streamable;
 }
 export {
   createAI,
@@ -1894,7 +1843,6 @@ export {
   createStreamableValue,
   getAIState,
   getMutableAIState,
-  render,
   streamUI
 };
 //# sourceMappingURL=rsc-server.mjs.map