@mindstone/mcp-server-elevenlabs 0.2.2 → 0.4.0

package/dist/tools/alignment.js

@@ -0,0 +1,55 @@
+import { z } from 'zod';
+import { getApiKey } from '../auth.js';
+import { elevenLabsJson } from '../client.js';
+import { ENDPOINTS } from '../endpoints.js';
+import { ElevenLabsError } from '../types.js';
+import { wrapUntrusted } from '../untrusted-content.js';
+import { withErrorHandling } from '../utils.js';
+import { readSandboxedFile, sandboxedFileToBlob } from './file-input.js';
+export function registerAlignmentTools(server) {
+    server.registerTool('forced_alignment', {
+        description: `Align a transcript to audio and return per-word timestamps.
+
+WHEN TO USE:
+- Build karaoke-style captions or precise edit markers from audio + transcript
+- Verify that spoken words match a provided script
+
+EXAMPLE: {"file_path": "/path/to/clip.mp3", "text": "Hello world."}
+
+RELATED TOOLS:
+- transcribe_audio: generate transcript text from audio alone
+- generate_speech: create audio from text (inverse workflow)
+
+RETURNS: words[] with enveloped aligned text and start/end times, plus loss score. Input transcript text is caller-supplied and not echoed raw.
+
+COST: Credits based on audio duration.`,
+        inputSchema: z.object({
+            file_path: z.string().min(1).describe('Absolute path to local audio inside MCP_WORKSPACE_PATH (or os.tmpdir()).'),
+            text: z.string().min(1).describe('Transcript text to align against the audio.'),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        const fileInput = readSandboxedFile(args.file_path);
+        const formData = new FormData();
+        formData.append('file', sandboxedFileToBlob(fileInput), fileInput.fileName);
+        formData.append('text', args.text);
+        const data = await elevenLabsJson(apiKey, ENDPOINTS.FORCED_ALIGNMENT, { method: 'POST', body: formData });
+        const words = (data.words ?? []).map((w) => ({
+            text: wrapUntrusted(w.text, 'elevenlabs:forced_alignment:word_text'),
+            start: w.start,
+            end: w.end,
+        }));
+        return JSON.stringify({
+            ok: true,
+            words,
+            word_count: words.length,
+            loss: data.loss,
+            message: `Aligned ${words.length} word${words.length === 1 ? '' : 's'} to audio.`,
+        });
+    }));
+}
+//# sourceMappingURL=alignment.js.map

package/dist/tools/audio-isolation.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerAudioIsolationTools(server: McpServer): void;
+//# sourceMappingURL=audio-isolation.d.ts.map

package/dist/tools/audio-isolation.js

@@ -0,0 +1,51 @@
+import { z } from 'zod';
+import { getApiKey } from '../auth.js';
+import { elevenLabsAudio } from '../client.js';
+import { ENDPOINTS } from '../endpoints.js';
+import { ElevenLabsError } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+import { readSandboxedFile, sandboxedFileToBlob } from './file-input.js';
+export function registerAudioIsolationTools(server) {
+    server.registerTool('isolate_audio', {
+        description: `Remove background noise from an audio file (audio isolation).
+
+WHEN TO USE:
+- Clean up meeting recordings or voice memos with background noise
+- Prepare a cleaner clip before transcription or voice cloning
+- Source audio is at least ~4.6 seconds long (shorter clips fail upstream)
+
+COMMON MISTAKES:
+- Clips under ~4.6 seconds — the API rejects them; trim/merge or pick a longer sample first
+
+EXAMPLE: {"audio_path": "/path/to/noisy.mp3"}
+
+RELATED TOOLS:
+- transcribe_audio: transcribe the isolated clip
+- speech_to_speech: apply a different voice after isolation
+- clone_voice: clone from a cleaner sample
+
+RETURNS: file_path and size_bytes for the isolated audio (saved under os.tmpdir()).
+
+COST: Credits based on audio duration.`,
+        inputSchema: z.object({
+            audio_path: z.string().min(1).describe('Absolute path to local audio inside MCP_WORKSPACE_PATH (or os.tmpdir()).'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        const fileInput = readSandboxedFile(args.audio_path);
+        const formData = new FormData();
+        formData.append('audio', sandboxedFileToBlob(fileInput), fileInput.fileName);
+        const result = await elevenLabsAudio(apiKey, ENDPOINTS.AUDIO_ISOLATION, { method: 'POST', body: formData }, 'mp3');
+        return JSON.stringify({
+            ok: true,
+            file_path: result.filePath,
+            size_bytes: result.sizeBytes,
+            message: `Isolated audio saved to ${result.filePath} (${(result.sizeBytes / 1024).toFixed(1)} KB).`,
+        });
+    }));
+}
+//# sourceMappingURL=audio-isolation.js.map

package/dist/tools/configure.js

@@ -3,11 +3,23 @@ import { setApiKey } from '../auth.js';
 import { bridgeRequest, BRIDGE_STATE_PATH } from '../bridge.js';
 import { ElevenLabsError } from '../types.js';
 import { withErrorHandling } from '../utils.js';
+const CONFIGURED_MESSAGE = 'ElevenLabs API key configured successfully. Feature-specific permissions are checked on first use; call check_subscription to verify the account and credits now.';
 export function registerConfigureTools(server) {
     server.registerTool('configure_elevenlabs_api_key', {
-        description: 'Save your ElevenLabs API key. Call this when the user provides their key. ' +
-            'WHERE TO GET A KEY: Go to https://elevenlabs.io/app/settings/api-keys → Create new API key → Copy the key (starts with "sk_"). ' +
-            'FREE TIER: 10,000 characters/month for TTS. Music generation requires a paid plan.',
+        description: `Save the user's ElevenLabs API key for this session.
+
+WHEN TO USE:
+- When the user provides their API key in chat
+- After AUTH_REQUIRED errors from any other tool
+
+EXAMPLE: {"api_key": "sk_..."}
+
+RELATED TOOLS:
+- check_subscription: verify the key and see credits after configuring
+
+RETURNS: ok, message.
+
+COST: FREE.`,
         inputSchema: z.object({
             api_key: z.string().min(1).describe('ElevenLabs API key (starts with "sk_").'),
         }),
@@ -21,8 +33,8 @@ export function registerConfigureTools(server) {
                 if (result.success) {
                     setApiKey(key);
                     const message = result.warning
-                        ? `ElevenLabs API key configured successfully. Note: ${result.warning}`
-                        : 'ElevenLabs API key configured successfully! You can now generate music, speech, sound effects, and more.';
+                        ? `${CONFIGURED_MESSAGE} Note: ${result.warning}`
+                        : (result.message ?? CONFIGURED_MESSAGE);
                     return JSON.stringify({ ok: true, message });
                 }
                 // Bridge returned failure — surface as error, do NOT fall through
@@ -39,7 +51,7 @@ export function registerConfigureTools(server) {
         setApiKey(key);
         return JSON.stringify({
             ok: true,
-            message: 'ElevenLabs API key configured successfully! You can now generate music, speech, sound effects, and more.',
+            message: CONFIGURED_MESSAGE,
         });
     }));
 }

package/dist/tools/dialogue.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDialogueTools(server: McpServer): void;
+//# sourceMappingURL=dialogue.d.ts.map

package/dist/tools/dialogue.js

@@ -0,0 +1,70 @@
+import { z } from 'zod';
+import { getApiKey } from '../auth.js';
+import { elevenLabsAudio } from '../client.js';
+import { ENDPOINTS } from '../endpoints.js';
+import { ElevenLabsError, LONG_REQUEST_TIMEOUT_MS } from '../types.js';
+import { withErrorHandling } from '../utils.js';
+const dialogueInputSchema = z.object({
+    text: z.string().min(1).describe('Line of dialogue to speak.'),
+    voice_id: z.string().min(1).describe('Voice ID for this line (from list_voices).'),
+});
+export function registerDialogueTools(server) {
+    server.registerTool('text_to_dialogue', {
+        description: `Generate multi-voice dialogue audio from a script with one voice per line.
+
+WHEN TO USE:
+- Produce a conversation or script with different speakers
+- Podcast-style back-and-forth with distinct voices per line
+
+EXAMPLE: {"inputs": [{"text": "Hello there.", "voice_id": "21m00Tcm4TlvDq8ikWAM"}, {"text": "Hi!", "voice_id": "pNInz6obpgDQGcFmaJgB"}], "model_id": "eleven_v3"}
+
+RELATED TOOLS:
+- list_voices: pick voice_id values for each speaker
+- generate_speech: single-voice TTS when you only need one narrator
+- check_subscription: confirm credits before long scripts
+
+RETURNS: file_path and size_bytes for the combined dialogue audio (tmp file).
+
+COST: ~1 credit per 100 characters across all lines.`,
+        inputSchema: z.object({
+            inputs: z.array(dialogueInputSchema).min(1).describe('Ordered dialogue lines, each with text and voice_id.'),
+            model_id: z.enum([
+                'eleven_v3',
+                'eleven_multilingual_v2',
+                'eleven_flash_v2_5',
+                'eleven_turbo_v2_5',
+            ]).optional().describe('TTS model. Default: eleven_v3.'),
+            language_code: z.string().optional().describe('ISO 639-1 language code (e.g. en, es). Optional hint for pronunciation.'),
+            seed: z.number().int().optional().describe('Optional seed for reproducible generation.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        const modelId = args.model_id ?? 'eleven_v3';
+        const body = {
+            inputs: args.inputs,
+            model_id: modelId,
+        };
+        if (args.language_code)
+            body.language_code = args.language_code;
+        if (args.seed != null)
+            body.seed = args.seed;
+        const audio = await elevenLabsAudio(apiKey, ENDPOINTS.TEXT_TO_DIALOGUE, {
+            method: 'POST',
+            body: JSON.stringify(body),
+            timeoutMs: LONG_REQUEST_TIMEOUT_MS,
+        });
+        return JSON.stringify({
+            ok: true,
+            file_path: audio.filePath,
+            size_bytes: audio.sizeBytes,
+            line_count: args.inputs.length,
+            model_id: modelId,
+            message: `Dialogue audio saved to ${audio.filePath} (${audio.sizeBytes} bytes, ${args.inputs.length} lines).`,
+        });
+    }));
+}
+//# sourceMappingURL=dialogue.js.map

package/dist/tools/dubbing.d.ts

@@ -0,0 +1,3 @@
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+export declare function registerDubbingTools(server: McpServer): void;
+//# sourceMappingURL=dubbing.d.ts.map

package/dist/tools/dubbing.js

@@ -0,0 +1,234 @@
+import { z } from 'zod';
+import { getApiKey } from '../auth.js';
+import { elevenLabsBinaryDownload, elevenLabsFetch, elevenLabsJson } from '../client.js';
+import { ENDPOINTS } from '../endpoints.js';
+import { ElevenLabsError, LONG_REQUEST_TIMEOUT_MS, } from '../types.js';
+import { wrapUntrusted } from '../untrusted-content.js';
+import { withErrorHandling } from '../utils.js';
+import { readSandboxedFile, sandboxedFileToBlob } from './file-input.js';
+const TERMINAL_DUBBING_STATUSES = new Set(['dubbed', 'failed', 'cancelled']);
+const TERMINAL_STATUS_PHRASE = 'dubbed, failed, or cancelled';
+function dubbingNextStep(status) {
+    if (status === 'dubbed') {
+        return 'Call download_dubbed_audio with dubbing_id and language_code.';
+    }
+    if (status === 'failed') {
+        return 'Inspect error_detail; fix source media or retry create_dubbing.';
+    }
+    if (status === 'cancelled') {
+        return 'Job was cancelled — do not poll further; submit a new create_dubbing if needed.';
+    }
+    return 'Poll get_dubbing again in ~10 seconds.';
+}
+function envelopDubbingStatusField(value, field) {
+    if (!value)
+        return undefined;
+    return wrapUntrusted(value, `elevenlabs:get_dubbing:${field}`);
+}
+export function registerDubbingTools(server) {
+    server.registerTool('create_dubbing', {
+        description: `Submit an async dubbing job (v1 API). You MUST poll get_dubbing until status is ${TERMINAL_STATUS_PHRASE}.
+
+WHEN TO USE:
+- Translate/dub existing audio or video into another language
+- Localize a short clip the user already has on disk
+
+EXAMPLE: {"file_path": "/path/in/workspace/clip.mp3", "target_lang": "es", "name": "rebel-live-test-dub"}
+
+RELATED TOOLS:
+- get_dubbing: poll job status (every ~10s; respect expected_duration_sec from this response)
+- download_dubbed_audio: fetch audio once status is dubbed
+- delete_dubbing: cleanup test jobs
+
+RETURNS: dubbing_id and expected_duration_sec. The job runs server-side — poll get_dubbing; do not assume instant completion.
+
+COST: Dubbing credits per minute of source media.`,
+        inputSchema: z.object({
+            target_lang: z.string().min(2).describe('Target language code (e.g. es, fr, de). Required.'),
+            file_path: z.string().optional().describe('Local audio/video file inside MCP_WORKSPACE_PATH (multipart field file).'),
+            source_url: z.string().url().optional().describe('Alternatively, a URL ElevenLabs fetches server-side (no local sandbox).'),
+            name: z.string().optional().describe('Optional job label (echoed by get_dubbing).'),
+            source_lang: z.string().optional().describe('Source language code when known (auto-detect when omitted).'),
+            num_speakers: z.number().int().min(1).optional().describe('Number of speakers when known.'),
+            watermark: z.boolean().optional().describe('Apply watermark when supported. Default: false.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        if (!args.file_path && !args.source_url) {
+            throw new ElevenLabsError('Provide either file_path (local sandboxed file) or source_url (ElevenLabs-side fetch).', 'INVALID_INPUT', 'Pass file_path for a clip in MCP_WORKSPACE_PATH, or source_url for a remote asset.');
+        }
+        if (args.file_path && args.source_url) {
+            throw new ElevenLabsError('Provide only one of file_path or source_url, not both.', 'INVALID_INPUT', 'Choose a local file_path OR a remote source_url.');
+        }
+        const formData = new FormData();
+        formData.append('target_lang', args.target_lang);
+        if (args.name)
+            formData.append('name', args.name);
+        if (args.source_lang)
+            formData.append('source_lang', args.source_lang);
+        if (args.num_speakers != null)
+            formData.append('num_speakers', String(args.num_speakers));
+        formData.append('watermark', String(args.watermark ?? false));
+        if (args.file_path) {
+            const fileInput = readSandboxedFile(args.file_path);
+            formData.append('file', sandboxedFileToBlob(fileInput), fileInput.fileName);
+        }
+        else if (args.source_url) {
+            formData.append('source_url', args.source_url);
+        }
+        let data;
+        try {
+            data = await elevenLabsJson(apiKey, ENDPOINTS.DUBBING, { method: 'POST', body: formData, timeoutMs: LONG_REQUEST_TIMEOUT_MS });
+        }
+        catch (error) {
+            if (error instanceof ElevenLabsError && error.code === 'TIMEOUT') {
+                throw new ElevenLabsError(error.message, 'TIMEOUT', 'The submit may have timed out after uploading, but the job might still be processing. Call get_dubbing with the dubbing_id if you have one, or check recent jobs in the ElevenLabs dashboard before resubmitting to avoid duplicate jobs.');
+            }
+            throw error;
+        }
+        const expectedSec = data.expected_duration_sec;
+        return JSON.stringify({
+            ok: true,
+            dubbing_id: data.dubbing_id,
+            expected_duration_sec: expectedSec,
+            target_lang: args.target_lang,
+            message: `Dubbing job ${data.dubbing_id} submitted. You MUST poll get_dubbing every ~10 seconds until status is ${TERMINAL_STATUS_PHRASE}${expectedSec != null ? ` (expected ~${expectedSec}s)` : ''}.`,
+            poll_hint: `Call get_dubbing with this dubbing_id until status is ${TERMINAL_STATUS_PHRASE}; when dubbed, call download_dubbed_audio.`,
+        });
+    }));
+    server.registerTool('get_dubbing', {
+        description: `Poll dubbing job status. Call repeatedly after create_dubbing until status is ${TERMINAL_STATUS_PHRASE}.
+
+WHEN TO USE:
+- After create_dubbing — poll every ~10s (respect expected_duration_sec)
+- Check whether a dub failed before retrying
+
+EXAMPLE: {"dubbing_id": "dub_abc123"}
+
+RELATED TOOLS:
+- create_dubbing: submit the job
+- download_dubbed_audio: fetch audio when status is dubbed
+- delete_dubbing: remove test jobs
+
+RETURNS: status (verbatim, incl. failed), enveloped name and error detail when present.
+
+COST: FREE — status read only.`,
+        inputSchema: z.object({
+            dubbing_id: z.string().min(1).describe('Dubbing job ID from create_dubbing.'),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        let data;
+        try {
+            data = await elevenLabsJson(apiKey, ENDPOINTS.dubbing(args.dubbing_id));
+        }
+        catch (error) {
+            if (error instanceof ElevenLabsError && error.code === 'HTTP_404') {
+                throw new ElevenLabsError(`Dubbing job not found: ${args.dubbing_id}`, 'DUBBING_NOT_FOUND', 'Verify the dubbing_id from create_dubbing or list recent jobs in the ElevenLabs dashboard.');
+            }
+            throw error;
+        }
+        const status = data.status;
+        const errorDetail = data.error_message ?? data.error;
+        const isTerminal = TERMINAL_DUBBING_STATUSES.has(status);
+        return JSON.stringify({
+            ok: true,
+            dubbing_id: data.dubbing_id ?? args.dubbing_id,
+            status,
+            name: envelopDubbingStatusField(data.name, 'name'),
+            target_languages: data.target_languages,
+            error_detail: envelopDubbingStatusField(errorDetail, 'error_detail'),
+            is_terminal: isTerminal,
+            message: isTerminal
+                ? `Dubbing ${args.dubbing_id} reached terminal status: ${status}.`
+                : `Dubbing ${args.dubbing_id} status: ${status}. Keep polling get_dubbing until ${TERMINAL_STATUS_PHRASE}.`,
+            next_step: dubbingNextStep(status),
+        });
+    }));
+    server.registerTool('download_dubbed_audio', {
+        description: `Download dubbed audio for a completed dubbing job.
+
+WHEN TO USE:
+- After get_dubbing reports status dubbed
+- Fetch the localized track for a target language
+
+EXAMPLE: {"dubbing_id": "dub_abc123", "language_code": "es"}
+
+RELATED TOOLS:
+- get_dubbing: confirm status is dubbed before downloading
+- delete_dubbing: cleanup after testing
+
+RETURNS: file_path and size_bytes (extension sniffed from Content-Type).
+
+COST: FREE — download only (generation credits charged at submit).`,
+        inputSchema: z.object({
+            dubbing_id: z.string().min(1).describe('Dubbing job ID.'),
+            language_code: z.string().min(2).describe('Target language code used when creating the dub (e.g. es).'),
+        }),
+        annotations: { readOnlyHint: true, destructiveHint: false, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        const audio = await elevenLabsBinaryDownload(apiKey, ENDPOINTS.dubbingAudio(args.dubbing_id, args.language_code));
+        return JSON.stringify({
+            ok: true,
+            file_path: audio.filePath,
+            size_bytes: audio.sizeBytes,
+            dubbing_id: args.dubbing_id,
+            language_code: args.language_code,
+            message: `Dubbed audio saved to ${audio.filePath} (${audio.sizeBytes} bytes).`,
+        });
+    }));
+    server.registerTool('delete_dubbing', {
+        description: `Permanently delete a dubbing job and its outputs.
+
+WHEN TO USE:
+- Cleanup rebel-live-test-* dubbing jobs after live tests
+- Remove a failed or unwanted dub from the account
+
+EXAMPLE: {"dubbing_id": "dub_abc123"}
+
+RELATED TOOLS:
+- create_dubbing / get_dubbing / download_dubbed_audio: the dubbing lifecycle
+
+RETURNS: ok confirmation. Irreversible.
+
+COST: FREE — no generation; permanently removes the dubbing job.`,
+        inputSchema: z.object({
+            dubbing_id: z.string().min(1).describe('Dubbing job ID to delete.'),
+        }),
+        annotations: { readOnlyHint: false, destructiveHint: true, openWorldHint: true },
+    }, withErrorHandling(async (args) => {
+        const apiKey = getApiKey();
+        if (!apiKey) {
+            throw new ElevenLabsError('ElevenLabs API key not configured', 'AUTH_REQUIRED', 'Ask the user for their API key, then call configure_elevenlabs_api_key.');
+        }
+        try {
+            await elevenLabsFetch(apiKey, ENDPOINTS.dubbing(args.dubbing_id), {
+                method: 'DELETE',
+            });
+        }
+        catch (error) {
+            if (error instanceof ElevenLabsError && error.code === 'HTTP_404') {
+                throw new ElevenLabsError(`Dubbing job not found: ${args.dubbing_id}`, 'DUBBING_NOT_FOUND', 'The job may already be deleted.');
+            }
+            throw error;
+        }
+        return JSON.stringify({
+            ok: true,
+            dubbing_id: args.dubbing_id,
+            message: `Dubbing job ${args.dubbing_id} deleted permanently.`,
+        });
+    }));
+}
+//# sourceMappingURL=dubbing.js.map

package/dist/tools/file-input.d.ts

@@ -0,0 +1,28 @@
+export interface SandboxedFileInput {
+    buffer: Buffer;
+    fileName: string;
+    verifiedPath: string;
+}
+/**
+ * Read bytes from a local file path constrained to the MCP_WORKSPACE_PATH
+ * sandbox (or os.tmpdir() when unset).
+ *
+ * Security invariants (R1 — see planning doc Refactor Assessment):
+ * 1. Remote URL inputs bypass the sandbox → FILE_NOT_FOUND at existsSync.
+ * 2. Out-of-root lexical path → PATH_SANDBOX_VIOLATION before any disk read.
+ * 3. In-root-but-missing file → FILE_NOT_FOUND.
+ * 4. Symlink inside root pointing outside root → refused.
+ * 5. Last-moment realpathSync re-canonicalisation before read (TOCTOU).
+ *
+ * Callers own multipart field naming (`file` vs `audio`); this helper
+ * returns `{ buffer, fileName, verifiedPath }` only.
+ */
+export declare function readSandboxedFile(rawFilePath: string): SandboxedFileInput;
+/**
+ * Resolve a MIME type from a file name extension for multipart uploads.
+ * Defaults to audio/mpeg when the extension is unknown (most uploads are audio).
+ */
+export declare function mimeTypeForFileName(fileName: string): string;
+/** Build a typed Blob from sandboxed file bytes for FormData multipart parts. */
+export declare function sandboxedFileToBlob({ buffer, fileName }: SandboxedFileInput): Blob;
+//# sourceMappingURL=file-input.d.ts.map

package/dist/tools/file-input.js

@@ -0,0 +1,77 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { ElevenLabsError } from '../types.js';
+import { getAudioWorkspaceRoot, isInsideAudioWorkspaceRoot, isRemoteUrl, resolveAudioPath } from './path-safety.js';
+const FILE_INPUT_RESOLUTION = 'Provide a path to an existing audio file inside MCP_WORKSPACE_PATH (or os.tmpdir() when unset). Remote URLs are not supported.';
+/**
+ * Read bytes from a local file path constrained to the MCP_WORKSPACE_PATH
+ * sandbox (or os.tmpdir() when unset).
+ *
+ * Security invariants (R1 — see planning doc Refactor Assessment):
+ * 1. Remote URL inputs bypass the sandbox → FILE_NOT_FOUND at existsSync.
+ * 2. Out-of-root lexical path → PATH_SANDBOX_VIOLATION before any disk read.
+ * 3. In-root-but-missing file → FILE_NOT_FOUND.
+ * 4. Symlink inside root pointing outside root → refused.
+ * 5. Last-moment realpathSync re-canonicalisation before read (TOCTOU).
+ *
+ * Callers own multipart field naming (`file` vs `audio`); this helper
+ * returns `{ buffer, fileName, verifiedPath }` only.
+ */
+export function readSandboxedFile(rawFilePath) {
+    let filePath;
+    if (isRemoteUrl(rawFilePath)) {
+        // Preserve pre-existing behaviour for URL inputs: existsSync below
+        // returns FILE_NOT_FOUND (non-sandbox error code).
+        filePath = rawFilePath;
+    }
+    else {
+        const resolution = resolveAudioPath(rawFilePath);
+        if (!resolution.ok) {
+            const code = resolution.error.startsWith('File not found')
+                ? 'FILE_NOT_FOUND'
+                : 'PATH_SANDBOX_VIOLATION';
+            throw new ElevenLabsError(resolution.error, code, FILE_INPUT_RESOLUTION);
+        }
+        filePath = resolution.path;
+    }
+    if (!fs.existsSync(filePath)) {
+        throw new ElevenLabsError(`File not found: ${rawFilePath}`, 'FILE_NOT_FOUND', 'Provide an absolute path to an existing audio file.');
+    }
+    // Defence-in-depth: re-canonicalise via realpathSync at the very last moment
+    // to close the TOCTOU window between sandbox validation and readFileSync.
+    const verifiedPath = isRemoteUrl(rawFilePath) ? filePath : fs.realpathSync(filePath);
+    if (!isRemoteUrl(rawFilePath)) {
+        const root = getAudioWorkspaceRoot();
+        if (!isInsideAudioWorkspaceRoot(verifiedPath, root)) {
+            throw new ElevenLabsError(`file_path resolves outside the workspace sandbox root (${root}); ` +
+                `symlinks may not escape the workspace. Got: ${rawFilePath}`, 'PATH_SANDBOX_VIOLATION', FILE_INPUT_RESOLUTION);
+        }
+    }
+    const buffer = fs.readFileSync(verifiedPath);
+    const fileName = path.basename(verifiedPath);
+    return { buffer, fileName, verifiedPath };
+}
+/** Extension → MIME for multipart uploads (ElevenLabs rejects application/octet-stream). */
+const EXTENSION_TO_MIME = {
+    mp3: 'audio/mpeg',
+    wav: 'audio/wav',
+    m4a: 'audio/mp4',
+    ogg: 'audio/ogg',
+    flac: 'audio/flac',
+    webm: 'video/webm',
+    mp4: 'video/mp4',
+    mov: 'video/quicktime',
+};
+/**
+ * Resolve a MIME type from a file name extension for multipart uploads.
+ * Defaults to audio/mpeg when the extension is unknown (most uploads are audio).
+ */
+export function mimeTypeForFileName(fileName) {
+    const ext = path.extname(fileName).slice(1).toLowerCase();
+    return EXTENSION_TO_MIME[ext] ?? 'audio/mpeg';
+}
+/** Build a typed Blob from sandboxed file bytes for FormData multipart parts. */
+export function sandboxedFileToBlob({ buffer, fileName }) {
+    return new Blob([new Uint8Array(buffer)], { type: mimeTypeForFileName(fileName) });
+}
+//# sourceMappingURL=file-input.js.map

package/dist/tools/index.d.ts

@@ -1,6 +1,14 @@
 export { registerConfigureTools } from './configure.js';
+export { registerAccountTools } from './account.js';
 export { registerMusicTools } from './music.js';
 export { registerSpeechTools } from './speech.js';
 export { registerVoiceTools } from './voices.js';
 export { registerTranscriptionTools } from './transcription.js';
+export { registerVoiceChangerTools } from './voice-changer.js';
+export { registerAudioIsolationTools } from './audio-isolation.js';
+export { registerAlignmentTools } from './alignment.js';
+export { registerVoiceCloneTools } from './voice-clone.js';
+export { registerDialogueTools } from './dialogue.js';
+export { registerVoiceDesignTools } from './voice-design.js';
+export { registerDubbingTools } from './dubbing.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/tools/index.js

@@ -1,6 +1,14 @@
 export { registerConfigureTools } from './configure.js';
+export { registerAccountTools } from './account.js';
 export { registerMusicTools } from './music.js';
 export { registerSpeechTools } from './speech.js';
 export { registerVoiceTools } from './voices.js';
 export { registerTranscriptionTools } from './transcription.js';
+export { registerVoiceChangerTools } from './voice-changer.js';
+export { registerAudioIsolationTools } from './audio-isolation.js';
+export { registerAlignmentTools } from './alignment.js';
+export { registerVoiceCloneTools } from './voice-clone.js';
+export { registerDialogueTools } from './dialogue.js';
+export { registerVoiceDesignTools } from './voice-design.js';
+export { registerDubbingTools } from './dubbing.js';
 //# sourceMappingURL=index.js.map