ai
Version:
AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript
1,687 lines (1,635 loc) • 329 kB
JavaScript
"use strict";
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __export = (target, all) => {
for (var name17 in all)
__defProp(target, name17, { get: all[name17], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// src/index.ts
var src_exports = {};
__export(src_exports, {
AISDKError: () => import_provider17.AISDKError,
APICallError: () => import_provider17.APICallError,
AbstractChat: () => AbstractChat,
DefaultChatTransport: () => DefaultChatTransport,
DownloadError: () => DownloadError,
EmptyResponseBodyError: () => import_provider17.EmptyResponseBodyError,
Experimental_Agent: () => Agent,
HttpChatTransport: () => HttpChatTransport,
InvalidArgumentError: () => InvalidArgumentError,
InvalidDataContentError: () => InvalidDataContentError,
InvalidMessageRoleError: () => InvalidMessageRoleError,
InvalidPromptError: () => import_provider17.InvalidPromptError,
InvalidResponseDataError: () => import_provider17.InvalidResponseDataError,
InvalidStreamPartError: () => InvalidStreamPartError,
InvalidToolInputError: () => InvalidToolInputError,
JSONParseError: () => import_provider17.JSONParseError,
JsonToSseTransformStream: () => JsonToSseTransformStream,
LoadAPIKeyError: () => import_provider17.LoadAPIKeyError,
MCPClientError: () => MCPClientError,
MessageConversionError: () => MessageConversionError,
NoContentGeneratedError: () => import_provider17.NoContentGeneratedError,
NoImageGeneratedError: () => NoImageGeneratedError,
NoObjectGeneratedError: () => NoObjectGeneratedError,
NoOutputGeneratedError: () => NoOutputGeneratedError,
NoOutputSpecifiedError: () => NoOutputSpecifiedError,
NoSuchModelError: () => import_provider17.NoSuchModelError,
NoSuchProviderError: () => NoSuchProviderError,
NoSuchToolError: () => NoSuchToolError,
Output: () => output_exports,
RetryError: () => RetryError,
SerialJobExecutor: () => SerialJobExecutor,
TextStreamChatTransport: () => TextStreamChatTransport,
ToolCallRepairError: () => ToolCallRepairError,
TypeValidationError: () => import_provider17.TypeValidationError,
UI_MESSAGE_STREAM_HEADERS: () => UI_MESSAGE_STREAM_HEADERS,
UnsupportedFunctionalityError: () => import_provider17.UnsupportedFunctionalityError,
UnsupportedModelVersionError: () => UnsupportedModelVersionError,
asSchema: () => import_provider_utils29.asSchema,
assistantModelMessageSchema: () => assistantModelMessageSchema,
callCompletionApi: () => callCompletionApi,
consumeStream: () => consumeStream,
convertFileListToFileUIParts: () => convertFileListToFileUIParts,
convertToCoreMessages: () => convertToCoreMessages,
convertToModelMessages: () => convertToModelMessages,
coreAssistantMessageSchema: () => coreAssistantMessageSchema,
coreMessageSchema: () => coreMessageSchema,
coreSystemMessageSchema: () => coreSystemMessageSchema,
coreToolMessageSchema: () => coreToolMessageSchema,
coreUserMessageSchema: () => coreUserMessageSchema,
cosineSimilarity: () => cosineSimilarity,
createIdGenerator: () => import_provider_utils29.createIdGenerator,
createProviderRegistry: () => createProviderRegistry,
createTextStreamResponse: () => createTextStreamResponse,
createUIMessageStream: () => createUIMessageStream,
createUIMessageStreamResponse: () => createUIMessageStreamResponse,
customProvider: () => customProvider,
defaultSettingsMiddleware: () => defaultSettingsMiddleware,
dynamicTool: () => import_provider_utils29.dynamicTool,
embed: () => embed,
embedMany: () => embedMany,
experimental_createMCPClient: () => createMCPClient,
experimental_createProviderRegistry: () => experimental_createProviderRegistry,
experimental_customProvider: () => experimental_customProvider,
experimental_generateImage: () => generateImage,
experimental_generateSpeech: () => generateSpeech,
experimental_transcribe: () => transcribe,
extractReasoningMiddleware: () => extractReasoningMiddleware,
generateId: () => import_provider_utils29.generateId,
generateObject: () => generateObject,
generateText: () => generateText,
getTextFromDataUrl: () => getTextFromDataUrl,
getToolName: () => getToolName,
getToolOrDynamicToolName: () => getToolOrDynamicToolName,
hasToolCall: () => hasToolCall,
isDeepEqualData: () => isDeepEqualData,
isToolOrDynamicToolUIPart: () => isToolOrDynamicToolUIPart,
isToolUIPart: () => isToolUIPart,
jsonSchema: () => import_provider_utils29.jsonSchema,
lastAssistantMessageIsCompleteWithToolCalls: () => lastAssistantMessageIsCompleteWithToolCalls,
modelMessageSchema: () => modelMessageSchema,
parsePartialJson: () => parsePartialJson,
pipeTextStreamToResponse: () => pipeTextStreamToResponse,
pipeUIMessageStreamToResponse: () => pipeUIMessageStreamToResponse,
readUIMessageStream: () => readUIMessageStream,
simulateReadableStream: () => simulateReadableStream,
simulateStreamingMiddleware: () => simulateStreamingMiddleware,
smoothStream: () => smoothStream,
stepCountIs: () => stepCountIs,
streamObject: () => streamObject,
streamText: () => streamText,
systemModelMessageSchema: () => systemModelMessageSchema,
tool: () => import_provider_utils29.tool,
toolModelMessageSchema: () => toolModelMessageSchema,
userModelMessageSchema: () => userModelMessageSchema,
validateUIMessages: () => validateUIMessages,
wrapLanguageModel: () => wrapLanguageModel,
wrapProvider: () => wrapProvider,
zodSchema: () => import_provider_utils29.zodSchema
});
module.exports = __toCommonJS(src_exports);
var import_provider_utils29 = require("@ai-sdk/provider-utils");
// src/generate-text/generate-text.ts
var import_provider_utils9 = require("@ai-sdk/provider-utils");
// src/error/no-output-specified-error.ts
var import_provider = require("@ai-sdk/provider");
var name = "AI_NoOutputSpecifiedError";
var marker = `vercel.ai.error.${name}`;
var symbol = Symbol.for(marker);
var _a;
var NoOutputSpecifiedError = class extends import_provider.AISDKError {
// used in isInstance
constructor({ message = "No output specified." } = {}) {
super({ name, message });
this[_a] = true;
}
static isInstance(error) {
return import_provider.AISDKError.hasMarker(error, marker);
}
};
_a = symbol;
// src/logger/log-warnings.ts
function formatWarning(warning) {
const prefix = "AI SDK Warning:";
switch (warning.type) {
case "unsupported-setting": {
let message = `${prefix} The "${warning.setting}" setting is not supported by this model`;
if (warning.details) {
message += ` - ${warning.details}`;
}
return message;
}
case "unsupported-tool": {
const toolName = "name" in warning.tool ? warning.tool.name : "unknown tool";
let message = `${prefix} The tool "${toolName}" is not supported by this model`;
if (warning.details) {
message += ` - ${warning.details}`;
}
return message;
}
case "other": {
return `${prefix} ${warning.message}`;
}
default: {
return `${prefix} ${JSON.stringify(warning, null, 2)}`;
}
}
}
var FIRST_WARNING_INFO_MESSAGE = "AI SDK Warning System: To turn off warning logging, set the AI_SDK_LOG_WARNINGS global to false.";
var hasLoggedBefore = false;
var logWarnings = (warnings) => {
if (warnings.length === 0) {
return;
}
const logger = globalThis.AI_SDK_LOG_WARNINGS;
if (logger === false) {
return;
}
if (typeof logger === "function") {
logger(warnings);
return;
}
if (!hasLoggedBefore) {
hasLoggedBefore = true;
console.info(FIRST_WARNING_INFO_MESSAGE);
}
for (const warning of warnings) {
console.warn(formatWarning(warning));
}
};
// src/model/resolve-model.ts
var import_gateway = require("@ai-sdk/gateway");
// src/error/index.ts
var import_provider17 = require("@ai-sdk/provider");
// src/error/invalid-argument-error.ts
var import_provider2 = require("@ai-sdk/provider");
var name2 = "AI_InvalidArgumentError";
var marker2 = `vercel.ai.error.${name2}`;
var symbol2 = Symbol.for(marker2);
var _a2;
var InvalidArgumentError = class extends import_provider2.AISDKError {
constructor({
parameter,
value,
message
}) {
super({
name: name2,
message: `Invalid argument for parameter ${parameter}: ${message}`
});
this[_a2] = true;
this.parameter = parameter;
this.value = value;
}
static isInstance(error) {
return import_provider2.AISDKError.hasMarker(error, marker2);
}
};
_a2 = symbol2;
// src/error/invalid-stream-part-error.ts
var import_provider3 = require("@ai-sdk/provider");
var name3 = "AI_InvalidStreamPartError";
var marker3 = `vercel.ai.error.${name3}`;
var symbol3 = Symbol.for(marker3);
var _a3;
var InvalidStreamPartError = class extends import_provider3.AISDKError {
constructor({
chunk,
message
}) {
super({ name: name3, message });
this[_a3] = true;
this.chunk = chunk;
}
static isInstance(error) {
return import_provider3.AISDKError.hasMarker(error, marker3);
}
};
_a3 = symbol3;
// src/error/invalid-tool-input-error.ts
var import_provider4 = require("@ai-sdk/provider");
var name4 = "AI_InvalidToolInputError";
var marker4 = `vercel.ai.error.${name4}`;
var symbol4 = Symbol.for(marker4);
var _a4;
var InvalidToolInputError = class extends import_provider4.AISDKError {
constructor({
toolInput,
toolName,
cause,
message = `Invalid input for tool ${toolName}: ${(0, import_provider4.getErrorMessage)(cause)}`
}) {
super({ name: name4, message, cause });
this[_a4] = true;
this.toolInput = toolInput;
this.toolName = toolName;
}
static isInstance(error) {
return import_provider4.AISDKError.hasMarker(error, marker4);
}
};
_a4 = symbol4;
// src/error/mcp-client-error.ts
var import_provider5 = require("@ai-sdk/provider");
var name5 = "AI_MCPClientError";
var marker5 = `vercel.ai.error.${name5}`;
var symbol5 = Symbol.for(marker5);
var _a5;
var MCPClientError = class extends import_provider5.AISDKError {
constructor({
name: name17 = "MCPClientError",
message,
cause
}) {
super({ name: name17, message, cause });
this[_a5] = true;
}
static isInstance(error) {
return import_provider5.AISDKError.hasMarker(error, marker5);
}
};
_a5 = symbol5;
// src/error/no-image-generated-error.ts
var import_provider6 = require("@ai-sdk/provider");
var name6 = "AI_NoImageGeneratedError";
var marker6 = `vercel.ai.error.${name6}`;
var symbol6 = Symbol.for(marker6);
var _a6;
var NoImageGeneratedError = class extends import_provider6.AISDKError {
constructor({
message = "No image generated.",
cause,
responses
}) {
super({ name: name6, message, cause });
this[_a6] = true;
this.responses = responses;
}
static isInstance(error) {
return import_provider6.AISDKError.hasMarker(error, marker6);
}
};
_a6 = symbol6;
// src/error/no-object-generated-error.ts
var import_provider7 = require("@ai-sdk/provider");
var name7 = "AI_NoObjectGeneratedError";
var marker7 = `vercel.ai.error.${name7}`;
var symbol7 = Symbol.for(marker7);
var _a7;
var NoObjectGeneratedError = class extends import_provider7.AISDKError {
constructor({
message = "No object generated.",
cause,
text: text2,
response,
usage,
finishReason
}) {
super({ name: name7, message, cause });
this[_a7] = true;
this.text = text2;
this.response = response;
this.usage = usage;
this.finishReason = finishReason;
}
static isInstance(error) {
return import_provider7.AISDKError.hasMarker(error, marker7);
}
};
_a7 = symbol7;
// src/error/no-output-generated-error.ts
var import_provider8 = require("@ai-sdk/provider");
var name8 = "AI_NoOutputGeneratedError";
var marker8 = `vercel.ai.error.${name8}`;
var symbol8 = Symbol.for(marker8);
var _a8;
var NoOutputGeneratedError = class extends import_provider8.AISDKError {
// used in isInstance
constructor({
message = "No output generated.",
cause
} = {}) {
super({ name: name8, message, cause });
this[_a8] = true;
}
static isInstance(error) {
return import_provider8.AISDKError.hasMarker(error, marker8);
}
};
_a8 = symbol8;
// src/error/no-such-tool-error.ts
var import_provider9 = require("@ai-sdk/provider");
var name9 = "AI_NoSuchToolError";
var marker9 = `vercel.ai.error.${name9}`;
var symbol9 = Symbol.for(marker9);
var _a9;
var NoSuchToolError = class extends import_provider9.AISDKError {
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: name9, message });
this[_a9] = true;
this.toolName = toolName;
this.availableTools = availableTools;
}
static isInstance(error) {
return import_provider9.AISDKError.hasMarker(error, marker9);
}
};
_a9 = symbol9;
// src/error/tool-call-repair-error.ts
var import_provider10 = require("@ai-sdk/provider");
var name10 = "AI_ToolCallRepairError";
var marker10 = `vercel.ai.error.${name10}`;
var symbol10 = Symbol.for(marker10);
var _a10;
var ToolCallRepairError = class extends import_provider10.AISDKError {
constructor({
cause,
originalError,
message = `Error repairing tool call: ${(0, import_provider10.getErrorMessage)(cause)}`
}) {
super({ name: name10, message, cause });
this[_a10] = true;
this.originalError = originalError;
}
static isInstance(error) {
return import_provider10.AISDKError.hasMarker(error, marker10);
}
};
_a10 = symbol10;
// src/error/unsupported-model-version-error.ts
var import_provider11 = require("@ai-sdk/provider");
var UnsupportedModelVersionError = class extends import_provider11.AISDKError {
constructor(options) {
super({
name: "AI_UnsupportedModelVersionError",
message: `Unsupported model version ${options.version} for provider "${options.provider}" and model "${options.modelId}". AI SDK 5 only supports models that implement specification version "v2".`
});
this.version = options.version;
this.provider = options.provider;
this.modelId = options.modelId;
}
};
// src/prompt/invalid-data-content-error.ts
var import_provider12 = require("@ai-sdk/provider");
var name11 = "AI_InvalidDataContentError";
var marker11 = `vercel.ai.error.${name11}`;
var symbol11 = Symbol.for(marker11);
var _a11;
var InvalidDataContentError = class extends import_provider12.AISDKError {
constructor({
content,
cause,
message = `Invalid data content. Expected a base64 string, Uint8Array, ArrayBuffer, or Buffer, but got ${typeof content}.`
}) {
super({ name: name11, message, cause });
this[_a11] = true;
this.content = content;
}
static isInstance(error) {
return import_provider12.AISDKError.hasMarker(error, marker11);
}
};
_a11 = symbol11;
// src/prompt/invalid-message-role-error.ts
var import_provider13 = require("@ai-sdk/provider");
var name12 = "AI_InvalidMessageRoleError";
var marker12 = `vercel.ai.error.${name12}`;
var symbol12 = Symbol.for(marker12);
var _a12;
var InvalidMessageRoleError = class extends import_provider13.AISDKError {
constructor({
role,
message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
}) {
super({ name: name12, message });
this[_a12] = true;
this.role = role;
}
static isInstance(error) {
return import_provider13.AISDKError.hasMarker(error, marker12);
}
};
_a12 = symbol12;
// src/prompt/message-conversion-error.ts
var import_provider14 = require("@ai-sdk/provider");
var name13 = "AI_MessageConversionError";
var marker13 = `vercel.ai.error.${name13}`;
var symbol13 = Symbol.for(marker13);
var _a13;
var MessageConversionError = class extends import_provider14.AISDKError {
constructor({
originalMessage,
message
}) {
super({ name: name13, message });
this[_a13] = true;
this.originalMessage = originalMessage;
}
static isInstance(error) {
return import_provider14.AISDKError.hasMarker(error, marker13);
}
};
_a13 = symbol13;
// src/util/download/download-error.ts
var import_provider15 = require("@ai-sdk/provider");
var name14 = "AI_DownloadError";
var marker14 = `vercel.ai.error.${name14}`;
var symbol14 = Symbol.for(marker14);
var _a14;
var DownloadError = class extends import_provider15.AISDKError {
constructor({
url,
statusCode,
statusText,
cause,
message = cause == null ? `Failed to download ${url}: ${statusCode} ${statusText}` : `Failed to download ${url}: ${cause}`
}) {
super({ name: name14, message, cause });
this[_a14] = true;
this.url = url;
this.statusCode = statusCode;
this.statusText = statusText;
}
static isInstance(error) {
return import_provider15.AISDKError.hasMarker(error, marker14);
}
};
_a14 = symbol14;
// src/util/retry-error.ts
var import_provider16 = require("@ai-sdk/provider");
var name15 = "AI_RetryError";
var marker15 = `vercel.ai.error.${name15}`;
var symbol15 = Symbol.for(marker15);
var _a15;
var RetryError = class extends import_provider16.AISDKError {
constructor({
message,
reason,
errors
}) {
super({ name: name15, message });
this[_a15] = true;
this.reason = reason;
this.errors = errors;
this.lastError = errors[errors.length - 1];
}
static isInstance(error) {
return import_provider16.AISDKError.hasMarker(error, marker15);
}
};
_a15 = symbol15;
// src/model/resolve-model.ts
function resolveLanguageModel(model) {
if (typeof model !== "string") {
if (model.specificationVersion !== "v2") {
throw new UnsupportedModelVersionError({
version: model.specificationVersion,
provider: model.provider,
modelId: model.modelId
});
}
return model;
}
return getGlobalProvider().languageModel(model);
}
function resolveEmbeddingModel(model) {
if (typeof model !== "string") {
if (model.specificationVersion !== "v2") {
throw new UnsupportedModelVersionError({
version: model.specificationVersion,
provider: model.provider,
modelId: model.modelId
});
}
return model;
}
return getGlobalProvider().textEmbeddingModel(
model
);
}
function getGlobalProvider() {
var _a17;
return (_a17 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a17 : import_gateway.gateway;
}
// src/prompt/convert-to-language-model-prompt.ts
var import_provider_utils3 = require("@ai-sdk/provider-utils");
// src/util/detect-media-type.ts
var import_provider_utils = require("@ai-sdk/provider-utils");
var imageMediaTypeSignatures = [
{
mediaType: "image/gif",
bytesPrefix: [71, 73, 70],
base64Prefix: "R0lG"
},
{
mediaType: "image/png",
bytesPrefix: [137, 80, 78, 71],
base64Prefix: "iVBORw"
},
{
mediaType: "image/jpeg",
bytesPrefix: [255, 216],
base64Prefix: "/9j/"
},
{
mediaType: "image/webp",
bytesPrefix: [82, 73, 70, 70],
base64Prefix: "UklGRg"
},
{
mediaType: "image/bmp",
bytesPrefix: [66, 77],
base64Prefix: "Qk"
},
{
mediaType: "image/tiff",
bytesPrefix: [73, 73, 42, 0],
base64Prefix: "SUkqAA"
},
{
mediaType: "image/tiff",
bytesPrefix: [77, 77, 0, 42],
base64Prefix: "TU0AKg"
},
{
mediaType: "image/avif",
bytesPrefix: [
0,
0,
0,
32,
102,
116,
121,
112,
97,
118,
105,
102
],
base64Prefix: "AAAAIGZ0eXBhdmlm"
},
{
mediaType: "image/heic",
bytesPrefix: [
0,
0,
0,
32,
102,
116,
121,
112,
104,
101,
105,
99
],
base64Prefix: "AAAAIGZ0eXBoZWlj"
}
];
var audioMediaTypeSignatures = [
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 251],
base64Prefix: "//s="
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 250],
base64Prefix: "//o="
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 243],
base64Prefix: "//M="
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 242],
base64Prefix: "//I="
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 227],
base64Prefix: "/+M="
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 226],
base64Prefix: "/+I="
},
{
mediaType: "audio/wav",
bytesPrefix: [82, 73, 70, 70],
base64Prefix: "UklGR"
},
{
mediaType: "audio/ogg",
bytesPrefix: [79, 103, 103, 83],
base64Prefix: "T2dnUw"
},
{
mediaType: "audio/flac",
bytesPrefix: [102, 76, 97, 67],
base64Prefix: "ZkxhQw"
},
{
mediaType: "audio/aac",
bytesPrefix: [64, 21, 0, 0],
base64Prefix: "QBUA"
},
{
mediaType: "audio/mp4",
bytesPrefix: [102, 116, 121, 112],
base64Prefix: "ZnR5cA"
},
{
mediaType: "audio/webm",
bytesPrefix: [26, 69, 223, 163],
base64Prefix: "GkXf"
}
];
var stripID3 = (data) => {
const bytes = typeof data === "string" ? (0, import_provider_utils.convertBase64ToUint8Array)(data) : data;
const id3Size = (bytes[6] & 127) << 21 | (bytes[7] & 127) << 14 | (bytes[8] & 127) << 7 | bytes[9] & 127;
return bytes.slice(id3Size + 10);
};
function stripID3TagsIfPresent(data) {
const hasId3 = typeof data === "string" && data.startsWith("SUQz") || typeof data !== "string" && data.length > 10 && data[0] === 73 && // 'I'
data[1] === 68 && // 'D'
data[2] === 51;
return hasId3 ? stripID3(data) : data;
}
function detectMediaType({
data,
signatures
}) {
const processedData = stripID3TagsIfPresent(data);
for (const signature of signatures) {
if (typeof processedData === "string" ? processedData.startsWith(signature.base64Prefix) : processedData.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
(byte, index) => processedData[index] === byte
)) {
return signature.mediaType;
}
}
return void 0;
}
// src/util/download/download.ts
var download = async ({ url }) => {
var _a17;
const urlText = url.toString();
try {
const response = await fetch(urlText);
if (!response.ok) {
throw new DownloadError({
url: urlText,
statusCode: response.status,
statusText: response.statusText
});
}
return {
data: new Uint8Array(await response.arrayBuffer()),
mediaType: (_a17 = response.headers.get("content-type")) != null ? _a17 : void 0
};
} catch (error) {
if (DownloadError.isInstance(error)) {
throw error;
}
throw new DownloadError({ url: urlText, cause: error });
}
};
// src/util/download/download-function.ts
var createDefaultDownloadFunction = (download2 = download) => (requestedDownloads) => Promise.all(
requestedDownloads.map(
async (requestedDownload) => requestedDownload.isUrlSupportedByModel ? null : download2(requestedDownload)
)
);
// src/prompt/data-content.ts
var import_provider18 = require("@ai-sdk/provider");
var import_provider_utils2 = require("@ai-sdk/provider-utils");
var import_v4 = require("zod/v4");
// src/prompt/split-data-url.ts
function splitDataUrl(dataUrl) {
try {
const [header, base64Content] = dataUrl.split(",");
return {
mediaType: header.split(";")[0].split(":")[1],
base64Content
};
} catch (error) {
return {
mediaType: void 0,
base64Content: void 0
};
}
}
// src/prompt/data-content.ts
var dataContentSchema = import_v4.z.union([
import_v4.z.string(),
import_v4.z.instanceof(Uint8Array),
import_v4.z.instanceof(ArrayBuffer),
import_v4.z.custom(
// Buffer might not be available in some environments such as CloudFlare:
(value) => {
var _a17, _b;
return (_b = (_a17 = globalThis.Buffer) == null ? void 0 : _a17.isBuffer(value)) != null ? _b : false;
},
{ message: "Must be a Buffer" }
)
]);
function convertToLanguageModelV2DataContent(content) {
if (content instanceof Uint8Array) {
return { data: content, mediaType: void 0 };
}
if (content instanceof ArrayBuffer) {
return { data: new Uint8Array(content), mediaType: void 0 };
}
if (typeof content === "string") {
try {
content = new URL(content);
} catch (error) {
}
}
if (content instanceof URL && content.protocol === "data:") {
const { mediaType: dataUrlMediaType, base64Content } = splitDataUrl(
content.toString()
);
if (dataUrlMediaType == null || base64Content == null) {
throw new import_provider18.AISDKError({
name: "InvalidDataContentError",
message: `Invalid data URL format in content ${content.toString()}`
});
}
return { data: base64Content, mediaType: dataUrlMediaType };
}
return { data: content, mediaType: void 0 };
}
function convertDataContentToBase64String(content) {
if (typeof content === "string") {
return content;
}
if (content instanceof ArrayBuffer) {
return (0, import_provider_utils2.convertUint8ArrayToBase64)(new Uint8Array(content));
}
return (0, import_provider_utils2.convertUint8ArrayToBase64)(content);
}
function convertDataContentToUint8Array(content) {
if (content instanceof Uint8Array) {
return content;
}
if (typeof content === "string") {
try {
return (0, import_provider_utils2.convertBase64ToUint8Array)(content);
} catch (error) {
throw new InvalidDataContentError({
message: "Invalid data content. Content string is not a base64-encoded media.",
content,
cause: error
});
}
}
if (content instanceof ArrayBuffer) {
return new Uint8Array(content);
}
throw new InvalidDataContentError({ content });
}
// src/prompt/convert-to-language-model-prompt.ts
async function convertToLanguageModelPrompt({
prompt,
supportedUrls,
download: download2 = createDefaultDownloadFunction()
}) {
const downloadedAssets = await downloadAssets(
prompt.messages,
download2,
supportedUrls
);
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,
providerOptions: message.providerOptions
};
}
case "user": {
if (typeof message.content === "string") {
return {
role: "user",
content: [{ type: "text", text: message.content }],
providerOptions: message.providerOptions
};
}
return {
role: "user",
content: message.content.map((part) => convertPartToLanguageModelPart(part, downloadedAssets)).filter((part) => part.type !== "text" || part.text !== ""),
providerOptions: message.providerOptions
};
}
case "assistant": {
if (typeof message.content === "string") {
return {
role: "assistant",
content: [{ type: "text", text: message.content }],
providerOptions: message.providerOptions
};
}
return {
role: "assistant",
content: message.content.filter(
// remove empty text parts:
(part) => part.type !== "text" || part.text !== ""
).map((part) => {
const providerOptions = part.providerOptions;
switch (part.type) {
case "file": {
const { data, mediaType } = convertToLanguageModelV2DataContent(
part.data
);
return {
type: "file",
data,
filename: part.filename,
mediaType: mediaType != null ? mediaType : part.mediaType,
providerOptions
};
}
case "reasoning": {
return {
type: "reasoning",
text: part.text,
providerOptions
};
}
case "text": {
return {
type: "text",
text: part.text,
providerOptions
};
}
case "tool-call": {
return {
type: "tool-call",
toolCallId: part.toolCallId,
toolName: part.toolName,
input: part.input,
providerExecuted: part.providerExecuted,
providerOptions
};
}
case "tool-result": {
return {
type: "tool-result",
toolCallId: part.toolCallId,
toolName: part.toolName,
output: part.output,
providerOptions
};
}
}
}),
providerOptions: message.providerOptions
};
}
case "tool": {
return {
role: "tool",
content: message.content.map((part) => ({
type: "tool-result",
toolCallId: part.toolCallId,
toolName: part.toolName,
output: part.output,
providerOptions: part.providerOptions
})),
providerOptions: message.providerOptions
};
}
default: {
const _exhaustiveCheck = role;
throw new InvalidMessageRoleError({ role: _exhaustiveCheck });
}
}
}
async function downloadAssets(messages, download2, supportedUrls) {
const plannedDownloads = messages.filter((message) => message.role === "user").map((message) => message.content).filter(
(content) => Array.isArray(content)
).flat().filter(
(part) => part.type === "image" || part.type === "file"
).map((part) => {
var _a17;
const mediaType = (_a17 = part.mediaType) != null ? _a17 : part.type === "image" ? "image/*" : void 0;
let data = part.type === "image" ? part.image : part.data;
if (typeof data === "string") {
try {
data = new URL(data);
} catch (ignored) {
}
}
return { mediaType, data };
}).filter(
(part) => part.data instanceof URL
).map((part) => ({
url: part.data,
isUrlSupportedByModel: part.mediaType != null && (0, import_provider_utils3.isUrlSupported)({
url: part.data.toString(),
mediaType: part.mediaType,
supportedUrls
})
}));
const downloadedFiles = await download2(plannedDownloads);
return Object.fromEntries(
downloadedFiles.filter(
(downloadedFile) => (downloadedFile == null ? void 0 : downloadedFile.data) != null
).map(({ data, mediaType }, index) => [
plannedDownloads[index].url.toString(),
{ data, mediaType }
])
);
}
function convertPartToLanguageModelPart(part, downloadedAssets) {
var _a17;
if (part.type === "text") {
return {
type: "text",
text: part.text,
providerOptions: part.providerOptions
};
}
let originalData;
const type = part.type;
switch (type) {
case "image":
originalData = part.image;
break;
case "file":
originalData = part.data;
break;
default:
throw new Error(`Unsupported part type: ${type}`);
}
const { data: convertedData, mediaType: convertedMediaType } = convertToLanguageModelV2DataContent(originalData);
let mediaType = convertedMediaType != null ? convertedMediaType : part.mediaType;
let data = convertedData;
if (data instanceof URL) {
const downloadedFile = downloadedAssets[data.toString()];
if (downloadedFile) {
data = downloadedFile.data;
mediaType != null ? mediaType : mediaType = downloadedFile.mediaType;
}
}
switch (type) {
case "image": {
if (data instanceof Uint8Array || typeof data === "string") {
mediaType = (_a17 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a17 : mediaType;
}
return {
type: "file",
mediaType: mediaType != null ? mediaType : "image/*",
// any image
filename: void 0,
data,
providerOptions: part.providerOptions
};
}
case "file": {
if (mediaType == null) {
throw new Error(`Media type is missing for file part`);
}
return {
type: "file",
mediaType,
filename: part.filename,
data,
providerOptions: part.providerOptions
};
}
}
}
// src/prompt/prepare-call-settings.ts
function prepareCallSettings({
maxOutputTokens,
temperature,
topP,
topK,
presencePenalty,
frequencyPenalty,
seed,
stopSequences
}) {
if (maxOutputTokens != null) {
if (!Number.isInteger(maxOutputTokens)) {
throw new InvalidArgumentError({
parameter: "maxOutputTokens",
value: maxOutputTokens,
message: "maxOutputTokens must be an integer"
});
}
if (maxOutputTokens < 1) {
throw new InvalidArgumentError({
parameter: "maxOutputTokens",
value: maxOutputTokens,
message: "maxOutputTokens must be >= 1"
});
}
}
if (temperature != null) {
if (typeof temperature !== "number") {
throw new InvalidArgumentError({
parameter: "temperature",
value: temperature,
message: "temperature must be a number"
});
}
}
if (topP != null) {
if (typeof topP !== "number") {
throw new InvalidArgumentError({
parameter: "topP",
value: topP,
message: "topP must be a number"
});
}
}
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({
parameter: "presencePenalty",
value: presencePenalty,
message: "presencePenalty must be a number"
});
}
}
if (frequencyPenalty != null) {
if (typeof frequencyPenalty !== "number") {
throw new InvalidArgumentError({
parameter: "frequencyPenalty",
value: frequencyPenalty,
message: "frequencyPenalty must be a number"
});
}
}
if (seed != null) {
if (!Number.isInteger(seed)) {
throw new InvalidArgumentError({
parameter: "seed",
value: seed,
message: "seed must be an integer"
});
}
}
return {
maxOutputTokens,
temperature,
topP,
topK,
presencePenalty,
frequencyPenalty,
stopSequences,
seed
};
}
// src/prompt/prepare-tools-and-tool-choice.ts
var import_provider_utils4 = require("@ai-sdk/provider-utils");
// src/util/is-non-empty-object.ts
function isNonEmptyObject(object2) {
return object2 != null && Object.keys(object2).length > 0;
}
// src/prompt/prepare-tools-and-tool-choice.ts
function prepareToolsAndToolChoice({
tools,
toolChoice,
activeTools
}) {
if (!isNonEmptyObject(tools)) {
return {
tools: void 0,
toolChoice: void 0
};
}
const filteredTools = activeTools != null ? Object.entries(tools).filter(
([name17]) => activeTools.includes(name17)
) : Object.entries(tools);
return {
tools: filteredTools.map(([name17, tool3]) => {
const toolType = tool3.type;
switch (toolType) {
case void 0:
case "dynamic":
case "function":
return {
type: "function",
name: name17,
description: tool3.description,
inputSchema: (0, import_provider_utils4.asSchema)(tool3.inputSchema).jsonSchema,
providerOptions: tool3.providerOptions
};
case "provider-defined":
return {
type: "provider-defined",
name: name17,
id: tool3.id,
args: tool3.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 }
};
}
// src/prompt/standardize-prompt.ts
var import_provider19 = require("@ai-sdk/provider");
var import_provider_utils5 = require("@ai-sdk/provider-utils");
var import_v46 = require("zod/v4");
// src/prompt/message.ts
var import_v45 = require("zod/v4");
// src/types/provider-metadata.ts
var import_v43 = require("zod/v4");
// src/types/json-value.ts
var import_v42 = require("zod/v4");
var jsonValueSchema = import_v42.z.lazy(
() => import_v42.z.union([
import_v42.z.null(),
import_v42.z.string(),
import_v42.z.number(),
import_v42.z.boolean(),
import_v42.z.record(import_v42.z.string(), jsonValueSchema),
import_v42.z.array(jsonValueSchema)
])
);
// src/types/provider-metadata.ts
var providerMetadataSchema = import_v43.z.record(
import_v43.z.string(),
import_v43.z.record(import_v43.z.string(), jsonValueSchema)
);
// src/prompt/content-part.ts
var import_v44 = require("zod/v4");
var textPartSchema = import_v44.z.object({
type: import_v44.z.literal("text"),
text: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
});
var imagePartSchema = import_v44.z.object({
type: import_v44.z.literal("image"),
image: import_v44.z.union([dataContentSchema, import_v44.z.instanceof(URL)]),
mediaType: import_v44.z.string().optional(),
providerOptions: providerMetadataSchema.optional()
});
var filePartSchema = import_v44.z.object({
type: import_v44.z.literal("file"),
data: import_v44.z.union([dataContentSchema, import_v44.z.instanceof(URL)]),
filename: import_v44.z.string().optional(),
mediaType: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
});
var reasoningPartSchema = import_v44.z.object({
type: import_v44.z.literal("reasoning"),
text: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
});
var toolCallPartSchema = import_v44.z.object({
type: import_v44.z.literal("tool-call"),
toolCallId: import_v44.z.string(),
toolName: import_v44.z.string(),
input: import_v44.z.unknown(),
providerOptions: providerMetadataSchema.optional(),
providerExecuted: import_v44.z.boolean().optional()
});
var outputSchema = import_v44.z.discriminatedUnion("type", [
import_v44.z.object({
type: import_v44.z.literal("text"),
value: import_v44.z.string()
}),
import_v44.z.object({
type: import_v44.z.literal("json"),
value: jsonValueSchema
}),
import_v44.z.object({
type: import_v44.z.literal("error-text"),
value: import_v44.z.string()
}),
import_v44.z.object({
type: import_v44.z.literal("error-json"),
value: jsonValueSchema
}),
import_v44.z.object({
type: import_v44.z.literal("content"),
value: import_v44.z.array(
import_v44.z.union([
import_v44.z.object({
type: import_v44.z.literal("text"),
text: import_v44.z.string()
}),
import_v44.z.object({
type: import_v44.z.literal("media"),
data: import_v44.z.string(),
mediaType: import_v44.z.string()
})
])
)
})
]);
var toolResultPartSchema = import_v44.z.object({
type: import_v44.z.literal("tool-result"),
toolCallId: import_v44.z.string(),
toolName: import_v44.z.string(),
output: outputSchema,
providerOptions: providerMetadataSchema.optional()
});
// src/prompt/message.ts
var systemModelMessageSchema = import_v45.z.object(
{
role: import_v45.z.literal("system"),
content: import_v45.z.string(),
providerOptions: providerMetadataSchema.optional()
}
);
var coreSystemMessageSchema = systemModelMessageSchema;
var userModelMessageSchema = import_v45.z.object({
role: import_v45.z.literal("user"),
content: import_v45.z.union([
import_v45.z.string(),
import_v45.z.array(import_v45.z.union([textPartSchema, imagePartSchema, filePartSchema]))
]),
providerOptions: providerMetadataSchema.optional()
});
var coreUserMessageSchema = userModelMessageSchema;
var assistantModelMessageSchema = import_v45.z.object({
role: import_v45.z.literal("assistant"),
content: import_v45.z.union([
import_v45.z.string(),
import_v45.z.array(
import_v45.z.union([
textPartSchema,
filePartSchema,
reasoningPartSchema,
toolCallPartSchema,
toolResultPartSchema
])
)
]),
providerOptions: providerMetadataSchema.optional()
});
var coreAssistantMessageSchema = assistantModelMessageSchema;
var toolModelMessageSchema = import_v45.z.object({
role: import_v45.z.literal("tool"),
content: import_v45.z.array(toolResultPartSchema),
providerOptions: providerMetadataSchema.optional()
});
var coreToolMessageSchema = toolModelMessageSchema;
var modelMessageSchema = import_v45.z.union([
systemModelMessageSchema,
userModelMessageSchema,
assistantModelMessageSchema,
toolModelMessageSchema
]);
var coreMessageSchema = modelMessageSchema;
// src/prompt/standardize-prompt.ts
async function standardizePrompt(prompt) {
if (prompt.prompt == null && prompt.messages == null) {
throw new import_provider19.InvalidPromptError({
prompt,
message: "prompt or messages must be defined"
});
}
if (prompt.prompt != null && prompt.messages != null) {
throw new import_provider19.InvalidPromptError({
prompt,
message: "prompt and messages cannot be defined at the same time"
});
}
if (prompt.system != null && typeof prompt.system !== "string") {
throw new import_provider19.InvalidPromptError({
prompt,
message: "system must be a string"
});
}
let messages;
if (prompt.prompt != null && typeof prompt.prompt === "string") {
messages = [{ role: "user", content: prompt.prompt }];
} else if (prompt.prompt != null && Array.isArray(prompt.prompt)) {
messages = prompt.prompt;
} else if (prompt.messages != null) {
messages = prompt.messages;
} else {
throw new import_provider19.InvalidPromptError({
prompt,
message: "prompt or messages must be defined"
});
}
if (messages.length === 0) {
throw new import_provider19.InvalidPromptError({
prompt,
message: "messages must not be empty"
});
}
const validationResult = await (0, import_provider_utils5.safeValidateTypes)({
value: messages,
schema: import_v46.z.array(modelMessageSchema)
});
if (!validationResult.success) {
throw new import_provider19.InvalidPromptError({
prompt,
message: "The messages must be a ModelMessage[]. If you have passed a UIMessage[], you can use convertToModelMessages to convert them.",
cause: validationResult.error
});
}
return {
messages,
system: prompt.system
};
}
// src/prompt/wrap-gateway-error.ts
var import_gateway2 = require("@ai-sdk/gateway");
var import_provider20 = require("@ai-sdk/provider");
function wrapGatewayError(error) {
if (import_gateway2.GatewayAuthenticationError.isInstance(error) || import_gateway2.GatewayModelNotFoundError.isInstance(error)) {
return new import_provider20.AISDKError({
name: "GatewayError",
message: "Vercel AI Gateway access failed. If you want to use AI SDK providers directly, use the providers, e.g. @ai-sdk/openai, or register a different global default provider.",
cause: error
});
}
return error;
}
// src/telemetry/assemble-operation-name.ts
function assembleOperationName({
operationId,
telemetry
}) {
return {
// standardized operation and resource name:
"operation.name": `${operationId}${(telemetry == null ? void 0 : telemetry.functionId) != null ? ` ${telemetry.functionId}` : ""}`,
"resource.name": telemetry == null ? void 0 : telemetry.functionId,
// detailed, AI SDK specific data:
"ai.operationId": operationId,
"ai.telemetry.functionId": telemetry == null ? void 0 : telemetry.functionId
};
}
// src/telemetry/get-base-telemetry-attributes.ts
function getBaseTelemetryAttributes({
model,
settings,
telemetry,
headers
}) {
var _a17;
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;
}, {}),
// add metadata as attributes:
...Object.entries((_a17 = telemetry == null ? void 0 : telemetry.metadata) != null ? _a17 : {}).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;
}, {})
};
}
// src/telemetry/get-tracer.ts
var import_api = require("@opentelemetry/api");
// src/telemetry/noop-tracer.ts
var noopTracer = {
startSpan() {
return noopSpan;
},
startActiveSpan(name17, 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
};
// src/telemetry/get-tracer.ts
function getTracer({
isEnabled = false,
tracer
} = {}) {
if (!isEnabled) {
return noopTracer;
}
if (tracer) {
return tracer;
}
return import_api.trace.getTracer("ai");
}
// src/telemetry/record-span.ts
var import_api2 = require("@opentelemetry/api");
function recordSpan({
name: name17,
tracer,
attributes,
fn,
endWhenDone = true
}) {
return tracer.startActiveSpan(name17, { attributes }, async (span) => {
try {
const result = await fn(span);
if (endWhenDone) {
span.end();
}
return result;
} catch (error) {
try {
recordErrorOnSpan(span, error);
} finally {
span.end();
}
throw error;
}
});
}
function recordErrorOnSpan(span, error) {
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 });
}
}
// src/telemetry/select-telemetry-attributes.ts
function selectTelemetryAttributes({
telemetry,
attributes
}) {
if ((telemetry == null ? void 0 : telemetry.isEnabled) !== true) {
return {};
}
return Object.entries(attributes).reduce((attributes2, [key, value]) => {
if (value == null) {
return attributes2;
}
if (typeof value === "object" && "input" in value && typeof value.input === "function") {
if ((telemetry == null ? void 0 : telemetry.recordInputs) === false) {
return attributes2;
}
const result = value.input();
return result == null ? attributes2 : { ...attributes2, [key]: result };
}
if (typeof value === "object" && "output" in value && typeof value.output === "function") {
if ((telemetry == null ? void 0 : telemetry.recordOutputs) === false) {
return attributes2;
}
const result = value.output();
return result == null ? attributes2 : { ...attributes2, [key]: result };
}
return { ...attributes2, [key]: value };
}, {});
}
// src/telemetry/stringify-for-telemetry.ts
function stringifyForTelemetry(prompt) {
return JSON.stringify(
prompt.map((message) => ({
...message,
content: typeof message.content === "string" ? message.content : message.content.map(
(part) => part.type === "file" ? {
...part,
data: part.data instanceof Uint8Array ? convertDataContentToBase64String(part.data) : part.data
} : part
)
}))
);
}
// src/types/usage.ts
function addLanguageModelUsage(usage1, usage2) {
return {
inputTokens: addTokenCounts(usage1.inputTokens, usage2.inputTokens),
outputTokens: addTokenCounts(usage1.outputTokens, usage2.outputTokens),
totalTokens: addTokenCounts(usage1.totalTokens, usage2.totalTokens),
reasoningTokens: addTokenCounts(
usage1.reasoningTokens,
usage2.reasoningTokens
),
cachedInputTokens: addTokenCounts(
usage1.cachedInputTokens,
usage2.cachedInputTokens
)
};
}
function addTokenCounts(tokenCount1, tokenCount2) {
return tokenCount1 == null && tokenCount2 == null ? void 0 : (tokenCount1 != null ? tokenCount1 : 0) + (tok