@recombine-ai/platform 0.2.6-test.8 → 0.3.0

package/build/call-control/call-control.js

@@ -0,0 +1,207 @@
+import { DataPacket_Kind, RoomServiceClient } from 'livekit-server-sdk';
+import { NoopCallDetailsStorage } from './call-details/noop-storage';
+import { SipManager } from './sip';
+import { CallDataTopic, CallSignalType } from './types';
+import { CallControlError, getCallIdFromRoomName, getLiveKitConnectionOptions } from './utils';
+export const DEFAULT_ROOM_PREFIX = 'call';
+const STALE_FREEZE_MS = 30 * 60 * 1000;
+export class CallControl {
+    roomService;
+    livekit;
+    sips = new Map();
+    storage;
+    conversationalTracer;
+    eventTracer;
+    freezeStarts = new Map();
+    logger;
+    constructor({ livekit = {}, storage, conversationalTracer, eventTracer }, logger = console) {
+        const { url, key, secret } = getLiveKitConnectionOptions(livekit);
+        this.roomService = new RoomServiceClient(url, key, secret);
+        this.livekit = livekit;
+        this.storage = storage ?? new NoopCallDetailsStorage();
+        this.conversationalTracer = conversationalTracer;
+        this.eventTracer = eventTracer;
+        this.logger = logger;
+    }
+    async trace(eventName, callId, content) {
+        if (!this.conversationalTracer)
+            return;
+        try {
+            this.conversationalTracer.addConversationalTrace({
+                conversationId: callId,
+                eventName,
+                role: 'agent',
+                medium: 'phone',
+                content,
+                createdAt: Date.now(),
+            });
+            await this.conversationalTracer.flush();
+        }
+        catch (err) {
+            this.logger.error('Failed to write conversational trace', { err });
+        }
+    }
+    endFreeze(callId, endedBy) {
+        const startedAt = this.freezeStarts.get(callId);
+        if (startedAt === undefined)
+            return;
+        this.freezeStarts.delete(callId);
+        this.eventTracer?.emit({
+            event: 'workflow.freeze.outlier',
+            attributes: {
+                conversationId: callId,
+                durationMs: Date.now() - startedAt,
+                endedBy,
+            },
+        });
+    }
+    dropStaleFreezes() {
+        const oldest = Date.now() - STALE_FREEZE_MS;
+        for (const [callId, startedAt] of this.freezeStarts) {
+            if (startedAt < oldest)
+                this.freezeStarts.delete(callId);
+        }
+    }
+    async sendSignalToRoom(room, signal, packetType = DataPacket_Kind.RELIABLE, topic = CallDataTopic.AgentSignal) {
+        const data = Buffer.from(JSON.stringify(signal));
+        await this.roomService.sendData(room.name, data, packetType, { topic });
+    }
+    async setVoiceSettings(callId, settings) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.UpdateSettings,
+            payload: settings,
+        });
+        this.logger.info('Settings update request sent', { settings });
+    }
+    async setUpSip(agentName, sip) {
+        const options = {
+            ...sip,
+            roomPrefix: sip.roomPrefix ?? DEFAULT_ROOM_PREFIX,
+            livekit: this.livekit,
+            agentName,
+        };
+        const sipManager = new SipManager(options, this.logger);
+        await this.waitForHealth();
+        await sipManager.setup();
+        this.sips.set(agentName, sipManager);
+    }
+    async freeze(callId, muteBackgroundAudio = true) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.Freeze,
+            payload: { mute_background_audio: muteBackgroundAudio },
+        });
+        this.dropStaleFreezes();
+        if (!this.freezeStarts.has(callId)) {
+            this.freezeStarts.set(callId, Date.now());
+        }
+    }
+    async unfreeze(callId) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.Unfreeze,
+        });
+        this.endFreeze(callId, 'unfreeze');
+    }
+    async steer(callId, payload) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.Steer,
+            payload,
+        });
+        if (payload.respond) {
+            this.endFreeze(callId, 'steer');
+        }
+    }
+    async addMessage(callId, message) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.SendMessage,
+            payload: { content: message.text, role: message.sender },
+        });
+    }
+    async reload(callId) {
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.Reload,
+        });
+        this.endFreeze(callId, 'reload');
+    }
+    async transfer(agentName, destination, callId, headers, reason = 'escalation', disclaimer, waitBefore = 500) {
+        await this.trace('transfer-requested', callId, destination);
+        this.eventTracer?.emit({
+            event: 'agent.escalation.requested',
+            attributes: {
+                conversationId: callId,
+                agentId: agentName,
+                escalationReason: reason,
+                channel: 'phone',
+            },
+        });
+        if (waitBefore > 0) {
+            await new Promise((resolve) => setTimeout(resolve, waitBefore));
+        }
+        const room = await this.getRoomByCallId(callId);
+        const sipTrunkId = await this.sips.get(agentName)?.getTransferTrunkId();
+        if (!sipTrunkId) {
+            this.logger.warn('Transfer requested without SIP trunk configured: proceeding with empty `sipTrunkId`', { agentName, callId, destination, reason });
+        }
+        const request = {
+            to: destination,
+            ...(sipTrunkId ? { sipTrunkId } : {}),
+            ...(headers ? { headers } : {}),
+            ...(disclaimer ? { disclaimer } : {}),
+            reason,
+            playDialtone: true,
+        };
+        this.logger.info('Transfer requested', { request });
+        await this.sendSignalToRoom(room, { signal: CallSignalType.Transfer, payload: request });
+        this.endFreeze(callId, 'transfer');
+    }
+    async hangup(callId, waitBefore = 500) {
+        await this.trace('hangup-requested', callId, 'hangup');
+        if (waitBefore > 0) {
+            await new Promise((resolve) => setTimeout(resolve, waitBefore));
+        }
+        await this.sendSignalToRoom(await this.getRoomByCallId(callId), {
+            signal: CallSignalType.HangUp,
+        });
+        this.endFreeze(callId, 'hangup');
+    }
+    async getCallDetails(callId) {
+        return await this.storage.get(callId);
+    }
+    async healthCheck() {
+        try {
+            await this.roomService.listRooms();
+            return true;
+        }
+        catch (err) {
+            console.error('LiveKit health-check error', { err });
+            return false;
+        }
+    }
+    async waitForHealth(retries = 5, baseDelayMs = 1000) {
+        let isHealthy = false;
+        for (let attempt = 0; attempt < retries; attempt++) {
+            this.logger.debug('Checking LiveKit connection...', { attempt: attempt + 1, retries });
+            isHealthy = await this.healthCheck();
+            if (isHealthy) {
+                break;
+            }
+            if (attempt === retries - 1) {
+                throw new CallControlError(`Failed to connect to LiveKit after ${retries} attempts`);
+            }
+            const delayMs = baseDelayMs * Math.pow(2, attempt);
+            this.logger.error('Failed to connect to LiveKit, retrying...', { delayMs });
+            await new Promise((resolve) => setTimeout(resolve, delayMs));
+        }
+        return isHealthy;
+    }
+    async getRoomByCallId(callId) {
+        const roomsList = await this.roomService.listRooms();
+        const room = roomsList.find(({ name }) => getCallIdFromRoomName(name) === callId);
+        if (!room) {
+            const err = new CallControlError(`Room not found for call [${callId}]`);
+            this.logger.error('Room not found', { callId, err });
+            throw err;
+        }
+        return room;
+    }
+}
+export { CallControlError };

package/build/call-control/call-details/index.d.ts

@@ -0,0 +1,2 @@
+export { NoopCallDetailsStorage } from './noop-storage';
+//# sourceMappingURL=index.d.ts.map

package/build/call-control/call-details/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/call-control/call-details/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA"}

package/build/call-control/call-details/index.js

@@ -0,0 +1 @@
+export { NoopCallDetailsStorage } from './noop-storage';

package/build/call-control/call-details/noop-storage.d.ts

@@ -0,0 +1,10 @@
+import type { CallDetails, CallDetailsStorage } from '../types';
+export declare class NoopCallDetailsStorage implements CallDetailsStorage {
+    get(_: string): Promise<CallDetails | null>;
+    list(): Promise<Array<{
+        sid: string;
+        date: Date;
+    }>>;
+    delete(_: string): Promise<void>;
+}
+//# sourceMappingURL=noop-storage.d.ts.map

package/build/call-control/call-details/noop-storage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"noop-storage.d.ts","sourceRoot":"","sources":["../../../src/call-control/call-details/noop-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE/D,qBAAa,sBAAuB,YAAW,kBAAkB;IACvD,GAAG,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC;IAI3C,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC;QAAE,GAAG,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAE,CAAC,CAAC;IAInD,MAAM,CAAC,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;CAGzC"}

package/build/call-control/call-details/noop-storage.js

@@ -0,0 +1,11 @@
+export class NoopCallDetailsStorage {
+    async get(_) {
+        return null;
+    }
+    async list() {
+        return [];
+    }
+    async delete(_) {
+        return;
+    }
+}

package/build/call-control/index.d.ts

@@ -0,0 +1,7 @@
+export { CallDataTopic, CallSignalType, IncludeHeaders, MediaEncryption, Room, SipDispatchRule, SipInboundTrunk, SipOutboundTrunk, Transport, voiceAgentConfigSchema, voiceAgentDefaultConfig, } from './types';
+export type { AddMessagePayload, CallControlOptions, CallDetails, CallDetailsStorage, CallSignalRequest, ConversationalTrace, ConversationalTracer, EventTracer, FreezeEnd, FreezePayload, LiveKitConnectionOptions, LiveKitConnectionOptionsPartial, Logger, Message, MonitoringEvent, SipInboundTrunkConfig, SipManagerOptions, SipOptions, SipOutboundTrunkConfig, SipTrunks, SipResource, SipResourceMap, SteerPayload, TranscriptItem, TransferReason, TransferRequest, VoiceAgentConfig, VoiceAgentConfigField, } from './types';
+export type { ICallControl } from './port';
+export { NoopCallDetailsStorage } from './call-details';
+export { SipManager, SipError } from './sip';
+export { CallControl, CallControl as default, DEFAULT_ROOM_PREFIX, CallControlError, } from './call-control';
+//# sourceMappingURL=index.d.ts.map

package/build/call-control/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/call-control/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACH,aAAa,EACb,cAAc,EACd,cAAc,EACd,eAAe,EACf,IAAI,EACJ,eAAe,EACf,eAAe,EACf,gBAAgB,EAChB,SAAS,EACT,sBAAsB,EACtB,uBAAuB,GAC1B,MAAM,SAAS,CAAA;AAChB,YAAY,EACR,iBAAiB,EACjB,kBAAkB,EAClB,WAAW,EACX,kBAAkB,EAClB,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,WAAW,EACX,SAAS,EACT,aAAa,EACb,wBAAwB,EACxB,+BAA+B,EAC/B,MAAM,EACN,OAAO,EACP,eAAe,EACf,qBAAqB,EACrB,iBAAiB,EACjB,UAAU,EACV,sBAAsB,EACtB,SAAS,EACT,WAAW,EACX,cAAc,EACd,YAAY,EACZ,cAAc,EACd,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,qBAAqB,GACxB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAA;AAC1C,OAAO,EAAE,sBAAsB,EAAE,MAAM,gBAAgB,CAAA;AACvD,OAAO,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,OAAO,CAAA;AAC5C,OAAO,EACH,WAAW,EACX,WAAW,IAAI,OAAO,EACtB,mBAAmB,EACnB,gBAAgB,GACnB,MAAM,gBAAgB,CAAA"}

package/build/call-control/index.js

@@ -0,0 +1,4 @@
+export { CallDataTopic, CallSignalType, IncludeHeaders, MediaEncryption, Room, SipDispatchRule, SipInboundTrunk, SipOutboundTrunk, Transport, voiceAgentConfigSchema, voiceAgentDefaultConfig, } from './types';
+export { NoopCallDetailsStorage } from './call-details';
+export { SipManager, SipError } from './sip';
+export { CallControl, CallControl as default, DEFAULT_ROOM_PREFIX, CallControlError, } from './call-control';

package/build/call-control/port.d.ts

@@ -0,0 +1,15 @@
+import { Message } from '../engine';
+import { CallDetails, SipOptions, SteerPayload, TransferReason, VoiceAgentConfig } from './types';
+export interface ICallControl {
+    setUpSip(agentName: string, sip: SipOptions): Promise<void>;
+    freeze(callId: string): Promise<void>;
+    unfreeze(callId: string): Promise<void>;
+    steer(callId: string, payload: SteerPayload): Promise<void>;
+    addMessage(callId: string, message: Message): Promise<void>;
+    setVoiceSettings(callId: string, settings: VoiceAgentConfig): Promise<void>;
+    reload(callId: string): Promise<void>;
+    transfer(agentName: string, destination: string, callId: string, headers?: Record<string, string>, reason?: TransferReason, disclaimer?: string, waitBefore?: number): Promise<void>;
+    hangup(callId: string, waitBefore?: number): Promise<void>;
+    getCallDetails(callId: string): Promise<CallDetails | null>;
+}
+//# sourceMappingURL=port.d.ts.map

package/build/call-control/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","sourceRoot":"","sources":["../../src/call-control/port.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACnC,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,YAAY,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAA;AAGjG,MAAM,WAAW,YAAY;IACzB,QAAQ,CAAC,SAAS,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3D,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAErC,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEvC,KAAK,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3D,UAAU,CAAC,MAAM,EAAE,MAAM,EAAE,OAAO,EAAE,OAAO,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3D,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE3E,MAAM,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAErC,QAAQ,CACJ,SAAS,EAAE,MAAM,EACjB,WAAW,EAAE,MAAM,EACnB,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,EAChC,MAAM,CAAC,EAAE,cAAc,EACvB,UAAU,CAAC,EAAE,MAAM,EACnB,UAAU,CAAC,EAAE,MAAM,GACpB,OAAO,CAAC,IAAI,CAAC,CAAA;IAEhB,MAAM,CAAC,MAAM,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE1D,cAAc,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC,WAAW,GAAG,IAAI,CAAC,CAAA;CAC9D"}

package/build/call-control/port.js

@@ -0,0 +1 @@
+export {};

package/build/call-control/schemas.generated.d.ts

@@ -0,0 +1,156 @@
+import { z } from 'zod';
+export declare const configSchema: z.ZodObject<{
+    agent_background_audio_volume: z.ZodDefault<z.ZodNumber>;
+    agent_background_audio_autopause: z.ZodDefault<z.ZodBoolean>;
+    session_turn_detection: z.ZodDefault<z.ZodEnum<{
+        stt: "stt";
+        vad: "vad";
+        model_multi: "model_multi";
+        model_en: "model_en";
+    }>>;
+    session_allow_interruptions: z.ZodDefault<z.ZodBoolean>;
+    agent_dynamic_interruption_escalation: z.ZodDefault<z.ZodBoolean>;
+    session_min_interruption_words: z.ZodDefault<z.ZodNumber>;
+    session_min_interruption_duration: z.ZodDefault<z.ZodNumber>;
+    session_min_endpointing_delay: z.ZodDefault<z.ZodNumber>;
+    session_max_endpointing_delay: z.ZodDefault<z.ZodNumber>;
+    session_preemptive_generation: z.ZodDefault<z.ZodBoolean>;
+    vad_min_speech_duration: z.ZodDefault<z.ZodNumber>;
+    vad_min_silence_duration: z.ZodDefault<z.ZodNumber>;
+    vad_prefix_padding_duration: z.ZodDefault<z.ZodNumber>;
+    vad_max_buffered_speech: z.ZodDefault<z.ZodNumber>;
+    vad_activation_threshold: z.ZodDefault<z.ZodNumber>;
+    vad_deactivation_threshold: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+    vad_sample_rate: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<8000>, z.ZodLiteral<16000>]>>;
+    stt_api_version: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<1>, z.ZodLiteral<2>]>>;
+    stt_model: z.ZodDefault<z.ZodUnion<readonly [z.ZodLiteral<"flux-general-en">, z.ZodEnum<{
+        "nova-general": "nova-general";
+        "nova-phonecall": "nova-phonecall";
+        "nova-meeting": "nova-meeting";
+        "nova-2-general": "nova-2-general";
+        "nova-2-meeting": "nova-2-meeting";
+        "nova-2-phonecall": "nova-2-phonecall";
+        "nova-2-finance": "nova-2-finance";
+        "nova-2-conversationalai": "nova-2-conversationalai";
+        "nova-2-voicemail": "nova-2-voicemail";
+        "nova-2-video": "nova-2-video";
+        "nova-2-medical": "nova-2-medical";
+        "nova-2-drivethru": "nova-2-drivethru";
+        "nova-2-automotive": "nova-2-automotive";
+        "nova-3": "nova-3";
+        "nova-3-general": "nova-3-general";
+        "nova-3-medical": "nova-3-medical";
+        "enhanced-general": "enhanced-general";
+        "enhanced-meeting": "enhanced-meeting";
+        "enhanced-phonecall": "enhanced-phonecall";
+        "enhanced-finance": "enhanced-finance";
+        base: "base";
+        meeting: "meeting";
+        phonecall: "phonecall";
+        finance: "finance";
+        conversationalai: "conversationalai";
+        voicemail: "voicemail";
+        video: "video";
+        "whisper-tiny": "whisper-tiny";
+        "whisper-base": "whisper-base";
+        "whisper-small": "whisper-small";
+        "whisper-medium": "whisper-medium";
+        "whisper-large": "whisper-large";
+    }>]>>;
+    stt_language: z.ZodDefault<z.ZodEnum<{
+        no: "no";
+        zh: "zh";
+        "zh-CN": "zh-CN";
+        "zh-TW": "zh-TW";
+        da: "da";
+        nl: "nl";
+        en: "en";
+        "en-US": "en-US";
+        "en-AU": "en-AU";
+        "en-GB": "en-GB";
+        "en-NZ": "en-NZ";
+        "en-IN": "en-IN";
+        fr: "fr";
+        "fr-CA": "fr-CA";
+        de: "de";
+        hi: "hi";
+        "hi-Latn": "hi-Latn";
+        pt: "pt";
+        "pt-BR": "pt-BR";
+        es: "es";
+        "es-419": "es-419";
+        it: "it";
+        ja: "ja";
+        ko: "ko";
+        pl: "pl";
+        "es-LATAM": "es-LATAM";
+        sv: "sv";
+        ta: "ta";
+        taq: "taq";
+        uk: "uk";
+        tr: "tr";
+        id: "id";
+        ru: "ru";
+        th: "th";
+        multi: "multi";
+    }>>;
+    stt_detect_language: z.ZodDefault<z.ZodBoolean>;
+    stt_interim_results: z.ZodDefault<z.ZodBoolean>;
+    stt_punctuate: z.ZodDefault<z.ZodBoolean>;
+    stt_smart_format: z.ZodDefault<z.ZodBoolean>;
+    stt_sample_rate: z.ZodDefault<z.ZodNumber>;
+    stt_no_delay: z.ZodDefault<z.ZodBoolean>;
+    stt_endpointing_ms: z.ZodDefault<z.ZodNumber>;
+    stt_filler_words: z.ZodDefault<z.ZodBoolean>;
+    stt_keyterms: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stt_tags: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    stt_profanity_filter: z.ZodDefault<z.ZodBoolean>;
+    stt_eager_eot_threshold: z.ZodDefault<z.ZodUnion<readonly [z.ZodNumber, z.ZodNull]>>;
+    stt_eot_threshold: z.ZodDefault<z.ZodNumber>;
+    stt_eot_timeout_ms: z.ZodDefault<z.ZodNumber>;
+    tts_voice_id: z.ZodDefault<z.ZodString>;
+    tts_voice_similarity_boost: z.ZodDefault<z.ZodNumber>;
+    tts_voice_stability: z.ZodDefault<z.ZodNumber>;
+    tts_voice_speed: z.ZodDefault<z.ZodNumber>;
+    tts_voice_style: z.ZodDefault<z.ZodNumber>;
+    tts_voice_use_speaker_boost: z.ZodDefault<z.ZodBoolean>;
+    tts_model: z.ZodDefault<z.ZodEnum<{
+        eleven_monolingual_v1: "eleven_monolingual_v1";
+        eleven_multilingual_v1: "eleven_multilingual_v1";
+        eleven_multilingual_v2: "eleven_multilingual_v2";
+        eleven_turbo_v2: "eleven_turbo_v2";
+        eleven_turbo_v2_5: "eleven_turbo_v2_5";
+        eleven_flash_v2_5: "eleven_flash_v2_5";
+        eleven_flash_v2: "eleven_flash_v2";
+        eleven_v3: "eleven_v3";
+    }>>;
+    tts_inactivity_timeout: z.ZodDefault<z.ZodNumber>;
+    tts_enable_ssml_parsing: z.ZodDefault<z.ZodBoolean>;
+    tts_streaming_latency: z.ZodDefault<z.ZodNumber>;
+    tts_auto_mode: z.ZodDefault<z.ZodBoolean>;
+    tts_encoding: z.ZodDefault<z.ZodEnum<{
+        mp3_22050_32: "mp3_22050_32";
+        mp3_24000_48: "mp3_24000_48";
+        mp3_44100: "mp3_44100";
+        mp3_44100_32: "mp3_44100_32";
+        mp3_44100_64: "mp3_44100_64";
+        mp3_44100_96: "mp3_44100_96";
+        mp3_44100_128: "mp3_44100_128";
+        mp3_44100_192: "mp3_44100_192";
+        opus_48000_32: "opus_48000_32";
+        opus_48000_64: "opus_48000_64";
+        opus_48000_96: "opus_48000_96";
+        opus_48000_128: "opus_48000_128";
+        opus_48000_192: "opus_48000_192";
+        pcm_8000: "pcm_8000";
+        pcm_16000: "pcm_16000";
+        pcm_22050: "pcm_22050";
+        pcm_24000: "pcm_24000";
+        pcm_32000: "pcm_32000";
+        pcm_44100: "pcm_44100";
+        pcm_48000: "pcm_48000";
+    }>>;
+    tts_chunk_length_schedule: z.ZodDefault<z.ZodArray<z.ZodNumber>>;
+    tts_language: z.ZodDefault<z.ZodString>;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.generated.d.ts.map

package/build/call-control/schemas.generated.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.generated.d.ts","sourceRoot":"","sources":["../../src/call-control/schemas.generated.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAEvB,eAAO,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAmTvB,CAAA"}