ai 3.2.34 → 3.2.36

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai",
-  "version": "3.2.34",
+  "version": "3.2.36",
   "description": "Vercel AI SDK - The AI Toolkit for TypeScript and JavaScript",
   "license": "Apache-2.0",
   "sideEffects": false,
@@ -58,20 +58,19 @@
     }
   },
   "dependencies": {
-    "@ai-sdk/provider": "0.0.13",
-    "@ai-sdk/provider-utils": "1.0.3",
-    "@ai-sdk/react": "0.0.27",
-    "@ai-sdk/solid": "0.0.20",
-    "@ai-sdk/svelte": "0.0.21",
-    "@ai-sdk/ui-utils": "0.0.18",
-    "@ai-sdk/vue": "0.0.22",
+    "@ai-sdk/provider": "0.0.14",
+    "@ai-sdk/provider-utils": "1.0.5",
+    "@ai-sdk/react": "0.0.29",
+    "@ai-sdk/solid": "0.0.22",
+    "@ai-sdk/svelte": "0.0.23",
+    "@ai-sdk/ui-utils": "0.0.20",
+    "@ai-sdk/vue": "0.0.24",
     "@opentelemetry/api": "1.9.0",
     "eventsource-parser": "1.1.2",
     "jsondiffpatch": "0.6.0",
     "json-schema": "0.4.0",
     "nanoid": "3.3.6",
     "secure-json-parse": "2.7.0",
-    "sswr": "2.1.0",
     "zod-to-json-schema": "3.22.5"
   },
   "devDependencies": {
@@ -97,6 +96,7 @@
     "openai": "4.52.6",
     "react-dom": "^18",
     "react-server-dom-webpack": "18.3.0-canary-eb33bd747-20240312",
+    "sswr": "2.1.0",
     "tsup": "^7.2.0",
     "typescript": "5.1.3",
     "zod": "3.23.8",
@@ -107,6 +107,7 @@
     "openai": "^4.42.0",
     "react": "^18 || ^19",
     "zod": "^3.0.0",
+    "sswr": "^2.1.0",
     "svelte": "^3.0.0 || ^4.0.0"
   },
   "peerDependenciesMeta": {
@@ -119,6 +120,9 @@
     "openai": {
       "optional": true
     },
+    "sswr": {
+      "optional": true
+    },
     "svelte": {
       "optional": true
     }

package/rsc/dist/rsc-server.mjs

@@ -239,6 +239,9 @@ async function _retryWithExponentialBackoff(f, {
   }
 }
 
+// core/prompt/convert-to-language-model-prompt.ts
+import { getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider-utils";
+
 // core/util/detect-image-mimetype.ts
 var mimeTypeSignatures = [
   { mimeType: "image/gif", bytes: [71, 73, 70] },
@@ -255,6 +258,35 @@ function detectImageMimeType(image) {
   return void 0;
 }
 
+// core/util/download.ts
+import { DownloadError } from "@ai-sdk/provider";
+async function download({
+  url,
+  fetchImplementation = fetch
+}) {
+  var _a;
+  const urlText = url.toString();
+  try {
+    const response = await fetchImplementation(urlText);
+    if (!response.ok) {
+      throw new DownloadError({
+        url: urlText,
+        statusCode: response.status,
+        statusText: response.statusText
+      });
+    }
+    return {
+      data: new Uint8Array(await response.arrayBuffer()),
+      mimeType: (_a = response.headers.get("content-type")) != null ? _a : void 0
+    };
+  } catch (error) {
+    if (DownloadError.isDownloadError(error)) {
+      throw error;
+    }
+    throw new DownloadError({ url: urlText, cause: error });
+  }
+}
+
 // core/prompt/data-content.ts
 import { InvalidDataContentError } from "@ai-sdk/provider";
 import {
@@ -306,12 +338,16 @@ var InvalidMessageRoleError = class extends Error {
 };
 
 // core/prompt/convert-to-language-model-prompt.ts
-import { getErrorMessage as getErrorMessage2 } from "@ai-sdk/provider-utils";
-function convertToLanguageModelPrompt(prompt) {
+async function convertToLanguageModelPrompt({
+  prompt,
+  modelSupportsImageUrls = true,
+  downloadImplementation = download
+}) {
   const languageModelMessages = [];
   if (prompt.system != null) {
     languageModelMessages.push({ role: "system", content: prompt.system });
   }
+  const downloadedImages = modelSupportsImageUrls || prompt.messages == null ? null : await downloadImages(prompt.messages, downloadImplementation);
   const promptType = prompt.type;
   switch (promptType) {
     case "prompt": {
@@ -323,7 +359,9 @@ function convertToLanguageModelPrompt(prompt) {
     }
     case "messages": {
       languageModelMessages.push(
-        ...prompt.messages.map(convertToLanguageModelMessage)
+        ...prompt.messages.map(
+          (message) => convertToLanguageModelMessage(message, downloadedImages)
+        )
       );
       break;
     }
@@ -334,7 +372,7 @@ function convertToLanguageModelPrompt(prompt) {
   }
   return languageModelMessages;
 }
-function convertToLanguageModelMessage(message) {
+function convertToLanguageModelMessage(message, downloadedImages) {
   const role = message.role;
   switch (role) {
     case "system": {
@@ -351,18 +389,27 @@ function convertToLanguageModelMessage(message) {
         role: "user",
         content: message.content.map(
           (part) => {
-            var _a;
+            var _a, _b, _c;
             switch (part.type) {
               case "text": {
                 return part;
               }
               case "image": {
                 if (part.image instanceof URL) {
-                  return {
-                    type: "image",
-                    image: part.image,
-                    mimeType: part.mimeType
-                  };
+                  if (downloadedImages == null) {
+                    return {
+                      type: "image",
+                      image: part.image,
+                      mimeType: part.mimeType
+                    };
+                  } else {
+                    const downloadedImage = downloadedImages[part.image.toString()];
+                    return {
+                      type: "image",
+                      image: downloadedImage.data,
+                      mimeType: (_a = part.mimeType) != null ? _a : downloadedImage.mimeType
+                    };
+                  }
                 }
                 if (typeof part.image === "string") {
                   try {
@@ -370,11 +417,20 @@ function convertToLanguageModelMessage(message) {
                     switch (url.protocol) {
                       case "http:":
                       case "https:": {
-                        return {
-                          type: "image",
-                          image: url,
-                          mimeType: part.mimeType
-                        };
+                        if (downloadedImages == null) {
+                          return {
+                            type: "image",
+                            image: url,
+                            mimeType: part.mimeType
+                          };
+                        } else {
+                          const downloadedImage = downloadedImages[part.image];
+                          return {
+                            type: "image",
+                            image: downloadedImage.data,
+                            mimeType: (_b = part.mimeType) != null ? _b : downloadedImage.mimeType
+                          };
+                        }
                       }
                       case "data:": {
                         try {
@@ -409,7 +465,7 @@ function convertToLanguageModelMessage(message) {
                 return {
                   type: "image",
                   image: imageUint8,
-                  mimeType: (_a = part.mimeType) != null ? _a : detectImageMimeType(imageUint8)
+                  mimeType: (_c = part.mimeType) != null ? _c : detectImageMimeType(imageUint8)
                 };
               }
             }
@@ -441,6 +497,25 @@ function convertToLanguageModelMessage(message) {
     }
   }
 }
+async function downloadImages(messages, downloadImplementation) {
+  const urls = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
+    (content) => Array.isArray(content)
+  ).flat().filter((part) => part.type === "image").map((part) => part.image).map(
+    (part) => (
+      // support string urls in image parts:
+      typeof part === "string" && (part.startsWith("http:") || part.startsWith("https:")) ? new URL(part) : part
+    )
+  ).filter((image) => image instanceof 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])
+  );
+}
 
 // core/prompt/get-validated-prompt.ts
 import { InvalidPromptError } from "@ai-sdk/provider";
@@ -591,10 +666,39 @@ function calculateCompletionTokenUsage(usage) {
   };
 }
 
-// core/util/convert-zod-to-json-schema.ts
+// core/util/schema.ts
+import { validatorSymbol } from "@ai-sdk/provider-utils";
 import zodToJsonSchema from "zod-to-json-schema";
-function convertZodToJSONSchema(zodSchema) {
-  return zodToJsonSchema(zodSchema);
+var schemaSymbol = Symbol("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return isSchema(schema) ? schema : zodSchema(schema);
+}
+function zodSchema(zodSchema2) {
+  return jsonSchema(
+    // we assume that zodToJsonSchema will return a valid JSONSchema7:
+    zodToJsonSchema(zodSchema2),
+    {
+      validate: (value) => {
+        const result = zodSchema2.safeParse(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
 }
 
 // core/util/is-non-empty-object.ts
@@ -618,7 +722,7 @@ function prepareToolsAndToolChoice({
       type: "function",
       name,
       description: tool.description,
-      parameters: convertZodToJSONSchema(tool.parameters)
+      parameters: asSchema(tool.parameters).jsonSchema
     })),
     toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
   };
@@ -1564,14 +1668,17 @@ async function streamUI({
   const retry = retryWithExponentialBackoff({ maxRetries });
   const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
   const result = await retry(
-    () => model.doStream({
+    async () => model.doStream({
       mode: {
         type: "regular",
         ...prepareToolsAndToolChoice({ tools, toolChoice })
       },
       ...prepareCallSettings(settings),
       inputFormat: validatedPrompt.type,
-      prompt: convertToLanguageModelPrompt(validatedPrompt),
+      prompt: await convertToLanguageModelPrompt({
+        prompt: validatedPrompt,
+        modelSupportsImageUrls: model.supportsImageUrls
+      }),
       abortSignal,
       headers
     })