@stabgan/openrouter-mcp-multimodal 2.0.0 → 3.0.0

package/dist/tool-handlers/fetch-utils.d.ts

@@ -1,8 +1,29 @@
 export declare function readEnvInt(name: string, fallback: number, min?: number): number;
 /** Blocks RFC1918, loopback, link-local, CGNAT, metadata. */
 export declare function isBlockedIPv4(ip: string): boolean;
+/**
+ * Comprehensive IPv6 SSRF block list. Covers loopback, unspecified,
+ * IPv4-mapped, IPv4-compatible, link-local, site-local, ULA, multicast,
+ * discard, documentation, Teredo, 6to4 (re-validates the embedded IPv4
+ * against `isBlockedIPv4`), and ORCHID. Returns `true` for any input that
+ * is a valid IPv6 literal in a reserved or private range.
+ *
+ * For non-IPv6 input returns `false` (the caller is expected to also run
+ * `isBlockedIPv4` for IPv4 input).
+ */
+export declare function isBlockedIPv6(ip: string): boolean;
 /** Resolve hostname and ensure the resolved address is not private/link-local. */
 export declare function assertUrlSafeForFetch(urlString: string): Promise<URL>;
+/**
+ * Parse an RFC 2397 data URL into `{ mediaType, base64 }`. Accepts MIME
+ * parameters (`data:audio/wav;charset=binary;base64,...`) and the bare
+ * `data:;base64,...` form. Returns `null` for anything that is not a
+ * base64-encoded data URL.
+ */
+export declare function parseBase64DataUrl(source: string): {
+    mediaType: string;
+    base64: string;
+} | null;
 export interface FetchOptions {
     timeoutMs: number;
     maxBytes: number;

package/dist/tool-handlers/fetch-utils.js

@@ -3,6 +3,7 @@
  * Used by both image-utils and audio-utils to avoid duplication.
  */
 import dns from 'node:dns/promises';
+import net from 'node:net';
 export function readEnvInt(name, fallback, min = 1) {
     const raw = process.env[name];
     if (raw === undefined || raw === '')
@@ -36,18 +37,136 @@ export function isBlockedIPv4(ip) {
         return true;
     return false;
 }
-function isBlockedIPv6(ip) {
-    const raw = ip.includes('%') ? ip.split('%')[0] : ip;
-    const x = raw.toLowerCase();
-    if (x === '::1')
+/**
+ * Expand an IPv6 literal to eight 16-bit groups as lowercase hex without
+ * separators. Accepts compressed forms (::), zone ids (%eth0), and IPv4-mapped
+ * / IPv4-compatible tails. Returns null if the input is not a valid IPv6
+ * literal.
+ */
+function expandIPv6(ip) {
+    // Strip optional brackets (URL host form) and zone id before validation.
+    const noZone = ip.includes('%') ? ip.split('%')[0] : ip;
+    const noBrackets = noZone.replace(/^\[|\]$/g, '');
+    if (!net.isIPv6(noBrackets))
+        return null;
+    let addr = noBrackets.toLowerCase();
+    // Pull out any IPv4 tail (`::ffff:a.b.c.d`, `::a.b.c.d`, `x:y::a.b.c.d`)
+    // and substitute two 16-bit zero groups in its place. This way the rest
+    // of the parser only needs to handle pure-hex 8-group form.
+    let v4Tail = null;
+    const dotIndex = addr.indexOf('.');
+    if (dotIndex >= 0) {
+        const lastColon = addr.lastIndexOf(':', dotIndex);
+        if (lastColon < 0)
+            return null;
+        const tail = addr.slice(lastColon + 1);
+        const parts = tail.split('.').map((p) => parseInt(p, 10));
+        if (parts.length !== 4 || parts.some((p) => !Number.isInteger(p) || p < 0 || p > 255)) {
+            return null;
+        }
+        v4Tail = [((parts[0] << 8) | parts[1]) & 0xffff, ((parts[2] << 8) | parts[3]) & 0xffff];
+        // Substitute "g6:g7" in hex. E.g. "::ffff:127.0.0.1" -> "::ffff:7f00:0001"
+        const hex6 = v4Tail[0].toString(16);
+        const hex7 = v4Tail[1].toString(16);
+        addr = addr.slice(0, lastColon) + ':' + hex6 + ':' + hex7;
+    }
+    // Split on "::" at most once; fill the gap with zero groups.
+    const halves = addr.split('::');
+    if (halves.length > 2)
+        return null;
+    const left = halves[0] ? halves[0].split(':') : [];
+    const right = halves.length === 2 && halves[1] ? halves[1].split(':') : [];
+    const missing = 8 - left.length - right.length;
+    if (halves.length === 2) {
+        if (missing < 0)
+            return null;
+    }
+    else {
+        if (missing !== 0)
+            return null;
+    }
+    const zeros = Array(Math.max(0, missing)).fill('0');
+    const hexGroups = [...left, ...zeros, ...right];
+    if (hexGroups.length !== 8)
+        return null;
+    const out = [];
+    for (const g of hexGroups) {
+        if (g.length === 0 || g.length > 4 || !/^[0-9a-f]+$/.test(g))
+            return null;
+        out.push(parseInt(g, 16));
+    }
+    return out.length === 8 ? out : null;
+}
+/**
+ * Comprehensive IPv6 SSRF block list. Covers loopback, unspecified,
+ * IPv4-mapped, IPv4-compatible, link-local, site-local, ULA, multicast,
+ * discard, documentation, Teredo, 6to4 (re-validates the embedded IPv4
+ * against `isBlockedIPv4`), and ORCHID. Returns `true` for any input that
+ * is a valid IPv6 literal in a reserved or private range.
+ *
+ * For non-IPv6 input returns `false` (the caller is expected to also run
+ * `isBlockedIPv4` for IPv4 input).
+ */
+export function isBlockedIPv6(ip) {
+    const groups = expandIPv6(ip);
+    if (!groups)
+        return false;
+    const [g0, g1, g2, g3, g4, g5, g6, g7] = groups;
+    // ::  (unspecified)
+    if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0 && g7 === 0) {
         return true;
-    if (x.startsWith('fe80:') || x.startsWith('fec0:'))
+    }
+    // ::1 (loopback)
+    if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0 && g6 === 0 && g7 === 1) {
         return true;
-    const first = x.split(':').find((p) => p.length > 0);
-    if (first) {
-        const v = parseInt(first, 16);
-        if (!Number.isNaN(v) && v >= 0xfc00 && v <= 0xfdff)
-            return true;
+    }
+    // ::ffff:0:0/96 — IPv4-mapped. Re-check the embedded IPv4.
+    if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0xffff) {
+        const v4 = ((g6 << 16) >>> 0) | g7;
+        const dotted = `${(v4 >>> 24) & 0xff}.${(v4 >>> 16) & 0xff}.${(v4 >>> 8) & 0xff}.${v4 & 0xff}`;
+        return isBlockedIPv4(dotted);
+    }
+    // ::/96 IPv4-compatible (deprecated but still routable in places).
+    if (g0 === 0 && g1 === 0 && g2 === 0 && g3 === 0 && g4 === 0 && g5 === 0) {
+        // Only treat as IPv4-compat if g6/g7 actually look like an IPv4 (both
+        // are nonzero or this is the all-zeros case handled above).
+        if (g6 !== 0 || g7 !== 0) {
+            const v4 = ((g6 << 16) >>> 0) | g7;
+            const dotted = `${(v4 >>> 24) & 0xff}.${(v4 >>> 16) & 0xff}.${(v4 >>> 8) & 0xff}.${v4 & 0xff}`;
+            return isBlockedIPv4(dotted);
+        }
+    }
+    // fc00::/7 — ULA
+    if ((g0 & 0xfe00) === 0xfc00)
+        return true;
+    // fe80::/10 — link-local
+    if ((g0 & 0xffc0) === 0xfe80)
+        return true;
+    // fec0::/10 — deprecated site-local
+    if ((g0 & 0xffc0) === 0xfec0)
+        return true;
+    // ff00::/8 — multicast (all forms)
+    if ((g0 & 0xff00) === 0xff00)
+        return true;
+    // 100::/64 — discard prefix (RFC 6666)
+    if (g0 === 0x0100 && g1 === 0 && g2 === 0 && g3 === 0)
+        return true;
+    // 2001:db8::/32 — documentation
+    if (g0 === 0x2001 && g1 === 0x0db8)
+        return true;
+    // 2001::/32 — Teredo
+    if (g0 === 0x2001 && g1 === 0x0000)
+        return true;
+    // 2001:10::/28, 2001:20::/28 — ORCHID / deprecated
+    if (g0 === 0x2001 && (g1 & 0xfff0) === 0x0010)
+        return true;
+    if (g0 === 0x2001 && (g1 & 0xfff0) === 0x0020)
+        return true;
+    // 2002::/16 — 6to4; re-check embedded IPv4 for private/reserved use.
+    if (g0 === 0x2002) {
+        const v4 = ((g1 << 16) >>> 0) | g2;
+        const dotted = `${(v4 >>> 24) & 0xff}.${(v4 >>> 16) & 0xff}.${(v4 >>> 8) & 0xff}.${v4 & 0xff}`;
+        return isBlockedIPv4(dotted);
     }
     return false;
 }
@@ -107,6 +226,13 @@ export async function assertUrlSafeForFetch(urlString) {
     return url;
 }
 async function readResponseBodyWithLimit(res, maxBytes) {
+    const declared = res.headers.get('content-length');
+    if (declared) {
+        const n = parseInt(declared, 10);
+        if (Number.isFinite(n) && n > maxBytes) {
+            throw new Error('Response too large');
+        }
+    }
     const reader = res.body?.getReader();
     if (!reader) {
         const buf = Buffer.from(await res.arrayBuffer());
@@ -121,12 +247,41 @@ async function readResponseBodyWithLimit(res, maxBytes) {
         if (done)
             break;
         total += value.byteLength;
-        if (total > maxBytes)
+        if (total > maxBytes) {
+            // Cancel the underlying body so the server connection can be released.
+            try {
+                await reader.cancel();
+            }
+            catch {
+                /* ignore */
+            }
             throw new Error('Response too large');
+        }
         chunks.push(Buffer.from(value));
     }
     return Buffer.concat(chunks);
 }
+/**
+ * Parse an RFC 2397 data URL into `{ mediaType, base64 }`. Accepts MIME
+ * parameters (`data:audio/wav;charset=binary;base64,...`) and the bare
+ * `data:;base64,...` form. Returns `null` for anything that is not a
+ * base64-encoded data URL.
+ */
+export function parseBase64DataUrl(source) {
+    if (!source.startsWith('data:'))
+        return null;
+    const comma = source.indexOf(',');
+    if (comma < 0)
+        return null;
+    const prefix = source.slice(5, comma); // between "data:" and ","
+    const payload = source.slice(comma + 1);
+    const parts = prefix.split(';').map((p) => p.trim());
+    const hasBase64 = parts[parts.length - 1]?.toLowerCase() === 'base64';
+    if (!hasBase64)
+        return null;
+    const mediaType = (parts[0] && parts[0].includes('/') ? parts[0] : 'application/octet-stream').toLowerCase();
+    return { mediaType, base64: payload };
+}
 /**
  * Fetch a remote HTTP(S) resource with SSRF protection, size limits,
  * redirect cap, and timeout. Returns body Buffer + Content-Type header.

package/dist/tool-handlers/generate-audio.d.ts

@@ -6,40 +6,60 @@ export interface GenerateAudioToolRequest {
     format?: string;
     save_path?: string;
 }
-/** Create a 44-byte WAV header for raw PCM16 data. */
+/** Create a 44-byte WAV header for raw PCM16 data at `sampleRate` Hz. */
 export declare function createWavHeader(dataLength: number, sampleRate?: number): Buffer;
 /**
- * Detect audio container format from magic bytes.
- * Uses subarray (not deprecated slice). Tighter MP3 frame sync validation.
+ * Detect audio container format from magic bytes. Uses `Buffer.subarray()`
+ * (not deprecated `slice()`). MP3 detection is intentionally strict:
+ * - Accept ID3v2 tags (`'ID3'`) as unambiguous MP3.
+ * - Accept raw frame sync only when every MPEG header field falls in a
+ *   non-reserved range: version != 0b01, layer != 0b00, bitrate != 0b1111,
+ *   sample rate index != 0b11. This removes the false positives that a
+ *   sync-word-only check produces on random binary.
  */
 export declare function detectAudioFormat(data: Buffer): {
     ext: string;
     mimeType: string;
 };
-export declare function wrapPcmInWav(pcmData: Buffer): Buffer;
+export declare function wrapPcmInWav(pcmData: Buffer, sampleRate?: number): Buffer;
 /** Strip existing extension (if any) and append a new one. */
 export declare function replaceExtension(filePath: string, newExt: string): string;
 export declare function handleGenerateAudio(request: {
     params: {
         arguments: GenerateAudioToolRequest;
     };
-}, openai: OpenAI): Promise<{
-    content: {
-        type: string;
+}, openai: OpenAI): Promise<import("../errors.js").ToolErrorResult | {
+    content: ({
+        type: "text";
         text: string;
-    }[];
-    isError: boolean;
+        mimeType?: undefined;
+        data?: undefined;
+    } | {
+        type: "audio";
+        mimeType: string;
+        data: string;
+        text?: undefined;
+    })[];
+    _meta: {
+        save_path: string;
+        mime: string;
+        size_bytes: number;
+    };
 } | {
     content: ({
-        type: string;
+        type: "text";
         text: string;
         mimeType?: undefined;
         data?: undefined;
     } | {
-        type: string;
+        type: "audio";
         mimeType: string;
         data: string;
         text?: undefined;
     })[];
-    isError?: undefined;
+    _meta: {
+        mime: string;
+        size_bytes: number;
+        save_path?: undefined;
+    };
 }>;

package/dist/tool-handlers/generate-audio.js

@@ -1,14 +1,17 @@
 import { promises as fs } from 'fs';
-import { dirname, extname } from 'path';
+import { extname } from 'path';
+import { resolveSafeOutputPath, UnsafeOutputPathError } from './path-safety.js';
+import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
+import { classifyUpstreamError } from './openrouter-errors.js';
 const DEFAULT_MODEL = 'openai/gpt-audio';
 const DEFAULT_VOICE = 'alloy';
 const DEFAULT_FORMAT = 'pcm16';
 const VALID_FORMATS = ['wav', 'mp3', 'flac', 'opus', 'pcm16'];
-const PCM_SAMPLE_RATE = 24000;
+const DEFAULT_PCM_SAMPLE_RATE = 24000;
 const PCM_BITS_PER_SAMPLE = 16;
 const PCM_NUM_CHANNELS = 1;
-/** Create a 44-byte WAV header for raw PCM16 data. */
-export function createWavHeader(dataLength, sampleRate = PCM_SAMPLE_RATE) {
+/** Create a 44-byte WAV header for raw PCM16 data at `sampleRate` Hz. */
+export function createWavHeader(dataLength, sampleRate = DEFAULT_PCM_SAMPLE_RATE) {
     const header = Buffer.alloc(44);
     const byteRate = sampleRate * PCM_NUM_CHANNELS * (PCM_BITS_PER_SAMPLE / 8);
     const blockAlign = PCM_NUM_CHANNELS * (PCM_BITS_PER_SAMPLE / 8);
@@ -28,20 +31,31 @@ export function createWavHeader(dataLength, sampleRate = PCM_SAMPLE_RATE) {
     return header;
 }
 /**
- * Detect audio container format from magic bytes.
- * Uses subarray (not deprecated slice). Tighter MP3 frame sync validation.
+ * Detect audio container format from magic bytes. Uses `Buffer.subarray()`
+ * (not deprecated `slice()`). MP3 detection is intentionally strict:
+ * - Accept ID3v2 tags (`'ID3'`) as unambiguous MP3.
+ * - Accept raw frame sync only when every MPEG header field falls in a
+ *   non-reserved range: version != 0b01, layer != 0b00, bitrate != 0b1111,
+ *   sample rate index != 0b11. This removes the false positives that a
+ *   sync-word-only check produces on random binary.
  */
 export function detectAudioFormat(data) {
-    if (data.length >= 3) {
-        if (data[0] === 0x49 && data[1] === 0x44 && data[2] === 0x33) {
+    if (data.length >= 3 && data[0] === 0x49 && data[1] === 0x44 && data[2] === 0x33) {
+        return { ext: 'mp3', mimeType: 'audio/mpeg' };
+    }
+    if (data.length >= 4 && data[0] === 0xff && (data[1] & 0xe0) === 0xe0) {
+        const b1 = data[1];
+        const b2 = data[2];
+        const versionBits = (b1 >> 3) & 0x03; // 01 = reserved
+        const layerBits = (b1 >> 1) & 0x03; // 00 = reserved
+        const bitrateIndex = (b2 >> 4) & 0x0f; // 1111 = bad
+        const sampleRateIndex = (b2 >> 2) & 0x03; // 11 = reserved
+        if (versionBits !== 0x01 &&
+            layerBits !== 0x00 &&
+            bitrateIndex !== 0x0f &&
+            sampleRateIndex !== 0x03) {
             return { ext: 'mp3', mimeType: 'audio/mpeg' };
         }
-        if (data[0] === 0xff && (data[1] & 0xe0) === 0xe0) {
-            const versionBits = (data[1] >> 3) & 0x03;
-            if (versionBits !== 0x01) {
-                return { ext: 'mp3', mimeType: 'audio/mpeg' };
-            }
-        }
     }
     if (data.length >= 12) {
         const riff = data.subarray(0, 4).toString('ascii');
@@ -59,8 +73,8 @@ export function detectAudioFormat(data) {
     }
     return { ext: 'pcm', mimeType: 'audio/pcm' };
 }
-export function wrapPcmInWav(pcmData) {
-    return Buffer.concat([createWavHeader(pcmData.length), pcmData]);
+export function wrapPcmInWav(pcmData, sampleRate = DEFAULT_PCM_SAMPLE_RATE) {
+    return Buffer.concat([createWavHeader(pcmData.length, sampleRate), pcmData]);
 }
 /** Strip existing extension (if any) and append a new one. */
 export function replaceExtension(filePath, newExt) {
@@ -69,39 +83,62 @@ export function replaceExtension(filePath, newExt) {
     return `${base}.${newExt}`;
 }
 export async function handleGenerateAudio(request, openai) {
-    const { prompt, model, voice, format, save_path } = request.params.arguments;
+    const { prompt, model, voice, format, save_path } = request.params.arguments ?? {
+        prompt: '',
+    };
     if (!prompt?.trim()) {
-        return { content: [{ type: 'text', text: 'Prompt is required.' }], isError: true };
+        return toolError(ErrorCode.INVALID_INPUT, 'prompt is required.');
+    }
+    // Fail-fast on unsafe paths BEFORE spending tokens.
+    let safeBase = null;
+    if (save_path) {
+        try {
+            safeBase = await resolveSafeOutputPath(save_path);
+        }
+        catch (e) {
+            if (e instanceof UnsafeOutputPathError)
+                return toolErrorFrom(ErrorCode.UNSAFE_PATH, e);
+            return toolErrorFrom(ErrorCode.INTERNAL, e);
+        }
     }
     const selectedFormat = VALID_FORMATS.includes(format ?? '')
         ? format
         : DEFAULT_FORMAT;
     const selectedVoice = voice?.trim() || DEFAULT_VOICE;
+    let stream;
     try {
-        const stream = await openai.chat.completions.create({
+        stream = (await openai.chat.completions.create({
             model: model || DEFAULT_MODEL,
             messages: [{ role: 'user', content: prompt }],
             modalities: ['text', 'audio'],
             audio: { voice: selectedVoice, format: selectedFormat },
             stream: true,
             // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        });
+        }));
+    }
+    catch (err) {
+        return classifyUpstreamError(err, 'generate_audio');
+    }
+    try {
         const audioChunks = [];
         const transcriptChunks = [];
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
         for await (const chunk of stream) {
-            const delta = chunk.choices?.[0]?.delta;
-            if (delta?.audio) {
-                if (delta.audio.data)
-                    audioChunks.push(delta.audio.data);
-                if (delta.audio.transcript)
-                    transcriptChunks.push(delta.audio.transcript);
+            const delta = chunk.choices?.[0]
+                ?.delta;
+            if (delta && typeof delta === 'object' && delta.audio) {
+                const a = delta.audio;
+                if (typeof a.data === 'string')
+                    audioChunks.push(a.data);
+                if (typeof a.transcript === 'string')
+                    transcriptChunks.push(a.transcript);
             }
         }
         const fullAudioBase64 = audioChunks.join('');
         const transcript = transcriptChunks.join('');
         if (!fullAudioBase64) {
-            return { content: [{ type: 'text', text: transcript || 'No audio generated.' }] };
+            return toolError(ErrorCode.INTERNAL, transcript
+                ? `No audio returned (model emitted transcript only): ${transcript.slice(0, 300)}`
+                : 'No audio returned.', { reason: 'no_audio_in_stream' });
         }
         let audioBuffer = Buffer.from(fullAudioBase64, 'base64');
         const detected = detectAudioFormat(audioBuffer);
@@ -112,13 +149,11 @@ export async function handleGenerateAudio(request, openai) {
             detected.mimeType = 'audio/wav';
         }
         const returnBase64 = audioBuffer.toString('base64');
-        if (save_path) {
-            const dir = dirname(save_path);
-            await fs.mkdir(dir, { recursive: true });
-            const fileExt = extname(save_path).toLowerCase().slice(1);
-            const actualSavePath = fileExt === detected.ext ? save_path : replaceExtension(save_path, detected.ext);
+        if (safeBase) {
+            const fileExt = extname(safeBase).toLowerCase().slice(1);
+            const actualSavePath = fileExt === detected.ext ? safeBase : replaceExtension(safeBase, detected.ext);
             await fs.writeFile(actualSavePath, audioBuffer);
-            const formatNote = actualSavePath !== save_path
+            const formatNote = actualSavePath !== safeBase
                 ? ` (detected ${detected.ext.toUpperCase()}, saved as ${actualSavePath})`
                 : '';
             const result = transcript
@@ -129,6 +164,11 @@ export async function handleGenerateAudio(request, openai) {
                     { type: 'text', text: result },
                     { type: 'audio', mimeType: detected.mimeType, data: returnBase64 },
                 ],
+                _meta: {
+                    save_path: actualSavePath,
+                    mime: detected.mimeType,
+                    size_bytes: audioBuffer.length,
+                },
             };
         }
         return {
@@ -136,19 +176,10 @@ export async function handleGenerateAudio(request, openai) {
                 { type: 'text', text: transcript || 'Audio generated successfully.' },
                 { type: 'audio', mimeType: detected.mimeType, data: returnBase64 },
             ],
+            _meta: { mime: detected.mimeType, size_bytes: audioBuffer.length },
         };
     }
-    catch (error) {
-        let msg;
-        if (error instanceof Error) {
-            msg = error.message;
-            const oaiErr = error;
-            if (oaiErr.error?.message)
-                msg = `${msg} - ${oaiErr.error.message}`;
-        }
-        else {
-            msg = String(error);
-        }
-        return { content: [{ type: 'text', text: `Error: ${msg}` }], isError: true };
+    catch (err) {
+        return classifyUpstreamError(err, 'generate_audio (stream)');
     }
 }

package/dist/tool-handlers/generate-image.d.ts

@@ -8,23 +8,39 @@ export declare function handleGenerateImage(request: {
     params: {
         arguments: GenerateImageToolRequest;
     };
-}, openai: OpenAI): Promise<{
-    content: {
-        type: string;
-        text: string;
-    }[];
-    isError: boolean;
-} | {
+}, openai: OpenAI): Promise<import("../errors.js").ToolErrorResult | {
     content: ({
-        type: string;
+        type: "text";
         text: string;
         mimeType?: undefined;
         data?: undefined;
     } | {
-        type: string;
+        type: "image";
         mimeType: string;
         data: string;
         text?: undefined;
     })[];
-    isError?: undefined;
+    _meta: {
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        save_path: string;
+        mime: string;
+    };
+} | {
+    content: {
+        type: "image";
+        mimeType: string;
+        data: string;
+    }[];
+    _meta: {
+        usage?: {
+            prompt_tokens: number;
+            completion_tokens: number;
+            total_tokens: number;
+        } | undefined;
+        mime: string;
+    };
 }>;