aillom-vox-client 1.0.2 → 2.1.0

package/dist/AillomVox.js

@@ -4,28 +4,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AillomVox = void 0;
+const constants_1 = require("./constants");
+const gateway_url_1 = require("./gateway-url");
 const isomorphic_ws_1 = __importDefault(require("isomorphic-ws"));
+function isNodeRuntime() {
+    return typeof process !== 'undefined' && Boolean(process.versions?.node);
+}
+function resolveHttpOrigin(baseUrl) {
+    if (baseUrl?.startsWith('wss://') || baseUrl?.startsWith('ws://')) {
+        return (0, gateway_url_1.httpOriginFromGatewayUrl)(baseUrl);
+    }
+    return baseUrl?.replace(/\/?$/, '') || constants_1.AILLOMVOX_DEFAULT_HTTP_ORIGIN;
+}
+function setSearchParams(url, params) {
+    for (const [key, value] of Object.entries(params)) {
+        if (value === undefined || value === null || String(value).trim() === '')
+            continue;
+        url.searchParams.set(key, String(value));
+    }
+}
+/**
+ * Browser or Node.js WebSocket client for the AillomVox voice gateway.
+ *
+ * Protocol summary: after `connect()`, the first outbound message must be the JSON `config`
+ * handshake (sent automatically). All further outbound binary messages are PCM16 mono chunks.
+ */
 class AillomVox {
     constructor(config) {
         this.ws = null;
         this.eventListeners = new Map();
         this.isConnected = false;
-        this.url = 'wss://wss.aillom.com/ws';
         this.config = config;
-        if (this.config.gatewayUrl) {
-            this.url = this.config.gatewayUrl;
-        }
-        if (!this.config.apiKey) {
+        this.url = (0, gateway_url_1.normalizeWebSocketUrl)(config.gatewayUrl);
+        if (!config.apiKey) {
             throw new Error('AillomVox: apiKey is required');
         }
     }
+    /** Resolved WebSocket URL after normalization. */
+    get websocketUrl() {
+        return this.url;
+    }
+    /** True when the underlying WebSocket is open. */
+    get connected() {
+        return Boolean(this.ws && this.ws.readyState === isomorphic_ws_1.default.OPEN);
+    }
     /**
-     * Connects to the AillomVox Gateway
+     * Connects to the gateway and sends the `config` handshake as the first message.
      */
     connect() {
         return new Promise((resolve, reject) => {
             try {
-                this.ws = new isomorphic_ws_1.default(this.url);
+                this.ws = this.createWebSocket();
                 this.ws.binaryType = 'arraybuffer';
                 this.ws.onopen = () => {
                     this.isConnected = true;
@@ -51,29 +80,71 @@ class AillomVox {
             }
         });
     }
+    createWebSocket() {
+        if (this.config.authMode === 'header' && !isNodeRuntime()) {
+            throw new Error('AillomVox: authMode "header" requires a Node.js runtime with WebSocket header support');
+        }
+        if (this.shouldUseHeaderAuth()) {
+            const WebSocketWithOptions = isomorphic_ws_1.default;
+            return new WebSocketWithOptions(this.url, [], {
+                headers: { 'x-api-key': this.config.apiKey },
+            });
+        }
+        return new isomorphic_ws_1.default(this.url);
+    }
+    shouldUseHeaderAuth() {
+        const mode = this.config.authMode ?? 'auto';
+        if (mode === 'header' || mode === 'both')
+            return isNodeRuntime();
+        return mode === 'auto' && isNodeRuntime();
+    }
+    shouldSendHandshakeApiKey() {
+        const mode = this.config.authMode ?? 'auto';
+        if (mode === 'handshake' || mode === 'both')
+            return true;
+        if (mode === 'header')
+            return false;
+        return !this.shouldUseHeaderAuth();
+    }
     /**
-     * Sends audio chunk (PCM 16-bit) to the AI
+     * Send microphone capture to the model. PCM16 LE mono at the configured `sampleRate`.
      */
     sendAudio(chunk) {
         if (!this.ws || this.ws.readyState !== isomorphic_ws_1.default.OPEN)
             return;
+        if (chunk instanceof Int16Array) {
+            this.ws.send(chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength));
+            return;
+        }
         this.ws.send(chunk);
     }
     /**
-     * Sends a tool result back to the AI
+     * Reply to a `tool_call` event within 15 seconds or the model may stall.
      */
     sendToolResult(callId, result) {
-        if (!this.ws || this.ws.readyState !== isomorphic_ws_1.default.OPEN)
-            return;
-        this.ws.send(JSON.stringify({
+        this.sendJson({
             type: 'tool_result',
             call_id: callId,
-            result: result
-        }));
+            result,
+        });
+    }
+    /** Ask the server to end the call (mirrors dashboard playground). */
+    sendHangup() {
+        this.sendJson({ type: 'hangup' });
+    }
+    /** Send a text turn over the same WebSocket session. */
+    sendText(text) {
+        this.sendJson({ type: 'text', data: text });
+    }
+    /** Send image payload data for gateways with vision support. */
+    sendImage(data) {
+        this.sendJson({ type: 'image', data });
+    }
+    sendJson(payload) {
+        if (!this.ws || this.ws.readyState !== isomorphic_ws_1.default.OPEN)
+            return;
+        this.ws.send(JSON.stringify(payload));
     }
-    /**
-     * Disconnects the session
-     */
     disconnect() {
         if (this.ws) {
             this.ws.close();
@@ -85,71 +156,285 @@ class AillomVox {
         if (!this.eventListeners.has(event)) {
             this.eventListeners.set(event, []);
         }
-        this.eventListeners.get(event)?.push(handler);
+        this.eventListeners.get(event).push(handler);
+    }
+    off(event, handler) {
+        const list = this.eventListeners.get(event);
+        if (!list)
+            return;
+        this.eventListeners.set(event, list.filter((h) => h !== handler));
     }
     sendConfig() {
         if (!this.ws)
             return;
         const payload = {
             type: 'config',
-            apikey: this.config.apiKey,
-            provider: this.config.provider || 'aillomvox',
-            voice: this.config.voice || 'Edward',
-            language: this.config.language || 'en-US',
-            sample_rate: this.config.sampleRate || 16000,
-            system_prompt: this.config.systemPrompt,
-            tools: this.config.tools,
-            webhook_url: this.config.webhookUrl,
-            max_duration: this.config.maxDuration
+            provider: (this.config.provider ?? 'aillomvox').toLowerCase(),
+            voice: this.config.voice ?? 'Aanya',
+            language: this.config.language ?? 'en-US',
+            sample_rate: this.config.sampleRate ?? 16000,
+            tools: this.config.tools ?? [],
         };
+        if (this.shouldSendHandshakeApiKey()) {
+            payload.apikey = this.config.apiKey;
+        }
+        if (this.config.systemPrompt !== undefined) {
+            payload.system_prompt = this.config.systemPrompt;
+        }
+        if (this.config.workspaceId) {
+            payload.workspace_id = this.config.workspaceId;
+        }
+        if (this.config.webhookUrl) {
+            payload.webhook_url = this.config.webhookUrl;
+        }
+        if (this.config.maxDuration !== undefined) {
+            payload.max_duration = this.config.maxDuration;
+        }
+        if (this.config.firstMessage !== undefined) {
+            payload.first_message = this.config.firstMessage;
+        }
+        if (this.config.farewellMessage !== undefined) {
+            payload.farewell_message = this.config.farewellMessage;
+        }
+        if (this.config.qualityProfile)
+            payload.quality_profile = this.config.qualityProfile;
+        if (this.config.toolTimeout !== undefined)
+            payload.tool_timeout = this.config.toolTimeout;
+        if (this.config.ttsBufferMs !== undefined)
+            payload.tts_buffer_ms = this.config.ttsBufferMs;
+        if (this.config.ttsEarlyStartMs !== undefined)
+            payload.tts_early_start_ms = this.config.ttsEarlyStartMs;
+        if (this.config.ttsMinChunkMs !== undefined)
+            payload.tts_min_chunk_ms = this.config.ttsMinChunkMs;
+        if (this.config.streamLlmTextToTts !== undefined)
+            payload.stream_llm_text_to_tts = this.config.streamLlmTextToTts;
+        if (this.config.accumulatorMs !== undefined)
+            payload.accumulator_ms = this.config.accumulatorMs;
+        if (this.config.extraConfig)
+            payload.extra_config = this.config.extraConfig;
+        const provider = String(payload.provider);
+        if (provider === 'aillomvox') {
+            payload.tts_engine = this.config.ttsEngine ?? 'inworld';
+        }
         if (this.config.debug) {
-            console.log('[AillomVox] Sending config:', JSON.stringify(payload, null, 2));
+            const redacted = { ...payload };
+            if (redacted.apikey)
+                redacted.apikey = '[REDACTED]';
+            console.log('[AillomVox] config:', JSON.stringify(redacted, null, 2));
         }
         this.ws.send(JSON.stringify(payload));
     }
     handleMessage(event) {
         const data = event.data;
-        // Handle Binary Audio
         if (data instanceof ArrayBuffer || (typeof Buffer !== 'undefined' && Buffer.isBuffer(data))) {
             this.emit('audio', data);
             return;
         }
-        // Handle JSON Control Messages
-        if (typeof data === 'string') {
-            try {
-                const msg = JSON.parse(data);
-                switch (msg.type) {
-                    case 'transcript':
-                        this.emit('transcript', msg);
-                        break;
-                    case 'tool_call':
-                        this.emit('tool_call', msg);
-                        break;
-                    case 'error':
-                        this.emit('error', msg);
-                        break;
-                    case 'interruption':
-                        this.emit('interruption', {});
-                        break;
-                    case 'hangup':
-                        this.disconnect();
-                        this.emit('disconnected', { reason: 'agent_hangup' });
-                        break;
-                    default:
-                        if (this.config.debug)
-                            console.log('[AillomVox] Data:', msg);
-                }
-            }
-            catch (e) {
-                console.error('[AillomVox] Failed to parse message:', e);
-            }
+        if (typeof data !== 'string')
+            return;
+        let msg;
+        try {
+            msg = JSON.parse(data);
+        }
+        catch {
+            console.error('[AillomVox] Non-JSON text message');
+            return;
+        }
+        this.emit('raw', msg);
+        const t = msg.type;
+        switch (t) {
+            case 'transcript':
+                this.emit('transcript', msg);
+                break;
+            case 'tool_call':
+                this.emit('tool_call', msg);
+                break;
+            case 'error':
+                this.emit('error', msg);
+                break;
+            case 'interruption':
+                this.emit('interruption', {});
+                break;
+            case 'playback_clear_buffer':
+                this.emit('playback_clear_buffer', {});
+                break;
+            case 'state':
+                this.emit('state', msg);
+                break;
+            case 'control':
+                this.emit('control', msg);
+                break;
+            case 'hangup':
+            case 'close':
+                this.disconnect();
+                this.emit('disconnected', { reason: 'server_hangup' });
+                break;
+            default:
+                if (this.config.debug)
+                    console.log('[AillomVox] message:', msg);
         }
     }
     emit(event, data) {
         const listeners = this.eventListeners.get(event);
-        if (listeners) {
-            listeners.forEach(handler => handler(data));
+        if (!listeners)
+            return;
+        for (const handler of listeners)
+            handler(data);
+    }
+    /**
+     * `GET /api/providers` — models and nested voices (public; optional auth for workspace scoping).
+     */
+    static async fetchProviders(options) {
+        const origin = resolveHttpOrigin(options?.baseUrl);
+        const url = new URL('/api/providers', origin.endsWith('/') ? origin : `${origin}/`);
+        setSearchParams(url, {
+            workspace_id: options?.workspaceId,
+            include_voices: options?.includeVoices === undefined ? undefined : options.includeVoices,
+        });
+        const headers = {};
+        if (options?.apiKey)
+            headers['x-api-key'] = options.apiKey;
+        const res = await fetch(url.toString(), { headers });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`fetchProviders failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /**
+     * `GET /api/pricing` — public USD/min rate card from the live gateway.
+     */
+    static async fetchPricing(options) {
+        const origin = resolveHttpOrigin(options?.baseUrl);
+        const url = new URL('/api/pricing', origin.endsWith('/') ? origin : `${origin}/`);
+        const res = await fetch(url.toString());
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`fetchPricing failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /**
+     * `GET /api/voices` — optional provider filter matches dashboard catalog keys.
+     */
+    static async fetchVoices(options) {
+        const origin = resolveHttpOrigin(options?.baseUrl);
+        const url = new URL('/api/voices', origin.endsWith('/') ? origin : `${origin}/`);
+        setSearchParams(url, {
+            provider: options.provider,
+            workspace_id: options.workspaceId,
+            page_size: options.pageSize,
+            page_number: options.pageNumber,
+            max_pages: options.maxPages,
+            q: options.q,
+            title: options.title,
+            tag: options.tag,
+            language: options.language,
+            title_language: options.titleLanguage,
+            sort_by: options.sortBy,
+            preferred_language: options.preferredLanguage,
+            type: options.type,
+            scope: options.scope,
+            visibility: options.visibility,
+        });
+        const headers = {};
+        if (options?.apiKey)
+            headers['x-api-key'] = options.apiKey;
+        const res = await fetch(url.toString(), { headers });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`fetchVoices failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /** Build the public `/api/voices/preview` URL for a provider voice. */
+    static buildVoicePreviewUrl(options) {
+        const origin = resolveHttpOrigin(options.baseUrl);
+        const url = new URL('/api/voices/preview', origin.endsWith('/') ? origin : `${origin}/`);
+        setSearchParams(url, {
+            provider: options.provider,
+            voice: options.voice,
+        });
+        return url.toString();
+    }
+    /** `GET /api/voices/preview` — returns an audio Blob for UI preview playback. */
+    static async fetchVoicePreview(options) {
+        const res = await fetch(AillomVox.buildVoicePreviewUrl(options));
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`fetchVoicePreview failed (${res.status}): ${body}`);
+        }
+        return res.blob();
+    }
+    /** `DELETE /api/voices/:id` — removes a workspace-owned cloned voice. */
+    static async deleteVoice(voiceId, apiKey, options = {}) {
+        const origin = resolveHttpOrigin(options.baseUrl);
+        const url = new URL(`/api/voices/${encodeURIComponent(voiceId)}`, origin.endsWith('/') ? origin : `${origin}/`);
+        setSearchParams(url, {
+            provider: options.provider,
+            workspace_id: options.workspaceId,
+        });
+        const res = await fetch(url.toString(), {
+            method: 'DELETE',
+            headers: { 'x-api-key': apiKey },
+        });
+        if (!res.ok) {
+            const body = await res.text();
+            throw new Error(`deleteVoice failed (${res.status}): ${body}`);
+        }
+        return res.json();
+    }
+    /**
+     * Upload a short clean recording to create a cloned voice handle.
+     */
+    static async cloneVoice(clip, apiKey, options = {}) {
+        const data = await AillomVox.cloneVoiceDetailed(clip, apiKey, options);
+        if (!data.voice_id) {
+            throw new Error(data.message || 'Voice clone did not return a voice_id');
+        }
+        return data.voice_id;
+    }
+    /**
+     * Upload a short clean recording and return the full multi-provider clone response.
+     */
+    static async cloneVoiceDetailed(clip, apiKey, options = {}) {
+        const origin = resolveHttpOrigin(options.baseUrl || options.gatewayUrl);
+        const formData = new FormData();
+        formData.append('clip', clip, options.filename || 'clone.wav');
+        if (options.name)
+            formData.append('name', options.name);
+        if (options.description)
+            formData.append('description', options.description);
+        if (options.providers?.length)
+            formData.append('providers', options.providers.join(','));
+        if (options.workspaceId)
+            formData.append('workspace_id', options.workspaceId);
+        if (options.language)
+            formData.append('language', options.language);
+        if (options.transcription || options.transcript)
+            formData.append('transcription', options.transcription || options.transcript || '');
+        if (options.gender)
+            formData.append('gender', options.gender);
+        if (options.accent)
+            formData.append('accent', options.accent);
+        if (options.age)
+            formData.append('age', options.age);
+        if (options.tone)
+            formData.append('tone', options.tone);
+        if (options.useCase)
+            formData.append('use_case', options.useCase);
+        const response = await fetch(`${origin.replace(/\/?$/, '')}/api/voices/clone`, {
+            method: 'POST',
+            headers: {
+                'x-api-key': apiKey,
+            },
+            body: formData,
+        });
+        if (!response.ok) {
+            const err = (await response.json().catch(() => ({})));
+            throw new Error(err.error || `Failed to clone voice: ${response.status}`);
         }
+        return (await response.json());
     }
 }
 exports.AillomVox = AillomVox;

package/dist/constants.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Canonical endpoints — keep in sync with `aillom-vox/flow-src/src/constants/publicGateway.ts`.
+ */
+export declare const AILLOMVOX_DEFAULT_WS_URL = "wss://vox.aillom.com/ws";
+/** @deprecated Hostname only — use {@link AILLOMVOX_DEFAULT_WS_URL}. The SDK rewrites this to `vox.aillom.com` in {@link migrateLegacyGatewayUrl}. */
+export declare const AILLOMVOX_LEGACY_WS_URL = "wss://wss.aillom.com/ws";
+export declare const AILLOMVOX_DEFAULT_HTTP_ORIGIN = "https://vox.aillom.com";
+/**
+ * Providers exposed in the public playground (`aillom-vox` WebSocket `provider` field).
+ * The server accepts aliases (case-insensitive); see docs on the dashboard.
+ */
+export declare const AILLOMVOX_PUBLIC_PROVIDERS: readonly ["aillomvox", "aws", "gemini", "grok", "openai", "qwen", "ultravox"];
+export type AillomVoxPublicProviderId = (typeof AILLOMVOX_PUBLIC_PROVIDERS)[number];
+/**
+ * When `provider === "aillomvox"`, the gateway selects a TTS stack via `tts_engine`
+ * (see `GET /api/providers` → `aillomvox.tts_options`).
+ */
+export declare const AILLOMVOX_TTS_ENGINES: readonly ["inworld", "xai", "lmnt", "soniox", "rime", "fish"];
+export type AillomVoxTtsEngineId = (typeof AILLOMVOX_TTS_ENGINES)[number];

package/dist/constants.js

@@ -0,0 +1,35 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AILLOMVOX_TTS_ENGINES = exports.AILLOMVOX_PUBLIC_PROVIDERS = exports.AILLOMVOX_DEFAULT_HTTP_ORIGIN = exports.AILLOMVOX_LEGACY_WS_URL = exports.AILLOMVOX_DEFAULT_WS_URL = void 0;
+/**
+ * Canonical endpoints — keep in sync with `aillom-vox/flow-src/src/constants/publicGateway.ts`.
+ */
+exports.AILLOMVOX_DEFAULT_WS_URL = 'wss://vox.aillom.com/ws';
+/** @deprecated Hostname only — use {@link AILLOMVOX_DEFAULT_WS_URL}. The SDK rewrites this to `vox.aillom.com` in {@link migrateLegacyGatewayUrl}. */
+exports.AILLOMVOX_LEGACY_WS_URL = 'wss://wss.aillom.com/ws';
+exports.AILLOMVOX_DEFAULT_HTTP_ORIGIN = 'https://vox.aillom.com';
+/**
+ * Providers exposed in the public playground (`aillom-vox` WebSocket `provider` field).
+ * The server accepts aliases (case-insensitive); see docs on the dashboard.
+ */
+exports.AILLOMVOX_PUBLIC_PROVIDERS = [
+    'aillomvox',
+    'aws',
+    'gemini',
+    'grok',
+    'openai',
+    'qwen',
+    'ultravox',
+];
+/**
+ * When `provider === "aillomvox"`, the gateway selects a TTS stack via `tts_engine`
+ * (see `GET /api/providers` → `aillomvox.tts_options`).
+ */
+exports.AILLOMVOX_TTS_ENGINES = [
+    'inworld',
+    'xai',
+    'lmnt',
+    'soniox',
+    'rime',
+    'fish',
+];

package/dist/gateway-url.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rewrites `wss.aillom.com` (legacy) to `vox.aillom.com` so old configs keep working.
+ */
+export declare function migrateLegacyGatewayUrl(url: string): string;
+/**
+ * Normalizes user input into a WebSocket URL ending with `/ws`.
+ * Accepts `wss://…/ws`, `https://vox.aillom.com`, or `wss://vox.aillom.com`.
+ * Legacy `https://wss.aillom.com` / `wss://wss.aillom.com/ws` is migrated to **vox**.
+ */
+export declare function normalizeWebSocketUrl(gatewayUrl?: string): string;
+/** Converts a gateway WebSocket base URL into `https://` origin for REST (`/api/*`). */
+export declare function httpOriginFromGatewayUrl(gatewayUrl?: string): string;

package/dist/gateway-url.js

@@ -0,0 +1,74 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.migrateLegacyGatewayUrl = migrateLegacyGatewayUrl;
+exports.normalizeWebSocketUrl = normalizeWebSocketUrl;
+exports.httpOriginFromGatewayUrl = httpOriginFromGatewayUrl;
+const constants_1 = require("./constants");
+/** Query parameter names that must not carry secrets (logs, referrers, browser history). */
+const SENSITIVE_WS_QUERY_KEYS = new Set(['apikey', 'api_key', 'x-api-key', 'token', 'secret']);
+function warnIfWebSocketUrlLeaksCredentials(url) {
+    try {
+        const { searchParams } = new URL(url);
+        for (const name of searchParams.keys()) {
+            if (SENSITIVE_WS_QUERY_KEYS.has(name.toLowerCase())) {
+                console.warn('[AillomVox] Do not put API keys in the WebSocket URL query string. ' +
+                    'Use `x-api-key` headers in Node.js or the JSON `config` `apikey` field in browsers. ' +
+                    'Query credentials appear in logs, proxies, and analytics.');
+                return;
+            }
+        }
+    }
+    catch {
+        /* invalid URL — caller may pass partial strings; ignore */
+    }
+}
+/** Legacy WebSocket hostname — rewritten to `vox.aillom.com` for all clients. */
+const LEGACY_GATEWAY_HOSTNAME = 'wss.aillom.com';
+const CANONICAL_GATEWAY_HOSTNAME = 'vox.aillom.com';
+/**
+ * Rewrites `wss.aillom.com` (legacy) to `vox.aillom.com` so old configs keep working.
+ */
+function migrateLegacyGatewayUrl(url) {
+    try {
+        const parsed = new URL(url);
+        if (parsed.hostname === LEGACY_GATEWAY_HOSTNAME) {
+            parsed.hostname = CANONICAL_GATEWAY_HOSTNAME;
+            return parsed.toString();
+        }
+    }
+    catch {
+        /* ignore */
+    }
+    return url;
+}
+/**
+ * Normalizes user input into a WebSocket URL ending with `/ws`.
+ * Accepts `wss://…/ws`, `https://vox.aillom.com`, or `wss://vox.aillom.com`.
+ * Legacy `https://wss.aillom.com` / `wss://wss.aillom.com/ws` is migrated to **vox**.
+ */
+function normalizeWebSocketUrl(gatewayUrl) {
+    if (!gatewayUrl?.trim()) {
+        return constants_1.AILLOMVOX_DEFAULT_WS_URL;
+    }
+    let u = migrateLegacyGatewayUrl(gatewayUrl.trim());
+    if (u.startsWith('https://')) {
+        u = `wss://${u.slice('https://'.length)}`;
+    }
+    else if (u.startsWith('http://')) {
+        u = `ws://${u.slice('http://'.length)}`;
+    }
+    if (!/\/ws\/?($|\?)/i.test(u)) {
+        u = `${u.replace(/\/?$/, '')}/ws`;
+    }
+    warnIfWebSocketUrlLeaksCredentials(u);
+    return u;
+}
+/** Converts a gateway WebSocket base URL into `https://` origin for REST (`/api/*`). */
+function httpOriginFromGatewayUrl(gatewayUrl) {
+    if (!gatewayUrl?.trim()) {
+        return constants_1.AILLOMVOX_DEFAULT_HTTP_ORIGIN;
+    }
+    const ws = normalizeWebSocketUrl(gatewayUrl);
+    const withoutPath = ws.replace(/\/ws\/?$/i, '').replace(/\/ws\?.*$/i, '');
+    return withoutPath.replace(/^wss:\/\//i, 'https://').replace(/^ws:\/\//i, 'http://');
+}

package/dist/index.d.ts

@@ -1,2 +1,5 @@
 export * from './types';
+export * from './constants';
+export * from './gateway-url';
+export * from './pricing';
 export * from './AillomVox';

package/dist/index.js

@@ -15,4 +15,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./types"), exports);
+__exportStar(require("./constants"), exports);
+__exportStar(require("./gateway-url"), exports);
+__exportStar(require("./pricing"), exports);
 __exportStar(require("./AillomVox"), exports);

package/dist/pricing.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Public rate card (USD per **billed** minute of voice usage), aligned with the
+ * marketing table on https://vox.aillom.com and `GET /api/pricing`.
+ *
+ * **Do not treat this as a legal quote** — always confirm charges in the billing
+ * dashboard; `GET /api/providers` may expose model metadata but not necessarily
+ * your negotiated rates.
+ */
+export type VoxRateTier = 'Gateway' | 'S2S' | 'Premium';
+export interface VoxProviderRateRow {
+    /** Row label on the marketing site */
+    label: string;
+    /** WebSocket handshake `provider` field */
+    provider: string;
+    /**
+     * When `provider === "aillomvox"`, this hints the currently documented
+     * TTS lanes. Omit when not applicable.
+     */
+    ttsEngineHint?: string;
+    usdPerMinute: number;
+    tier: VoxRateTier;
+    /** Short model / stack description from the live site */
+    modelSummary: string;
+    badge?: string;
+}
+export declare const VOX_PROVIDER_RATECARD: readonly VoxProviderRateRow[];