ai 3.2.34 → 3.2.36

package/dist/index.js

@@ -31,7 +31,7 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 var streams_exports = {};
 __export(streams_exports, {
   AIStream: () => AIStream,
-  APICallError: () => import_provider8.APICallError,
+  APICallError: () => import_provider9.APICallError,
   AWSBedrockAnthropicMessagesStream: () => AWSBedrockAnthropicMessagesStream,
   AWSBedrockAnthropicStream: () => AWSBedrockAnthropicStream,
   AWSBedrockCohereStream: () => AWSBedrockCohereStream,
@@ -40,35 +40,35 @@ __export(streams_exports, {
   AnthropicStream: () => AnthropicStream,
   AssistantResponse: () => AssistantResponse,
   CohereStream: () => CohereStream,
-  EmptyResponseBodyError: () => import_provider8.EmptyResponseBodyError,
+  EmptyResponseBodyError: () => import_provider9.EmptyResponseBodyError,
   GoogleGenerativeAIStream: () => GoogleGenerativeAIStream,
   HuggingFaceStream: () => HuggingFaceStream,
   InkeepStream: () => InkeepStream,
-  InvalidArgumentError: () => import_provider8.InvalidArgumentError,
-  InvalidDataContentError: () => import_provider8.InvalidDataContentError,
+  InvalidArgumentError: () => import_provider9.InvalidArgumentError,
+  InvalidDataContentError: () => import_provider9.InvalidDataContentError,
   InvalidMessageRoleError: () => InvalidMessageRoleError,
   InvalidModelIdError: () => InvalidModelIdError,
-  InvalidPromptError: () => import_provider8.InvalidPromptError,
-  InvalidResponseDataError: () => import_provider8.InvalidResponseDataError,
-  InvalidToolArgumentsError: () => import_provider8.InvalidToolArgumentsError,
-  JSONParseError: () => import_provider8.JSONParseError,
+  InvalidPromptError: () => import_provider9.InvalidPromptError,
+  InvalidResponseDataError: () => import_provider9.InvalidResponseDataError,
+  InvalidToolArgumentsError: () => import_provider9.InvalidToolArgumentsError,
+  JSONParseError: () => import_provider9.JSONParseError,
   LangChainAdapter: () => langchain_adapter_exports,
   LangChainStream: () => LangChainStream,
-  LoadAPIKeyError: () => import_provider8.LoadAPIKeyError,
+  LoadAPIKeyError: () => import_provider9.LoadAPIKeyError,
   MistralStream: () => MistralStream,
-  NoObjectGeneratedError: () => import_provider8.NoObjectGeneratedError,
+  NoObjectGeneratedError: () => import_provider9.NoObjectGeneratedError,
   NoSuchModelError: () => NoSuchModelError,
   NoSuchProviderError: () => NoSuchProviderError,
-  NoSuchToolError: () => import_provider8.NoSuchToolError,
+  NoSuchToolError: () => import_provider9.NoSuchToolError,
   OpenAIStream: () => OpenAIStream,
   ReplicateStream: () => ReplicateStream,
-  RetryError: () => import_provider8.RetryError,
+  RetryError: () => import_provider9.RetryError,
   StreamData: () => StreamData2,
   StreamingTextResponse: () => StreamingTextResponse,
-  ToolCallParseError: () => import_provider8.ToolCallParseError,
-  TypeValidationError: () => import_provider8.TypeValidationError,
-  UnsupportedFunctionalityError: () => import_provider8.UnsupportedFunctionalityError,
-  UnsupportedJSONSchemaError: () => import_provider8.UnsupportedJSONSchemaError,
+  ToolCallParseError: () => import_provider9.ToolCallParseError,
+  TypeValidationError: () => import_provider9.TypeValidationError,
+  UnsupportedFunctionalityError: () => import_provider9.UnsupportedFunctionalityError,
+  UnsupportedJSONSchemaError: () => import_provider9.UnsupportedJSONSchemaError,
   convertDataContentToBase64String: () => convertDataContentToBase64String,
   convertDataContentToUint8Array: () => convertDataContentToUint8Array,
   convertToCoreMessages: () => convertToCoreMessages,
@@ -91,6 +91,7 @@ __export(streams_exports, {
   generateId: () => generateId2,
   generateObject: () => generateObject,
   generateText: () => generateText,
+  jsonSchema: () => jsonSchema,
   nanoid: () => nanoid,
   parseComplexResponse: () => import_ui_utils6.parseComplexResponse,
   parseStreamPart: () => import_ui_utils6.parseStreamPart,
@@ -104,7 +105,158 @@ __export(streams_exports, {
 });
 module.exports = __toCommonJS(streams_exports);
 var import_ui_utils6 = require("@ai-sdk/ui-utils");
-var import_provider_utils7 = require("@ai-sdk/provider-utils");
+var import_provider_utils8 = require("@ai-sdk/provider-utils");
+
+// core/telemetry/get-base-telemetry-attributes.ts
+function getBaseTelemetryAttributes({
+  operationName,
+  model,
+  settings,
+  telemetry,
+  headers
+}) {
+  var _a;
+  return {
+    "ai.model.provider": model.provider,
+    "ai.model.id": model.modelId,
+    // settings:
+    ...Object.entries(settings).reduce((attributes, [key, value]) => {
+      attributes[`ai.settings.${key}`] = value;
+      return attributes;
+    }, {}),
+    // special telemetry information
+    "operation.name": operationName,
+    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
+    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId,
+    // add metadata as attributes:
+    ...Object.entries((_a = telemetry == null ? void 0 : telemetry.metadata) != null ? _a : {}).reduce(
+      (attributes, [key, value]) => {
+        attributes[`ai.telemetry.metadata.${key}`] = value;
+        return attributes;
+      },
+      {}
+    ),
+    // request headers
+    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
+      if (value !== void 0) {
+        attributes[`ai.request.headers.${key}`] = value;
+      }
+      return attributes;
+    }, {})
+  };
+}
+
+// core/telemetry/get-tracer.ts
+var import_api = require("@opentelemetry/api");
+
+// core/telemetry/noop-tracer.ts
+var noopTracer = {
+  startSpan() {
+    return noopSpan;
+  },
+  startActiveSpan(name, arg1, arg2, arg3) {
+    if (typeof arg1 === "function") {
+      return arg1(noopSpan);
+    }
+    if (typeof arg2 === "function") {
+      return arg2(noopSpan);
+    }
+    if (typeof arg3 === "function") {
+      return arg3(noopSpan);
+    }
+  }
+};
+var noopSpan = {
+  spanContext() {
+    return noopSpanContext;
+  },
+  setAttribute() {
+    return this;
+  },
+  setAttributes() {
+    return this;
+  },
+  addEvent() {
+    return this;
+  },
+  addLink() {
+    return this;
+  },
+  addLinks() {
+    return this;
+  },
+  setStatus() {
+    return this;
+  },
+  updateName() {
+    return this;
+  },
+  end() {
+    return this;
+  },
+  isRecording() {
+    return false;
+  },
+  recordException() {
+    return this;
+  }
+};
+var noopSpanContext = {
+  traceId: "",
+  spanId: "",
+  traceFlags: 0
+};
+
+// core/telemetry/get-tracer.ts
+var testTracer = void 0;
+function getTracer({ isEnabled }) {
+  if (!isEnabled) {
+    return noopTracer;
+  }
+  if (testTracer) {
+    return testTracer;
+  }
+  return import_api.trace.getTracer("ai");
+}
+
+// core/telemetry/record-span.ts
+var import_api2 = require("@opentelemetry/api");
+function recordSpan({
+  name,
+  tracer,
+  attributes,
+  fn,
+  endWhenDone = true
+}) {
+  return tracer.startActiveSpan(name, { attributes }, async (span) => {
+    try {
+      const result = await fn(span);
+      if (endWhenDone) {
+        span.end();
+      }
+      return result;
+    } catch (error) {
+      try {
+        if (error instanceof Error) {
+          span.recordException({
+            name: error.name,
+            message: error.message,
+            stack: error.stack
+          });
+          span.setStatus({
+            code: import_api2.SpanStatusCode.ERROR,
+            message: error.message
+          });
+        } else {
+          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
+        }
+      } finally {
+        span.end();
+      }
+      throw error;
+    }
+  });
+}
 
 // core/util/retry-with-exponential-backoff.ts
 var import_provider = require("@ai-sdk/provider");
@@ -174,18 +326,69 @@ async function embed({
   value,
   maxRetries,
   abortSignal,
-  headers
+  headers,
+  experimental_telemetry: telemetry
 }) {
   var _a;
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const modelResponse = await retry(
-    () => model.doEmbed({ values: [value], abortSignal, headers })
-  );
-  return new DefaultEmbedResult({
-    value,
-    embedding: modelResponse.embeddings[0],
-    usage: (_a = modelResponse.usage) != null ? _a : { tokens: NaN },
-    rawResponse: modelResponse.rawResponse
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    operationName: "ai.embed",
+    model,
+    telemetry,
+    headers,
+    settings: { maxRetries }
+  });
+  const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
+  return recordSpan({
+    name: "ai.embed",
+    attributes: {
+      ...baseTelemetryAttributes,
+      // specific settings that only make sense on the outer level:
+      "ai.value": JSON.stringify(value)
+    },
+    tracer,
+    fn: async (span) => {
+      const retry = retryWithExponentialBackoff({ maxRetries });
+      const { embedding, usage, rawResponse } = await retry(
+        () => (
+          // nested spans to align with the embedMany telemetry data:
+          recordSpan({
+            name: "ai.embed.doEmbed",
+            attributes: {
+              ...baseTelemetryAttributes,
+              // specific settings that only make sense on the outer level:
+              "ai.values": [JSON.stringify(value)]
+            },
+            tracer,
+            fn: async (doEmbedSpan) => {
+              var _a2;
+              const modelResponse = await model.doEmbed({
+                values: [value],
+                abortSignal,
+                headers
+              });
+              const embedding2 = modelResponse.embeddings[0];
+              const usage2 = (_a2 = modelResponse.usage) != null ? _a2 : { tokens: NaN };
+              doEmbedSpan.setAttributes({
+                "ai.embeddings": modelResponse.embeddings.map(
+                  (embedding3) => JSON.stringify(embedding3)
+                ),
+                "ai.usage.tokens": usage2.tokens
+              });
+              return {
+                embedding: embedding2,
+                usage: usage2,
+                rawResponse: modelResponse.rawResponse
+              };
+            }
+          })
+        )
+      );
+      span.setAttributes({
+        "ai.embedding": JSON.stringify(embedding),
+        "ai.usage.tokens": usage.tokens
+      });
+      return new DefaultEmbedResult({ value, embedding, usage, rawResponse });
+    }
   });
 }
 var DefaultEmbedResult = class {
@@ -215,32 +418,112 @@ async function embedMany({
   values,
   maxRetries,
   abortSignal,
-  headers
+  headers,
+  experimental_telemetry: telemetry
 }) {
-  var _a, _b, _c;
-  const retry = retryWithExponentialBackoff({ maxRetries });
-  const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall;
-  if (maxEmbeddingsPerCall == null) {
-    const modelResponse = await retry(
-      () => model.doEmbed({ values, abortSignal, headers })
-    );
-    return new DefaultEmbedManyResult({
-      values,
-      embeddings: modelResponse.embeddings,
-      usage: (_a = modelResponse.usage) != null ? _a : { tokens: NaN }
-    });
-  }
-  const valueChunks = splitArray(values, maxEmbeddingsPerCall);
-  const embeddings = [];
-  let tokens = 0;
-  for (const chunk of valueChunks) {
-    const modelResponse = await retry(
-      () => model.doEmbed({ values: chunk, abortSignal, headers })
-    );
-    embeddings.push(...modelResponse.embeddings);
-    tokens += (_c = (_b = modelResponse.usage) == null ? void 0 : _b.tokens) != null ? _c : NaN;
-  }
-  return new DefaultEmbedManyResult({ values, embeddings, usage: { tokens } });
+  var _a;
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    operationName: "ai.embedMany",
+    model,
+    telemetry,
+    headers,
+    settings: { maxRetries }
+  });
+  const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
+  return recordSpan({
+    name: "ai.embedMany",
+    attributes: {
+      ...baseTelemetryAttributes,
+      // specific settings that only make sense on the outer level:
+      "ai.values": values.map((value) => JSON.stringify(value))
+    },
+    tracer,
+    fn: async (span) => {
+      const retry = retryWithExponentialBackoff({ maxRetries });
+      const maxEmbeddingsPerCall = model.maxEmbeddingsPerCall;
+      if (maxEmbeddingsPerCall == null) {
+        const { embeddings: embeddings2, usage } = await retry(() => {
+          return recordSpan({
+            name: "ai.embedMany.doEmbed",
+            attributes: {
+              ...baseTelemetryAttributes,
+              // specific settings that only make sense on the outer level:
+              "ai.values": values.map((value) => JSON.stringify(value))
+            },
+            tracer,
+            fn: async (doEmbedSpan) => {
+              var _a2;
+              const modelResponse = await model.doEmbed({
+                values,
+                abortSignal,
+                headers
+              });
+              const embeddings3 = modelResponse.embeddings;
+              const usage2 = (_a2 = modelResponse.usage) != null ? _a2 : { tokens: NaN };
+              doEmbedSpan.setAttributes({
+                "ai.embeddings": embeddings3.map(
+                  (embedding) => JSON.stringify(embedding)
+                ),
+                "ai.usage.tokens": usage2.tokens
+              });
+              return { embeddings: embeddings3, usage: usage2 };
+            }
+          });
+        });
+        span.setAttributes({
+          "ai.embeddings": embeddings2.map(
+            (embedding) => JSON.stringify(embedding)
+          ),
+          "ai.usage.tokens": usage.tokens
+        });
+        return new DefaultEmbedManyResult({ values, embeddings: embeddings2, usage });
+      }
+      const valueChunks = splitArray(values, maxEmbeddingsPerCall);
+      const embeddings = [];
+      let tokens = 0;
+      for (const chunk of valueChunks) {
+        const { embeddings: responseEmbeddings, usage } = await retry(() => {
+          return recordSpan({
+            name: "ai.embedMany.doEmbed",
+            attributes: {
+              ...baseTelemetryAttributes,
+              // specific settings that only make sense on the outer level:
+              "ai.values": chunk.map((value) => JSON.stringify(value))
+            },
+            tracer,
+            fn: async (doEmbedSpan) => {
+              var _a2;
+              const modelResponse = await model.doEmbed({
+                values: chunk,
+                abortSignal,
+                headers
+              });
+              const embeddings2 = modelResponse.embeddings;
+              const usage2 = (_a2 = modelResponse.usage) != null ? _a2 : { tokens: NaN };
+              doEmbedSpan.setAttributes({
+                "ai.embeddings": embeddings2.map(
+                  (embedding) => JSON.stringify(embedding)
+                ),
+                "ai.usage.tokens": usage2.tokens
+              });
+              return { embeddings: embeddings2, usage: usage2 };
+            }
+          });
+        });
+        embeddings.push(...responseEmbeddings);
+        tokens += usage.tokens;
+      }
+      span.setAttributes({
+        "ai.embeddings": embeddings.map((embedding) => JSON.stringify(embedding)),
+        "ai.usage.tokens": tokens
+      });
+      return new DefaultEmbedManyResult({
+        values,
+        embeddings,
+        usage: { tokens }
+      });
+    }
+  });
 }
 var DefaultEmbedManyResult = class {
   constructor(options) {
@@ -251,8 +534,11 @@ var DefaultEmbedManyResult = class {
 };
 
 // core/generate-object/generate-object.ts
-var import_provider5 = require("@ai-sdk/provider");
-var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_provider6 = require("@ai-sdk/provider");
+var import_provider_utils5 = require("@ai-sdk/provider-utils");
+
+// core/prompt/convert-to-language-model-prompt.ts
+var import_provider_utils3 = require("@ai-sdk/provider-utils");
 
 // core/util/detect-image-mimetype.ts
 var mimeTypeSignatures = [
@@ -270,8 +556,37 @@ function detectImageMimeType(image) {
   return void 0;
 }
 
-// core/prompt/data-content.ts
+// core/util/download.ts
 var import_provider2 = require("@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 import_provider2.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 (import_provider2.DownloadError.isDownloadError(error)) {
+      throw error;
+    }
+    throw new import_provider2.DownloadError({ url: urlText, cause: error });
+  }
+}
+
+// core/prompt/data-content.ts
+var import_provider3 = require("@ai-sdk/provider");
 var import_provider_utils2 = require("@ai-sdk/provider-utils");
 function convertDataContentToBase64String(content) {
   if (typeof content === "string") {
@@ -290,7 +605,7 @@ function convertDataContentToUint8Array(content) {
     try {
       return (0, import_provider_utils2.convertBase64ToUint8Array)(content);
     } catch (error) {
-      throw new import_provider2.InvalidDataContentError({
+      throw new import_provider3.InvalidDataContentError({
         message: "Invalid data content. Content string is not a base64-encoded media.",
         content,
         cause: error
@@ -300,7 +615,7 @@ function convertDataContentToUint8Array(content) {
   if (content instanceof ArrayBuffer) {
     return new Uint8Array(content);
   }
-  throw new import_provider2.InvalidDataContentError({ content });
+  throw new import_provider3.InvalidDataContentError({ content });
 }
 function convertUint8ArrayToText(uint8Array) {
   try {
@@ -334,12 +649,16 @@ var InvalidMessageRoleError = class extends Error {
 };
 
 // core/prompt/convert-to-language-model-prompt.ts
-var import_provider_utils3 = require("@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": {
@@ -351,7 +670,9 @@ function convertToLanguageModelPrompt(prompt) {
     }
     case "messages": {
       languageModelMessages.push(
-        ...prompt.messages.map(convertToLanguageModelMessage)
+        ...prompt.messages.map(
+          (message) => convertToLanguageModelMessage(message, downloadedImages)
+        )
       );
       break;
     }
@@ -362,7 +683,7 @@ function convertToLanguageModelPrompt(prompt) {
   }
   return languageModelMessages;
 }
-function convertToLanguageModelMessage(message) {
+function convertToLanguageModelMessage(message, downloadedImages) {
   const role = message.role;
   switch (role) {
     case "system": {
@@ -379,18 +700,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 {
@@ -398,11 +728,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 {
@@ -437,7 +776,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)
                 };
               }
             }
@@ -469,18 +808,37 @@ 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
-var import_provider3 = require("@ai-sdk/provider");
+var import_provider4 = require("@ai-sdk/provider");
 function getValidatedPrompt(prompt) {
   if (prompt.prompt == null && prompt.messages == null) {
-    throw new import_provider3.InvalidPromptError({
+    throw new import_provider4.InvalidPromptError({
       prompt,
       message: "prompt or messages must be defined"
     });
   }
   if (prompt.prompt != null && prompt.messages != null) {
-    throw new import_provider3.InvalidPromptError({
+    throw new import_provider4.InvalidPromptError({
       prompt,
       message: "prompt and messages cannot be defined at the same time"
     });
@@ -488,7 +846,7 @@ function getValidatedPrompt(prompt) {
   if (prompt.messages != null) {
     for (const message of prompt.messages) {
       if (message.role === "system" && typeof message.content !== "string") {
-        throw new import_provider3.InvalidPromptError({
+        throw new import_provider4.InvalidPromptError({
           prompt,
           message: "system message content must be a string"
         });
@@ -510,7 +868,7 @@ function getValidatedPrompt(prompt) {
 }
 
 // core/prompt/prepare-call-settings.ts
-var import_provider4 = require("@ai-sdk/provider");
+var import_provider5 = require("@ai-sdk/provider");
 function prepareCallSettings({
   maxTokens,
   temperature,
@@ -523,14 +881,14 @@ function prepareCallSettings({
 }) {
   if (maxTokens != null) {
     if (!Number.isInteger(maxTokens)) {
-      throw new import_provider4.InvalidArgumentError({
+      throw new import_provider5.InvalidArgumentError({
         parameter: "maxTokens",
         value: maxTokens,
         message: "maxTokens must be an integer"
       });
     }
     if (maxTokens < 1) {
-      throw new import_provider4.InvalidArgumentError({
+      throw new import_provider5.InvalidArgumentError({
         parameter: "maxTokens",
         value: maxTokens,
         message: "maxTokens must be >= 1"
@@ -539,7 +897,7 @@ function prepareCallSettings({
   }
   if (temperature != null) {
     if (typeof temperature !== "number") {
-      throw new import_provider4.InvalidArgumentError({
+      throw new import_provider5.InvalidArgumentError({
         parameter: "temperature",
         value: temperature,
         message: "temperature must be a number"
@@ -548,7 +906,7 @@ function prepareCallSettings({
   }
   if (topP != null) {
     if (typeof topP !== "number") {
-      throw new import_provider4.InvalidArgumentError({
+      throw new import_provider5.InvalidArgumentError({
         parameter: "topP",
         value: topP,
         message: "topP must be a number"
@@ -557,208 +915,57 @@ function prepareCallSettings({
   }
   if (presencePenalty != null) {
     if (typeof presencePenalty !== "number") {
-      throw new import_provider4.InvalidArgumentError({
+      throw new import_provider5.InvalidArgumentError({
         parameter: "presencePenalty",
         value: presencePenalty,
         message: "presencePenalty must be a number"
       });
     }
   }
-  if (frequencyPenalty != null) {
-    if (typeof frequencyPenalty !== "number") {
-      throw new import_provider4.InvalidArgumentError({
-        parameter: "frequencyPenalty",
-        value: frequencyPenalty,
-        message: "frequencyPenalty must be a number"
-      });
-    }
-  }
-  if (seed != null) {
-    if (!Number.isInteger(seed)) {
-      throw new import_provider4.InvalidArgumentError({
-        parameter: "seed",
-        value: seed,
-        message: "seed must be an integer"
-      });
-    }
-  }
-  if (maxRetries != null) {
-    if (!Number.isInteger(maxRetries)) {
-      throw new import_provider4.InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be an integer"
-      });
-    }
-    if (maxRetries < 0) {
-      throw new import_provider4.InvalidArgumentError({
-        parameter: "maxRetries",
-        value: maxRetries,
-        message: "maxRetries must be >= 0"
-      });
-    }
-  }
-  return {
-    maxTokens,
-    temperature: temperature != null ? temperature : 0,
-    topP,
-    presencePenalty,
-    frequencyPenalty,
-    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
-    seed,
-    maxRetries: maxRetries != null ? maxRetries : 2
-  };
-}
-
-// core/telemetry/get-base-telemetry-attributes.ts
-function getBaseTelemetryAttributes({
-  operationName,
-  model,
-  settings,
-  telemetry,
-  headers
-}) {
-  var _a;
-  return {
-    "ai.model.provider": model.provider,
-    "ai.model.id": model.modelId,
-    // settings:
-    ...Object.entries(settings).reduce((attributes, [key, value]) => {
-      attributes[`ai.settings.${key}`] = value;
-      return attributes;
-    }, {}),
-    // special telemetry information
-    "operation.name": operationName,
-    "resource.name": telemetry == null ? void 0 : telemetry.functionId,
-    "ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId,
-    // add metadata as attributes:
-    ...Object.entries((_a = telemetry == null ? void 0 : telemetry.metadata) != null ? _a : {}).reduce(
-      (attributes, [key, value]) => {
-        attributes[`ai.telemetry.metadata.${key}`] = value;
-        return attributes;
-      },
-      {}
-    ),
-    // request headers
-    ...Object.entries(headers != null ? headers : {}).reduce((attributes, [key, value]) => {
-      if (value !== void 0) {
-        attributes[`ai.request.headers.${key}`] = value;
-      }
-      return attributes;
-    }, {})
-  };
-}
-
-// core/telemetry/get-tracer.ts
-var import_api = require("@opentelemetry/api");
-
-// core/telemetry/noop-tracer.ts
-var noopTracer = {
-  startSpan() {
-    return noopSpan;
-  },
-  startActiveSpan(name, arg1, arg2, arg3) {
-    if (typeof arg1 === "function") {
-      return arg1(noopSpan);
-    }
-    if (typeof arg2 === "function") {
-      return arg2(noopSpan);
-    }
-    if (typeof arg3 === "function") {
-      return arg3(noopSpan);
-    }
-  }
-};
-var noopSpan = {
-  spanContext() {
-    return noopSpanContext;
-  },
-  setAttribute() {
-    return this;
-  },
-  setAttributes() {
-    return this;
-  },
-  addEvent() {
-    return this;
-  },
-  addLink() {
-    return this;
-  },
-  addLinks() {
-    return this;
-  },
-  setStatus() {
-    return this;
-  },
-  updateName() {
-    return this;
-  },
-  end() {
-    return this;
-  },
-  isRecording() {
-    return false;
-  },
-  recordException() {
-    return this;
-  }
-};
-var noopSpanContext = {
-  traceId: "",
-  spanId: "",
-  traceFlags: 0
-};
-
-// core/telemetry/get-tracer.ts
-var testTracer = void 0;
-function getTracer({ isEnabled }) {
-  if (!isEnabled) {
-    return noopTracer;
-  }
-  if (testTracer) {
-    return testTracer;
+  if (frequencyPenalty != null) {
+    if (typeof frequencyPenalty !== "number") {
+      throw new import_provider5.InvalidArgumentError({
+        parameter: "frequencyPenalty",
+        value: frequencyPenalty,
+        message: "frequencyPenalty must be a number"
+      });
+    }
   }
-  return import_api.trace.getTracer("ai");
-}
-
-// core/telemetry/record-span.ts
-var import_api2 = require("@opentelemetry/api");
-function recordSpan({
-  name,
-  tracer,
-  attributes,
-  fn,
-  endWhenDone = true
-}) {
-  return tracer.startActiveSpan(name, { attributes }, async (span) => {
-    try {
-      const result = await fn(span);
-      if (endWhenDone) {
-        span.end();
-      }
-      return result;
-    } catch (error) {
-      try {
-        if (error instanceof Error) {
-          span.recordException({
-            name: error.name,
-            message: error.message,
-            stack: error.stack
-          });
-          span.setStatus({
-            code: import_api2.SpanStatusCode.ERROR,
-            message: error.message
-          });
-        } else {
-          span.setStatus({ code: import_api2.SpanStatusCode.ERROR });
-        }
-      } finally {
-        span.end();
-      }
-      throw error;
+  if (seed != null) {
+    if (!Number.isInteger(seed)) {
+      throw new import_provider5.InvalidArgumentError({
+        parameter: "seed",
+        value: seed,
+        message: "seed must be an integer"
+      });
     }
-  });
+  }
+  if (maxRetries != null) {
+    if (!Number.isInteger(maxRetries)) {
+      throw new import_provider5.InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be an integer"
+      });
+    }
+    if (maxRetries < 0) {
+      throw new import_provider5.InvalidArgumentError({
+        parameter: "maxRetries",
+        value: maxRetries,
+        message: "maxRetries must be >= 0"
+      });
+    }
+  }
+  return {
+    maxTokens,
+    temperature: temperature != null ? temperature : 0,
+    topP,
+    presencePenalty,
+    frequencyPenalty,
+    stopSequences: stopSequences != null && stopSequences.length > 0 ? stopSequences : void 0,
+    seed,
+    maxRetries: maxRetries != null ? maxRetries : 2
+  };
 }
 
 // core/types/token-usage.ts
@@ -770,12 +977,6 @@ function calculateCompletionTokenUsage(usage) {
   };
 }
 
-// core/util/convert-zod-to-json-schema.ts
-var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
-function convertZodToJSONSchema(zodSchema) {
-  return (0, import_zod_to_json_schema.default)(zodSchema);
-}
-
 // core/util/prepare-response-headers.ts
 function prepareResponseHeaders(init, { contentType }) {
   var _a;
@@ -786,6 +987,41 @@ function prepareResponseHeaders(init, { contentType }) {
   return headers;
 }
 
+// core/util/schema.ts
+var import_provider_utils4 = require("@ai-sdk/provider-utils");
+var import_zod_to_json_schema = __toESM(require("zod-to-json-schema"));
+var schemaSymbol = Symbol("vercel.ai.schema");
+function jsonSchema(jsonSchema2, {
+  validate
+} = {}) {
+  return {
+    [schemaSymbol]: true,
+    _type: void 0,
+    // should never be used directly
+    [import_provider_utils4.validatorSymbol]: true,
+    jsonSchema: jsonSchema2,
+    validate
+  };
+}
+function isSchema(value) {
+  return typeof value === "object" && value !== null && schemaSymbol in value && value[schemaSymbol] === true && "jsonSchema" in value && "validate" in value;
+}
+function asSchema(schema) {
+  return isSchema(schema) ? schema : zodSchema(schema);
+}
+function zodSchema(zodSchema2) {
+  return jsonSchema(
+    // we assume that zodToJsonSchema will return a valid JSONSchema7:
+    (0, import_zod_to_json_schema.default)(zodSchema2),
+    {
+      validate: (value) => {
+        const result = zodSchema2.safeParse(value);
+        return result.success ? { success: true, value: result.data } : { success: false, error: result.error };
+      }
+    }
+  );
+}
+
 // core/generate-object/inject-json-schema-into-system.ts
 var DEFAULT_SCHEMA_PREFIX = "JSON schema:";
 var DEFAULT_SCHEMA_SUFFIX = "You MUST answer with a JSON object that matches the JSON schema above.";
@@ -808,7 +1044,7 @@ function injectJsonSchemaIntoSystem({
 // core/generate-object/generate-object.ts
 async function generateObject({
   model,
-  schema,
+  schema: inputSchema,
   mode,
   system,
   prompt,
@@ -827,7 +1063,7 @@ async function generateObject({
     headers,
     settings: { ...settings, maxRetries }
   });
-  const jsonSchema = convertZodToJSONSchema(schema);
+  const schema = asSchema(inputSchema);
   const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
   return recordSpan({
     name: "ai.generateObject",
@@ -835,7 +1071,7 @@ async function generateObject({
       ...baseTelemetryAttributes,
       // specific settings that only make sense on the outer level:
       "ai.prompt": JSON.stringify({ system, prompt, messages }),
-      "ai.settings.jsonSchema": JSON.stringify(jsonSchema),
+      "ai.schema": JSON.stringify(schema.jsonSchema),
       "ai.settings.mode": mode
     },
     tracer,
@@ -854,11 +1090,17 @@ async function generateObject({
       switch (mode) {
         case "json": {
           const validatedPrompt = getValidatedPrompt({
-            system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
+            system: injectJsonSchemaIntoSystem({
+              system,
+              schema: schema.jsonSchema
+            }),
             prompt,
             messages
           });
-          const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: validatedPrompt,
+            modelSupportsImageUrls: model.supportsImageUrls
+          });
           const inputFormat = validatedPrompt.type;
           const generateResult = await retry(
             () => recordSpan({
@@ -890,7 +1132,7 @@ async function generateObject({
             })
           );
           if (generateResult.text === void 0) {
-            throw new import_provider5.NoObjectGeneratedError();
+            throw new import_provider6.NoObjectGeneratedError();
           }
           result = generateResult.text;
           finishReason = generateResult.finishReason;
@@ -906,7 +1148,10 @@ async function generateObject({
             prompt,
             messages
           });
-          const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+          const promptMessages = await convertToLanguageModelPrompt({
+            prompt: validatedPrompt,
+            modelSupportsImageUrls: model.supportsImageUrls
+          });
           const inputFormat = validatedPrompt.type;
           const generateResult = await retry(
             () => recordSpan({
@@ -926,7 +1171,7 @@ async function generateObject({
                       type: "function",
                       name: "json",
                       description: "Respond with a JSON object.",
-                      parameters: jsonSchema
+                      parameters: schema.jsonSchema
                     }
                   },
                   ...prepareCallSettings(settings),
@@ -948,7 +1193,7 @@ async function generateObject({
           );
           const functionArgs = (_b = (_a2 = generateResult.toolCalls) == null ? void 0 : _a2[0]) == null ? void 0 : _b.args;
           if (functionArgs === void 0) {
-            throw new import_provider5.NoObjectGeneratedError();
+            throw new import_provider6.NoObjectGeneratedError();
           }
           result = functionArgs;
           finishReason = generateResult.finishReason;
@@ -968,7 +1213,7 @@ async function generateObject({
           throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
         }
       }
-      const parseResult = (0, import_provider_utils4.safeParseJSON)({ text: result, schema });
+      const parseResult = (0, import_provider_utils5.safeParseJSON)({ text: result, schema });
       if (!parseResult.success) {
         throw parseResult.error;
       }
@@ -1011,7 +1256,7 @@ var DefaultGenerateObjectResult = class {
 var experimental_generateObject = generateObject;
 
 // core/generate-object/stream-object.ts
-var import_provider_utils5 = require("@ai-sdk/provider-utils");
+var import_provider_utils6 = require("@ai-sdk/provider-utils");
 var import_ui_utils = require("@ai-sdk/ui-utils");
 
 // core/util/async-iterable-stream.ts
@@ -1072,7 +1317,7 @@ var DelayedPromise = class {
 // core/generate-object/stream-object.ts
 async function streamObject({
   model,
-  schema,
+  schema: inputSchema,
   mode,
   system,
   prompt,
@@ -1080,98 +1325,156 @@ async function streamObject({
   maxRetries,
   abortSignal,
   headers,
+  experimental_telemetry: telemetry,
   onFinish,
   ...settings
 }) {
+  var _a;
+  const baseTelemetryAttributes = getBaseTelemetryAttributes({
+    operationName: "ai.streamObject",
+    model,
+    telemetry,
+    headers,
+    settings: { ...settings, maxRetries }
+  });
+  const tracer = getTracer({ isEnabled: (_a = telemetry == null ? void 0 : telemetry.isEnabled) != null ? _a : false });
   const retry = retryWithExponentialBackoff({ maxRetries });
-  const jsonSchema = convertZodToJSONSchema(schema);
-  if (mode === "auto" || mode == null) {
-    mode = model.defaultObjectGenerationMode;
-  }
-  let callOptions;
-  let transformer;
-  switch (mode) {
-    case "json": {
-      const validatedPrompt = getValidatedPrompt({
-        system: injectJsonSchemaIntoSystem({ system, schema: jsonSchema }),
-        prompt,
-        messages
-      });
-      callOptions = {
-        mode: { type: "object-json" },
-        ...prepareCallSettings(settings),
-        inputFormat: validatedPrompt.type,
-        prompt: convertToLanguageModelPrompt(validatedPrompt),
-        abortSignal,
-        headers
-      };
-      transformer = {
-        transform: (chunk, controller) => {
-          switch (chunk.type) {
-            case "text-delta":
-              controller.enqueue(chunk.textDelta);
-              break;
-            case "finish":
-            case "error":
-              controller.enqueue(chunk);
-              break;
-          }
+  const schema = asSchema(inputSchema);
+  return recordSpan({
+    name: "ai.streamObject",
+    attributes: {
+      ...baseTelemetryAttributes,
+      // specific settings that only make sense on the outer level:
+      "ai.prompt": JSON.stringify({ system, prompt, messages }),
+      "ai.schema": JSON.stringify(schema.jsonSchema),
+      "ai.settings.mode": mode
+    },
+    tracer,
+    endWhenDone: false,
+    fn: async (rootSpan) => {
+      if (mode === "auto" || mode == null) {
+        mode = model.defaultObjectGenerationMode;
+      }
+      let callOptions;
+      let transformer;
+      switch (mode) {
+        case "json": {
+          const validatedPrompt = getValidatedPrompt({
+            system: injectJsonSchemaIntoSystem({
+              system,
+              schema: schema.jsonSchema
+            }),
+            prompt,
+            messages
+          });
+          callOptions = {
+            mode: { type: "object-json" },
+            ...prepareCallSettings(settings),
+            inputFormat: validatedPrompt.type,
+            prompt: await convertToLanguageModelPrompt({
+              prompt: validatedPrompt,
+              modelSupportsImageUrls: model.supportsImageUrls
+            }),
+            abortSignal,
+            headers
+          };
+          transformer = {
+            transform: (chunk, controller) => {
+              switch (chunk.type) {
+                case "text-delta":
+                  controller.enqueue(chunk.textDelta);
+                  break;
+                case "finish":
+                case "error":
+                  controller.enqueue(chunk);
+                  break;
+              }
+            }
+          };
+          break;
         }
-      };
-      break;
-    }
-    case "tool": {
-      const validatedPrompt = getValidatedPrompt({
-        system,
-        prompt,
-        messages
-      });
-      callOptions = {
-        mode: {
-          type: "object-tool",
-          tool: {
-            type: "function",
-            name: "json",
-            description: "Respond with a JSON object.",
-            parameters: jsonSchema
-          }
-        },
-        ...prepareCallSettings(settings),
-        inputFormat: validatedPrompt.type,
-        prompt: convertToLanguageModelPrompt(validatedPrompt),
-        abortSignal,
-        headers
-      };
-      transformer = {
-        transform(chunk, controller) {
-          switch (chunk.type) {
-            case "tool-call-delta":
-              controller.enqueue(chunk.argsTextDelta);
-              break;
-            case "finish":
-            case "error":
-              controller.enqueue(chunk);
-              break;
-          }
+        case "tool": {
+          const validatedPrompt = getValidatedPrompt({
+            system,
+            prompt,
+            messages
+          });
+          callOptions = {
+            mode: {
+              type: "object-tool",
+              tool: {
+                type: "function",
+                name: "json",
+                description: "Respond with a JSON object.",
+                parameters: schema.jsonSchema
+              }
+            },
+            ...prepareCallSettings(settings),
+            inputFormat: validatedPrompt.type,
+            prompt: await convertToLanguageModelPrompt({
+              prompt: validatedPrompt,
+              modelSupportsImageUrls: model.supportsImageUrls
+            }),
+            abortSignal,
+            headers
+          };
+          transformer = {
+            transform(chunk, controller) {
+              switch (chunk.type) {
+                case "tool-call-delta":
+                  controller.enqueue(chunk.argsTextDelta);
+                  break;
+                case "finish":
+                case "error":
+                  controller.enqueue(chunk);
+                  break;
+              }
+            }
+          };
+          break;
         }
-      };
-      break;
-    }
-    case void 0: {
-      throw new Error("Model does not have a default object generation mode.");
-    }
-    default: {
-      const _exhaustiveCheck = mode;
-      throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
+        case void 0: {
+          throw new Error(
+            "Model does not have a default object generation mode."
+          );
+        }
+        default: {
+          const _exhaustiveCheck = mode;
+          throw new Error(`Unsupported mode: ${_exhaustiveCheck}`);
+        }
+      }
+      const {
+        result: { stream, warnings, rawResponse },
+        doStreamSpan
+      } = await retry(
+        () => recordSpan({
+          name: "ai.streamObject.doStream",
+          attributes: {
+            ...baseTelemetryAttributes,
+            "ai.prompt.format": callOptions.inputFormat,
+            "ai.prompt.messages": JSON.stringify(callOptions.prompt),
+            "ai.settings.mode": mode
+          },
+          tracer,
+          endWhenDone: false,
+          fn: async (doStreamSpan2) => {
+            return {
+              result: await model.doStream(callOptions),
+              doStreamSpan: doStreamSpan2
+            };
+          }
+        })
+      );
+      return new DefaultStreamObjectResult({
+        stream: stream.pipeThrough(new TransformStream(transformer)),
+        warnings,
+        rawResponse,
+        schema,
+        onFinish,
+        rootSpan,
+        doStreamSpan
+      });
     }
-  }
-  const result = await retry(() => model.doStream(callOptions));
-  return new DefaultStreamObjectResult({
-    stream: result.stream.pipeThrough(new TransformStream(transformer)),
-    warnings: result.warnings,
-    rawResponse: result.rawResponse,
-    schema,
-    onFinish
   });
 }
 var DefaultStreamObjectResult = class {
@@ -1180,7 +1483,9 @@ var DefaultStreamObjectResult = class {
     warnings,
     rawResponse,
     schema,
-    onFinish
+    onFinish,
+    rootSpan,
+    doStreamSpan
   }) {
     this.warnings = warnings;
     this.rawResponse = rawResponse;
@@ -1195,10 +1500,15 @@ var DefaultStreamObjectResult = class {
     let accumulatedText = "";
     let delta = "";
     let latestObject = void 0;
+    let firstChunk = true;
     const self = this;
     this.originalStream = stream.pipeThrough(
       new TransformStream({
         async transform(chunk, controller) {
+          if (firstChunk) {
+            firstChunk = false;
+            doStreamSpan.addEvent("ai.stream.firstChunk");
+          }
           if (typeof chunk === "string") {
             accumulatedText += chunk;
             delta += chunk;
@@ -1230,7 +1540,7 @@ var DefaultStreamObjectResult = class {
               usage = calculateCompletionTokenUsage(chunk.usage);
               controller.enqueue({ ...chunk, usage });
               resolveUsage(usage);
-              const validationResult = (0, import_provider_utils5.safeValidateTypes)({
+              const validationResult = (0, import_provider_utils6.safeValidateTypes)({
                 value: latestObject,
                 schema
               });
@@ -1252,12 +1562,24 @@ var DefaultStreamObjectResult = class {
         // invoke onFinish callback and resolve toolResults promise when the stream is about to close:
         async flush(controller) {
           try {
+            const finalUsage = usage != null ? usage : {
+              promptTokens: NaN,
+              completionTokens: NaN,
+              totalTokens: NaN
+            };
+            doStreamSpan.setAttributes({
+              "ai.usage.promptTokens": finalUsage.promptTokens,
+              "ai.usage.completionTokens": finalUsage.completionTokens,
+              "ai.result.object": JSON.stringify(object)
+            });
+            doStreamSpan.end();
+            rootSpan.setAttributes({
+              "ai.usage.promptTokens": finalUsage.promptTokens,
+              "ai.usage.completionTokens": finalUsage.completionTokens,
+              "ai.result.object": JSON.stringify(object)
+            });
             await (onFinish == null ? void 0 : onFinish({
-              usage: usage != null ? usage : {
-                promptTokens: NaN,
-                completionTokens: NaN,
-                totalTokens: NaN
-              },
+              usage: finalUsage,
               object,
               error,
               rawResponse,
@@ -1265,6 +1587,8 @@ var DefaultStreamObjectResult = class {
             }));
           } catch (error2) {
             controller.error(error2);
+          } finally {
+            rootSpan.end();
           }
         }
       })
@@ -1378,36 +1702,36 @@ function prepareToolsAndToolChoice({
       type: "function",
       name,
       description: tool2.description,
-      parameters: convertZodToJSONSchema(tool2.parameters)
+      parameters: asSchema(tool2.parameters).jsonSchema
     })),
     toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
   };
 }
 
 // core/generate-text/tool-call.ts
-var import_provider6 = require("@ai-sdk/provider");
-var import_provider_utils6 = require("@ai-sdk/provider-utils");
+var import_provider7 = require("@ai-sdk/provider");
+var import_provider_utils7 = require("@ai-sdk/provider-utils");
 function parseToolCall({
   toolCall,
   tools
 }) {
   const toolName = toolCall.toolName;
   if (tools == null) {
-    throw new import_provider6.NoSuchToolError({ toolName: toolCall.toolName });
+    throw new import_provider7.NoSuchToolError({ toolName: toolCall.toolName });
   }
   const tool2 = tools[toolName];
   if (tool2 == null) {
-    throw new import_provider6.NoSuchToolError({
+    throw new import_provider7.NoSuchToolError({
       toolName: toolCall.toolName,
       availableTools: Object.keys(tools)
     });
   }
-  const parseResult = (0, import_provider_utils6.safeParseJSON)({
+  const parseResult = (0, import_provider_utils7.safeParseJSON)({
     text: toolCall.args,
-    schema: tool2.parameters
+    schema: asSchema(tool2.parameters)
   });
   if (parseResult.success === false) {
-    throw new import_provider6.InvalidToolArgumentsError({
+    throw new import_provider7.InvalidToolArgumentsError({
       toolName,
       toolArgs: toolCall.args,
       cause: parseResult.error
@@ -1468,7 +1792,10 @@ async function generateText({
         ...prepareToolsAndToolChoice({ tools, toolChoice })
       };
       const callSettings = prepareCallSettings(settings);
-      const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+      const promptMessages = await convertToLanguageModelPrompt({
+        prompt: validatedPrompt,
+        modelSupportsImageUrls: model.supportsImageUrls
+      });
       let currentModelResponse;
       let currentToolCalls = [];
       let currentToolResults = [];
@@ -1541,7 +1868,9 @@ async function generateText({
         });
         responseMessages.push(...newResponseMessages);
         promptMessages.push(
-          ...newResponseMessages.map(convertToLanguageModelMessage)
+          ...newResponseMessages.map(
+            (message) => convertToLanguageModelMessage(message, null)
+          )
         );
       } while (
         // there are tool calls:
@@ -1744,7 +2073,7 @@ function mergeStreams(stream1, stream2) {
 }
 
 // core/generate-text/run-tools-transformation.ts
-var import_provider7 = require("@ai-sdk/provider");
+var import_provider8 = require("@ai-sdk/provider");
 var import_ui_utils2 = require("@ai-sdk/ui-utils");
 function runToolsTransformation({
   tools,
@@ -1794,7 +2123,7 @@ function runToolsTransformation({
           if (tools == null) {
             toolResultsStreamController.enqueue({
               type: "error",
-              error: new import_provider7.NoSuchToolError({ toolName: chunk.toolName })
+              error: new import_provider8.NoSuchToolError({ toolName: chunk.toolName })
             });
             break;
           }
@@ -1802,7 +2131,7 @@ function runToolsTransformation({
           if (tool2 == null) {
             toolResultsStreamController.enqueue({
               type: "error",
-              error: new import_provider7.NoSuchToolError({
+              error: new import_provider8.NoSuchToolError({
                 toolName: chunk.toolName,
                 availableTools: Object.keys(tools)
               })
@@ -1951,7 +2280,10 @@ async function streamText({
     fn: async (rootSpan) => {
       const retry = retryWithExponentialBackoff({ maxRetries });
       const validatedPrompt = getValidatedPrompt({ system, prompt, messages });
-      const promptMessages = convertToLanguageModelPrompt(validatedPrompt);
+      const promptMessages = await convertToLanguageModelPrompt({
+        prompt: validatedPrompt,
+        modelSupportsImageUrls: model.supportsImageUrls
+      });
       const {
         result: { stream, warnings, rawResponse },
         doStreamSpan
@@ -2580,7 +2912,7 @@ function tool(tool2) {
 }
 
 // core/types/errors.ts
-var import_provider8 = require("@ai-sdk/provider");
+var import_provider9 = require("@ai-sdk/provider");
 
 // core/util/cosine-similarity.ts
 function cosineSimilarity(vector1, vector2) {
@@ -3619,8 +3951,8 @@ var StreamingTextResponse = class extends Response {
 };
 
 // streams/index.ts
-var generateId2 = import_provider_utils7.generateId;
-var nanoid = import_provider_utils7.generateId;
+var generateId2 = import_provider_utils8.generateId;
+var nanoid = import_provider_utils8.generateId;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   AIStream,
@@ -3684,6 +4016,7 @@ var nanoid = import_provider_utils7.generateId;
   generateId,
   generateObject,
   generateText,
+  jsonSchema,
   nanoid,
   parseComplexResponse,
   parseStreamPart,