@convex-dev/agent 0.6.4 → 0.7.0-alpha.0

package/dist/{mapping.js → vercel/mapping.js}

@@ -1,9 +1,9 @@
 import {} from "ai";
-import { vMessageWithMetadata, vToolResultOutput, vToolApprovalRequest, vToolApprovalResponse, } from "./validators.js";
+import { vMessageWithMetadata, vToolResultOutput, vToolApprovalRequest, vToolApprovalResponse, vProviderReference, } from "../validators.js";
 import { MAX_FILE_SIZE, storeFile } from "./client/files.js";
 import { convertUint8ArrayToBase64, } from "@ai-sdk/provider-utils";
 import { parse, validate } from "convex-helpers/validators";
-import { getModelName, getProviderName, } from "./shared.js";
+import { getModelName, getProviderName, } from "../shared.js";
 export async function serializeMessage(ctx, component, message) {
     const { content, fileIds } = await serializeContent(ctx, component, message.content);
     return {
@@ -126,31 +126,15 @@ export function autoDenyUnresolvedApprovals(messages) {
 }
 export function serializeUsage(usage) {
     return {
-        promptTokens: usage.inputTokens ?? 0,
-        completionTokens: usage.outputTokens ?? 0,
-        totalTokens: usage.totalTokens ?? 0,
-        reasoningTokens: usage.reasoningTokens,
-        cachedInputTokens: usage.cachedInputTokens,
-    };
-}
-export function toModelMessageUsage(usage) {
-    return {
-        inputTokens: usage.promptTokens,
-        outputTokens: usage.completionTokens,
+        promptTokens: usage.inputTokens,
+        completionTokens: usage.outputTokens,
         totalTokens: usage.totalTokens,
-        reasoningTokens: usage.reasoningTokens,
-        cachedInputTokens: usage.cachedInputTokens,
-        // These detail fields are required by LanguageModelUsage type but we don't
-        // have the granular data, so we provide empty objects with undefined values.
-        inputTokenDetails: {
-            cacheReadTokens: undefined,
-            cacheWriteTokens: undefined,
-            noCacheTokens: undefined,
-        },
-        outputTokenDetails: {
-            textTokens: undefined,
-            reasoningTokens: undefined,
-        },
+        reasoningTokens: usage.outputTokenDetails?.reasoningTokens,
+        cachedInputTokens: usage.inputTokenDetails?.cacheReadTokens,
+        nonCachedInputTokens: usage.inputTokenDetails?.noCacheTokens,
+        cacheWriteInputTokens: usage.inputTokenDetails?.cacheWriteTokens,
+        textOutputTokens: usage.outputTokenDetails?.textTokens,
+        raw: usage.raw,
     };
 }
 export function serializeWarnings(warnings) {
@@ -158,29 +142,23 @@ export function serializeWarnings(warnings) {
         return undefined;
     }
     return warnings.map((warning) => {
-        if (warning.type === "compatibility") {
-            return {
-                type: "unsupported-setting",
-                setting: warning.feature,
-                details: warning.details,
-            };
-        }
-        return warning;
-    });
-}
-export function toModelMessageWarnings(warnings) {
-    if (!warnings) {
-        return undefined;
-    }
-    return warnings.map((warning) => {
-        if (warning.type === "unsupported-setting") {
-            return {
-                type: "compatibility",
-                feature: warning.setting,
-                details: warning.details,
-            };
+        switch (warning.type) {
+            case "unsupported":
+            case "compatibility":
+                return {
+                    type: warning.type,
+                    feature: warning.feature,
+                    details: warning.details,
+                };
+            case "deprecated":
+                return {
+                    type: warning.type,
+                    setting: warning.setting,
+                    message: warning.message,
+                };
+            case "other":
+                return { type: warning.type, message: warning.message };
         }
-        return warning;
     });
 }
 /**
@@ -191,36 +169,17 @@ export function toModelMessageWarnings(warnings) {
 export async function serializeResponseMessages(ctx, component, step, model, responseMessages) {
     return serializeStepMessages(ctx, component, step, model, responseMessages);
 }
-/**
- * Serialize the new response messages produced by this step.
- *
- * `step.response.messages` is cumulative across steps in AI SDK v6 — each
- * step's array contains all messages from prior steps too. Pass
- * `previousResponseMessageCount` (the prior step's `response.messages.length`,
- * or `0` for the first step) so we slice only the new tail. The parameter is
- * required: defaulting it would silently duplicate every prior message on
- * every multi-step save.
- */
-export async function serializeNewMessagesInStep(ctx, component, step, model, previousResponseMessageCount) {
-    const newMessages = step.response.messages.slice(previousResponseMessageCount);
-    // Keep at least one message in the output so the step still anchors an
-    // order slot — downstream `addMessages` relies on each step contributing a
-    // row even when AI SDK produced no response messages.
-    const messagesToSerialize = newMessages.length > 0
-        ? newMessages
-        : [{ role: "assistant", content: [] }];
-    return serializeStepMessages(ctx, component, step, model, messagesToSerialize);
-}
 async function serializeStepMessages(ctx, component, step, model, messagesToSerialize) {
     // If there are tool results, there's another message with the tool results
     // ref: https://github.com/vercel/ai/blob/main/packages/ai/src/generate-text/to-response-messages.ts#L120
     const hasToolMessage = step.response.messages.at(-1)?.role === "tool";
+    const resolvedModel = step.model ?? model;
     const assistantFields = {
-        model: model ? getModelName(model) : undefined,
-        provider: model ? getProviderName(model) : undefined,
+        model: resolvedModel ? getModelName(resolvedModel) : undefined,
+        provider: resolvedModel ? getProviderName(resolvedModel) : undefined,
         providerMetadata: step.providerMetadata,
         reasoning: step.reasoningText,
-        reasoningDetails: step.reasoning,
+        reasoningDetails: step.reasoning.filter((part) => part.type !== "reasoning-file"),
         usage: serializeUsage(step.usage),
         warnings: serializeWarnings(step.warnings),
         finishReason: step.finishReason,
@@ -237,7 +196,6 @@ async function serializeStepMessages(ctx, component, step, model, messagesToSeri
             fileIds,
         });
     }));
-    // TODO: capture step.files separately?
     return { messages };
 }
 export async function serializeObjectResult(ctx, component, result, model) {
@@ -293,7 +251,8 @@ export async function serializeContent(ctx, component, content) {
                 };
             }
             case "image": {
-                let image = serializeDataOrUrl(part.image);
+                let image = toStoredProviderReference(part.image) ??
+                    serializeDataOrUrl(part.image);
                 if (image instanceof ArrayBuffer &&
                     image.byteLength > MAX_FILE_SIZE) {
                     const { file } = await storeFile(ctx, component, new Blob([image], {
@@ -310,7 +269,8 @@ export async function serializeContent(ctx, component, content) {
                 };
             }
             case "file": {
-                let data = serializeDataOrUrl(part.data);
+                let data = toStoredProviderReference(part.data) ??
+                    serializeDataOrUrl(part.data);
                 if (data instanceof ArrayBuffer && data.byteLength > MAX_FILE_SIZE) {
                     const { file } = await storeFile(ctx, component, new Blob([data], { type: getMimeOrMediaType(part) }));
                     data = file.url;
@@ -335,16 +295,36 @@ export async function serializeContent(ctx, component, content) {
                     toolCallId: part.toolCallId,
                     toolName: part.toolName,
                     providerExecuted: part.providerExecuted,
+                    title: "title" in part ? part.title : undefined,
+                    toolMetadata: "toolMetadata" in part ? part.toolMetadata : undefined,
                     ...metadata,
                 };
             }
             case "tool-result": {
-                return normalizeToolResult(part, metadata);
+                return serializeToolResult(part, metadata);
             }
             case "reasoning": {
                 return {
                     type: part.type,
                     text: part.text,
+                    signature: "signature" in part && typeof part.signature === "string"
+                        ? part.signature
+                        : undefined,
+                    ...metadata,
+                };
+            }
+            case "reasoning-file": {
+                return {
+                    type: part.type,
+                    ...serializeReasoningFile(part),
+                    mediaType: part.mediaType,
+                    ...metadata,
+                };
+            }
+            case "custom": {
+                return {
+                    type: part.type,
+                    kind: part.kind,
                     ...metadata,
                 };
             }
@@ -364,6 +344,8 @@ export async function serializeContent(ctx, component, content) {
                     type: part.type,
                     approvalId: part.approvalId,
                     toolCallId: part.toolCallId,
+                    isAutomatic: "isAutomatic" in part ? part.isAutomatic : undefined,
+                    signature: "signature" in part ? part.signature : undefined,
                     ...metadata,
                 };
             }
@@ -407,12 +389,14 @@ export function fromModelMessageContent(content) {
                     type: part.type,
                     mediaType: getMimeOrMediaType(part),
                     ...metadata,
-                    image: serializeDataOrUrl(part.image),
+                    image: toStoredProviderReference(part.image) ??
+                        serializeDataOrUrl(part.image),
                 };
             case "file":
                 return {
                     type: part.type,
-                    data: serializeDataOrUrl(part.data),
+                    data: toStoredProviderReference(part.data) ??
+                        serializeDataOrUrl(part.data),
                     filename: part.filename,
                     mediaType: getMimeOrMediaType(part),
                     ...metadata,
@@ -430,11 +414,28 @@ export function fromModelMessageContent(content) {
                     ...metadata,
                 };
             case "tool-result":
-                return normalizeToolResult(part, metadata);
+                return serializeToolResult(part, metadata);
             case "reasoning":
                 return {
                     type: part.type,
                     text: part.text,
+                    signature: "signature" in part && typeof part.signature === "string"
+                        ? part.signature
+                        : undefined,
+                    ...metadata,
+                };
+            case "reasoning-file": {
+                return {
+                    type: part.type,
+                    ...serializeReasoningFile(part),
+                    mediaType: part.mediaType,
+                    ...metadata,
+                };
+            }
+            case "custom":
+                return {
+                    type: part.type,
+                    kind: part.kind,
                     ...metadata,
                 };
             case "tool-approval-request":
@@ -442,6 +443,8 @@ export function fromModelMessageContent(content) {
                     type: part.type,
                     approvalId: part.approvalId,
                     toolCallId: part.toolCallId,
+                    isAutomatic: "isAutomatic" in part ? part.isAutomatic : undefined,
+                    signature: "signature" in part ? part.signature : undefined,
                     ...metadata,
                 };
             case "tool-approval-response":
@@ -483,14 +486,18 @@ export function toModelMessageContent(content) {
             case "image":
                 return {
                     type: part.type,
-                    image: toModelMessageDataOrUrl(part.image),
+                    image: (isStoredProviderReference(part.image)
+                        ? part.image.reference
+                        : toModelMessageDataOrUrl(part.image)),
                     mediaType: getMimeOrMediaType(part),
                     ...metadata,
                 };
             case "file":
                 return {
                     type: part.type,
-                    data: toModelMessageDataOrUrl(part.data),
+                    data: (isStoredProviderReference(part.data)
+                        ? { type: "reference", reference: part.data.reference }
+                        : toModelMessageDataOrUrl(part.data)),
                     filename: part.filename,
                     mediaType: getMimeOrMediaType(part),
                     ...metadata,
@@ -508,7 +515,7 @@ export function toModelMessageContent(content) {
                 };
             }
             case "tool-result": {
-                return normalizeToolResult(part, metadata);
+                return deserializeToolResult(part, metadata);
             }
             case "reasoning":
                 return {
@@ -516,19 +523,26 @@ export function toModelMessageContent(content) {
                     text: part.text,
                     ...metadata,
                 };
+            case "reasoning-file":
+                return {
+                    type: "reasoning-file",
+                    data: deserializeReasoningFile(part),
+                    mediaType: part.mediaType,
+                    ...metadata,
+                };
+            case "custom":
+                return { type: "custom", kind: part.kind, ...metadata };
             case "redacted-reasoning":
-                // TODO: should we just drop this?
+                // Legacy v5 part: round-trip the redacted payload via providerOptions.
                 return {
                     type: "reasoning",
                     text: "",
                     ...metadata,
                     providerOptions: metadata.providerOptions
-                        ? {
-                            ...Object.fromEntries(Object.entries(metadata.providerOptions ?? {}).map(([key, value]) => [
-                                key,
-                                { ...value, redactedData: part.data },
-                            ])),
-                        }
+                        ? Object.fromEntries(Object.entries(metadata.providerOptions ?? {}).map(([key, value]) => [
+                            key,
+                            { ...value, redactedData: part.data },
+                        ]))
                         : undefined,
                 };
             case "source":
@@ -538,6 +552,8 @@ export function toModelMessageContent(content) {
                     type: part.type,
                     approvalId: part.approvalId,
                     toolCallId: part.toolCallId,
+                    isAutomatic: "isAutomatic" in part ? part.isAutomatic : undefined,
+                    signature: "signature" in part ? part.signature : undefined,
                     ...metadata,
                 };
             case "tool-approval-response":
@@ -570,21 +586,238 @@ export function normalizeToolOutput(result) {
         value: result ?? null,
     };
 }
-function normalizeToolResult(part, metadata) {
+function serializeToolResult(part, metadata) {
     return {
         type: part.type,
-        output: part.output
-            ? validate(vToolResultOutput, part.output)
-                ? part.output
-                : normalizeToolOutput(JSON.stringify(part.output))
+        output: "output" in part && part.output !== undefined
+            ? serializeToolResultOutput(part.output)
             : normalizeToolOutput("result" in part ? part.result : undefined),
         toolCallId: part.toolCallId,
         toolName: part.toolName,
+        ...("providerExecuted" in part
+            ? { providerExecuted: part.providerExecuted }
+            : {}),
         // Preserve isError flag for error reporting
         ...("isError" in part && part.isError ? { isError: true } : {}),
         ...metadata,
     };
 }
+function deserializeToolResult(part, metadata) {
+    return {
+        type: part.type,
+        output: "output" in part && part.output !== undefined
+            ? deserializeToolResultOutput(part.output)
+            : normalizeToolOutput("result" in part ? part.result : undefined),
+        toolCallId: part.toolCallId,
+        toolName: part.toolName,
+        ...("isError" in part && part.isError ? { isError: true } : {}),
+        ...metadata,
+    };
+}
+function serializeToolResultOutput(output) {
+    if (output === undefined) {
+        return normalizeToolOutput(undefined);
+    }
+    if (!isRecord(output) || typeof output.type !== "string") {
+        return normalizeToolOutput(output);
+    }
+    if (output.type !== "content") {
+        if (validate(vToolResultOutput, output)) {
+            return output;
+        }
+        throw new Error(`Invalid AI SDK 7 tool-result output: ${output.type}`);
+    }
+    if (!Array.isArray(output.value)) {
+        throw new Error("Invalid AI SDK 7 tool-result content output");
+    }
+    const serialized = {
+        ...output,
+        value: output.value.map(serializeToolResultContentPart),
+    };
+    if (!validate(vToolResultOutput, serialized)) {
+        throw new Error("Invalid AI SDK 7 tool-result content part");
+    }
+    return serialized;
+}
+function serializeToolResultContentPart(part) {
+    if (!isRecord(part) || typeof part.type !== "string") {
+        throw new Error("Invalid AI SDK 7 tool-result content part");
+    }
+    if (part.type !== "file")
+        return part;
+    if (!isRecord(part.data) || typeof part.data.type !== "string") {
+        throw new Error("Invalid AI SDK 7 tool-result file data");
+    }
+    const common = {
+        type: "file",
+        mediaType: part.mediaType,
+        ...(typeof part.filename === "string" ? { filename: part.filename } : {}),
+        ...(isRecord(part.providerOptions)
+            ? { providerOptions: part.providerOptions }
+            : {}),
+    };
+    switch (part.data.type) {
+        case "data":
+            return {
+                ...common,
+                data: {
+                    type: "data",
+                    data: serializeDataOrUrl(part.data.data),
+                },
+            };
+        case "url": {
+            const { url } = part.data;
+            if (typeof url !== "string" && !(url instanceof URL)) {
+                throw new Error("Invalid AI SDK 7 tool-result file URL");
+            }
+            return { ...common, data: { type: "url", url: url.toString() } };
+        }
+        case "text":
+            if (typeof part.data.text !== "string") {
+                throw new Error("Invalid AI SDK 7 tool-result file text");
+            }
+            return {
+                ...common,
+                data: { type: "text", text: part.data.text },
+            };
+        case "reference":
+            if (!isProviderReference(part.data.reference)) {
+                throw new Error("Invalid AI SDK 7 tool-result file reference");
+            }
+            return {
+                ...common,
+                data: { type: "reference", reference: part.data.reference },
+            };
+        default:
+            throw new Error(`Invalid AI SDK 7 tool-result file data: ${part.data.type}`);
+    }
+}
+function deserializeToolResultOutput(output) {
+    if (!validate(vToolResultOutput, output)) {
+        return normalizeToolOutput(output);
+    }
+    const stored = output;
+    if (stored.type !== "content")
+        return stored;
+    return {
+        type: "content",
+        value: stored.value.map(deserializeToolResultContentPart),
+    };
+}
+function deserializeToolResultContentPart(part) {
+    if (part.type === "file") {
+        return {
+            ...part,
+            data: part.data.type === "url"
+                ? { type: "url", url: new URL(part.data.url) }
+                : part.data,
+        };
+    }
+    switch (part.type) {
+        case "media":
+            return {
+                type: "file",
+                data: { type: "data", data: part.data },
+                mediaType: part.mediaType,
+            };
+        case "file-data":
+            return {
+                type: "file",
+                data: { type: "data", data: part.data },
+                mediaType: part.mediaType,
+                ...(part.filename !== undefined ? { filename: part.filename } : {}),
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        case "file-url":
+            return {
+                type: "file",
+                data: { type: "url", url: new URL(part.url) },
+                mediaType: part.mediaType ?? "application/octet-stream",
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        case "file-id":
+        case "image-file-id":
+            if (typeof part.fileId === "string")
+                return part;
+            return {
+                type: "file",
+                data: {
+                    type: "reference",
+                    reference: part.fileId,
+                },
+                mediaType: part.type === "image-file-id" ? "image" : "application/octet-stream",
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        case "file-reference":
+        case "image-file-reference":
+            return {
+                type: "file",
+                data: { type: "reference", reference: part.providerReference },
+                mediaType: part.type === "image-file-reference"
+                    ? "image"
+                    : "application/octet-stream",
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        case "image-data":
+            return {
+                type: "file",
+                data: { type: "data", data: part.data },
+                mediaType: part.mediaType,
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        case "image-url":
+            return {
+                type: "file",
+                data: { type: "url", url: new URL(part.url) },
+                mediaType: "image",
+                ...(part.providerOptions !== undefined
+                    ? { providerOptions: part.providerOptions }
+                    : {}),
+            };
+        default:
+            return part;
+    }
+}
+function serializeReasoningFile(part) {
+    if ("url" in part && part.url !== undefined) {
+        return { url: part.url.toString() };
+    }
+    if (!("data" in part) || part.data === undefined) {
+        throw new Error("reasoning-file requires data or url");
+    }
+    const { data } = part;
+    if (data instanceof URL)
+        return { url: data.toString() };
+    if (isRecord(data) && data.type === "url" && data.url instanceof URL) {
+        return { url: data.url.toString() };
+    }
+    if (isRecord(data) && data.type === "data") {
+        return { data: serializeDataOrUrl(data.data) };
+    }
+    if (isRecord(data) && "type" in data) {
+        throw new Error("Invalid AI SDK 7 reasoning-file data");
+    }
+    return { data: serializeDataOrUrl(data) };
+}
+function deserializeReasoningFile(part) {
+    if (part.url !== undefined) {
+        return { type: "url", url: new URL(part.url) };
+    }
+    if (part.data !== undefined) {
+        return { type: "data", data: part.data };
+    }
+    throw new Error("reasoning-file requires data or url");
+}
 /**
  * Return a best-guess MIME type based on the magic-number signature
  * found at the start of an ArrayBuffer.
@@ -673,6 +906,21 @@ export function serializeDataOrUrl(dataOrUrl) {
     if (dataOrUrl instanceof URL) {
         return dataOrUrl.toString();
     }
+    if ("type" in dataOrUrl) {
+        switch (dataOrUrl.type) {
+            case "data":
+                return serializeDataOrUrl(dataOrUrl.data);
+            case "url":
+                return dataOrUrl.url.toString();
+            case "text":
+                return convertUint8ArrayToBase64(new TextEncoder().encode(dataOrUrl.text));
+            case "reference":
+                throw new Error("Provider references must be stored as references");
+        }
+    }
+    if (!(dataOrUrl instanceof Uint8Array)) {
+        throw new Error("Unsupported provider reference");
+    }
     return dataOrUrl.buffer.slice(dataOrUrl.byteOffset, dataOrUrl.byteOffset + dataOrUrl.byteLength);
 }
 export function toModelMessageDataOrUrl(urlOrString) {
@@ -688,35 +936,84 @@ export function toModelMessageDataOrUrl(urlOrString) {
     }
     return urlOrString;
 }
+function isRecord(value) {
+    return typeof value === "object" && value !== null;
+}
+function isProviderReference(value) {
+    return (isRecord(value) &&
+        !(value instanceof ArrayBuffer) &&
+        !(value instanceof Uint8Array) &&
+        !(value instanceof URL) &&
+        !("type" in value) &&
+        Object.values(value).every((id) => typeof id === "string"));
+}
+function isStoredProviderReference(value) {
+    return (isRecord(value) &&
+        value.type === "reference" &&
+        isProviderReference(value.reference));
+}
+function toStoredProviderReference(value) {
+    if (isStoredProviderReference(value))
+        return value;
+    if (isProviderReference(value))
+        return { type: "reference", reference: value };
+    if (isRecord(value) &&
+        value.type === "reference" &&
+        isProviderReference(value.reference)) {
+        return { type: "reference", reference: value.reference };
+    }
+    return undefined;
+}
+function isFileReference(value) {
+    return (isRecord(value) &&
+        value.type === "reference" &&
+        isProviderReference(value.reference));
+}
 export function toUIFilePart(part) {
     const dataOrUrl = part.type === "image" ? part.image : part.data;
-    const url = dataOrUrl instanceof ArrayBuffer
-        ? convertUint8ArrayToBase64(new Uint8Array(dataOrUrl))
-        : dataOrUrl.toString();
+    const providerReference = isProviderReference(dataOrUrl)
+        ? dataOrUrl
+        : isFileReference(dataOrUrl)
+            ? dataOrUrl.reference
+            : undefined;
+    const url = providerReference
+        ? ""
+        : toUIFileUrl(dataOrUrl, part.mediaType ?? "application/octet-stream");
     return {
         type: "file",
         mediaType: part.mediaType,
         filename: part.type === "file" ? part.filename : undefined,
         url,
+        ...(providerReference !== undefined ? { providerReference } : {}),
         providerMetadata: part.providerOptions,
     };
 }
-// Currently unused
-// export function toModelMessages(args: {
-//   messages?: ModelMessage[] | AIMessageWithoutId[];
-// }): ModelMessage[] {
-//   const messages: ModelMessage[] = [];
-//   if (args.messages) {
-//     if (
-//       args.messages.every(
-//         (m) => typeof m === "object" && m !== null && "parts" in m,
-//       )
-//     ) {
-//       messages.push(...convertToModelMessages(args.messages));
-//     } else {
-//       messages.push(...modelMessageSchema.array().parse(args.messages));
-//     }
-//   }
-//   return messages;
-// }
+function toUIFileUrl(data, mediaType) {
+    if (isFileReference(data))
+        return "";
+    if (isRecord(data) && typeof data.type === "string") {
+        switch (data.type) {
+            case "url":
+                return data.url.toString();
+            case "data":
+                return toUIFileDataUrl(data.data, mediaType);
+            case "text":
+                return toUIFileDataUrl(new TextEncoder().encode(data.text), mediaType);
+        }
+    }
+    if (data instanceof URL)
+        return data.toString();
+    if (typeof data === "string")
+        return data;
+    return toUIFileDataUrl(data, mediaType);
+}
+function toUIFileDataUrl(data, mediaType) {
+    if (typeof data === "string") {
+        return data.startsWith("data:") ? data : `data:${mediaType};base64,${data}`;
+    }
+    const bytes = data instanceof ArrayBuffer
+        ? new Uint8Array(data)
+        : new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+    return `data:${mediaType};base64,${convertUint8ArrayToBase64(bytes)}`;
+}
 //# sourceMappingURL=mapping.js.map