sharpe-ai
Version:
AI SDK by Vercel - The AI Toolkit for TypeScript and JavaScript
1,644 lines (1,596 loc) • 366 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 name16 in all)
__defProp(target, name16, { get: all[name16], 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: () => ToolLoopAgent,
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,
LoadSettingError: () => import_provider17.LoadSettingError,
MessageConversionError: () => MessageConversionError,
NoContentGeneratedError: () => import_provider17.NoContentGeneratedError,
NoImageGeneratedError: () => NoImageGeneratedError,
NoObjectGeneratedError: () => NoObjectGeneratedError,
NoOutputGeneratedError: () => NoOutputGeneratedError,
NoOutputSpecifiedError: () => NoOutputSpecifiedError,
NoSpeechGeneratedError: () => NoSpeechGeneratedError,
NoSuchModelError: () => import_provider17.NoSuchModelError,
NoSuchProviderError: () => NoSuchProviderError,
NoSuchToolError: () => NoSuchToolError,
Output: () => output_exports,
RetryError: () => RetryError,
SerialJobExecutor: () => SerialJobExecutor,
TextStreamChatTransport: () => TextStreamChatTransport,
TooManyEmbeddingValuesForCallError: () => import_provider17.TooManyEmbeddingValuesForCallError,
ToolCallRepairError: () => ToolCallRepairError,
ToolLoopAgent: () => ToolLoopAgent,
TypeValidationError: () => import_provider17.TypeValidationError,
UI_MESSAGE_STREAM_HEADERS: () => UI_MESSAGE_STREAM_HEADERS,
UnsupportedFunctionalityError: () => import_provider17.UnsupportedFunctionalityError,
UnsupportedModelVersionError: () => UnsupportedModelVersionError,
asSchema: () => import_provider_utils36.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,
createAgentUIStream: () => createAgentUIStream,
createAgentUIStreamResponse: () => createAgentUIStreamResponse,
createGateway: () => import_gateway3.createGateway,
createIdGenerator: () => import_provider_utils36.createIdGenerator,
createProviderRegistry: () => createProviderRegistry,
createTextStreamResponse: () => createTextStreamResponse,
createUIMessageStream: () => createUIMessageStream,
createUIMessageStreamResponse: () => createUIMessageStreamResponse,
customProvider: () => customProvider,
defaultSettingsMiddleware: () => defaultSettingsMiddleware,
dynamicTool: () => import_provider_utils36.dynamicTool,
embed: () => embed,
embedMany: () => embedMany,
experimental_createProviderRegistry: () => experimental_createProviderRegistry,
experimental_customProvider: () => experimental_customProvider,
experimental_generateImage: () => generateImage,
experimental_generateSpeech: () => generateSpeech,
experimental_transcribe: () => transcribe,
extractReasoningMiddleware: () => extractReasoningMiddleware,
gateway: () => import_gateway3.gateway,
generateId: () => import_provider_utils36.generateId,
generateObject: () => generateObject,
generateText: () => generateText,
getTextFromDataUrl: () => getTextFromDataUrl,
getToolName: () => getToolName,
getToolOrDynamicToolName: () => getToolOrDynamicToolName,
hasToolCall: () => hasToolCall,
isDataUIPart: () => isDataUIPart,
isDeepEqualData: () => isDeepEqualData,
isFileUIPart: () => isFileUIPart,
isReasoningUIPart: () => isReasoningUIPart,
isTextUIPart: () => isTextUIPart,
isToolOrDynamicToolUIPart: () => isToolOrDynamicToolUIPart,
isToolUIPart: () => isToolUIPart,
jsonSchema: () => import_provider_utils36.jsonSchema,
lastAssistantMessageIsCompleteWithApprovalResponses: () => lastAssistantMessageIsCompleteWithApprovalResponses,
lastAssistantMessageIsCompleteWithToolCalls: () => lastAssistantMessageIsCompleteWithToolCalls,
modelMessageSchema: () => modelMessageSchema,
parseJsonEventStream: () => import_provider_utils36.parseJsonEventStream,
parsePartialJson: () => parsePartialJson,
pipeAgentUIStreamToResponse: () => pipeAgentUIStreamToResponse,
pipeTextStreamToResponse: () => pipeTextStreamToResponse,
pipeUIMessageStreamToResponse: () => pipeUIMessageStreamToResponse,
pruneMessages: () => pruneMessages,
readUIMessageStream: () => readUIMessageStream,
rerank: () => rerank,
safeValidateUIMessages: () => safeValidateUIMessages,
simulateReadableStream: () => simulateReadableStream,
simulateStreamingMiddleware: () => simulateStreamingMiddleware,
smoothStream: () => smoothStream,
stepCountIs: () => stepCountIs,
streamObject: () => streamObject,
streamText: () => streamText,
systemModelMessageSchema: () => systemModelMessageSchema,
tool: () => import_provider_utils36.tool,
toolModelMessageSchema: () => toolModelMessageSchema,
uiMessageChunkSchema: () => uiMessageChunkSchema,
userModelMessageSchema: () => userModelMessageSchema,
validateUIMessages: () => validateUIMessages,
wrapLanguageModel: () => wrapLanguageModel,
wrapProvider: () => wrapProvider,
zodSchema: () => import_provider_utils36.zodSchema
});
module.exports = __toCommonJS(src_exports);
var import_gateway3 = require("@ai-sdk/gateway");
var import_provider_utils36 = require("@ai-sdk/provider-utils");
// src/generate-text/generate-text.ts
var import_provider_utils11 = 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,
provider,
model
}) {
const prefix = `AI SDK Warning (${provider} / ${model}):`;
switch (warning.type) {
case "unsupported-setting": {
let message = `${prefix} The "${warning.setting}" setting is not supported.`;
if (warning.details) {
message += ` ${warning.details}`;
}
return message;
}
case "compatibility": {
let message = `${prefix} The "${warning.feature}" feature is not fully supported.`;
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.`;
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 = (options) => {
if (options.warnings.length === 0) {
return;
}
const logger = globalThis.AI_SDK_LOG_WARNINGS;
if (logger === false) {
return;
}
if (typeof logger === "function") {
logger(options);
return;
}
if (!hasLoggedBefore) {
hasLoggedBefore = true;
console.info(FIRST_WARNING_INFO_MESSAGE);
}
for (const warning of options.warnings) {
console.warn(
formatWarning({
warning,
provider: options.provider,
model: options.model
})
);
}
};
// 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/no-image-generated-error.ts
var import_provider5 = require("@ai-sdk/provider");
var name5 = "AI_NoImageGeneratedError";
var marker5 = `vercel.ai.error.${name5}`;
var symbol5 = Symbol.for(marker5);
var _a5;
var NoImageGeneratedError = class extends import_provider5.AISDKError {
constructor({
message = "No image generated.",
cause,
responses
}) {
super({ name: name5, message, cause });
this[_a5] = true;
this.responses = responses;
}
static isInstance(error) {
return import_provider5.AISDKError.hasMarker(error, marker5);
}
};
_a5 = symbol5;
// src/error/no-object-generated-error.ts
var import_provider6 = require("@ai-sdk/provider");
var name6 = "AI_NoObjectGeneratedError";
var marker6 = `vercel.ai.error.${name6}`;
var symbol6 = Symbol.for(marker6);
var _a6;
var NoObjectGeneratedError = class extends import_provider6.AISDKError {
constructor({
message = "No object generated.",
cause,
text: text2,
response,
usage,
finishReason
}) {
super({ name: name6, message, cause });
this[_a6] = true;
this.text = text2;
this.response = response;
this.usage = usage;
this.finishReason = finishReason;
}
static isInstance(error) {
return import_provider6.AISDKError.hasMarker(error, marker6);
}
};
_a6 = symbol6;
// src/error/no-output-generated-error.ts
var import_provider7 = require("@ai-sdk/provider");
var name7 = "AI_NoOutputGeneratedError";
var marker7 = `vercel.ai.error.${name7}`;
var symbol7 = Symbol.for(marker7);
var _a7;
var NoOutputGeneratedError = class extends import_provider7.AISDKError {
// used in isInstance
constructor({
message = "No output generated.",
cause
} = {}) {
super({ name: name7, message, cause });
this[_a7] = true;
}
static isInstance(error) {
return import_provider7.AISDKError.hasMarker(error, marker7);
}
};
_a7 = symbol7;
// src/error/no-speech-generated-error.ts
var import_provider8 = require("@ai-sdk/provider");
var NoSpeechGeneratedError = class extends import_provider8.AISDKError {
constructor(options) {
super({
name: "AI_NoSpeechGeneratedError",
message: "No speech audio generated."
});
this.responses = options.responses;
}
};
// src/error/no-such-tool-error.ts
var import_provider9 = require("@ai-sdk/provider");
var name8 = "AI_NoSuchToolError";
var marker8 = `vercel.ai.error.${name8}`;
var symbol8 = Symbol.for(marker8);
var _a8;
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: name8, message });
this[_a8] = true;
this.toolName = toolName;
this.availableTools = availableTools;
}
static isInstance(error) {
return import_provider9.AISDKError.hasMarker(error, marker8);
}
};
_a8 = symbol8;
// src/error/tool-call-repair-error.ts
var import_provider10 = require("@ai-sdk/provider");
var name9 = "AI_ToolCallRepairError";
var marker9 = `vercel.ai.error.${name9}`;
var symbol9 = Symbol.for(marker9);
var _a9;
var ToolCallRepairError = class extends import_provider10.AISDKError {
constructor({
cause,
originalError,
message = `Error repairing tool call: ${(0, import_provider10.getErrorMessage)(cause)}`
}) {
super({ name: name9, message, cause });
this[_a9] = true;
this.originalError = originalError;
}
static isInstance(error) {
return import_provider10.AISDKError.hasMarker(error, marker9);
}
};
_a9 = symbol9;
// 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 name10 = "AI_InvalidDataContentError";
var marker10 = `vercel.ai.error.${name10}`;
var symbol10 = Symbol.for(marker10);
var _a10;
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: name10, message, cause });
this[_a10] = true;
this.content = content;
}
static isInstance(error) {
return import_provider12.AISDKError.hasMarker(error, marker10);
}
};
_a10 = symbol10;
// src/prompt/invalid-message-role-error.ts
var import_provider13 = require("@ai-sdk/provider");
var name11 = "AI_InvalidMessageRoleError";
var marker11 = `vercel.ai.error.${name11}`;
var symbol11 = Symbol.for(marker11);
var _a11;
var InvalidMessageRoleError = class extends import_provider13.AISDKError {
constructor({
role,
message = `Invalid message role: '${role}'. Must be one of: "system", "user", "assistant", "tool".`
}) {
super({ name: name11, message });
this[_a11] = true;
this.role = role;
}
static isInstance(error) {
return import_provider13.AISDKError.hasMarker(error, marker11);
}
};
_a11 = symbol11;
// src/prompt/message-conversion-error.ts
var import_provider14 = require("@ai-sdk/provider");
var name12 = "AI_MessageConversionError";
var marker12 = `vercel.ai.error.${name12}`;
var symbol12 = Symbol.for(marker12);
var _a12;
var MessageConversionError = class extends import_provider14.AISDKError {
constructor({
originalMessage,
message
}) {
super({ name: name12, message });
this[_a12] = true;
this.originalMessage = originalMessage;
}
static isInstance(error) {
return import_provider14.AISDKError.hasMarker(error, marker12);
}
};
_a12 = symbol12;
// src/util/download/download-error.ts
var import_provider15 = require("@ai-sdk/provider");
var name13 = "AI_DownloadError";
var marker13 = `vercel.ai.error.${name13}`;
var symbol13 = Symbol.for(marker13);
var _a13;
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: name13, message, cause });
this[_a13] = true;
this.url = url;
this.statusCode = statusCode;
this.statusText = statusText;
}
static isInstance(error) {
return import_provider15.AISDKError.hasMarker(error, marker13);
}
};
_a13 = symbol13;
// src/util/retry-error.ts
var import_provider16 = require("@ai-sdk/provider");
var name14 = "AI_RetryError";
var marker14 = `vercel.ai.error.${name14}`;
var symbol14 = Symbol.for(marker14);
var _a14;
var RetryError = class extends import_provider16.AISDKError {
constructor({
message,
reason,
errors
}) {
super({ name: name14, message });
this[_a14] = true;
this.reason = reason;
this.errors = errors;
this.lastError = errors[errors.length - 1];
}
static isInstance(error) {
return import_provider16.AISDKError.hasMarker(error, marker14);
}
};
_a14 = symbol14;
// src/model/as-embedding-model-v3.ts
function asEmbeddingModelV3(model) {
if (model.specificationVersion === "v3") {
return model;
}
return new Proxy(model, {
get(target, prop) {
if (prop === "specificationVersion")
return "v3";
return target[prop];
}
});
}
// src/model/as-language-model-v3.ts
function asLanguageModelV3(model) {
if (model.specificationVersion === "v3") {
return model;
}
return new Proxy(model, {
get(target, prop) {
if (prop === "specificationVersion")
return "v3";
return target[prop];
}
});
}
// src/model/as-speech-model-v3.ts
function asSpeechModelV3(model) {
if (model.specificationVersion === "v3") {
return model;
}
return new Proxy(model, {
get(target, prop) {
if (prop === "specificationVersion")
return "v3";
return target[prop];
}
});
}
// src/model/as-transcription-model-v3.ts
function asTranscriptionModelV3(model) {
if (model.specificationVersion === "v3") {
return model;
}
return new Proxy(model, {
get(target, prop) {
if (prop === "specificationVersion")
return "v3";
return target[prop];
}
});
}
// src/model/resolve-model.ts
function resolveLanguageModel(model) {
if (typeof model !== "string") {
if (model.specificationVersion !== "v3" && model.specificationVersion !== "v2") {
const unsupportedModel = model;
throw new UnsupportedModelVersionError({
version: unsupportedModel.specificationVersion,
provider: unsupportedModel.provider,
modelId: unsupportedModel.modelId
});
}
return asLanguageModelV3(model);
}
return getGlobalProvider().languageModel(model);
}
function resolveEmbeddingModel(model) {
if (typeof model !== "string") {
if (model.specificationVersion !== "v3" && model.specificationVersion !== "v2") {
const unsupportedModel = model;
throw new UnsupportedModelVersionError({
version: unsupportedModel.specificationVersion,
provider: unsupportedModel.provider,
modelId: unsupportedModel.modelId
});
}
return asEmbeddingModelV3(model);
}
return getGlobalProvider().textEmbeddingModel(
model
);
}
function resolveTranscriptionModel(model) {
var _a16, _b;
if (typeof model !== "string") {
if (model.specificationVersion !== "v3" && model.specificationVersion !== "v2") {
const unsupportedModel = model;
throw new UnsupportedModelVersionError({
version: unsupportedModel.specificationVersion,
provider: unsupportedModel.provider,
modelId: unsupportedModel.modelId
});
}
return asTranscriptionModelV3(model);
}
return (_b = (_a16 = getGlobalProvider()).transcriptionModel) == null ? void 0 : _b.call(_a16, model);
}
function resolveSpeechModel(model) {
var _a16, _b;
if (typeof model !== "string") {
if (model.specificationVersion !== "v3" && model.specificationVersion !== "v2") {
const unsupportedModel = model;
throw new UnsupportedModelVersionError({
version: unsupportedModel.specificationVersion,
provider: unsupportedModel.provider,
modelId: unsupportedModel.modelId
});
}
return asSpeechModelV3(model);
}
return (_b = (_a16 = getGlobalProvider()).speechModel) == null ? void 0 : _b.call(_a16, model);
}
function getGlobalProvider() {
var _a16;
return (_a16 = globalThis.AI_SDK_DEFAULT_PROVIDER) != null ? _a16 : import_gateway.gateway;
}
// src/prompt/convert-to-language-model-prompt.ts
var import_provider_utils4 = 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]
// GIF
},
{
mediaType: "image/png",
bytesPrefix: [137, 80, 78, 71]
// PNG
},
{
mediaType: "image/jpeg",
bytesPrefix: [255, 216]
// JPEG
},
{
mediaType: "image/webp",
bytesPrefix: [
82,
73,
70,
70,
// "RIFF"
null,
null,
null,
null,
// file size (variable)
87,
69,
66,
80
// "WEBP"
]
},
{
mediaType: "image/bmp",
bytesPrefix: [66, 77]
},
{
mediaType: "image/tiff",
bytesPrefix: [73, 73, 42, 0]
},
{
mediaType: "image/tiff",
bytesPrefix: [77, 77, 0, 42]
},
{
mediaType: "image/avif",
bytesPrefix: [
0,
0,
0,
32,
102,
116,
121,
112,
97,
118,
105,
102
]
},
{
mediaType: "image/heic",
bytesPrefix: [
0,
0,
0,
32,
102,
116,
121,
112,
104,
101,
105,
99
]
}
];
var audioMediaTypeSignatures = [
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 251]
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 250]
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 243]
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 242]
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 227]
},
{
mediaType: "audio/mpeg",
bytesPrefix: [255, 226]
},
{
mediaType: "audio/wav",
bytesPrefix: [
82,
// R
73,
// I
70,
// F
70,
// F
null,
null,
null,
null,
87,
// W
65,
// A
86,
// V
69
// E
]
},
{
mediaType: "audio/ogg",
bytesPrefix: [79, 103, 103, 83]
},
{
mediaType: "audio/flac",
bytesPrefix: [102, 76, 97, 67]
},
{
mediaType: "audio/aac",
bytesPrefix: [64, 21, 0, 0]
},
{
mediaType: "audio/mp4",
bytesPrefix: [102, 116, 121, 112]
},
{
mediaType: "audio/webm",
bytesPrefix: [26, 69, 223, 163]
}
];
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);
const bytes = typeof processedData === "string" ? (0, import_provider_utils.convertBase64ToUint8Array)(
processedData.substring(0, Math.min(processedData.length, 24))
) : processedData;
for (const signature of signatures) {
if (bytes.length >= signature.bytesPrefix.length && signature.bytesPrefix.every(
(byte, index) => byte === null || bytes[index] === byte
)) {
return signature.mediaType;
}
}
return void 0;
}
// src/util/download/download.ts
var import_provider_utils2 = require("@ai-sdk/provider-utils");
// src/version.ts
var VERSION = true ? "6.0.0-beta.83" : "0.0.0-test";
// src/util/download/download.ts
var download = async ({ url }) => {
var _a16;
const urlText = url.toString();
try {
const response = await fetch(urlText, {
headers: (0, import_provider_utils2.withUserAgentSuffix)(
{},
`ai-sdk/${VERSION}`,
(0, import_provider_utils2.getRuntimeEnvironmentUserAgent)()
)
});
if (!response.ok) {
throw new DownloadError({
url: urlText,
statusCode: response.status,
statusText: response.statusText
});
}
return {
data: new Uint8Array(await response.arrayBuffer()),
mediaType: (_a16 = response.headers.get("content-type")) != null ? _a16 : 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_utils3 = 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 _a16, _b;
return (_b = (_a16 = globalThis.Buffer) == null ? void 0 : _a16.isBuffer(value)) != null ? _b : false;
},
{ message: "Must be a Buffer" }
)
]);
function convertToLanguageModelV3DataContent(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_utils3.convertUint8ArrayToBase64)(new Uint8Array(content));
}
return (0, import_provider_utils3.convertUint8ArrayToBase64)(content);
}
function convertDataContentToUint8Array(content) {
if (content instanceof Uint8Array) {
return content;
}
if (typeof content === "string") {
try {
return (0, import_provider_utils3.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
);
const messages = [
...prompt.system != null ? [{ role: "system", content: prompt.system }] : [],
...prompt.messages.map(
(message) => convertToLanguageModelMessage({ message, downloadedAssets })
)
];
const combinedMessages = [];
for (const message of messages) {
if (message.role !== "tool") {
combinedMessages.push(message);
continue;
}
const lastCombinedMessage = combinedMessages.at(-1);
if ((lastCombinedMessage == null ? void 0 : lastCombinedMessage.role) === "tool") {
lastCombinedMessage.content.push(...message.content);
} else {
combinedMessages.push(message);
}
}
return combinedMessages;
}
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 (no text, and no provider options):
(part) => part.type !== "text" || part.text !== "" || part.providerOptions != null
).filter(
(part) => part.type !== "tool-approval-request"
).map((part) => {
const providerOptions = part.providerOptions;
switch (part.type) {
case "file": {
const { data, mediaType } = convertToLanguageModelV3DataContent(
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: mapToolResultOutput(part.output),
providerOptions
};
}
}
}),
providerOptions: message.providerOptions
};
}
case "tool": {
return {
role: "tool",
content: message.content.filter((part) => part.type !== "tool-approval-response").map((part) => ({
type: "tool-result",
toolCallId: part.toolCallId,
toolName: part.toolName,
output: mapToolResultOutput(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 _a16;
const mediaType = (_a16 = part.mediaType) != null ? _a16 : 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_utils4.isUrlSupported)({
url: part.data.toString(),
mediaType: part.mediaType,
supportedUrls
})
}));
const downloadedFiles = await download2(plannedDownloads);
return Object.fromEntries(
downloadedFiles.map(
(file, index) => file == null ? null : [
plannedDownloads[index].url.toString(),
{ data: file.data, mediaType: file.mediaType }
]
).filter((file) => file != null)
);
}
function convertPartToLanguageModelPart(part, downloadedAssets) {
var _a16;
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 } = convertToLanguageModelV3DataContent(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 = (_a16 = detectMediaType({ data, signatures: imageMediaTypeSignatures })) != null ? _a16 : 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
};
}
}
}
function mapToolResultOutput(output) {
if (output.type !== "content") {
return output;
}
return {
type: "content",
value: output.value.map((item) => {
if (item.type !== "media") {
return item;
}
if (item.mediaType.startsWith("image/")) {
return {
type: "image-data",
data: item.data,
mediaType: item.mediaType
};
}
return {
type: "file-data",
data: item.data,
mediaType: item.mediaType
};
})
};
}
// src/prompt/create-tool-model-output.ts
var import_provider19 = require("@ai-sdk/provider");
function createToolModelOutput({
output,
tool: tool2,
errorMode
}) {
if (errorMode === "text") {
return { type: "error-text", value: (0, import_provider19.getErrorMessage)(output) };
} else if (errorMode === "json") {
return { type: "error-json", value: toJSONValue(output) };
}
if (tool2 == null ? void 0 : tool2.toModelOutput) {
return tool2.toModelOutput(output);
}
return typeof output === "string" ? { type: "text", value: output } : { type: "json", value: toJSONValue(output) };
}
function toJSONValue(value) {
return value === void 0 ? null : value;
}
// 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_utils5 = 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
async function prepareToolsAndToolChoice({
tools,
toolChoice,
activeTools
}) {
if (!isNonEmptyObject(tools)) {
return {
tools: void 0,
toolChoice: void 0
};
}
const filteredTools = activeTools != null ? Object.entries(tools).filter(
([name16]) => activeTools.includes(name16)
) : Object.entries(tools);
const languageModelTools = [];
for (const [name16, tool2] of filteredTools) {
const toolType = tool2.type;
switch (toolType) {
case void 0:
case "dynamic":
case "function":
languageModelTools.push({
type: "function",
name: name16,
description: tool2.description,
inputSchema: await (0, import_provider_utils5.asSchema)(tool2.inputSchema).jsonSchema,
providerOptions: tool2.providerOptions
});
break;
case "provider-defined":
languageModelTools.push({
type: "provider-defined",
name: name16,
id: tool2.id,
args: tool2.args
});
break;
default: {
const exhaustiveCheck = toolType;
throw new Error(`Unsupported tool type: ${exhaustiveCheck}`);
}
}
}
return {
tools: languageModelTools,
toolChoice: toolChoice == null ? { type: "auto" } : typeof toolChoice === "string" ? { type: toolChoice } : { type: "tool", toolName: toolChoice.toolName }
};
}
// src/prompt/standardize-prompt.ts
var import_provider20 = require("@ai-sdk/provider");
var import_provider_utils6 = 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.optional()),
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.optional())
);
// 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(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("json"),
value: jsonValueSchema,
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("execution-denied"),
reason: import_v44.z.string().optional(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("error-text"),
value: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("error-json"),
value: jsonValueSchema,
providerOptions: providerMetadataSchema.optional()
}),
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(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("media"),
data: import_v44.z.string(),
mediaType: import_v44.z.string()
}),
import_v44.z.object({
type: import_v44.z.literal("file-data"),
data: import_v44.z.string(),
mediaType: import_v44.z.string(),
filename: import_v44.z.string().optional(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("file-url"),
url: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("file-id"),
fileId: import_v44.z.union([import_v44.z.string(), import_v44.z.record(import_v44.z.string(), import_v44.z.string())]),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("image-data"),
data: import_v44.z.string(),
mediaType: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("image-url"),
url: import_v44.z.string(),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("image-file-id"),
fileId: import_v44.z.union([import_v44.z.string(), import_v44.z.record(import_v44.z.string(), import_v44.z.string())]),
providerOptions: providerMetadataSchema.optional()
}),
import_v44.z.object({
type: import_v44.z.literal("custom"),
providerOptions: providerMetadataSchema.optional()
})
])
)
})
]
);
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()
});
var toolApprovalRequestSchema = import_v44.z.object({
type: import_v44.z.literal("tool-approval-request"),
approvalId: import_v44.z.string(),
toolCallId: import_v44.z.string()
});
var toolApprovalResponseSchema = import_v44.z.object({
type: import_v44.z.literal("tool-approval-response"),
approvalId: import_v44.z.string(),
approved: import_v44.z.boolean(),
reason: import_v44.z.string().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,
toolApprovalRequest