@stabgan/openrouter-mcp-multimodal 4.7.0 → 5.0.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)
@@ -73,7 +95,6 @@ function expandIPv6(ip) {
     if (!net.isIPv6(noBrackets))
         return null;
     let addr = noBrackets.toLowerCase();
-    let v4Tail = null;
     const dotIndex = addr.indexOf('.');
     if (dotIndex >= 0) {
         const lastColon = addr.lastIndexOf(':', dotIndex);
@@ -84,10 +105,9 @@ function expandIPv6(ip) {
         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];
-        const hex6 = v4Tail[0].toString(16);
-        const hex7 = v4Tail[1].toString(16);
-        addr = addr.slice(0, lastColon) + ':' + hex6 + ':' + hex7;
+        const v4Group6 = ((parts[0] << 8) | parts[1]) & 0xffff;
+        const v4Group7 = ((parts[2] << 8) | parts[3]) & 0xffff;
+        addr = addr.slice(0, lastColon) + ':' + v4Group6.toString(16) + ':' + v4Group7.toString(16);
     }
     const halves = addr.split('::');
     if (halves.length > 2)
@@ -179,10 +199,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 +285,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}`);
+        }
+    }
+    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)}`);
         }
     }
-    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;
+}
+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 +560,24 @@ 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',
-                },
-            });
-        }
-        finally {
-            clearTimeout(t);
-        }
-        if (res.status >= 300 && res.status < 400) {
-            const loc = res.headers.get('location');
+        const res = await pinnedRequestWithFallback(validated, addresses, opts.timeoutMs);
+        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,26 +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;
-export { replaceExtension } from './path-utils.js';
+/** 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 | {
+}, openai: OpenAI): Promise<{
     content: import("./tool-result-payload.js").BinaryToolContent[];
     _meta: Record<string, unknown>;
 }>;

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

@@ -1,5 +1,5 @@
-import { promises as fs } from 'node:fs';
 import { extname } from 'node:path';
+import { GENERATE_AUDIO_FORMATS } from '../tool-definitions.js';
 import { resolveOptionalOutputPath, isToolErrorResult } from './path-safety.js';
 import { asOpenAIChatBody } from './chat-request.js';
 import { ErrorCode, toolError } from '../errors.js';
@@ -7,11 +7,13 @@ import { SERVER_VERSION } from '../version.js';
 import { logger } from '../logger.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
 import { buildBinaryToolResult } from './tool-result-payload.js';
-import { replaceExtension } from './path-utils.js';
+import { replaceExtension, writeOutputFile } from './path-utils.js';
+import { detectAudioFormat } from './audio-utils.js';
+export { detectAudioFormat } from './audio-utils.js';
 const DEFAULT_MODEL = 'openai/gpt-audio';
 const DEFAULT_VOICE = 'alloy';
 const DEFAULT_FORMAT = 'pcm16';
-const VALID_FORMATS = ['wav', 'mp3', 'flac', 'opus', 'pcm16'];
+const VALID_FORMATS = GENERATE_AUDIO_FORMATS;
 const DEFAULT_PCM_SAMPLE_RATE = 24000;
 const PCM_BITS_PER_SAMPLE = 16;
 const PCM_NUM_CHANNELS = 1;
@@ -35,53 +37,17 @@ export function createWavHeader(dataLength, sampleRate = DEFAULT_PCM_SAMPLE_RATE
     header.writeUInt32LE(dataLength, 40);
     return header;
 }
-/**
- * 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 && 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.length >= 12) {
-        const riff = data.subarray(0, 4).toString('ascii');
-        const wave = data.subarray(8, 12).toString('ascii');
-        if (riff === 'RIFF' && wave === 'WAVE') {
-            return { ext: 'wav', mimeType: 'audio/wav' };
-        }
-    }
-    if (data.length >= 4) {
-        const magic = data.subarray(0, 4).toString('ascii');
-        if (magic === 'fLaC')
-            return { ext: 'flac', mimeType: 'audio/flac' };
-        if (magic === 'OggS')
-            return { ext: 'ogg', mimeType: 'audio/ogg' };
-    }
-    return { ext: 'pcm', mimeType: 'audio/pcm' };
-}
 export function wrapPcmInWav(pcmData, sampleRate = DEFAULT_PCM_SAMPLE_RATE) {
     return Buffer.concat([createWavHeader(pcmData.length, sampleRate), pcmData]);
 }
-export { replaceExtension } from './path-utils.js';
+/** Decode each streamed base64 fragment and concatenate binary (joining strings corrupts padding). */
+export function assembleBase64AudioChunks(chunks) {
+    if (chunks.length === 0)
+        return Buffer.alloc(0);
+    if (chunks.length === 1)
+        return Buffer.from(chunks[0], 'base64');
+    return Buffer.concat(chunks.map((chunk) => Buffer.from(chunk, 'base64')));
+}
 export async function handleGenerateAudio(request, openai) {
     const { prompt, model, voice, format, save_path } = request.params.arguments ?? {
         prompt: '',
@@ -89,10 +55,13 @@ export async function handleGenerateAudio(request, openai) {
     if (!prompt?.trim()) {
         return toolError(ErrorCode.INVALID_INPUT, 'prompt is required.');
     }
+    if (format && !VALID_FORMATS.includes(format)) {
+        return toolError(ErrorCode.INVALID_INPUT, `format '${format}' is not supported. Valid: ${VALID_FORMATS.join(', ')}.`);
+    }
     logger.audit('generate_audio.start', {
         model: model || DEFAULT_MODEL,
         voice: voice?.trim() || DEFAULT_VOICE,
-        format: VALID_FORMATS.includes(format ?? '') ? format : DEFAULT_FORMAT,
+        format: format || DEFAULT_FORMAT,
         prompt_preview: prompt.slice(0, 80),
         save_path: save_path ? 'provided' : 'none',
     });
@@ -131,24 +100,23 @@ export async function handleGenerateAudio(request, openai) {
                     transcriptChunks.push(a.transcript);
             }
         }
-        const fullAudioBase64 = audioChunks.join('');
         const transcript = transcriptChunks.join('');
-        if (!fullAudioBase64) {
+        if (audioChunks.length === 0) {
             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');
+        let audioBuffer = assembleBase64AudioChunks(audioChunks);
         const detected = detectAudioFormat(audioBuffer);
         if (detected.ext === 'pcm') {
-            audioBuffer = Buffer.from(wrapPcmInWav(audioBuffer));
+            audioBuffer = wrapPcmInWav(audioBuffer);
             detected.ext = 'wav';
             detected.mimeType = 'audio/wav';
         }
         if (safeBase) {
             const fileExt = extname(safeBase).toLowerCase().slice(1);
             const actualSavePath = fileExt === detected.ext ? safeBase : replaceExtension(safeBase, detected.ext);
-            await fs.writeFile(actualSavePath, audioBuffer);
+            await writeOutputFile(actualSavePath, audioBuffer);
             const formatNote = actualSavePath !== safeBase
                 ? ` (detected ${detected.ext.toUpperCase()}, saved as ${actualSavePath})`
                 : '';

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

@@ -16,7 +16,7 @@ export declare function handleGenerateImageDedicated(request: {
     params: {
         arguments: GenerateImageDedicatedRequest;
     };
-}, apiClient: OpenRouterAPIClient): Promise<import("../errors.js").ToolErrorResult | {
+}, apiClient: OpenRouterAPIClient): Promise<{
     content: import("./tool-result-payload.js").BinaryToolContent[];
     _meta: Record<string, unknown>;
 }>;