@pellux/goodvibes-sdk 0.18.3 → 0.18.11

package/dist/platform/utils/terminal-width.js

@@ -0,0 +1,188 @@
+/**
+ * Calculates the visual width of a string in the terminal.
+ * Handles CJK characters, emoji (including ZWJ sequences), and
+ * variation selectors correctly as double-width.
+ */
+export function getDisplayWidth(text) {
+    let width = 0;
+    let i = 0;
+    while (i < text.length) {
+        const code = text.codePointAt(i);
+        const charLen = code > 0xFFFF ? 2 : 1; // surrogate pair = 2 JS chars
+        if (code < 32 || code === 127) {
+            i += charLen;
+            continue;
+        }
+        // Zero-width joiners, variation selectors, combining marks — 0 width
+        if (code === 0x200D || // ZWJ
+            code === 0xFE0F || // emoji variation selector
+            code === 0xFE0E || // text variation selector
+            (code >= 0x0300 && code <= 0x036F) || // combining diacriticals
+            (code >= 0x1AB0 && code <= 0x1AFF) || // combining diacriticals ext
+            (code >= 0x20D0 && code <= 0x20FF) || // combining marks for symbols
+            (code >= 0xFE20 && code <= 0xFE2F) || // combining half marks
+            (code >= 0xE0100 && code <= 0xE01EF) // variation selectors supplement
+        ) {
+            i += charLen;
+            continue;
+        }
+        // Dingbat symbols (✓ ✗ ✔ ✘) that fall in the 0x2700-0x27BF range which is
+        // classified as double-width below, but terminals render them as single-width.
+        // Also includes defensive entries for box drawing and block elements.
+        if (code === 0x2713 || // ✓ check mark
+            code === 0x2717 || // ✗ ballot x
+            code === 0x2714 || // ✔ heavy check mark
+            code === 0x2718 || // ✘ heavy ballot x
+            code === 0x2022 || // • bullet
+            code === 0x258D || // ▍ left five eighths block
+            (code >= 0x2500 && code <= 0x257F) // box drawing block (all single-width)
+        ) {
+            width += 1;
+            i += charLen;
+            continue;
+        }
+        // Emoji and pictographic — double width in most terminals
+        // Note: 💭 (U+1F4AD) and 🧠 (U+1F9E0) are both in the 0x1F300–0x1F9FF range,
+        // so they are correctly handled as width 2 here.
+        if ((code >= 0x1F300 && code <= 0x1F9FF) || // misc symbols, emoticons, supplemental (includes 💭 U+1F4AD, 🧠 U+1F9E0)
+            (code >= 0x1FA00 && code <= 0x1FAFF) || // chess, symbols ext-A
+            (code >= 0x2600 && code <= 0x27BF) || // misc symbols, dingbats
+            (code >= 0x2300 && code <= 0x23FF) || // misc technical (hourglass, etc)
+            (code >= 0x2B50 && code <= 0x2B55) || // stars, circles
+            (code >= 0xFE00 && code <= 0xFE0F) || // variation selectors (handled above but safe)
+            (code >= 0x1F000 && code <= 0x1F02F) || // mahjong, dominos
+            (code >= 0x1F680 && code <= 0x1F6FF) || // transport symbols
+            code === 0x200D || // ZWJ (handled above)
+            (code >= 0xE000 && code <= 0xF8FF) || // private use area (some terminals render wide)
+            code === 0x2764 || code === 0x2763 || // hearts
+            code === 0x270A || code === 0x270B || code === 0x270C || // hand gestures
+            code === 0x261D || code === 0x2639 || code === 0x263A // misc
+        ) {
+            width += 2;
+            i += charLen;
+            continue;
+        }
+        // CJK and fullwidth — double width
+        if ((code >= 0x1100 && code <= 0x115F) || // Hangul Jamo
+            (code >= 0x2E80 && code <= 0xA4CF && code !== 0x303F) || // CJK
+            (code >= 0xAC00 && code <= 0xD7A3) || // Hangul syllables
+            (code >= 0xF900 && code <= 0xFAFF) || // CJK compat ideographs
+            (code >= 0xFF00 && code <= 0xFF60) || // fullwidth forms
+            (code >= 0x20000 && code <= 0x2FFFD) || // CJK unified ext B+
+            (code >= 0x30000 && code <= 0x3FFFD) // CJK unified ext G+
+        ) {
+            width += 2;
+            i += charLen;
+            continue;
+        }
+        // Everything else — single width
+        width += 1;
+        i += charLen;
+    }
+    return width;
+}
+export function center(text, width) {
+    const displayWidth = getDisplayWidth(text);
+    if (displayWidth >= width)
+        return text;
+    const left = Math.floor((width - displayWidth) / 2);
+    return ' '.repeat(left) + text;
+}
+export function truncateDisplay(text, width, ellipsis = '…') {
+    if (width <= 0)
+        return '';
+    if (getDisplayWidth(text) <= width)
+        return text;
+    const ellipsisWidth = getDisplayWidth(ellipsis);
+    if (ellipsisWidth >= width)
+        return truncateDisplay(ellipsis, width, '');
+    let result = '';
+    let currentWidth = 0;
+    for (const char of text) {
+        const charWidth = getDisplayWidth(char);
+        if (currentWidth + charWidth + ellipsisWidth > width)
+            break;
+        result += char;
+        currentWidth += charWidth;
+    }
+    return result + ellipsis;
+}
+export function padDisplayEnd(text, width) {
+    const currentWidth = getDisplayWidth(text);
+    if (currentWidth >= width)
+        return text;
+    return text + ' '.repeat(width - currentWidth);
+}
+export function fitDisplay(text, width, ellipsis = '…') {
+    return padDisplayEnd(truncateDisplay(text, width, ellipsis), width);
+}
+/**
+ * Smart Word Wrapping.
+ */
+export function wrapText(text, width) {
+    if (width <= 0)
+        return [text];
+    const lines = [];
+    const paragraphs = text.split('\n');
+    for (const paragraph of paragraphs) {
+        if (paragraph.length === 0) {
+            lines.push('');
+            continue;
+        }
+        const words = paragraph.split(' ');
+        let currentLine = '';
+        for (const word of words) {
+            const wordW = getDisplayWidth(word);
+            const currentLineW = getDisplayWidth(currentLine);
+            // Safety: If a single word is longer than the width, we must force-break it
+            if (wordW > width) {
+                if (currentLine)
+                    lines.push(currentLine);
+                let remaining = word;
+                while (getDisplayWidth(remaining) > width) {
+                    // Find split point
+                    let splitIdx = 0;
+                    let currentW = 0;
+                    for (let i = 0; i < remaining.length; i++) {
+                        const charW = getDisplayWidth(remaining[i]);
+                        if (currentW + charW > width)
+                            break;
+                        currentW += charW;
+                        splitIdx = i + 1;
+                    }
+                    lines.push(remaining.slice(0, splitIdx));
+                    remaining = remaining.slice(splitIdx);
+                }
+                currentLine = remaining;
+                continue;
+            }
+            if ((currentLineW + wordW + (currentLine ? 1 : 0)) <= width) {
+                currentLine += (currentLine ? ' ' : '') + word;
+            }
+            else {
+                lines.push(currentLine);
+                currentLine = word;
+            }
+        }
+        if (currentLine)
+            lines.push(currentLine);
+    }
+    return lines;
+}
+/**
+ * Interpolates between two RGB colors based on a factor (0-1).
+ */
+export function interpolateColor(startHex, endHex, factor) {
+    const parse = (hex) => {
+        const r = parseInt(hex.slice(1, 3), 16);
+        const g = parseInt(hex.slice(3, 5), 16);
+        const b = parseInt(hex.slice(5, 7), 16);
+        return [r, g, b];
+    };
+    const [r1, g1, b1] = parse(startHex);
+    const [r2, g2, b2] = parse(endHex);
+    const r = Math.round(r1 + factor * (r2 - r1));
+    const g = Math.round(g1 + factor * (g2 - g1));
+    const b = Math.round(b1 + factor * (b2 - b1));
+    return `${r};${g};${b}`;
+}

package/dist/platform/utils/url-safety.d.ts

@@ -0,0 +1,8 @@
+export declare function validatePublicWebhookUrl(rawUrl: string): {
+    ok: true;
+    url: string;
+} | {
+    ok: false;
+    error: string;
+};
+//# sourceMappingURL=url-safety.d.ts.map

package/dist/platform/utils/url-safety.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"url-safety.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/url-safety.ts"],"names":[],"mappings":"AAoDA,wBAAgB,wBAAwB,CAAC,MAAM,EAAE,MAAM,GAAG;IAAE,EAAE,EAAE,IAAI,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,EAAE,EAAE,KAAK,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAiBjH"}

package/dist/platform/utils/url-safety.js

@@ -0,0 +1,74 @@
+import { isIP } from 'node:net';
+function isPrivateIpv4(hostname) {
+    const parts = hostname.split('.').map((part) => Number(part));
+    if (parts.length !== 4 || parts.some((part) => !Number.isInteger(part) || part < 0 || part > 255)) {
+        return false;
+    }
+    const [a, b] = parts;
+    return a === 10
+        || a === 127
+        || (a === 169 && b === 254)
+        || (a === 172 && b >= 16 && b <= 31)
+        || (a === 192 && b === 168)
+        || a === 0
+        || a >= 224;
+}
+function mappedIpv4FromIpv6(host) {
+    const mappedHex = host.match(/^::ffff:([0-9a-f]{1,4}):([0-9a-f]{1,4})$/i);
+    if (!mappedHex)
+        return null;
+    const high = Number.parseInt(mappedHex[1], 16);
+    const low = Number.parseInt(mappedHex[2], 16);
+    if (!Number.isFinite(high) || !Number.isFinite(low))
+        return null;
+    return [
+        (high >> 8) & 0xff,
+        high & 0xff,
+        (low >> 8) & 0xff,
+        low & 0xff,
+    ].join('.');
+}
+function isBlockedHostname(hostname) {
+    const host = hostname.toLowerCase().replace(/^\[|\]$/g, '');
+    if (!host)
+        return true;
+    if (host === 'localhost' || host.endsWith('.localhost'))
+        return true;
+    if (host === 'metadata.google.internal')
+        return true;
+    const ipKind = isIP(host);
+    if (ipKind === 4)
+        return isPrivateIpv4(host);
+    if (ipKind === 6) {
+        const mappedIpv4 = mappedIpv4FromIpv6(host);
+        if (mappedIpv4)
+            return isPrivateIpv4(mappedIpv4);
+        return host === '::1'
+            || host.startsWith('fc')
+            || host.startsWith('fd')
+            || host.startsWith('fe80:')
+            || host.startsWith('ff')
+            || host === '::'
+            || host.startsWith('0:');
+    }
+    return false;
+}
+export function validatePublicWebhookUrl(rawUrl) {
+    let parsed;
+    try {
+        parsed = new URL(rawUrl);
+    }
+    catch {
+        return { ok: false, error: 'Invalid webhook URL' };
+    }
+    if (parsed.protocol !== 'https:') {
+        return { ok: false, error: 'Webhook URL must use https' };
+    }
+    if (parsed.username || parsed.password) {
+        return { ok: false, error: 'Webhook URL must not include credentials' };
+    }
+    if (isBlockedHostname(parsed.hostname)) {
+        return { ok: false, error: 'Webhook URL host is not allowed' };
+    }
+    return { ok: true, url: parsed.toString() };
+}

package/dist/platform/utils/walk-dir.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Directories that are always skipped during recursive directory walks.
+ * Covers version-control, package manager output, and build artefacts.
+ */
+export declare const WALK_SKIP_DIRS: Set<string>;
+/**
+ * Files larger than this threshold are skipped to avoid loading huge binaries
+ * or generated assets into memory (1 MB).
+ */
+export declare const WALK_MAX_FILE_SIZE: number;
+/**
+ * Recursively walk a directory tree, yielding all file paths whose size does
+ * not exceed {@link WALK_MAX_FILE_SIZE}. Hidden entries and entries in
+ * {@link WALK_SKIP_DIRS} are skipped. Unreadable directories are silently
+ * ignored so a single permission error never aborts the whole walk.
+ */
+export declare function walkDir(dirPath: string): AsyncGenerator<string>;
+//# sourceMappingURL=walk-dir.d.ts.map

package/dist/platform/utils/walk-dir.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"walk-dir.d.ts","sourceRoot":"","sources":["../../../src/platform/utils/walk-dir.ts"],"names":[],"mappings":"AAIA;;;GAGG;AACH,eAAO,MAAM,cAAc,aAQzB,CAAC;AAEH;;;GAGG;AACH,eAAO,MAAM,kBAAkB,QAAc,CAAC;AAE9C;;;;;GAKG;AACH,wBAAuB,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,cAAc,CAAC,MAAM,CAAC,CA0BtE"}

package/dist/platform/utils/walk-dir.js

@@ -0,0 +1,55 @@
+import { join } from 'node:path';
+import { readdir, stat } from 'node:fs/promises';
+/**
+ * Directories that are always skipped during recursive directory walks.
+ * Covers version-control, package manager output, and build artefacts.
+ */
+export const WALK_SKIP_DIRS = new Set([
+    '.git',
+    'node_modules',
+    'dist',
+    '.next',
+    '.nuxt',
+    '.cache',
+    '__pycache__',
+]);
+/**
+ * Files larger than this threshold are skipped to avoid loading huge binaries
+ * or generated assets into memory (1 MB).
+ */
+export const WALK_MAX_FILE_SIZE = 1024 * 1024; // 1 MB
+/**
+ * Recursively walk a directory tree, yielding all file paths whose size does
+ * not exceed {@link WALK_MAX_FILE_SIZE}. Hidden entries and entries in
+ * {@link WALK_SKIP_DIRS} are skipped. Unreadable directories are silently
+ * ignored so a single permission error never aborts the whole walk.
+ */
+export async function* walkDir(dirPath) {
+    let entries;
+    try {
+        entries = await readdir(dirPath, { withFileTypes: true });
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        // Skip hidden directories and known heavy directories
+        if (entry.name.startsWith('.') || WALK_SKIP_DIRS.has(entry.name))
+            continue;
+        const fullPath = join(dirPath, entry.name);
+        if (entry.isDirectory()) {
+            yield* walkDir(fullPath);
+        }
+        else if (entry.isFile()) {
+            try {
+                const info = await stat(fullPath);
+                if (info.size > WALK_MAX_FILE_SIZE)
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            yield fullPath;
+        }
+    }
+}

package/dist/platform/voice/builtin-providers.d.ts

@@ -0,0 +1,3 @@
+import { VoiceProviderRegistry } from './provider-registry.js';
+export declare function ensureBuiltinVoiceProviders(registry: VoiceProviderRegistry): void;
+//# sourceMappingURL=builtin-providers.d.ts.map

package/dist/platform/voice/builtin-providers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"builtin-providers.d.ts","sourceRoot":"","sources":["../../../src/platform/voice/builtin-providers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAQ/D,wBAAgB,2BAA2B,CAAC,QAAQ,EAAE,qBAAqB,GAAG,IAAI,CAOjF"}

package/dist/platform/voice/builtin-providers.js

@@ -0,0 +1,15 @@
+import { VoiceProviderRegistry } from './provider-registry.js';
+import { createDeepgramProvider } from './providers/deepgram.js';
+import { createElevenLabsProvider } from './providers/elevenlabs.js';
+import { createGoogleProvider } from './providers/google.js';
+import { createMicrosoftProvider } from './providers/microsoft.js';
+import { createOpenAIProvider } from './providers/openai.js';
+import { createVydraProvider } from './providers/vydra.js';
+export function ensureBuiltinVoiceProviders(registry) {
+    registry.register(createOpenAIProvider(), { replace: true });
+    registry.register(createDeepgramProvider(), { replace: true });
+    registry.register(createGoogleProvider(), { replace: true });
+    registry.register(createElevenLabsProvider(), { replace: true });
+    registry.register(createMicrosoftProvider(), { replace: true });
+    registry.register(createVydraProvider(), { replace: true });
+}

package/dist/platform/voice/index.d.ts

@@ -0,0 +1,7 @@
+export type { VoiceAudioArtifact, VoiceAudioFormat, VoiceDescriptor, VoiceProvider, VoiceProviderCapability, VoiceProviderState, VoiceProviderStatus, VoiceRealtimeSession, VoiceRealtimeSessionRequest, VoiceSynthesisRequest, VoiceSynthesisResult, VoiceTranscriptionRequest, VoiceTranscriptionResult, } from './types.js';
+export { VoiceProviderRegistry } from './provider-registry.js';
+export type { VoiceProviderDescriptor } from './provider-registry.js';
+export { VoiceService } from './service.js';
+export type { VoiceServiceStatus } from './service.js';
+export { ensureBuiltinVoiceProviders } from './builtin-providers.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/platform/voice/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/platform/voice/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,kBAAkB,EAClB,gBAAgB,EAChB,eAAe,EACf,aAAa,EACb,uBAAuB,EACvB,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,2BAA2B,EAC3B,qBAAqB,EACrB,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAC;AAC/D,YAAY,EAAE,uBAAuB,EAAE,MAAM,wBAAwB,CAAC;AACtE,OAAO,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAC5C,YAAY,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAC;AACvD,OAAO,EAAE,2BAA2B,EAAE,MAAM,wBAAwB,CAAC"}

package/dist/platform/voice/index.js

@@ -0,0 +1,3 @@
+export { VoiceProviderRegistry } from './provider-registry.js';
+export { VoiceService } from './service.js';
+export { ensureBuiltinVoiceProviders } from './builtin-providers.js';

package/dist/platform/voice/provider-registry.d.ts

@@ -0,0 +1,18 @@
+import type { VoiceProvider, VoiceProviderCapability, VoiceProviderStatus } from './types.js';
+export interface VoiceProviderDescriptor {
+    readonly id: string;
+    readonly label: string;
+    readonly capabilities: readonly VoiceProviderCapability[];
+}
+export declare class VoiceProviderRegistry {
+    private readonly providers;
+    register(provider: VoiceProvider, options?: {
+        readonly replace?: boolean;
+    }): () => void;
+    unregister(id: string): boolean;
+    get(id: string): VoiceProvider | null;
+    list(): VoiceProviderDescriptor[];
+    findProvider(capability: VoiceProviderCapability, providerId?: string): VoiceProvider | null;
+    status(): Promise<VoiceProviderStatus[]>;
+}
+//# sourceMappingURL=provider-registry.d.ts.map

package/dist/platform/voice/provider-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"provider-registry.d.ts","sourceRoot":"","sources":["../../../src/platform/voice/provider-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,aAAa,EACb,uBAAuB,EACvB,mBAAmB,EACpB,MAAM,YAAY,CAAC;AAEpB,MAAM,WAAW,uBAAuB;IACtC,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,YAAY,EAAE,SAAS,uBAAuB,EAAE,CAAC;CAC3D;AAED,qBAAa,qBAAqB;IAChC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAoC;IAE9D,QAAQ,CAAC,QAAQ,EAAE,aAAa,EAAE,OAAO,GAAE;QAAE,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO,GAAG,MAAM,IAAI;IAc3F,UAAU,CAAC,EAAE,EAAE,MAAM,GAAG,OAAO;IAI/B,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAIrC,IAAI,IAAI,uBAAuB,EAAE;IAUjC,YAAY,CAAC,UAAU,EAAE,uBAAuB,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI;IAQtF,MAAM,IAAI,OAAO,CAAC,mBAAmB,EAAE,CAAC;CAkB/C"}

package/dist/platform/voice/provider-registry.js

@@ -0,0 +1,58 @@
+export class VoiceProviderRegistry {
+    providers = new Map();
+    register(provider, options = {}) {
+        const id = provider.id.trim();
+        if (!id)
+            throw new Error('Voice provider id is required');
+        if (this.providers.has(id) && !options.replace) {
+            throw new Error(`Voice provider already registered: ${id}`);
+        }
+        const registered = { ...provider, id };
+        this.providers.set(id, registered);
+        return () => {
+            const current = this.providers.get(id);
+            if (current === registered)
+                this.unregister(id);
+        };
+    }
+    unregister(id) {
+        return this.providers.delete(id);
+    }
+    get(id) {
+        return this.providers.get(id) ?? null;
+    }
+    list() {
+        return [...this.providers.values()]
+            .map((provider) => ({
+            id: provider.id,
+            label: provider.label,
+            capabilities: [...provider.capabilities],
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+    findProvider(capability, providerId) {
+        if (providerId) {
+            const provider = this.get(providerId);
+            return provider?.capabilities.includes(capability) ? provider : null;
+        }
+        return [...this.providers.values()].find((provider) => provider.capabilities.includes(capability)) ?? null;
+    }
+    async status() {
+        const statuses = [];
+        for (const provider of this.providers.values()) {
+            if (provider.status) {
+                statuses.push(await provider.status());
+                continue;
+            }
+            statuses.push({
+                id: provider.id,
+                label: provider.label,
+                state: 'healthy',
+                capabilities: [...provider.capabilities],
+                configured: true,
+                metadata: {},
+            });
+        }
+        return statuses.sort((a, b) => a.label.localeCompare(b.label) || a.id.localeCompare(b.id));
+    }
+}

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

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

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

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

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

@@ -0,0 +1,54 @@
+import { buildStatus, normalizeBaseUrl, readFirstEnv, resolveAudioInput, } from './shared.js';
+export function createDeepgramProvider() {
+    const envVars = ['DEEPGRAM_API_KEY'];
+    const baseUrlEnvVars = ['DEEPGRAM_BASE_URL', 'DEEPGRAM_API_BASE'];
+    return {
+        id: 'deepgram',
+        label: 'Deepgram',
+        capabilities: ['stt'],
+        status() {
+            const configured = readFirstEnv(envVars) !== null;
+            return buildStatus('deepgram', 'Deepgram', ['stt'], configured, configured
+                ? 'Deepgram transcription API key available.'
+                : 'Set DEEPGRAM_API_KEY to enable Deepgram transcription.', {
+                baseUrl: normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.deepgram.com/v1'),
+            });
+        },
+        async transcribe(request) {
+            const apiKey = readFirstEnv(envVars);
+            if (!apiKey)
+                throw new Error('Deepgram API key missing');
+            const { buffer, mimeType } = await resolveAudioInput(request.audio);
+            const baseUrl = normalizeBaseUrl(readFirstEnv(baseUrlEnvVars), 'https://api.deepgram.com/v1');
+            const url = new URL(`${baseUrl}/listen`);
+            url.searchParams.set('model', request.modelId?.trim() || 'nova-3');
+            if (request.language?.trim())
+                url.searchParams.set('language', request.language.trim());
+            url.searchParams.set('smart_format', 'true');
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    Authorization: `Token ${apiKey}`,
+                    'Content-Type': mimeType || 'application/octet-stream',
+                },
+                body: Buffer.from(buffer),
+            });
+            if (!response.ok) {
+                throw new Error(`Deepgram transcription failed: HTTP ${response.status}`);
+            }
+            const payload = await response.json();
+            const text = payload.results?.channels?.[0]?.alternatives?.[0]?.transcript?.trim();
+            if (!text)
+                throw new Error('Deepgram transcription response missing transcript');
+            return {
+                providerId: 'deepgram',
+                text,
+                language: request.language,
+                metadata: {
+                    baseUrl,
+                    modelId: request.modelId?.trim() || 'nova-3',
+                },
+            };
+        },
+    };
+}

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

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

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

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