@stabgan/openrouter-mcp-multimodal 4.6.2 → 4.8.0

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

@@ -3,7 +3,10 @@
  * Used by both image-utils and audio-utils to avoid duplication.
  */
 import dns from 'node:dns/promises';
+import http from 'node:http';
+import https from 'node:https';
 import net from 'node:net';
+import { createBrotliDecompress, createGunzip, createInflate } from 'node:zlib';
 import { readFileSync } from 'node:fs';
 import { fileURLToPath } from 'node:url';
 import path from 'node:path';
@@ -37,9 +40,25 @@ export function readEnvInt(name, fallback, min = 1) {
     const raw = process.env[name];
     if (raw === undefined || raw === '')
         return fallback;
-    const n = parseInt(raw, 10);
+    if (!/^\d+$/.test(raw))
+        return fallback;
+    const n = Number(raw);
     return Number.isFinite(n) && n >= min ? n : fallback;
 }
+/** Normalize dotted / decimal / octal / shorthand IPv4 literals via the URL parser. */
+function normalizeIPv4Literal(host) {
+    const trimmed = host.trim().toLowerCase();
+    if (/^\d{1,3}(\.\d{1,3}){3}$/.test(trimmed))
+        return trimmed;
+    try {
+        const parsed = new URL(`http://${trimmed}/`);
+        const h = parsed.hostname;
+        return /^\d{1,3}(\.\d{1,3}){3}$/.test(h) ? h : null;
+    }
+    catch {
+        return null;
+    }
+}
 function ipv4ToUint(ip) {
     const parts = ip.split('.').map((p) => parseInt(p, 10));
     if (parts.length !== 4 || parts.some((p) => !Number.isInteger(p) || p < 0 || p > 255)) {
@@ -49,7 +68,10 @@ function ipv4ToUint(ip) {
 }
 /** Blocks RFC1918, loopback, link-local, CGNAT, metadata. */
 export function isBlockedIPv4(ip) {
-    const n = ipv4ToUint(ip);
+    const normalized = normalizeIPv4Literal(ip);
+    if (!normalized)
+        return false;
+    const n = ipv4ToUint(normalized);
     if (n >>> 24 === 127)
         return true;
     if (n >>> 24 === 10)
@@ -179,10 +201,74 @@ export function isBlockedIPv6(ip) {
     return false;
 }
 function isIPv4Literal(host) {
-    return /^\d{1,3}(\.\d{1,3}){3}$/.test(host);
+    return normalizeIPv4Literal(host) !== null;
 }
-/** Resolve hostname and ensure the resolved address is not private/link-local. */
-export async function assertUrlSafeForFetch(urlString) {
+/** Vitest-only hooks; inert outside `process.env.VITEST === 'true'`. */
+let testDnsLookup = null;
+let testTrustedCa;
+let testAllowLoopbackResolution = false;
+/** @internal Test seam — never active in production. */
+export function __setFetchUtilsTestHooks(hooks) {
+    if (process.env.VITEST !== 'true')
+        return;
+    if ('dnsLookup' in hooks)
+        testDnsLookup = hooks.dnsLookup ?? null;
+    if ('trustedCa' in hooks)
+        testTrustedCa = hooks.trustedCa;
+    if ('allowLoopbackResolution' in hooks) {
+        testAllowLoopbackResolution = hooks.allowLoopbackResolution ?? false;
+    }
+}
+/** @internal Test seam — never active in production. */
+export function __resetFetchUtilsTestHooks() {
+    testDnsLookup = null;
+    testTrustedCa = undefined;
+    testAllowLoopbackResolution = false;
+}
+function isAddressBlocked(address, family) {
+    if (family === 4)
+        return isBlockedIPv4(address);
+    return isBlockedIPv6(address);
+}
+function isLoopbackForTest(address, family) {
+    if (family === 4) {
+        const normalized = normalizeIPv4Literal(address);
+        if (!normalized)
+            return false;
+        return ipv4ToUint(normalized) >>> 24 === 127;
+    }
+    const groups = expandIPv6(address);
+    if (!groups)
+        return false;
+    return (groups[0] === 0 &&
+        groups[1] === 0 &&
+        groups[2] === 0 &&
+        groups[3] === 0 &&
+        groups[4] === 0 &&
+        groups[5] === 0 &&
+        groups[6] === 0 &&
+        groups[7] === 1);
+}
+function assertAddressAllowed(address, family) {
+    if (testAllowLoopbackResolution &&
+        process.env.VITEST === 'true' &&
+        isLoopbackForTest(address, family)) {
+        return;
+    }
+    if (isAddressBlocked(address, family))
+        throw new Error('Blocked host');
+}
+async function lookupHostAddresses(host) {
+    if (testDnsLookup && process.env.VITEST === 'true') {
+        return testDnsLookup(host);
+    }
+    const records = await dns.lookup(host, { all: true, verbatim: true });
+    return records.map((r) => ({
+        address: r.address,
+        family: r.family === 6 ? 6 : 4,
+    }));
+}
+async function validateUrlAndResolveAddresses(urlString) {
     let url;
     try {
         url = new URL(urlString);
@@ -201,74 +287,253 @@ export async function assertUrlSafeForFetch(urlString) {
         throw new Error('Blocked host');
     }
     if (isIPv4Literal(host)) {
-        if (isBlockedIPv4(host))
-            throw new Error('Blocked host');
-        return url;
+        const normalized = normalizeIPv4Literal(host);
+        assertAddressAllowed(normalized, 4);
+        return { url, addresses: [{ address: normalized, family: 4 }] };
     }
     if (host.includes(':') && !host.startsWith('[')) {
-        if (isBlockedIPv6(host))
-            throw new Error('Blocked host');
-        return url;
+        assertAddressAllowed(host, 6);
+        return { url, addresses: [{ address: host, family: 6 }] };
     }
     let lookupHost = host;
     if (host.startsWith('[') && host.endsWith(']')) {
         lookupHost = host.slice(1, -1);
-        if (isBlockedIPv6(lookupHost))
-            throw new Error('Blocked host');
-        return url;
+        assertAddressAllowed(lookupHost, 6);
+        return { url, addresses: [{ address: lookupHost, family: 6 }] };
     }
-    const records = await dns.lookup(lookupHost, { all: true, verbatim: true });
+    const records = await lookupHostAddresses(lookupHost);
     if (!records.length)
         throw new Error('Could not resolve host');
+    const addresses = [];
     for (const r of records) {
-        const { address, family } = r;
-        if (family === 4) {
-            if (isBlockedIPv4(address))
-                throw new Error('Blocked host');
+        assertAddressAllowed(r.address, r.family);
+        addresses.push(r);
+    }
+    return { url, addresses };
+}
+/** Resolve hostname and ensure the resolved address is not private/link-local. */
+export async function assertUrlSafeForFetch(urlString) {
+    const { url } = await validateUrlAndResolveAddresses(urlString);
+    return url;
+}
+// Pin the socket to a pre-validated IP so connect-time DNS cannot rebind to private space.
+function pinnedLookup(address, family) {
+    const deliver = (cb) => {
+        cb(null, address, family);
+    };
+    return (hostname, options, callback) => {
+        if (typeof options === 'function') {
+            deliver(options);
+            return;
+        }
+        if (!callback)
+            return;
+        const opts = typeof options === 'number' ? { family: options } : (options ?? {});
+        if (opts.all) {
+            callback(null, [{ address, family }]);
+            return;
+        }
+        deliver(callback);
+    };
+}
+function isConnectError(err) {
+    if (!(err instanceof Error))
+        return false;
+    const code = err.code;
+    return (code === 'ECONNREFUSED' ||
+        code === 'ECONNRESET' ||
+        code === 'ETIMEDOUT' ||
+        code === 'EHOSTUNREACH' ||
+        code === 'ENETUNREACH' ||
+        code === 'EPIPE');
+}
+function requestPort(url) {
+    if (url.port)
+        return Number(url.port);
+    return url.protocol === 'https:' ? 443 : 80;
+}
+function buildRequestOptions(url, pinned, timeoutMs) {
+    return {
+        hostname: url.hostname,
+        host: url.host,
+        port: requestPort(url),
+        path: `${url.pathname}${url.search}`,
+        method: 'GET',
+        headers: {
+            'User-Agent': FETCH_USER_AGENT,
+            Accept: 'image/*, audio/*, video/*, */*;q=0.8',
+            // Prefer identity; decompress defensively if the origin ignores this.
+            'Accept-Encoding': 'identity',
+            Host: url.host,
+        },
+        lookup: pinnedLookup(pinned.address, pinned.family),
+        signal: AbortSignal.timeout(timeoutMs),
+    };
+}
+function pinnedHttpRequest(url, pinned, timeoutMs) {
+    return new Promise((resolve, reject) => {
+        const options = buildRequestOptions(url, pinned, timeoutMs);
+        const req = http.request(options, (res) => resolve(res));
+        req.on('error', (err) => {
+            if (options.signal?.aborted) {
+                reject(new Error('Fetch timed out'));
+                return;
+            }
+            reject(err);
+        });
+        req.end();
+    });
+}
+function pinnedHttpsRequest(url, pinned, timeoutMs, ca) {
+    return new Promise((resolve, reject) => {
+        const options = buildRequestOptions(url, pinned, timeoutMs);
+        const req = https.request({ ...options, ca }, (res) => resolve(res));
+        req.on('error', (err) => {
+            if (options.signal?.aborted) {
+                reject(new Error('Fetch timed out'));
+                return;
+            }
+            reject(err);
+        });
+        req.end();
+    });
+}
+async function pinnedRequest(url, pinned, timeoutMs) {
+    const ca = testTrustedCa && process.env.VITEST === 'true' ? testTrustedCa : undefined;
+    if (url.protocol === 'https:') {
+        return pinnedHttpsRequest(url, pinned, timeoutMs, ca);
+    }
+    if (url.protocol === 'http:') {
+        return pinnedHttpRequest(url, pinned, timeoutMs);
+    }
+    throw new Error('Only HTTP(S) URLs are allowed');
+}
+async function pinnedRequestWithFallback(url, addresses, timeoutMs) {
+    if (!addresses.length)
+        throw new Error('Could not resolve host');
+    let lastError;
+    for (const pinned of addresses) {
+        try {
+            return await pinnedRequest(url, pinned, timeoutMs);
         }
-        else if (family === 6) {
-            if (isBlockedIPv6(address))
-                throw new Error('Blocked host');
+        catch (err) {
+            if (err instanceof Error && err.message === 'Fetch timed out')
+                throw err;
+            lastError = err;
+            if (!isConnectError(err))
+                throw err;
         }
     }
-    return url;
+    throw lastError instanceof Error ? lastError : new Error('Connection failed');
+}
+function drainIncomingMessage(res) {
+    return new Promise((resolve) => {
+        const finish = () => resolve();
+        res.on('end', finish);
+        res.on('close', finish);
+        res.on('error', finish);
+        res.resume();
+    });
 }
-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');
+function parseContentEncodings(raw) {
+    if (!raw)
+        return [];
+    const out = [];
+    for (const part of raw.split(',')) {
+        const enc = part.trim().toLowerCase();
+        if (!enc || enc === 'identity')
+            continue;
+        switch (enc) {
+            case 'gzip':
+            case 'x-gzip':
+            case 'deflate':
+            case 'br':
+                out.push(enc);
+                break;
+            default:
+                throw new Error(`Unsupported Content-Encoding: ${enc}`);
         }
     }
-    const reader = res.body?.getReader();
-    if (!reader) {
-        const buf = Buffer.from(await res.arrayBuffer());
-        if (buf.length > maxBytes)
-            throw new Error('Response too large');
-        return buf;
+    return out;
+}
+function createDecompressTransform(encoding) {
+    switch (encoding) {
+        case 'gzip':
+        case 'x-gzip':
+            return createGunzip();
+        case 'deflate':
+            return createInflate();
+        case 'br':
+            return createBrotliDecompress();
+        default: {
+            const _exhaustive = encoding;
+            throw new Error(`Unsupported Content-Encoding: ${String(_exhaustive)}`);
+        }
+    }
+}
+function bodyStreamForResponse(res, encodings) {
+    let stream = res;
+    for (const enc of [...encodings].reverse()) {
+        stream = stream.pipe(createDecompressTransform(enc));
+    }
+    return stream;
+}
+async function readIncomingMessageWithLimit(res, maxBytes) {
+    let encodings;
+    try {
+        encodings = parseContentEncodings(headerValue(res.headers, 'content-encoding'));
+    }
+    catch (err) {
+        await releaseIncomingMessage(res);
+        throw err;
     }
+    if (!encodings.length) {
+        const declared = res.headers['content-length'];
+        if (declared) {
+            const n = parseInt(String(declared), 10);
+            if (Number.isFinite(n) && n > maxBytes) {
+                res.destroy();
+                throw new Error('Response too large');
+            }
+        }
+    }
+    const stream = bodyStreamForResponse(res, encodings);
     const chunks = [];
     let total = 0;
-    for (;;) {
-        const { done, value } = await reader.read();
-        if (done)
-            break;
-        total += value.byteLength;
-        if (total > maxBytes) {
-            // Cancel the underlying body so the server connection can be released.
-            try {
-                await reader.cancel();
-            }
-            catch {
-                /* ignore */
+    try {
+        for await (const chunk of stream) {
+            const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+            total += buf.length;
+            if (total > maxBytes) {
+                res.destroy();
+                if ('destroy' in stream && typeof stream.destroy === 'function') {
+                    stream.destroy();
+                }
+                throw new Error('Response too large');
             }
-            throw new Error('Response too large');
+            chunks.push(buf);
         }
-        chunks.push(Buffer.from(value));
+    }
+    catch (err) {
+        if (err instanceof Error && err.message === 'Response too large')
+            throw err;
+        res.destroy();
+        if ('destroy' in stream && typeof stream.destroy === 'function') {
+            stream.destroy();
+        }
+        throw err;
     }
     return Buffer.concat(chunks);
 }
+async function releaseIncomingMessage(res) {
+    await drainIncomingMessage(res);
+}
+function headerValue(headers, name) {
+    const raw = headers[name.toLowerCase()];
+    if (raw === undefined)
+        return null;
+    return Array.isArray(raw) ? (raw[0] ?? null) : raw;
+}
 /**
  * Parse an RFC 2397 data URL into `{ mediaType, base64 }`. Accepts MIME
  * parameters (`data:audio/wav;charset=binary;base64,...`) and the bare
@@ -297,35 +562,33 @@ export function parseBase64DataUrl(source) {
 export async function fetchHttpResource(urlString, opts) {
     let current = urlString;
     for (let hop = 0; hop <= opts.maxRedirects; hop++) {
-        const validated = await assertUrlSafeForFetch(current);
+        const { url: validated, addresses } = await validateUrlAndResolveAddresses(current);
         const target = validated.href;
-        const controller = new AbortController();
-        const t = setTimeout(() => controller.abort(), opts.timeoutMs);
         let res;
         try {
-            res = await fetch(target, {
-                redirect: 'manual',
-                signal: controller.signal,
-                headers: {
-                    'User-Agent': FETCH_USER_AGENT,
-                    Accept: 'image/*, audio/*, video/*, */*;q=0.8',
-                },
-            });
+            res = await pinnedRequestWithFallback(validated, addresses, opts.timeoutMs);
         }
-        finally {
-            clearTimeout(t);
+        catch (err) {
+            if (err instanceof Error && err.message === 'Fetch timed out') {
+                throw new Error('Fetch timed out');
+            }
+            throw err;
         }
-        if (res.status >= 300 && res.status < 400) {
-            const loc = res.headers.get('location');
+        const statusCode = res.statusCode ?? 0;
+        if (statusCode >= 300 && statusCode < 400) {
+            const loc = headerValue(res.headers, 'location');
+            await releaseIncomingMessage(res);
             if (!loc)
                 throw new Error('Redirect without Location header');
             current = new URL(loc, target).href;
             continue;
         }
-        if (!res.ok)
-            throw new Error(`HTTP ${res.status}`);
-        const buffer = await readResponseBodyWithLimit(res, opts.maxBytes);
-        return { buffer, contentType: res.headers.get('content-type') };
+        if (statusCode < 200 || statusCode >= 300) {
+            await releaseIncomingMessage(res);
+            throw new Error(`HTTP ${statusCode}`);
+        }
+        const buffer = await readIncomingMessageWithLimit(res, opts.maxBytes);
+        return { buffer, contentType: headerValue(res.headers, 'content-type') };
     }
     throw new Error('Too many redirects');
 }

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

@@ -1,4 +1,5 @@
 import OpenAI from 'openai';
+export { detectAudioFormat } from './audio-utils.js';
 export interface GenerateAudioToolRequest {
     prompt: string;
     model?: string;
@@ -8,60 +9,14 @@ export interface GenerateAudioToolRequest {
 }
 /** 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 `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, sampleRate?: number): Buffer;
-/** Strip existing extension (if any) and append a new one. */
-export declare function replaceExtension(filePath: string, newExt: string): string;
+/** Decode each streamed base64 fragment and concatenate binary (joining strings corrupts padding). */
+export declare function assembleBase64AudioChunks(chunks: string[]): Buffer;
 export declare function handleGenerateAudio(request: {
     params: {
         arguments: GenerateAudioToolRequest;
     };
-}, openai: OpenAI): Promise<import("../errors.js").ToolErrorResult | {
-    content: ({
-        type: "text";
-        text: string;
-        mimeType?: undefined;
-        data?: undefined;
-    } | {
-        type: "audio";
-        mimeType: string;
-        data: string;
-        text?: undefined;
-    })[];
-    _meta: {
-        server_version: string;
-        save_path: string;
-        mime: string;
-        size_bytes: number;
-    };
-} | {
-    content: ({
-        type: "text";
-        text: string;
-        mimeType?: undefined;
-        data?: undefined;
-    } | {
-        type: "audio";
-        mimeType: string;
-        data: string;
-        text?: undefined;
-    })[];
-    _meta: {
-        server_version: string;
-        mime: string;
-        size_bytes: number;
-        save_path?: undefined;
-    };
+}, openai: OpenAI): Promise<{
+    content: import("./tool-result-payload.js").BinaryToolContent[];
+    _meta: Record<string, unknown>;
 }>;