@pellux/goodvibes-sdk 0.18.3 → 0.18.12

package/dist/_internal/platform/voice/providers/openai.js

@@ -0,0 +1,289 @@
+import { asFiniteNumber, asRecord, buildStatus, estimateConfidenceFromAvgLogprob, inferFilename, mimeTypeForVoiceFormat, normalizeBaseUrl, readFirstEnv, resolveAudioInput, trimToUndefined, } from './shared.js';
+const OPENAI_AUDIO_BASE_URL = 'https://api.openai.com/v1';
+const OPENAI_VOICES = [
+    'alloy',
+    'ash',
+    'ballad',
+    'coral',
+    'echo',
+    'fable',
+    'onyx',
+    'nova',
+    'sage',
+    'shimmer',
+    'verse',
+    'marin',
+    'cedar',
+];
+const DEFAULT_OPENAI_TTS_MODEL = 'gpt-4o-mini-tts';
+const DEFAULT_OPENAI_STT_MODEL = 'gpt-4o-mini-transcribe';
+const DEFAULT_OPENAI_REALTIME_MODEL = 'gpt-realtime';
+const DEFAULT_OPENAI_VOICE = 'coral';
+const DEFAULT_OPENAI_REALTIME_TTL_SECONDS = 600;
+function resolveOpenAISpeechFormat(format) {
+    const normalized = format?.trim().toLowerCase();
+    switch (normalized) {
+        case 'wav':
+        case 'aac':
+        case 'flac':
+        case 'mp3':
+            return normalized;
+        case 'ogg':
+        case 'opus':
+        case 'webm':
+            return 'opus';
+        case 'pcm16':
+        case 'pcm':
+            return 'pcm';
+        default:
+            return 'mp3';
+    }
+}
+function resolveOpenAIRealtimeAudioFormat(format) {
+    const normalized = format?.trim().toLowerCase();
+    if (normalized === 'pcmu' || normalized === 'g711_ulaw') {
+        return { type: 'audio/pcmu' };
+    }
+    if (normalized === 'pcma' || normalized === 'g711_alaw') {
+        return { type: 'audio/pcma' };
+    }
+    return { type: 'audio/pcm', rate: 24000 };
+}
+function buildOpenAIRealtimeMetadata(params) {
+    const trimmedBase = params.baseUrl.replace(/\/+$/, '');
+    const httpUrl = `${trimmedBase}/realtime?model=${encodeURIComponent(params.model)}`;
+    const websocketBase = trimmedBase.replace(/^http/i, 'ws');
+    const wsUrl = `${websocketBase}/realtime?model=${encodeURIComponent(params.model)}`;
+    return {
+        authMode: 'ephemeral-client-secret',
+        clientSecret: params.clientSecret,
+        expiresAt: params.expiresAt,
+        connect: {
+            webrtc: {
+                url: httpUrl,
+                method: 'POST',
+                contentType: 'application/sdp',
+                authorization: 'Bearer <client_secret>',
+            },
+            websocket: {
+                url: wsUrl,
+                headers: {
+                    Authorization: `Bearer ${params.clientSecret}`,
+                    'OpenAI-Beta': 'realtime=v1',
+                },
+            },
+        },
+        request: {
+            modelId: params.request.modelId,
+            voiceId: params.request.voiceId,
+            inputFormat: params.request.inputFormat,
+            outputFormat: params.request.outputFormat,
+        },
+        session: params.sessionPayload,
+    };
+}
+export function createOpenAIProvider() {
+    const envVars = ['OPENAI_API_KEY', 'OPENAI_KEY'];
+    const baseUrlEnvVars = ['OPENAI_BASE_URL', 'OPENAI_API_BASE'];
+    return {
+        id: 'openai',
+        label: 'OpenAI',
+        capabilities: ['tts', 'stt', 'realtime', 'voice-list'],
+        status() {
+            const configured = readFirstEnv(envVars) !== null;
+            return buildStatus('openai', 'OpenAI', ['tts', 'stt', 'realtime', 'voice-list'], configured, configured
+                ? 'OpenAI audio and realtime APIs are available.'
+                : 'Set OPENAI_API_KEY or OPENAI_KEY to enable OpenAI TTS, STT, and realtime voice.', {
+                baseUrl: normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), OPENAI_AUDIO_BASE_URL),
+                defaultTtsModel: DEFAULT_OPENAI_TTS_MODEL,
+                defaultSttModel: DEFAULT_OPENAI_STT_MODEL,
+                defaultRealtimeModel: DEFAULT_OPENAI_REALTIME_MODEL,
+            });
+        },
+        async listVoices() {
+            return OPENAI_VOICES.map((voice) => ({
+                id: voice,
+                label: voice,
+                metadata: {
+                    builtin: true,
+                },
+            }));
+        },
+        async synthesize(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('OpenAI API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), OPENAI_AUDIO_BASE_URL);
+            const responseFormat = resolveOpenAISpeechFormat(request.format);
+            const metadata = asRecord(request.metadata);
+            const response = await fetch(`${baseUrl}/audio/speech`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                    Accept: 'application/octet-stream',
+                },
+                body: JSON.stringify({
+                    input: request.text,
+                    model: request.modelId?.trim() || DEFAULT_OPENAI_TTS_MODEL,
+                    voice: request.voiceId?.trim() || DEFAULT_OPENAI_VOICE,
+                    response_format: responseFormat,
+                    ...(typeof request.speed === 'number' && Number.isFinite(request.speed)
+                        ? { speed: request.speed }
+                        : {}),
+                    ...(trimToUndefined(metadata?.['instructions'])
+                        ? { instructions: trimToUndefined(metadata?.['instructions']) }
+                        : {}),
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI synthesis failed: HTTP ${response.status}`);
+            }
+            const buffer = Buffer.from(await response.arrayBuffer());
+            return {
+                providerId: 'openai',
+                audio: {
+                    mimeType: mimeTypeForVoiceFormat(responseFormat),
+                    format: responseFormat === 'pcm' ? 'pcm16' : responseFormat,
+                    dataBase64: buffer.toString('base64'),
+                    metadata: {
+                        baseUrl,
+                        modelId: request.modelId?.trim() || DEFAULT_OPENAI_TTS_MODEL,
+                        voiceId: request.voiceId?.trim() || DEFAULT_OPENAI_VOICE,
+                    },
+                },
+                metadata: {
+                    baseUrl,
+                    modelId: request.modelId?.trim() || DEFAULT_OPENAI_TTS_MODEL,
+                    voiceId: request.voiceId?.trim() || DEFAULT_OPENAI_VOICE,
+                },
+            };
+        },
+        async transcribe(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('OpenAI API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), OPENAI_AUDIO_BASE_URL);
+            const { buffer, mimeType } = await resolveAudioInput(request.audio);
+            const form = new FormData();
+            form.append('file', new Blob([Buffer.from(buffer)], { type: mimeType || 'application/octet-stream' }), inferFilename(request.audio, '.wav'));
+            form.append('model', request.modelId?.trim() || DEFAULT_OPENAI_STT_MODEL);
+            form.append('response_format', 'verbose_json');
+            if (request.language?.trim())
+                form.append('language', request.language.trim());
+            if (request.prompt?.trim())
+                form.append('prompt', request.prompt.trim());
+            const response = await fetch(`${baseUrl}/audio/transcriptions`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                },
+                body: form,
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI transcription failed: HTTP ${response.status}`);
+            }
+            const payload = await response.json();
+            const text = payload.text?.trim();
+            if (!text)
+                throw new Error('OpenAI transcription response missing transcript');
+            return {
+                providerId: 'openai',
+                text,
+                language: payload.language?.trim() || request.language,
+                segments: (payload.segments ?? [])
+                    .map((segment) => ({
+                    text: segment.text?.trim() ?? '',
+                    startMs: typeof segment.start === 'number' ? Math.round(segment.start * 1000) : undefined,
+                    endMs: typeof segment.end === 'number' ? Math.round(segment.end * 1000) : undefined,
+                    confidence: estimateConfidenceFromAvgLogprob(segment.avg_logprob),
+                }))
+                    .filter((segment) => segment.text.length > 0),
+                metadata: {
+                    baseUrl,
+                    modelId: request.modelId?.trim() || DEFAULT_OPENAI_STT_MODEL,
+                },
+            };
+        },
+        async openRealtimeSession(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('OpenAI API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), OPENAI_AUDIO_BASE_URL);
+            const metadata = asRecord(request.metadata);
+            const model = request.modelId?.trim() || DEFAULT_OPENAI_REALTIME_MODEL;
+            const ttlSeconds = Math.max(10, Math.min(7200, Math.round(asFiniteNumber(metadata?.['ttlSeconds']) ?? DEFAULT_OPENAI_REALTIME_TTL_SECONDS)));
+            const voice = request.voiceId?.trim() || DEFAULT_OPENAI_VOICE;
+            const inputFormat = resolveOpenAIRealtimeAudioFormat(request.inputFormat);
+            const outputFormat = resolveOpenAIRealtimeAudioFormat(request.outputFormat);
+            const response = await fetch(`${baseUrl}/realtime/client_secrets`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    expires_after: {
+                        anchor: 'created_at',
+                        seconds: ttlSeconds,
+                    },
+                    session: {
+                        type: 'realtime',
+                        model,
+                        instructions: request.instructions?.trim() || undefined,
+                        output_modalities: ['audio'],
+                        audio: {
+                            input: {
+                                format: inputFormat,
+                                transcription: {
+                                    model: trimToUndefined(metadata?.['transcriptionModel']) || DEFAULT_OPENAI_STT_MODEL,
+                                    ...(trimToUndefined(metadata?.['transcriptionLanguage'])
+                                        ? { language: trimToUndefined(metadata?.['transcriptionLanguage']) }
+                                        : {}),
+                                    ...(trimToUndefined(metadata?.['transcriptionPrompt'])
+                                        ? { prompt: trimToUndefined(metadata?.['transcriptionPrompt']) }
+                                        : {}),
+                                },
+                            },
+                            output: {
+                                format: outputFormat,
+                                voice,
+                                ...(typeof metadata?.['speed'] === 'number' && Number.isFinite(metadata['speed'])
+                                    ? { speed: metadata['speed'] }
+                                    : {}),
+                            },
+                        },
+                        ...(metadata?.['includeLogprobs'] === true
+                            ? { include: ['item.input_audio_transcription.logprobs'] }
+                            : {}),
+                    },
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`OpenAI realtime session failed: HTTP ${response.status}`);
+            }
+            const payload = await response.json();
+            const clientSecret = payload.client_secret?.value?.trim();
+            if (!clientSecret)
+                throw new Error('OpenAI realtime session response missing client secret');
+            const expiresAt = typeof payload.client_secret?.expires_at === 'number'
+                ? payload.client_secret.expires_at * 1000
+                : undefined;
+            return {
+                providerId: 'openai',
+                sessionId: trimToUndefined(payload.id) || `openai-realtime-${Date.now()}`,
+                transport: 'webrtc',
+                url: `${baseUrl}/realtime?model=${encodeURIComponent(model)}`,
+                expiresAt,
+                metadata: buildOpenAIRealtimeMetadata({
+                    baseUrl,
+                    model,
+                    clientSecret,
+                    expiresAt,
+                    request,
+                    sessionPayload: payload,
+                }),
+            };
+        },
+    };
+}

package/dist/_internal/platform/voice/providers/shared.d.ts

@@ -0,0 +1,17 @@
+import type { VoiceAudioArtifact, VoiceProvider, VoiceProviderStatus } from '../types.js';
+export declare function trimToUndefined(value: unknown): string | undefined;
+export declare function asFiniteNumber(value: unknown): number | undefined;
+export declare function asRecord(value: unknown): Record<string, unknown> | undefined;
+export declare function readFirstEnv(envVars: readonly string[]): string | null;
+export declare function normalizeBaseUrl(value: string | null | undefined, fallback: string): string;
+export declare function resolveAudioInput(audio: VoiceAudioArtifact): Promise<{
+    buffer: Uint8Array;
+    mimeType: string;
+}>;
+export declare function buildStatus(id: string, label: string, capabilities: VoiceProvider['capabilities'], configured: boolean, detail: string, metadata?: Record<string, unknown>): VoiceProviderStatus;
+export declare function inferMimeFromExtension(ext: string): string;
+export declare function inferExtFromOutputFormat(outputFormat: string): string;
+export declare function inferFilename(audio: VoiceAudioArtifact, fallbackExt: string): string;
+export declare function mimeTypeForVoiceFormat(format: string): string;
+export declare function estimateConfidenceFromAvgLogprob(value: unknown): number | undefined;
+//# sourceMappingURL=shared.d.ts.map

package/dist/_internal/platform/voice/providers/shared.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shared.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/voice/providers/shared.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,kBAAkB,EAClB,aAAa,EACb,mBAAmB,EACpB,MAAM,aAAa,CAAC;AAErB,wBAAgB,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAElE;AAED,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAEjE;AAED,wBAAgB,QAAQ,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,SAAS,CAI5E;AAED,wBAAgB,YAAY,CAAC,OAAO,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,GAAG,IAAI,CAMtE;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,CAG3F;AAED,wBAAsB,iBAAiB,CACrC,KAAK,EAAE,kBAAkB,GACxB,OAAO,CAAC;IAAE,MAAM,EAAE,UAAU,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CAAC,CAgBnD;AAED,wBAAgB,WAAW,CACzB,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,EACb,YAAY,EAAE,aAAa,CAAC,cAAc,CAAC,EAC3C,UAAU,EAAE,OAAO,EACnB,MAAM,EAAE,MAAM,EACd,QAAQ,GAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAM,GACrC,mBAAmB,CAUrB;AAED,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAiB1D;AAED,wBAAgB,wBAAwB,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CASrE;AAED,wBAAgB,aAAa,CAAC,KAAK,EAAE,kBAAkB,EAAE,WAAW,EAAE,MAAM,GAAG,MAAM,CAKpF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAe7D;AAED,wBAAgB,gCAAgC,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,GAAG,SAAS,CAInF"}

package/dist/_internal/platform/voice/providers/shared.js

@@ -0,0 +1,115 @@
+export function trimToUndefined(value) {
+    return typeof value === 'string' && value.trim().length > 0 ? value.trim() : undefined;
+}
+export function asFiniteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+export function asRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value)
+        ? value
+        : undefined;
+}
+export function readFirstEnv(envVars) {
+    for (const envVar of envVars) {
+        const value = process.env[envVar];
+        if (typeof value === 'string' && value.trim().length > 0)
+            return value.trim();
+    }
+    return null;
+}
+export function normalizeBaseUrl(value, fallback) {
+    const trimmed = value?.trim();
+    return (trimmed && trimmed.length > 0 ? trimmed : fallback).replace(/\/+$/, '');
+}
+export async function resolveAudioInput(audio) {
+    if (typeof audio.dataBase64 === 'string' && audio.dataBase64.trim().length > 0) {
+        return {
+            buffer: Uint8Array.from(Buffer.from(audio.dataBase64, 'base64')),
+            mimeType: audio.mimeType,
+        };
+    }
+    if (typeof audio.uri === 'string' && audio.uri.trim().length > 0) {
+        const response = await fetch(audio.uri);
+        if (!response.ok)
+            throw new Error(`Failed to load audio URI: HTTP ${response.status}`);
+        return {
+            buffer: new Uint8Array(await response.arrayBuffer()),
+            mimeType: response.headers.get('content-type')?.trim() || audio.mimeType,
+        };
+    }
+    throw new Error('Voice audio input requires dataBase64 or uri.');
+}
+export function buildStatus(id, label, capabilities, configured, detail, metadata = {}) {
+    return {
+        id,
+        label,
+        state: configured ? 'healthy' : 'unconfigured',
+        capabilities: [...capabilities],
+        configured,
+        detail,
+        metadata,
+    };
+}
+export function inferMimeFromExtension(ext) {
+    switch (ext) {
+        case '.wav':
+            return 'audio/wav';
+        case '.ogg':
+            return 'audio/ogg';
+        case '.webm':
+            return 'audio/webm';
+        case '.flac':
+            return 'audio/flac';
+        case '.aac':
+            return 'audio/aac';
+        case '.pcm':
+            return 'audio/pcm';
+        default:
+            return 'audio/mpeg';
+    }
+}
+export function inferExtFromOutputFormat(outputFormat) {
+    const lower = outputFormat.toLowerCase();
+    if (lower.includes('webm'))
+        return '.webm';
+    if (lower.includes('ogg'))
+        return '.ogg';
+    if (lower.includes('flac'))
+        return '.flac';
+    if (lower.includes('aac'))
+        return '.aac';
+    if (lower.includes('wav') || lower.includes('riff'))
+        return '.wav';
+    if (lower.includes('pcm'))
+        return '.pcm';
+    return '.mp3';
+}
+export function inferFilename(audio, fallbackExt) {
+    const metadata = asRecord(audio.metadata);
+    const explicit = trimToUndefined(metadata?.['filename']);
+    if (explicit)
+        return explicit;
+    return `audio${fallbackExt}`;
+}
+export function mimeTypeForVoiceFormat(format) {
+    switch (format) {
+        case 'wav':
+            return 'audio/wav';
+        case 'opus':
+            return 'audio/ogg';
+        case 'aac':
+            return 'audio/aac';
+        case 'flac':
+            return 'audio/flac';
+        case 'pcm':
+            return 'audio/pcm';
+        default:
+            return 'audio/mpeg';
+    }
+}
+export function estimateConfidenceFromAvgLogprob(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value))
+        return undefined;
+    const bounded = Math.max(0, Math.min(1, Math.exp(value)));
+    return Number.isFinite(bounded) ? bounded : undefined;
+}

package/dist/_internal/platform/voice/providers/vydra.d.ts

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

package/dist/_internal/platform/voice/providers/vydra.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"vydra.d.ts","sourceRoot":"","sources":["../../../../../src/_internal/platform/voice/providers/vydra.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAmB,aAAa,EAAE,MAAM,aAAa,CAAC;AAOlE,wBAAgB,mBAAmB,IAAI,aAAa,CA2EnD"}

package/dist/_internal/platform/voice/providers/vydra.js

@@ -0,0 +1,74 @@
+import { buildStatus, normalizeBaseUrl, readFirstEnv, } from './shared.js';
+export function createVydraProvider() {
+    const envVars = ['VYDRA_API_KEY'];
+    const baseUrlEnvVars = ['VYDRA_BASE_URL'];
+    return {
+        id: 'vydra',
+        label: 'Vydra',
+        capabilities: ['tts', 'voice-list'],
+        status() {
+            const configured = readFirstEnv(envVars) !== null;
+            return buildStatus('vydra', 'Vydra', ['tts', 'voice-list'], configured, configured
+                ? 'Vydra speech API key available.'
+                : 'Set VYDRA_API_KEY to enable Vydra speech synthesis.', {
+                baseUrl: normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://www.vydra.ai/api/v1'),
+            });
+        },
+        async listVoices() {
+            return [{
+                    id: '21m00Tcm4TlvDq8ikWAM',
+                    label: 'Rachel',
+                    metadata: {},
+                }];
+        },
+        async synthesize(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('Vydra API key missing');
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://www.vydra.ai/api/v1');
+            const model = request.modelId?.trim() || 'elevenlabs/tts';
+            const response = await fetch(`${baseUrl}/models/${model}`, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Bearer ${apiKey}`,
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    text: request.text,
+                    voice_id: request.voiceId?.trim() || '21m00Tcm4TlvDq8ikWAM',
+                }),
+            });
+            if (!response.ok)
+                throw new Error(`Vydra synthesis failed: HTTP ${response.status}`);
+            const payload = await response.json();
+            const urls = [
+                typeof payload['audio_url'] === 'string' ? payload['audio_url'] : null,
+                ...(Array.isArray(payload['output'])
+                    ? payload['output'].filter((entry) => typeof entry === 'string')
+                    : []),
+                ...(Array.isArray(payload['results'])
+                    ? payload['results']
+                        .map((entry) => typeof entry['url'] === 'string' ? entry['url'] : null)
+                        .filter((entry) => Boolean(entry))
+                    : []),
+            ].filter((value) => Boolean(value && value.trim()));
+            const audioUrl = urls[0];
+            if (!audioUrl)
+                throw new Error('Vydra speech synthesis response missing audio URL');
+            const audioResponse = await fetch(audioUrl);
+            if (!audioResponse.ok)
+                throw new Error(`Vydra audio download failed: HTTP ${audioResponse.status}`);
+            const mimeType = audioResponse.headers.get('content-type')?.trim() || 'audio/mpeg';
+            return {
+                providerId: 'vydra',
+                audio: {
+                    mimeType,
+                    format: mimeType.includes('wav') ? 'wav' : 'mp3',
+                    dataBase64: Buffer.from(await audioResponse.arrayBuffer()).toString('base64'),
+                    metadata: { sourceUrl: audioUrl, baseUrl },
+                },
+                metadata: { sourceUrl: audioUrl, baseUrl },
+            };
+        },
+    };
+}

package/dist/_internal/platform/voice/service.d.ts

@@ -0,0 +1,18 @@
+import { VoiceProviderRegistry } from './provider-registry.js';
+import type { VoiceDescriptor, VoiceRealtimeSession, VoiceRealtimeSessionRequest, VoiceSynthesisRequest, VoiceSynthesisResult, VoiceTranscriptionRequest, VoiceTranscriptionResult } from './types.js';
+export interface VoiceServiceStatus {
+    readonly enabled: boolean;
+    readonly providerCount: number;
+    readonly providers: Awaited<ReturnType<VoiceProviderRegistry['status']>>;
+    readonly note: string;
+}
+export declare class VoiceService {
+    private readonly registry;
+    constructor(registry: VoiceProviderRegistry);
+    getStatus(enabled: boolean): Promise<VoiceServiceStatus>;
+    listVoices(providerId?: string): Promise<readonly VoiceDescriptor[]>;
+    synthesize(providerId: string | undefined, request: VoiceSynthesisRequest): Promise<VoiceSynthesisResult>;
+    transcribe(providerId: string | undefined, request: VoiceTranscriptionRequest): Promise<VoiceTranscriptionResult>;
+    openRealtimeSession(providerId: string | undefined, request: VoiceRealtimeSessionRequest): Promise<VoiceRealtimeSession>;
+}
+//# sourceMappingURL=service.d.ts.map

package/dist/_internal/platform/voice/service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.d.ts","sourceRoot":"","sources":["../../../../src/_internal/platform/voice/service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,OAAO,KAAK,EACV,eAAe,EACf,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;IAC/B,QAAQ,CAAC,SAAS,EAAE,OAAO,CAAC,UAAU,CAAC,qBAAqB,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC;IACzE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED,qBAAa,YAAY;IACX,OAAO,CAAC,QAAQ,CAAC,QAAQ;gBAAR,QAAQ,EAAE,qBAAqB;IAEtD,SAAS,CAAC,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,kBAAkB,CAAC;IAUxD,UAAU,CAAC,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,SAAS,eAAe,EAAE,CAAC;IAYpE,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,qBAAqB,GAAG,OAAO,CAAC,oBAAoB,CAAC;IAQzG,UAAU,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,yBAAyB,GAAG,OAAO,CAAC,wBAAwB,CAAC;IAQjH,mBAAmB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,OAAO,EAAE,2BAA2B,GAAG,OAAO,CAAC,oBAAoB,CAAC;CAO/H"}

package/dist/_internal/platform/voice/service.js

@@ -0,0 +1,49 @@
+import { VoiceProviderRegistry } from './provider-registry.js';
+export class VoiceService {
+    registry;
+    constructor(registry) {
+        this.registry = registry;
+    }
+    async getStatus(enabled) {
+        const providers = await this.registry.status();
+        return {
+            enabled,
+            providerCount: providers.length,
+            providers,
+            note: 'Voice capture is intentionally external to the SDK host process; terminal, web, or companion clients can stream audio into these provider-backed APIs.',
+        };
+    }
+    async listVoices(providerId) {
+        const providers = providerId
+            ? [this.registry.get(providerId)].filter((provider) => provider !== null)
+            : this.registry.list().map((entry) => this.registry.get(entry.id)).filter((provider) => provider !== null);
+        const voices = [];
+        for (const provider of providers) {
+            if (!provider.listVoices)
+                continue;
+            voices.push(...await provider.listVoices());
+        }
+        return voices.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+    async synthesize(providerId, request) {
+        const provider = this.registry.findProvider('tts', providerId);
+        if (!provider?.synthesize) {
+            throw new Error(providerId ? `Voice TTS provider unavailable: ${providerId}` : 'No voice TTS provider is registered');
+        }
+        return provider.synthesize(request);
+    }
+    async transcribe(providerId, request) {
+        const provider = this.registry.findProvider('stt', providerId);
+        if (!provider?.transcribe) {
+            throw new Error(providerId ? `Voice STT provider unavailable: ${providerId}` : 'No voice STT provider is registered');
+        }
+        return provider.transcribe(request);
+    }
+    async openRealtimeSession(providerId, request) {
+        const provider = this.registry.findProvider('realtime', providerId);
+        if (!provider?.openRealtimeSession) {
+            throw new Error(providerId ? `Voice realtime provider unavailable: ${providerId}` : 'No voice realtime provider is registered');
+        }
+        return provider.openRealtimeSession(request);
+    }
+}

package/dist/_internal/platform/voice/types.d.ts

@@ -0,0 +1,89 @@
+/** SDK-owned platform module. This implementation is maintained in goodvibes-sdk. */
+export type VoiceProviderCapability = 'tts' | 'stt' | 'realtime' | 'voice-list';
+export type VoiceProviderState = 'healthy' | 'degraded' | 'disabled' | 'unconfigured';
+export type VoiceAudioFormat = 'wav' | 'mp3' | 'ogg' | 'webm' | 'pcm16' | 'flac';
+export interface VoiceProviderStatus {
+    readonly id: string;
+    readonly label: string;
+    readonly state: VoiceProviderState;
+    readonly capabilities: readonly VoiceProviderCapability[];
+    readonly configured: boolean;
+    readonly detail?: string;
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceDescriptor {
+    readonly id: string;
+    readonly label: string;
+    readonly locale?: string;
+    readonly gender?: string;
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceAudioArtifact {
+    readonly mimeType: string;
+    readonly format: VoiceAudioFormat | string;
+    readonly dataBase64?: string;
+    readonly uri?: string;
+    readonly sampleRateHz?: number;
+    readonly durationMs?: number;
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceSynthesisRequest {
+    readonly text: string;
+    readonly voiceId?: string;
+    readonly modelId?: string;
+    readonly format?: VoiceAudioFormat | string;
+    readonly speed?: number;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface VoiceSynthesisResult {
+    readonly providerId: string;
+    readonly audio: VoiceAudioArtifact;
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceTranscriptionRequest {
+    readonly audio: VoiceAudioArtifact;
+    readonly language?: string;
+    readonly modelId?: string;
+    readonly prompt?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface VoiceTranscriptionResult {
+    readonly providerId: string;
+    readonly text: string;
+    readonly language?: string;
+    readonly segments?: readonly {
+        readonly text: string;
+        readonly startMs?: number;
+        readonly endMs?: number;
+        readonly confidence?: number;
+    }[];
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceRealtimeSessionRequest {
+    readonly modelId?: string;
+    readonly voiceId?: string;
+    readonly inputFormat?: VoiceAudioFormat | string;
+    readonly outputFormat?: VoiceAudioFormat | string;
+    readonly instructions?: string;
+    readonly metadata?: Record<string, unknown>;
+}
+export interface VoiceRealtimeSession {
+    readonly providerId: string;
+    readonly sessionId: string;
+    readonly transport: 'websocket' | 'webrtc' | 'sse' | 'http' | 'custom';
+    readonly url?: string;
+    readonly expiresAt?: number;
+    readonly headers?: Record<string, string>;
+    readonly metadata: Record<string, unknown>;
+}
+export interface VoiceProvider {
+    readonly id: string;
+    readonly label: string;
+    readonly capabilities: readonly VoiceProviderCapability[];
+    status?(): Promise<VoiceProviderStatus> | VoiceProviderStatus;
+    listVoices?(): Promise<readonly VoiceDescriptor[]> | readonly VoiceDescriptor[];
+    synthesize?(request: VoiceSynthesisRequest): Promise<VoiceSynthesisResult>;
+    transcribe?(request: VoiceTranscriptionRequest): Promise<VoiceTranscriptionResult>;
+    openRealtimeSession?(request: VoiceRealtimeSessionRequest): Promise<VoiceRealtimeSession>;
+}
+//# sourceMappingURL=types.d.ts.map