@stabgan/openrouter-mcp-multimodal 4.6.2 → 4.8.0

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

@@ -1,15 +1,19 @@
-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';
 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, 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;
@@ -33,57 +37,16 @@ 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]);
 }
-/** Strip existing extension (if any) and append a new one. */
-export function replaceExtension(filePath, newExt) {
-    const current = extname(filePath);
-    const base = current ? filePath.slice(0, -current.length) : filePath;
-    return `${base}.${newExt}`;
+/** 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 ?? {
@@ -92,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',
     });
@@ -134,55 +100,43 @@ 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';
         }
-        const returnBase64 = audioBuffer.toString('base64');
         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})`
                 : '';
             const result = transcript
                 ? `Audio saved to: ${actualSavePath}${formatNote}\nTranscript: ${transcript}`
                 : `Audio saved to: ${actualSavePath}${formatNote}`;
-            return {
-                content: [
-                    { type: 'text', text: result },
-                    { type: 'audio', mimeType: detected.mimeType, data: returnBase64 },
-                ],
-                _meta: {
+            return buildBinaryToolResult({ kind: 'audio', buffer: audioBuffer, mimeType: detected.mimeType }, {
+                savedPath: actualSavePath,
+                summaryText: result,
+                meta: {
                     server_version: SERVER_VERSION,
-                    save_path: actualSavePath,
-                    mime: detected.mimeType,
-                    size_bytes: audioBuffer.length,
                 },
-            };
+            });
         }
-        return {
-            content: [
-                { type: 'text', text: transcript || 'Audio generated successfully.' },
-                { type: 'audio', mimeType: detected.mimeType, data: returnBase64 },
-            ],
-            _meta: {
+        return buildBinaryToolResult({ kind: 'audio', buffer: audioBuffer, mimeType: detected.mimeType }, {
+            prefixText: transcript || 'Audio generated successfully.',
+            meta: {
                 server_version: SERVER_VERSION,
-                mime: detected.mimeType,
-                size_bytes: audioBuffer.length,
             },
-        };
+        });
     }
     catch (err) {
         return classifyUpstreamError(err, 'generate_audio (stream)');

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

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

package/dist/tool-handlers/generate-image-dedicated.js

@@ -1,16 +1,20 @@
-/** Dedicated POST /api/v1/images — distinct from chat-completions `generate_image`. */
-import { promises as fs } from 'node:fs';
+import { IMAGE_ASPECT_RATIOS, IMAGE_DEDICATED_QUALITIES, IMAGE_DEDICATED_RESOLUTIONS, IMAGE_OUTPUT_FORMATS, } from '../tool-definitions.js';
 import { resolveOptionalOutputPath, isToolErrorResult, UnsafeOutputPathError, } from './path-safety.js';
 import { toOpenRouterImageReference } from './image-source.js';
 import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 import { SERVER_VERSION } from '../version.js';
 import { logger } from '../logger.js';
 import { classifyUpstreamError } from './openrouter-errors.js';
-import { buildCacheHeaders } from './cache.js';
+import { buildBinaryToolResult } from './tool-result-payload.js';
+import { fetchHttpResource, readEnvInt } from './fetch-utils.js';
+import { buildCacheHeaders, validateCacheOptions } from './cache.js';
+import { writeOutputFile } from './path-utils.js';
 const DEFAULT_MODEL = 'google/gemini-2.5-flash-image';
-const VALID_RESOLUTIONS = new Set(['512', '0.5K', '1K', '2K', '4K']);
-const VALID_QUALITIES = new Set(['auto', 'low', 'medium', 'high']);
-const VALID_OUTPUT_FORMATS = new Set(['png', 'jpeg', 'webp', 'svg']);
+const MAX_IMAGES = 10;
+const VALID_ASPECT_RATIOS = new Set(IMAGE_ASPECT_RATIOS);
+const VALID_RESOLUTIONS = new Set(IMAGE_DEDICATED_RESOLUTIONS);
+const VALID_QUALITIES = new Set(IMAGE_DEDICATED_QUALITIES);
+const VALID_OUTPUT_FORMATS = new Set(IMAGE_OUTPUT_FORMATS);
 const MIME_BY_FORMAT = {
     png: 'image/png',
     webp: 'image/webp',
@@ -33,6 +37,9 @@ export async function handleGenerateImageDedicated(request, apiClient) {
         input_references_count: input_references?.length ?? 0,
         save_path: save_path ? 'provided' : 'none',
     });
+    if (aspect_ratio && !VALID_ASPECT_RATIOS.has(aspect_ratio)) {
+        return toolError(ErrorCode.INVALID_INPUT, `aspect_ratio '${aspect_ratio}' is not supported. Valid: ${[...VALID_ASPECT_RATIOS].join(', ')}.`);
+    }
     if (resolution && !VALID_RESOLUTIONS.has(resolution)) {
         return toolError(ErrorCode.INVALID_INPUT, `resolution '${resolution}' is not supported. Valid: ${[...VALID_RESOLUTIONS].join(', ')}.`);
     }
@@ -42,6 +49,12 @@ export async function handleGenerateImageDedicated(request, apiClient) {
     if (output_format && !VALID_OUTPUT_FORMATS.has(output_format)) {
         return toolError(ErrorCode.INVALID_INPUT, `output_format '${output_format}' is not supported. Valid: ${[...VALID_OUTPUT_FORMATS].join(', ')}.`);
     }
+    if (typeof n === 'number' && (n < 1 || n > MAX_IMAGES)) {
+        return toolError(ErrorCode.INVALID_INPUT, `n must be between 1 and ${MAX_IMAGES} (inclusive).`);
+    }
+    const cacheError = validateCacheOptions({ cache, cache_ttl, cache_clear });
+    if (cacheError)
+        return cacheError;
     const savePathResult = await resolveOptionalOutputPath(save_path);
     if (isToolErrorResult(savePathResult))
         return savePathResult;
@@ -58,7 +71,7 @@ export async function handleGenerateImageDedicated(request, apiClient) {
         body.quality = quality;
     if (output_format)
         body.output_format = output_format;
-    if (typeof n === 'number' && n > 0)
+    if (typeof n === 'number')
         body.n = n;
     if (provider && typeof provider === 'object')
         body.provider = provider;
@@ -88,41 +101,79 @@ export async function handleGenerateImageDedicated(request, apiClient) {
         });
     }
     const firstImage = images[0];
-    const imageData = firstImage.b64_json;
     const mimeType = MIME_BY_FORMAT[output_format ?? ''] ?? 'image/png';
     const baseMeta = {
         server_version: SERVER_VERSION,
         model: model || DEFAULT_MODEL,
         images_count: images.length,
+        saved_image_index: 0,
     };
+    if (images.length > 1) {
+        baseMeta.images_note = 'Only images[0] is saved or inlined; request n=1 for a single image.';
+    }
     if (response.usage)
         baseMeta.usage = response.usage;
     if (firstImage.revised_prompt)
         baseMeta.revised_prompt = firstImage.revised_prompt;
-    if (safeSavePath && imageData) {
-        try {
-            await fs.writeFile(safeSavePath, imageData, { encoding: 'base64' });
+    const decoded = decodeImageBuffer(firstImage.b64_json);
+    if (safeSavePath) {
+        if (decoded) {
+            try {
+                await writeOutputFile(safeSavePath, decoded);
+            }
+            catch (err) {
+                return toolErrorFrom(ErrorCode.INTERNAL, err, 'Write');
+            }
+            return buildBinaryToolResult({ kind: 'image', buffer: decoded, mimeType }, {
+                savedPath: safeSavePath,
+                summaryText: `Image saved to: ${safeSavePath}`,
+                meta: baseMeta,
+            });
         }
-        catch (err) {
-            return toolErrorFrom(ErrorCode.INTERNAL, err, 'Write');
+        if (firstImage.url) {
+            try {
+                const maxBytes = readEnvInt('OPENROUTER_IMAGE_MAX_DOWNLOAD_BYTES', 20 * 1024 * 1024, 1024);
+                const { buffer: fetched, contentType } = await fetchHttpResource(firstImage.url, {
+                    maxBytes,
+                    maxRedirects: 3,
+                    timeoutMs: 30_000,
+                });
+                if (fetched.length === 0) {
+                    return toolError(ErrorCode.UPSTREAM_REFUSED, 'Downloaded image URL returned empty body.');
+                }
+                const resolvedMime = contentType?.split(';')[0]?.trim() || mimeType;
+                await writeOutputFile(safeSavePath, fetched);
+                return buildBinaryToolResult({ kind: 'image', buffer: fetched, mimeType: resolvedMime }, {
+                    savedPath: safeSavePath,
+                    summaryText: `Image saved to: ${safeSavePath}`,
+                    meta: { ...baseMeta, mime: resolvedMime, image_url: firstImage.url },
+                });
+            }
+            catch (err) {
+                return toolErrorFrom(ErrorCode.UPSTREAM_HTTP, err, 'Download image URL for save_path');
+            }
         }
-        baseMeta.save_path = safeSavePath;
-        return {
-            content: [
-                { type: 'text', text: `Image saved to: ${safeSavePath}` },
-                ...(imageData ? [{ type: 'image', mimeType, data: imageData }] : []),
-            ],
-            _meta: baseMeta,
-        };
+        return toolError(ErrorCode.UPSTREAM_REFUSED, 'Model returned no usable image data for save_path (empty b64_json and URL download unavailable).');
     }
-    if (imageData) {
+    if (decoded) {
+        return buildBinaryToolResult({ kind: 'image', buffer: decoded, mimeType }, { inlineOnly: true, meta: baseMeta });
+    }
+    if (firstImage.url) {
         return {
-            content: [{ type: 'image', mimeType, data: imageData }],
-            _meta: baseMeta,
+            content: [{ type: 'text', text: `Image generated. URL: ${firstImage.url}` }],
+            _meta: { ...baseMeta, image_url: firstImage.url },
         };
     }
-    return {
-        content: [{ type: 'text', text: `Image generated. URL: ${firstImage.url}` }],
-        _meta: { ...baseMeta, image_url: firstImage.url },
-    };
+    return toolError(ErrorCode.UPSTREAM_REFUSED, 'Model returned no usable image data.');
+}
+function decodeImageBuffer(b64) {
+    if (!b64)
+        return null;
+    try {
+        const buffer = Buffer.from(b64, 'base64');
+        return buffer.length > 0 ? buffer : null;
+    }
+    catch {
+        return null;
+    }
 }

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

@@ -13,50 +13,7 @@ export declare function handleGenerateImage(request: {
     params: {
         arguments: GenerateImageToolRequest;
     };
-}, openai: OpenAI): Promise<import("../errors.js").ToolErrorResult | {
-    content: ({
-        type: "text";
-        text: string;
-        mimeType?: undefined;
-        data?: undefined;
-    } | {
-        type: "image";
-        mimeType: string;
-        data: string;
-        text?: undefined;
-    })[];
-    _meta: {
-        usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
-        };
-        server_version: string;
-        save_path: string;
-        mime: string;
-    } | {
-        usage?: undefined;
-        server_version: string;
-        save_path: string;
-        mime: string;
-    };
-} | {
-    content: {
-        type: "image";
-        mimeType: string;
-        data: string;
-    }[];
-    _meta: {
-        usage: {
-            prompt_tokens: number;
-            completion_tokens: number;
-            total_tokens: number;
-        };
-        server_version: string;
-        mime: string;
-    } | {
-        usage?: undefined;
-        server_version: string;
-        mime: string;
-    };
+}, openai: OpenAI): Promise<{
+    content: import("./tool-result-payload.js").BinaryToolContent[];
+    _meta: Record<string, unknown>;
 }>;

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

@@ -1,4 +1,4 @@
-import { promises as fs } from 'node:fs';
+import { IMAGE_ASPECT_RATIOS } from '../tool-definitions.js';
 import { resolveOptionalOutputPath, isToolErrorResult, UnsafeOutputPathError, } from './path-safety.js';
 import { parseBase64DataUrl } from './fetch-utils.js';
 import { buildUserContent } from './generate-image-input.js';
@@ -7,23 +7,10 @@ import { ErrorCode, toolError, toolErrorFrom } from '../errors.js';
 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 { writeOutputFile } from './path-utils.js';
 const DEFAULT_MODEL = 'google/gemini-2.5-flash-image';
-const VALID_ASPECT_RATIOS = new Set([
-    '1:1',
-    '2:3',
-    '3:2',
-    '3:4',
-    '4:3',
-    '4:5',
-    '5:4',
-    '9:16',
-    '16:9',
-    '21:9',
-    '1:4',
-    '4:1',
-    '1:8',
-    '8:1',
-]);
+const VALID_ASPECT_RATIOS = new Set(IMAGE_ASPECT_RATIOS);
 const VALID_IMAGE_SIZES = new Set(['0.5K', '1K', '2K', '4K']);
 export async function handleGenerateImage(request, openai) {
     const { prompt, model, save_path, aspect_ratio, image_size, max_tokens, input_images, modalities, } = request.params.arguments ?? { prompt: '' };
@@ -44,6 +31,14 @@ export async function handleGenerateImage(request, openai) {
     if (image_size !== undefined && !VALID_IMAGE_SIZES.has(image_size)) {
         return invalidEnumError('image_size', image_size, VALID_IMAGE_SIZES);
     }
+    if (max_tokens !== undefined) {
+        if (typeof max_tokens !== 'number' ||
+            !Number.isFinite(max_tokens) ||
+            max_tokens <= 0 ||
+            !Number.isInteger(max_tokens)) {
+            return toolError(ErrorCode.INVALID_INPUT, 'max_tokens must be a positive integer.');
+        }
+    }
     const savePathResult = await resolveOptionalOutputPath(save_path);
     if (isToolErrorResult(savePathResult))
         return savePathResult;
@@ -70,7 +65,7 @@ export async function handleGenerateImage(request, openai) {
     };
     if (Object.keys(imageConfig).length > 0)
         body.image_config = imageConfig;
-    if (typeof max_tokens === 'number' && max_tokens > 0)
+    if (typeof max_tokens === 'number')
         body.max_tokens = max_tokens;
     let completion;
     try {
@@ -92,20 +87,24 @@ export async function handleGenerateImage(request, openai) {
             finish_reason: completion.choices[0]?.finish_reason,
         });
     }
+    const buffer = Buffer.from(base64.data, 'base64');
+    if (buffer.length === 0) {
+        return toolError(ErrorCode.UPSTREAM_REFUSED, 'Model returned an empty image payload.');
+    }
     if (safePathResolved) {
         try {
-            await fs.writeFile(safePathResolved, base64.data, { encoding: 'base64' });
+            await writeOutputFile(safePathResolved, buffer);
         }
         catch (err) {
             return toolErrorFrom(ErrorCode.INTERNAL, err, 'Write');
         }
     }
-    return buildImageSuccessResult(base64, completion.usage, safePathResolved ?? undefined);
+    return buildImageSuccessResult(base64, buffer, completion.usage, safePathResolved ?? undefined);
 }
 function invalidEnumError(field, value, allowed) {
     return toolError(ErrorCode.INVALID_INPUT, `${field} '${value}' is not supported. Valid values: ${[...allowed].join(', ')}.`);
 }
-function buildImageSuccessResult(base64, usage, savePath) {
+function buildImageSuccessResult(base64, buffer, usage, savePath) {
     const usageMeta = usage
         ? {
             usage: {
@@ -115,28 +114,12 @@ function buildImageSuccessResult(base64, usage, savePath) {
             },
         }
         : {};
-    if (savePath) {
-        return {
-            content: [
-                { type: 'text', text: `Image saved to: ${savePath}` },
-                { type: 'image', mimeType: base64.mime, data: base64.data },
-            ],
-            _meta: {
-                server_version: SERVER_VERSION,
-                save_path: savePath,
-                mime: base64.mime,
-                ...usageMeta,
-            },
-        };
-    }
-    return {
-        content: [{ type: 'image', mimeType: base64.mime, data: base64.data }],
-        _meta: {
-            server_version: SERVER_VERSION,
-            mime: base64.mime,
-            ...usageMeta,
-        },
-    };
+    return buildBinaryToolResult({ kind: 'image', buffer, mimeType: base64.mime }, {
+        savedPath: savePath ?? null,
+        inlineOnly: !savePath,
+        summaryText: savePath ? `Image saved to: ${savePath}` : undefined,
+        meta: { server_version: SERVER_VERSION, ...usageMeta },
+    });
 }
 function extractBase64(message) {
     const images = message.images;

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

@@ -17,7 +17,6 @@ export interface GenerateVideoToolRequest {
 export interface GetVideoStatusToolRequest {
     video_id: string;
     save_path?: string;
-    polling_url?: string;
 }
 type ProgressHook = (update: {
     status: string;
@@ -25,9 +24,10 @@ type ProgressHook = (update: {
     attempt: number;
     video_id: string;
 }) => void | Promise<void>;
+declare function isTerminalFailureStatus(status: string): boolean;
+declare function invokeProgressHook(hook: ProgressHook | undefined, update: Parameters<ProgressHook>[0]): Promise<void>;
 declare function buildRequestBody(args: GenerateVideoToolRequest, model: string): Record<string, unknown>;
 declare function extractJobError(status: VideoJobStatus): string;
-declare function stripAndReplaceExt(p: string, newExt: string): string;
 export declare function handleGenerateVideo(request: {
     params: {
         arguments: GenerateVideoToolRequest;
@@ -109,7 +109,8 @@ export declare function handleGenerateVideoFromImage(request: {
 }>;
 export declare const _internals: {
     buildRequestBody: typeof buildRequestBody;
-    stripAndReplaceExt: typeof stripAndReplaceExt;
     extractJobError: typeof extractJobError;
+    isTerminalFailureStatus: typeof isTerminalFailureStatus;
+    invokeProgressHook: typeof invokeProgressHook;
 };
 export {};