@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/voice/providers/elevenlabs.js

@@ -0,0 +1,333 @@
+import { asRecord, buildStatus, estimateConfidenceFromAvgLogprob, inferFilename, normalizeBaseUrl, readFirstEnv, resolveAudioInput, trimToUndefined, } from './shared.js';
+const DEFAULT_ELEVENLABS_STT_MODEL = 'scribe_v2';
+const DEFAULT_ELEVENLABS_REALTIME_MODEL = 'scribe_v2_realtime';
+const ELEVENLABS_SINGLE_USE_TOKEN_TTL_MS = 15 * 60 * 1000;
+function normalizeBooleanString(value) {
+    return typeof value === 'boolean' ? String(value) : undefined;
+}
+function asStringArray(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    const values = value
+        .filter((entry) => typeof entry === 'string' && entry.trim().length > 0)
+        .map((entry) => entry.trim());
+    return values.length > 0 ? values : undefined;
+}
+function parseElevenLabsTranscript(payload) {
+    const text = trimToUndefined(payload.text);
+    if (!text)
+        throw new Error('ElevenLabs transcription response missing transcript');
+    const segments = (payload.words ?? [])
+        .filter((word) => (word.type?.trim() || 'word') === 'word')
+        .map((word) => ({
+        text: word.text?.trim() ?? '',
+        startMs: typeof word.start === 'number' ? Math.round(word.start * 1000) : undefined,
+        endMs: typeof word.end === 'number' ? Math.round(word.end * 1000) : undefined,
+        confidence: estimateConfidenceFromAvgLogprob(word.logprob),
+    }))
+        .filter((segment) => segment.text.length > 0);
+    return {
+        text,
+        language: trimToUndefined(payload.language_code),
+        segments,
+    };
+}
+function buildElevenLabsRealtimeMetadata(params) {
+    return {
+        authMode: params.token ? 'single-use-token' : 'api-key',
+        ...(params.token ? { token: params.token } : {}),
+        expiresAt: params.expiresAt,
+        connect: {
+            websocket: {
+                url: params.websocketUrl,
+                ...(params.token ? {} : { headers: { 'xi-api-key': '<server-managed>' } }),
+            },
+        },
+        request: {
+            modelId: params.request.modelId,
+            voiceId: params.request.voiceId,
+            inputFormat: params.request.inputFormat,
+            outputFormat: params.request.outputFormat,
+            instructions: params.request.instructions,
+            metadata: params.metadata ?? {},
+        },
+    };
+}
+export function createElevenLabsProvider() {
+    const envVars = ['ELEVENLABS_API_KEY', 'XI_API_KEY'];
+    const baseUrlEnvVars = ['ELEVENLABS_BASE_URL', 'XI_API_BASE'];
+    return {
+        id: 'elevenlabs',
+        label: 'ElevenLabs',
+        capabilities: ['tts', 'stt', 'realtime', 'voice-list'],
+        status() {
+            const configured = readFirstEnv(envVars) !== null;
+            return buildStatus('elevenlabs', 'ElevenLabs', ['tts', 'stt', 'realtime', 'voice-list'], configured, configured
+                ? 'ElevenLabs speech, transcription, and realtime APIs are available.'
+                : 'Set ELEVENLABS_API_KEY or XI_API_KEY to enable ElevenLabs speech and transcription.', {
+                baseUrl: normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.elevenlabs.io'),
+                defaultSttModel: DEFAULT_ELEVENLABS_STT_MODEL,
+                defaultRealtimeModel: DEFAULT_ELEVENLABS_REALTIME_MODEL,
+            });
+        },
+        async listVoices() {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                return [];
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.elevenlabs.io');
+            const response = await fetch(`${baseUrl}/v1/voices`, {
+                headers: { 'xi-api-key': apiKey },
+            });
+            if (!response.ok)
+                throw new Error(`ElevenLabs voices failed: HTTP ${response.status}`);
+            const payload = await response.json();
+            return (payload.voices ?? [])
+                .map((voice) => ({
+                id: voice.voice_id?.trim() ?? '',
+                label: voice.name?.trim() || voice.voice_id?.trim() || 'Voice',
+                metadata: {
+                    category: voice.category?.trim(),
+                    description: voice.description?.trim(),
+                },
+            }))
+                .filter((voice) => voice.id.length > 0);
+        },
+        async synthesize(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('ElevenLabs API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.elevenlabs.io');
+            const voiceId = request.voiceId?.trim() || 'pMsXgVXv3BLzUgSXRplE';
+            const response = await fetch(`${baseUrl}/v1/text-to-speech/${voiceId}`, {
+                method: 'POST',
+                headers: {
+                    'xi-api-key': apiKey,
+                    'Content-Type': 'application/json',
+                    Accept: 'audio/mpeg',
+                },
+                body: JSON.stringify({
+                    text: request.text,
+                    model_id: request.modelId?.trim() || 'eleven_multilingual_v2',
+                    voice_settings: {
+                        stability: 0.5,
+                        similarity_boost: 0.75,
+                        style: 0,
+                        use_speaker_boost: true,
+                        speed: request.speed ?? 1,
+                    },
+                }),
+            });
+            if (!response.ok)
+                throw new Error(`ElevenLabs synthesis failed: HTTP ${response.status}`);
+            const mimeType = response.headers.get('content-type')?.trim() || 'audio/mpeg';
+            const dataBase64 = Buffer.from(await response.arrayBuffer()).toString('base64');
+            return {
+                providerId: 'elevenlabs',
+                audio: {
+                    mimeType,
+                    format: mimeType.includes('wav') ? 'wav' : 'mp3',
+                    dataBase64,
+                    metadata: { voiceId, baseUrl },
+                },
+                metadata: { voiceId, baseUrl },
+            };
+        },
+        async transcribe(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('ElevenLabs API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.elevenlabs.io');
+            const metadata = asRecord(request.metadata);
+            const url = new URL(`${baseUrl}/v1/speech-to-text`);
+            if (metadata?.['enableLogging'] === false) {
+                url.searchParams.set('enable_logging', 'false');
+            }
+            const form = new FormData();
+            form.append('model_id', request.modelId?.trim() || DEFAULT_ELEVENLABS_STT_MODEL);
+            if (request.language?.trim())
+                form.append('language_code', request.language.trim());
+            const uri = trimToUndefined(request.audio.uri);
+            const canUseSourceUrl = !request.audio.dataBase64 && uri && /^https?:\/\//i.test(uri);
+            if (canUseSourceUrl) {
+                form.append('source_url', uri);
+            }
+            else {
+                const { buffer, mimeType } = await resolveAudioInput(request.audio);
+                form.append('file', new Blob([Buffer.from(buffer)], { type: mimeType || 'application/octet-stream' }), inferFilename(request.audio, '.wav'));
+                form.append('file_format', request.audio.format === 'pcm16' ? 'pcm_s16le_16' : 'other');
+            }
+            if (metadata?.['tagAudioEvents'] !== undefined) {
+                const value = normalizeBooleanString(metadata['tagAudioEvents']);
+                if (value)
+                    form.append('tag_audio_events', value);
+            }
+            if (metadata?.['diarize'] !== undefined) {
+                const value = normalizeBooleanString(metadata['diarize']);
+                if (value)
+                    form.append('diarize', value);
+            }
+            if (typeof metadata?.['diarizationThreshold'] === 'number'
+                && Number.isFinite(metadata['diarizationThreshold'])) {
+                form.append('diarization_threshold', String(metadata['diarizationThreshold']));
+            }
+            if (typeof metadata?.['numSpeakers'] === 'number'
+                && Number.isFinite(metadata['numSpeakers'])) {
+                form.append('num_speakers', String(Math.round(metadata['numSpeakers'])));
+            }
+            if (typeof metadata?.['temperature'] === 'number'
+                && Number.isFinite(metadata['temperature'])) {
+                form.append('temperature', String(metadata['temperature']));
+            }
+            if (typeof metadata?.['seed'] === 'number' && Number.isFinite(metadata['seed'])) {
+                form.append('seed', String(Math.round(metadata['seed'])));
+            }
+            if (metadata?.['useMultiChannel'] !== undefined) {
+                const value = normalizeBooleanString(metadata['useMultiChannel']);
+                if (value)
+                    form.append('use_multi_channel', value);
+            }
+            if (metadata?.['noVerbatim'] !== undefined) {
+                const value = normalizeBooleanString(metadata['noVerbatim']);
+                if (value)
+                    form.append('no_verbatim', value);
+            }
+            const timestampsGranularity = trimToUndefined(metadata?.['timestampsGranularity']);
+            if (timestampsGranularity && ['none', 'word', 'character'].includes(timestampsGranularity)) {
+                form.append('timestamps_granularity', timestampsGranularity);
+            }
+            const keyterms = asStringArray(metadata?.['keyterms']);
+            for (const keyterm of keyterms ?? [])
+                form.append('keyterms', keyterm);
+            const entityDetection = metadata?.['entityDetection'];
+            if (typeof entityDetection === 'string' && entityDetection.trim()) {
+                form.append('entity_detection', entityDetection.trim());
+            }
+            else {
+                for (const entry of asStringArray(entityDetection) ?? []) {
+                    form.append('entity_detection', entry);
+                }
+            }
+            const entityRedaction = metadata?.['entityRedaction'];
+            if (typeof entityRedaction === 'string' && entityRedaction.trim()) {
+                form.append('entity_redaction', entityRedaction.trim());
+            }
+            else {
+                for (const entry of asStringArray(entityRedaction) ?? []) {
+                    form.append('entity_redaction', entry);
+                }
+            }
+            const entityRedactionMode = trimToUndefined(metadata?.['entityRedactionMode']);
+            if (entityRedactionMode)
+                form.append('entity_redaction_mode', entityRedactionMode);
+            if (metadata?.['webhookMetadata'] !== undefined) {
+                form.append('webhook_metadata', JSON.stringify(metadata['webhookMetadata']));
+            }
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'xi-api-key': apiKey,
+                },
+                body: form,
+            });
+            if (!response.ok)
+                throw new Error(`ElevenLabs transcription failed: HTTP ${response.status}`);
+            const payload = await response.json();
+            const parsed = parseElevenLabsTranscript(payload);
+            return {
+                providerId: 'elevenlabs',
+                text: parsed.text,
+                language: parsed.language || request.language,
+                segments: parsed.segments,
+                metadata: {
+                    baseUrl,
+                    modelId: request.modelId?.trim() || DEFAULT_ELEVENLABS_STT_MODEL,
+                    transcriptionId: trimToUndefined(payload.transcription_id),
+                    sourceMode: canUseSourceUrl ? 'source_url' : 'file',
+                },
+            };
+        },
+        async openRealtimeSession(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('ElevenLabs API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.elevenlabs.io');
+            const metadata = asRecord(request.metadata);
+            const model = request.modelId?.trim() || DEFAULT_ELEVENLABS_REALTIME_MODEL;
+            const websocketBase = baseUrl.replace(/^http/i, 'ws').replace(/\/+$/, '');
+            const websocketUrl = new URL(`${websocketBase}/v1/speech-to-text/realtime`);
+            websocketUrl.searchParams.set('model_id', model);
+            if (metadata?.['includeTimestamps'] !== undefined) {
+                const value = normalizeBooleanString(metadata['includeTimestamps']);
+                if (value)
+                    websocketUrl.searchParams.set('include_timestamps', value);
+            }
+            if (metadata?.['includeLanguageDetection'] !== undefined) {
+                const value = normalizeBooleanString(metadata['includeLanguageDetection']);
+                if (value)
+                    websocketUrl.searchParams.set('include_language_detection', value);
+            }
+            const audioFormat = trimToUndefined(metadata?.['audioFormat'])
+                || (request.inputFormat === 'pcm16' ? 'pcm_16000' : undefined);
+            if (audioFormat)
+                websocketUrl.searchParams.set('audio_format', audioFormat);
+            const languageCode = trimToUndefined(metadata?.['languageCode']);
+            if (languageCode)
+                websocketUrl.searchParams.set('language_code', languageCode);
+            const commitStrategy = trimToUndefined(metadata?.['commitStrategy']);
+            if (commitStrategy && ['manual', 'vad'].includes(commitStrategy)) {
+                websocketUrl.searchParams.set('commit_strategy', commitStrategy);
+            }
+            if (typeof metadata?.['vadSilenceThresholdSecs'] === 'number'
+                && Number.isFinite(metadata['vadSilenceThresholdSecs'])) {
+                websocketUrl.searchParams.set('vad_silence_threshold_secs', String(metadata['vadSilenceThresholdSecs']));
+            }
+            if (typeof metadata?.['vadThreshold'] === 'number'
+                && Number.isFinite(metadata['vadThreshold'])) {
+                websocketUrl.searchParams.set('vad_threshold', String(metadata['vadThreshold']));
+            }
+            if (typeof metadata?.['minSpeechDurationMs'] === 'number'
+                && Number.isFinite(metadata['minSpeechDurationMs'])) {
+                websocketUrl.searchParams.set('min_speech_duration_ms', String(Math.round(metadata['minSpeechDurationMs'])));
+            }
+            if (typeof metadata?.['minSilenceDurationMs'] === 'number'
+                && Number.isFinite(metadata['minSilenceDurationMs'])) {
+                websocketUrl.searchParams.set('min_silence_duration_ms', String(Math.round(metadata['minSilenceDurationMs'])));
+            }
+            if (metadata?.['enableLogging'] !== undefined) {
+                const value = normalizeBooleanString(metadata['enableLogging']);
+                if (value)
+                    websocketUrl.searchParams.set('enable_logging', value);
+            }
+            const tokenResponse = await fetch(`${baseUrl}/v1/single-use-token/realtime_scribe`, {
+                method: 'POST',
+                headers: {
+                    'xi-api-key': apiKey,
+                },
+            });
+            if (!tokenResponse.ok) {
+                throw new Error(`ElevenLabs realtime token failed: HTTP ${tokenResponse.status}`);
+            }
+            const tokenPayload = await tokenResponse.json();
+            const token = trimToUndefined(tokenPayload.token);
+            if (!token)
+                throw new Error('ElevenLabs realtime token response missing token');
+            websocketUrl.searchParams.set('token', token);
+            const expiresAt = Date.now() + ELEVENLABS_SINGLE_USE_TOKEN_TTL_MS;
+            return {
+                providerId: 'elevenlabs',
+                sessionId: `elevenlabs-realtime-${Date.now()}`,
+                transport: 'websocket',
+                url: websocketUrl.toString(),
+                expiresAt,
+                metadata: buildElevenLabsRealtimeMetadata({
+                    baseUrl,
+                    websocketUrl: websocketUrl.toString(),
+                    token,
+                    expiresAt,
+                    request,
+                    metadata,
+                }),
+            };
+        },
+    };
+}

package/dist/platform/voice/providers/google.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceProvider } from '../types.js';
+export declare function createGoogleProvider(): VoiceProvider;
+//# sourceMappingURL=google.d.ts.map

package/dist/platform/voice/providers/google.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"google.d.ts","sourceRoot":"","sources":["../../../../src/platform/voice/providers/google.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,aAAa,CAAC;AA4HjD,wBAAgB,oBAAoB,IAAI,aAAa,CAiGpD"}

package/dist/platform/voice/providers/google.js

@@ -0,0 +1,166 @@
+import { asRecord, buildStatus, inferFilename, normalizeBaseUrl, readFirstEnv, resolveAudioInput, trimToUndefined, } from './shared.js';
+const GEMINI_API_BASE_URL = 'https://generativelanguage.googleapis.com/v1beta';
+const DEFAULT_GOOGLE_STT_MODEL = 'gemini-2.5-flash';
+const GOOGLE_INLINE_AUDIO_LIMIT_BYTES = 20 * 1024 * 1024;
+function parseGoogleTranscript(payload) {
+    const text = (payload.candidates ?? [])
+        .flatMap((candidate) => candidate.content?.parts ?? [])
+        .map((part) => part.text?.trim() ?? '')
+        .filter((entry) => entry.length > 0)
+        .join('\n')
+        .trim();
+    if (!text) {
+        throw new Error('Google transcription response missing transcript');
+    }
+    return text;
+}
+function parseGoogleFileRecord(payload) {
+    const file = payload.file;
+    const name = trimToUndefined(file?.name);
+    const uri = trimToUndefined(file?.uri);
+    const mimeType = trimToUndefined(file?.mimeType) || trimToUndefined(file?.mime_type);
+    if (!name || !uri || !mimeType) {
+        throw new Error('Google file upload response missing file metadata');
+    }
+    return { name, uri, mimeType };
+}
+async function uploadGoogleFile(baseUrl, apiKey, buffer, mimeType, displayName) {
+    const uploadBaseUrl = baseUrl.replace(/\/v1beta$/, '');
+    const startResponse = await fetch(`${uploadBaseUrl}/upload/v1beta/files`, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json',
+            'x-goog-api-key': apiKey,
+            'X-Goog-Upload-Protocol': 'resumable',
+            'X-Goog-Upload-Command': 'start',
+            'X-Goog-Upload-Header-Content-Length': String(buffer.byteLength),
+            'X-Goog-Upload-Header-Content-Type': mimeType,
+        },
+        body: JSON.stringify({
+            file: {
+                display_name: displayName,
+            },
+        }),
+    });
+    if (!startResponse.ok) {
+        throw new Error(`Google file upload start failed: HTTP ${startResponse.status}`);
+    }
+    const uploadUrl = trimToUndefined(startResponse.headers.get('x-goog-upload-url'));
+    if (!uploadUrl) {
+        throw new Error('Google file upload start response missing upload URL');
+    }
+    const uploadResponse = await fetch(uploadUrl, {
+        method: 'POST',
+        headers: {
+            'Content-Length': String(buffer.byteLength),
+            'x-goog-api-key': apiKey,
+            'X-Goog-Upload-Offset': '0',
+            'X-Goog-Upload-Command': 'upload, finalize',
+        },
+        body: Buffer.from(buffer),
+    });
+    if (!uploadResponse.ok) {
+        throw new Error(`Google file upload finalize failed: HTTP ${uploadResponse.status}`);
+    }
+    return parseGoogleFileRecord(await uploadResponse.json());
+}
+async function deleteGoogleFile(baseUrl, apiKey, name) {
+    try {
+        await fetch(`${baseUrl}/${name}`, {
+            method: 'DELETE',
+            headers: {
+                'x-goog-api-key': apiKey,
+            },
+        });
+    }
+    catch {
+        // Best-effort cleanup only.
+    }
+}
+export function createGoogleProvider() {
+    const envVars = ['GEMINI_API_KEY', 'GOOGLE_API_KEY', 'GOOGLE_GEMINI_API_KEY'];
+    const baseUrlEnvVars = ['GEMINI_API_BASE_URL', 'GOOGLE_API_BASE_URL'];
+    return {
+        id: 'google',
+        label: 'Google',
+        capabilities: ['stt'],
+        status() {
+            const configured = readFirstEnv(envVars) !== null;
+            return buildStatus('google', 'Google', ['stt'], configured, configured
+                ? 'Google Gemini audio transcription is available.'
+                : 'Set GEMINI_API_KEY, GOOGLE_API_KEY, or GOOGLE_GEMINI_API_KEY to enable Google transcription.', {
+                baseUrl: normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), GEMINI_API_BASE_URL),
+                defaultModel: DEFAULT_GOOGLE_STT_MODEL,
+            });
+        },
+        async transcribe(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('Google API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), GEMINI_API_BASE_URL);
+            const { buffer, mimeType } = await resolveAudioInput(request.audio);
+            const model = request.modelId?.trim() || DEFAULT_GOOGLE_STT_MODEL;
+            const prompt = request.prompt?.trim() || 'Transcribe the provided audio. Return only the transcript.';
+            const metadata = asRecord(request.metadata);
+            const effectiveMimeType = mimeType || 'audio/wav';
+            const useFilesApi = metadata?.['preferFilesApi'] === true
+                || buffer.byteLength > GOOGLE_INLINE_AUDIO_LIMIT_BYTES;
+            let uploadedFile = null;
+            try {
+                if (useFilesApi) {
+                    uploadedFile = await uploadGoogleFile(baseUrl, apiKey, buffer, effectiveMimeType, inferFilename(request.audio, '.wav'));
+                }
+                const response = await fetch(`${baseUrl}/models/${encodeURIComponent(model)}:generateContent`, {
+                    method: 'POST',
+                    headers: {
+                        'Content-Type': 'application/json',
+                        'x-goog-api-key': apiKey,
+                    },
+                    body: JSON.stringify({
+                        contents: [{
+                                role: 'user',
+                                parts: uploadedFile
+                                    ? [
+                                        {
+                                            file_data: {
+                                                mime_type: uploadedFile.mimeType,
+                                                file_uri: uploadedFile.uri,
+                                            },
+                                        },
+                                        { text: prompt },
+                                    ]
+                                    : [
+                                        { text: prompt },
+                                        {
+                                            inline_data: {
+                                                mime_type: effectiveMimeType,
+                                                data: Buffer.from(buffer).toString('base64'),
+                                            },
+                                        },
+                                    ],
+                            }],
+                    }),
+                });
+                if (!response.ok) {
+                    throw new Error(`Google transcription failed: HTTP ${response.status}`);
+                }
+                const payload = await response.json();
+                return {
+                    providerId: 'google',
+                    text: parseGoogleTranscript(payload),
+                    language: request.language,
+                    metadata: {
+                        baseUrl,
+                        modelId: model,
+                        uploadMode: uploadedFile ? 'file' : 'inline',
+                    },
+                };
+            }
+            finally {
+                if (uploadedFile) {
+                    await deleteGoogleFile(baseUrl, apiKey, uploadedFile.name);
+                }
+            }
+        },
+    };
+}

package/dist/platform/voice/providers/microsoft.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceProvider } from '../types.js';
+export declare function createMicrosoftProvider(): VoiceProvider;
+//# sourceMappingURL=microsoft.d.ts.map

package/dist/platform/voice/providers/microsoft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"microsoft.d.ts","sourceRoot":"","sources":["../../../../src/platform/voice/providers/microsoft.ts"],"names":[],"mappings":"AASA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAqDlE,wBAAgB,uBAAuB,IAAI,aAAa,CAoDvD"}

package/dist/platform/voice/providers/microsoft.js

@@ -0,0 +1,85 @@
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { EdgeTTS } from 'node-edge-tts';
+import { CHROMIUM_FULL_VERSION, TRUSTED_CLIENT_TOKEN, generateSecMsGecToken, } from 'node-edge-tts/dist/drm.js';
+import { buildStatus, inferExtFromOutputFormat, inferMimeFromExtension, } from './shared.js';
+function buildMicrosoftVoiceHeaders() {
+    const major = CHROMIUM_FULL_VERSION.split('.')[0] || '0';
+    return {
+        Authority: 'speech.platform.bing.com',
+        Origin: 'chrome-extension://jdiccldimpdaibmpdkjnbmckianbfold',
+        Accept: '*/*',
+        'User-Agent': `Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/${major}.0.0.0 Safari/537.36 Edg/${major}.0.0.0`,
+        'Sec-MS-GEC': generateSecMsGecToken(),
+        'Sec-MS-GEC-Version': `1-${CHROMIUM_FULL_VERSION}`,
+    };
+}
+async function listMicrosoftVoices() {
+    const response = await fetch(`https://speech.platform.bing.com/consumer/speech/synthesize/readaloud/voices/list?trustedclienttoken=${TRUSTED_CLIENT_TOKEN}`, { headers: buildMicrosoftVoiceHeaders() });
+    if (!response.ok)
+        throw new Error(`Microsoft voices failed: HTTP ${response.status}`);
+    const payload = await response.json();
+    return Array.isArray(payload)
+        ? payload
+            .map((voice) => ({
+            id: voice.ShortName?.trim() ?? '',
+            label: voice.FriendlyName?.trim() || voice.ShortName?.trim() || 'Voice',
+            locale: voice.Locale?.trim(),
+            gender: voice.Gender?.trim(),
+            metadata: {
+                categories: voice.VoiceTag?.ContentCategories ?? [],
+                personalities: voice.VoiceTag?.VoicePersonalities ?? [],
+            },
+        }))
+            .filter((voice) => voice.id.length > 0)
+        : [];
+}
+export function createMicrosoftProvider() {
+    return {
+        id: 'microsoft',
+        label: 'Microsoft',
+        capabilities: ['tts', 'voice-list'],
+        status() {
+            return buildStatus('microsoft', 'Microsoft', ['tts', 'voice-list'], true, 'Microsoft Edge speech does not require an API key and remains optional operator convenience.');
+        },
+        async listVoices() {
+            return listMicrosoftVoices();
+        },
+        async synthesize(request) {
+            const outputFormat = request.format === 'wav'
+                ? 'riff-24khz-16bit-mono-pcm'
+                : 'audio-24khz-48kbitrate-mono-mp3';
+            const ext = inferExtFromOutputFormat(outputFormat);
+            const dir = mkdtempSync(join(tmpdir(), 'gv-edge-tts-'));
+            const outPath = join(dir, `speech${ext}`);
+            try {
+                const tts = new EdgeTTS({
+                    voice: request.voiceId?.trim() || 'en-US-MichelleNeural',
+                    lang: 'en-US',
+                    outputFormat,
+                    rate: typeof request.speed === 'number' && Number.isFinite(request.speed)
+                        ? `${Math.round((request.speed - 1) * 100)}%`
+                        : 'default',
+                });
+                await tts.ttsPromise(request.text, outPath);
+                const buffer = readFileSync(outPath);
+                return {
+                    providerId: 'microsoft',
+                    audio: {
+                        mimeType: inferMimeFromExtension(ext),
+                        format: ext === '.wav' ? 'wav' : 'mp3',
+                        dataBase64: buffer.toString('base64'),
+                        metadata: {
+                            voiceId: request.voiceId?.trim() || 'en-US-MichelleNeural',
+                        },
+                    },
+                    metadata: {},
+                };
+            }
+            finally {
+                rmSync(dir, { recursive: true, force: true });
+            }
+        },
+    };
+}

package/dist/platform/voice/providers/openai.d.ts

@@ -0,0 +1,3 @@
+import type { VoiceProvider } from '../types.js';
+export declare function createOpenAIProvider(): VoiceProvider;
+//# sourceMappingURL=openai.d.ts.map

package/dist/platform/voice/providers/openai.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"openai.d.ts","sourceRoot":"","sources":["../../../../src/platform/voice/providers/openai.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,aAAa,EAGd,MAAM,aAAa,CAAC;AAoIrB,wBAAgB,oBAAoB,IAAI,aAAa,CAuNpD"}