@kognitivedev/backend-cloud 0.2.29

package/dist/cloud-voice-runtime-service.js

@@ -0,0 +1,443 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CLOUD_VOICE_PROVIDER_CAPABILITIES = exports.CLOUD_VOICE_PROMPT_COMPILER_VERSION = exports.CLOUD_VOICE_CONFIG_VERSION = exports.DEFAULT_CLOUD_VOICE_HUMANIZATION = void 0;
+exports.normalizeCloudVoiceHumanizationConfig = normalizeCloudVoiceHumanizationConfig;
+exports.normalizeCloudVoiceConversationProfile = normalizeCloudVoiceConversationProfile;
+exports.getCloudVoiceProviderCapabilities = getCloudVoiceProviderCapabilities;
+exports.normalizeSpeechConfig = normalizeSpeechConfig;
+exports.toLanguageInstruction = toLanguageInstruction;
+exports.resolveCloudVoiceSpeechLanguageCode = resolveCloudVoiceSpeechLanguageCode;
+exports.normalizeCloudVoicePipelineConfig = normalizeCloudVoicePipelineConfig;
+exports.toPreparedTranscription = toPreparedTranscription;
+exports.toOpenAITurnDetection = toOpenAITurnDetection;
+exports.normalizeCloudVoiceTurnDetection = normalizeCloudVoiceTurnDetection;
+exports.normalizeCloudVoiceInputNoiseReduction = normalizeCloudVoiceInputNoiseReduction;
+exports.compileCartesiaTtsOptions = compileCartesiaTtsOptions;
+const utils_1 = require("./utils");
+exports.DEFAULT_CLOUD_VOICE_HUMANIZATION = {
+    enabled: true,
+    openingMode: "auto",
+    openingStyle: "brief",
+    fillerStyle: "light",
+    backchannelFrequency: "low",
+    disfluency: "rare",
+    toolLatencyFillerMs: 700,
+    conversationProfile: {
+        personality: "warm",
+        tone: "professional",
+        pacing: "concise",
+        unclearAudio: "ask_repeat",
+        confirmation: "critical_fields",
+        escalation: "when_blocked",
+        numberReadback: true,
+    },
+};
+exports.CLOUD_VOICE_CONFIG_VERSION = 2;
+exports.CLOUD_VOICE_PROMPT_COMPILER_VERSION = "cloud-voice-provider-native-v2";
+exports.CLOUD_VOICE_PROVIDER_CAPABILITIES = {
+    "openai-realtime": {
+        canUpdateInstructionsLive: true,
+        supportsSessionResume: false,
+        supportsToolCalling: true,
+        supportsOutputAudioTranscripts: true,
+        supportsServerVadConfig: true,
+        supportsSemanticVad: true,
+    },
+    "gemini-live": {
+        canUpdateInstructionsLive: false,
+        supportsSessionResume: true,
+        supportsToolCalling: true,
+        supportsOutputAudioTranscripts: true,
+        supportsServerVadConfig: true,
+        supportsNativeAudioOptions: true,
+        supportsAffectiveDialog: true,
+        supportsProactiveAudio: true,
+    },
+    "kognitive-voice": {
+        canUpdateInstructionsLive: true,
+        supportsSessionResume: true,
+        supportsToolCalling: true,
+        supportsOutputAudioTranscripts: true,
+        supportsServerVadConfig: false,
+        supportsPipelineEotConfig: true,
+        supportsCartesiaTtsControls: true,
+    },
+    "xai-realtime": {
+        canUpdateInstructionsLive: true,
+        supportsSessionResume: false,
+        supportsToolCalling: true,
+        supportsOutputAudioTranscripts: true,
+        supportsServerVadConfig: true,
+    },
+};
+const DEFAULT_KOGNITIVE_PIPELINE = {
+    transport: { type: "websocket", provider: "kognitive-websocket" },
+    stt: { provider: "deepgram", model: "nova-3", language: "en" },
+    llm: { provider: "openai", model: "gpt-4o-mini" },
+    tts: { provider: "cartesia", model: "sonic-3", voice: "a0e99841-438c-4a64-b679-ae501e7d6091" },
+    turn: {
+        interruptResponse: true,
+        createResponse: true,
+        prefixPaddingMs: 300,
+        silenceDurationMs: 650,
+    },
+};
+const SPEECH_LANGUAGE_INSTRUCTIONS = {
+    en: "English",
+    "en-US": "English",
+    "en-GB": "English",
+    tr: "Turkish",
+    "tr-TR": "Turkish",
+    de: "German",
+    "de-DE": "German",
+    fr: "French",
+    "fr-FR": "French",
+    es: "Spanish",
+    "es-ES": "Spanish",
+    it: "Italian",
+    "it-IT": "Italian",
+    pt: "Portuguese",
+    "pt-PT": "Portuguese",
+    "pt-BR": "Portuguese",
+    nl: "Dutch",
+    "nl-NL": "Dutch",
+    sv: "Swedish",
+    "sv-SE": "Swedish",
+    no: "Norwegian",
+    "nb-NO": "Norwegian",
+    da: "Danish",
+    "da-DK": "Danish",
+    fi: "Finnish",
+    "fi-FI": "Finnish",
+    pl: "Polish",
+    "pl-PL": "Polish",
+    cs: "Czech",
+    "cs-CZ": "Czech",
+    ro: "Romanian",
+    "ro-RO": "Romanian",
+    el: "Greek",
+    "el-GR": "Greek",
+    ru: "Russian",
+    "ru-RU": "Russian",
+    uk: "Ukrainian",
+    "uk-UA": "Ukrainian",
+};
+const SPEECH_LANGUAGE_CODES = {
+    en: "en-US",
+    tr: "tr-TR",
+    de: "de-DE",
+    fr: "fr-FR",
+    es: "es-ES",
+    it: "it-IT",
+    pt: "pt-PT",
+    nl: "nl-NL",
+    sv: "sv-SE",
+    no: "nb-NO",
+    da: "da-DK",
+    fi: "fi-FI",
+    pl: "pl-PL",
+    cs: "cs-CZ",
+    ro: "ro-RO",
+    el: "el-GR",
+    ru: "ru-RU",
+    uk: "uk-UA",
+};
+const SPEECH_ACCENT_LANGUAGE_CODES = {
+    "neutral english": "en-US",
+    "british english": "en-GB",
+    "irish english": "en-IE",
+    "scottish english": "en-GB",
+    "standard istanbul turkish": "tr-TR",
+    "aegean turkish": "tr-TR",
+    "anatolian turkish": "tr-TR",
+    "standard german": "de-DE",
+    "austrian german": "de-AT",
+    "swiss german influenced standard german": "de-CH",
+    "standard french from france": "fr-FR",
+    "belgian french": "fr-BE",
+    "swiss french": "fr-CH",
+    "castilian spanish": "es-ES",
+    "andalusian spanish": "es-ES",
+    "canarian spanish": "es-ES",
+};
+function isPhoneChannel(channel) {
+    return channel === "phone" || channel === "sip" || channel === "outbound";
+}
+function normalizeCloudVoiceHumanizationConfig(value) {
+    var _a;
+    const record = (0, utils_1.getRecord)(value);
+    const openingMode = record.openingMode === "wait" || record.openingMode === "auto"
+        ? record.openingMode
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.openingMode;
+    const openingStyle = record.openingStyle === "warm" || record.openingStyle === "professional" || record.openingStyle === "brief"
+        ? record.openingStyle
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.openingStyle;
+    const fillerStyle = record.fillerStyle === "off" || record.fillerStyle === "natural" || record.fillerStyle === "light"
+        ? record.fillerStyle
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.fillerStyle;
+    const backchannelFrequency = record.backchannelFrequency === "off" || record.backchannelFrequency === "medium" || record.backchannelFrequency === "low"
+        ? record.backchannelFrequency
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.backchannelFrequency;
+    const disfluency = record.disfluency === "off" || record.disfluency === "rare"
+        ? record.disfluency
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.disfluency;
+    const toolLatencyFillerMs = typeof record.toolLatencyFillerMs === "number" && Number.isFinite(record.toolLatencyFillerMs)
+        ? Math.max(0, Math.round(record.toolLatencyFillerMs))
+        : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.toolLatencyFillerMs;
+    return {
+        enabled: typeof record.enabled === "boolean" ? record.enabled : exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.enabled,
+        openingMode,
+        openingStyle,
+        fillerStyle,
+        backchannelFrequency,
+        disfluency,
+        toolLatencyFillerMs,
+        conversationProfile: normalizeCloudVoiceConversationProfile((_a = record.conversationProfile) !== null && _a !== void 0 ? _a : record.profile, record),
+    };
+}
+function normalizeCloudVoiceConversationProfile(value, legacy = {}) {
+    const record = (0, utils_1.getRecord)(value);
+    const openingStyle = (0, utils_1.getString)(legacy.openingStyle, "");
+    const fillerStyle = (0, utils_1.getString)(legacy.fillerStyle, "");
+    const backchannelFrequency = (0, utils_1.getString)(legacy.backchannelFrequency, "");
+    const defaults = exports.DEFAULT_CLOUD_VOICE_HUMANIZATION.conversationProfile;
+    const personality = record.personality === "neutral" || record.personality === "warm" || record.personality === "expert" || record.personality === "concierge"
+        ? record.personality
+        : openingStyle === "professional"
+            ? "expert"
+            : "warm";
+    return {
+        personality,
+        tone: record.tone === "casual" || record.tone === "professional" || record.tone === "empathetic" || record.tone === "polished"
+            ? record.tone
+            : openingStyle === "warm"
+                ? "empathetic"
+                : defaults.tone,
+        pacing: record.pacing === "concise" || record.pacing === "measured" || record.pacing === "deliberate" || record.pacing === "energetic"
+            ? record.pacing
+            : fillerStyle === "natural" || backchannelFrequency === "medium"
+                ? "measured"
+                : defaults.pacing,
+        unclearAudio: record.unclearAudio === "ask_repeat" || record.unclearAudio === "confirm_best_guess"
+            ? record.unclearAudio
+            : defaults.unclearAudio,
+        confirmation: record.confirmation === "critical_fields" || record.confirmation === "all_actions" || record.confirmation === "minimal"
+            ? record.confirmation
+            : defaults.confirmation,
+        escalation: record.escalation === "when_blocked" || record.escalation === "on_request" || record.escalation === "never"
+            ? record.escalation
+            : defaults.escalation,
+        numberReadback: typeof record.numberReadback === "boolean" ? record.numberReadback : defaults.numberReadback,
+    };
+}
+function getCloudVoiceProviderCapabilities(provider) {
+    var _a;
+    return (_a = exports.CLOUD_VOICE_PROVIDER_CAPABILITIES[provider]) !== null && _a !== void 0 ? _a : exports.CLOUD_VOICE_PROVIDER_CAPABILITIES["openai-realtime"];
+}
+function normalizeSpeechConfig(config) {
+    const speech = (0, utils_1.getRecord)((0, utils_1.getRecord)(config.metadata).speech);
+    const normalized = {};
+    const knownKeys = ["language", "accent", "style", "pace", "emotion"];
+    for (const key of knownKeys) {
+        const value = speech[key];
+        if (typeof value === "string" && value.trim())
+            normalized[key] = value.trim();
+    }
+    for (const [key, value] of Object.entries(speech)) {
+        if (knownKeys.includes(key) || value === undefined)
+            continue;
+        normalized[key] = value;
+    }
+    return Object.keys(normalized).length > 0 ? normalized : undefined;
+}
+function toLanguageInstruction(value) {
+    var _a, _b;
+    return value ? (_b = (_a = SPEECH_LANGUAGE_INSTRUCTIONS[value]) !== null && _a !== void 0 ? _a : SPEECH_LANGUAGE_INSTRUCTIONS[value.toLowerCase()]) !== null && _b !== void 0 ? _b : value : undefined;
+}
+function resolveCloudVoiceSpeechLanguageCode(config) {
+    var _a, _b;
+    const speech = normalizeSpeechConfig(config);
+    const accentCode = (speech === null || speech === void 0 ? void 0 : speech.accent) ? SPEECH_ACCENT_LANGUAGE_CODES[speech.accent.toLowerCase()] : undefined;
+    if (accentCode)
+        return accentCode;
+    const language = speech === null || speech === void 0 ? void 0 : speech.language;
+    if (!language)
+        return undefined;
+    if (/^[a-z]{2,3}-[A-Z]{2}$/i.test(language))
+        return language;
+    return (_b = (_a = SPEECH_LANGUAGE_CODES[language]) !== null && _a !== void 0 ? _a : SPEECH_LANGUAGE_CODES[language.toLowerCase()]) !== null && _b !== void 0 ? _b : language;
+}
+function resolveCloudVoiceTranscriptionLanguage(config) {
+    const speech = normalizeSpeechConfig(config);
+    const language = speech === null || speech === void 0 ? void 0 : speech.language;
+    if (!language)
+        return undefined;
+    return language.includes("-") ? language.split("-")[0] : language;
+}
+function normalizePipelineTransport(config) {
+    var _a;
+    const transport = (0, utils_1.getRecord)((_a = config.pipeline) === null || _a === void 0 ? void 0 : _a.transport);
+    const type = transport.type === "webrtc" || transport.type === "websocket"
+        ? transport.type
+        : config.transport;
+    const provider = transport.provider === "daily" || transport.provider === "kognitive-websocket"
+        ? transport.provider
+        : type === "webrtc"
+            ? "daily"
+            : "kognitive-websocket";
+    return { type, provider };
+}
+function normalizeCloudVoicePipelineConfig(config) {
+    const pipeline = (0, utils_1.getRecord)(config.pipeline);
+    const stt = (0, utils_1.getRecord)(pipeline.stt);
+    const llm = (0, utils_1.getRecord)(pipeline.llm);
+    const tts = (0, utils_1.getRecord)(pipeline.tts);
+    const turn = (0, utils_1.getRecord)(pipeline.turn);
+    const backgroundAudio = (0, utils_1.getRecord)(pipeline.backgroundAudio);
+    const sttLanguage = typeof stt.language === "string" && stt.language.trim()
+        ? stt.language.trim()
+        : resolveCloudVoiceTranscriptionLanguage(config);
+    return Object.assign(Object.assign({ transport: normalizePipelineTransport(config), stt: Object.assign({ provider: (0, utils_1.getString)(stt.provider, DEFAULT_KOGNITIVE_PIPELINE.stt.provider), model: (0, utils_1.getString)(stt.model, DEFAULT_KOGNITIVE_PIPELINE.stt.model) }, (sttLanguage ? { language: sttLanguage } : {})), llm: {
+            provider: (0, utils_1.getString)(llm.provider, DEFAULT_KOGNITIVE_PIPELINE.llm.provider),
+            model: (0, utils_1.getString)(llm.model, config.model || DEFAULT_KOGNITIVE_PIPELINE.llm.model),
+        }, tts: Object.assign({ provider: (0, utils_1.getString)(tts.provider, DEFAULT_KOGNITIVE_PIPELINE.tts.provider), model: (0, utils_1.getString)(tts.model, DEFAULT_KOGNITIVE_PIPELINE.tts.model), voice: (0, utils_1.getString)(tts.voice, config.voice && config.voice !== "alloy" ? config.voice : DEFAULT_KOGNITIVE_PIPELINE.tts.voice) }, (Object.keys((0, utils_1.getRecord)(tts.options)).length > 0 ? { options: (0, utils_1.getRecord)(tts.options) } : {})) }, (Object.keys(turn).length > 0
+        ? { turn: Object.assign(Object.assign({}, DEFAULT_KOGNITIVE_PIPELINE.turn), turn) }
+        : { turn: DEFAULT_KOGNITIVE_PIPELINE.turn })), (Object.keys(backgroundAudio).length > 0 ? { backgroundAudio } : {}));
+}
+function toPreparedTranscription(config) {
+    if (config.transcription === null)
+        return null;
+    const transcription = (0, utils_1.getRecord)(config.transcription);
+    const language = resolveCloudVoiceTranscriptionLanguage(config);
+    return language
+        ? Object.assign(Object.assign({}, transcription), { language }) : transcription;
+}
+function toOpenAITurnDetection(value) {
+    if (value === null)
+        return null;
+    const turnDetection = (0, utils_1.getRecord)(value);
+    const type = typeof turnDetection.type === "string" ? turnDetection.type : "";
+    if (!type)
+        return undefined;
+    const config = { type };
+    if (typeof turnDetection.create_response === "boolean") {
+        config.create_response = turnDetection.create_response;
+    }
+    else if (typeof turnDetection.createResponse === "boolean") {
+        config.create_response = turnDetection.createResponse;
+    }
+    if (typeof turnDetection.interrupt_response === "boolean") {
+        config.interrupt_response = turnDetection.interrupt_response;
+    }
+    else if (typeof turnDetection.interruptResponse === "boolean") {
+        config.interrupt_response = turnDetection.interruptResponse;
+    }
+    if (typeof turnDetection.prefix_padding_ms === "number") {
+        config.prefix_padding_ms = turnDetection.prefix_padding_ms;
+    }
+    else if (typeof turnDetection.prefixPaddingMs === "number") {
+        config.prefix_padding_ms = turnDetection.prefixPaddingMs;
+    }
+    if (typeof turnDetection.silence_duration_ms === "number") {
+        config.silence_duration_ms = turnDetection.silence_duration_ms;
+    }
+    else if (typeof turnDetection.silenceDurationMs === "number") {
+        config.silence_duration_ms = turnDetection.silenceDurationMs;
+    }
+    if (typeof turnDetection.threshold === "number") {
+        config.threshold = turnDetection.threshold;
+    }
+    if (typeof turnDetection.eagerness === "string") {
+        config.eagerness = turnDetection.eagerness;
+    }
+    return config;
+}
+function normalizeCloudVoiceTurnDetection(provider, channel, value) {
+    if (value === null)
+        return null;
+    const record = (0, utils_1.getRecord)(value);
+    const isPhone = isPhoneChannel(channel);
+    if (provider === "openai-realtime" && !isPhone) {
+        const type = (0, utils_1.getString)(record.type, "semantic_vad") === "off" ? "off" : (0, utils_1.getString)(record.type, "semantic_vad");
+        if (type === "off")
+            return null;
+        if (type === "semantic_vad") {
+            return {
+                type: "semantic_vad",
+                createResponse: typeof record.createResponse === "boolean" ? record.createResponse : true,
+                interruptResponse: typeof record.interruptResponse === "boolean" ? record.interruptResponse : true,
+                eagerness: (0, utils_1.getString)(record.eagerness, "low") || "low",
+            };
+        }
+    }
+    if (provider === "gemini-live") {
+        return {
+            type: "server_vad",
+            createResponse: typeof record.createResponse === "boolean" ? record.createResponse : true,
+            interruptResponse: typeof record.interruptResponse === "boolean" ? record.interruptResponse : true,
+            prefixPaddingMs: typeof record.prefixPaddingMs === "number" ? record.prefixPaddingMs : 120,
+            silenceDurationMs: typeof record.silenceDurationMs === "number" ? record.silenceDurationMs : 700,
+            startOfSpeechSensitivity: (0, utils_1.getString)(record.startOfSpeechSensitivity, "START_SENSITIVITY_LOW"),
+            endOfSpeechSensitivity: (0, utils_1.getString)(record.endOfSpeechSensitivity, "END_SENSITIVITY_LOW"),
+            disabled: typeof record.disabled === "boolean" ? record.disabled : false,
+        };
+    }
+    if (provider === "kognitive-voice") {
+        return {
+            type: "flux_eot",
+            eager_eot_threshold: typeof record.eager_eot_threshold === "number" ? record.eager_eot_threshold : 0.85,
+            eot_threshold: typeof record.eot_threshold === "number" ? record.eot_threshold : 0.65,
+            eot_timeout_ms: typeof record.eot_timeout_ms === "number" ? record.eot_timeout_ms : 900,
+        };
+    }
+    return {
+        type: (0, utils_1.getString)(record.type, "server_vad") || "server_vad",
+        createResponse: typeof record.createResponse === "boolean" ? record.createResponse : true,
+        interruptResponse: typeof record.interruptResponse === "boolean" ? record.interruptResponse : true,
+        threshold: typeof record.threshold === "number" ? record.threshold : 0.6,
+        prefixPaddingMs: typeof record.prefixPaddingMs === "number" ? record.prefixPaddingMs : 300,
+        silenceDurationMs: typeof record.silenceDurationMs === "number" ? record.silenceDurationMs : 700,
+    };
+}
+function normalizeCloudVoiceInputNoiseReduction(provider, channel, value) {
+    if (value === null)
+        return null;
+    const record = (0, utils_1.getRecord)(value);
+    if (Object.keys(record).length > 0)
+        return record;
+    if (provider === "openai-realtime" && isPhoneChannel(channel)) {
+        return { type: "near_field" };
+    }
+    return null;
+}
+function compileCartesiaTtsOptions(config) {
+    var _a, _b, _c;
+    const providerOptions = (0, utils_1.getRecord)(config.providerOptions);
+    const pipeline = (0, utils_1.getRecord)((_a = config.pipeline) !== null && _a !== void 0 ? _a : providerOptions.pipeline);
+    const tts = (0, utils_1.getRecord)(pipeline.tts);
+    const cartesia = (0, utils_1.getRecord)((_c = (_b = tts.options) !== null && _b !== void 0 ? _b : tts.providerOptions) !== null && _c !== void 0 ? _c : providerOptions.cartesia);
+    const speech = normalizeSpeechConfig(config);
+    const options = {
+        modelId: (0, utils_1.getString)(tts.model, (0, utils_1.getString)(cartesia.modelId, "sonic-3")),
+        voice: (0, utils_1.getString)(tts.voice, config.voice && config.voice !== "alloy" ? config.voice : DEFAULT_KOGNITIVE_PIPELINE.tts.voice),
+    };
+    const pace = (0, utils_1.getString)(speech === null || speech === void 0 ? void 0 : speech.pace, "").toLowerCase();
+    const speed = typeof cartesia.speed === "number" || cartesia.speed === "slow" || cartesia.speed === "normal" || cartesia.speed === "fast"
+        ? cartesia.speed
+        : pace.includes("slow")
+            ? "slow"
+            : pace.includes("fast") || pace.includes("energetic")
+                ? "fast"
+                : "normal";
+    options.speed = speed;
+    const emotion = (0, utils_1.getString)(speech === null || speech === void 0 ? void 0 : speech.emotion, "");
+    if (emotion)
+        options.emotion = [emotion];
+    if (typeof cartesia.pronunciationDictId === "string" && cartesia.pronunciationDictId.trim()) {
+        options.pronunciationDictId = cartesia.pronunciationDictId.trim();
+    }
+    if (cartesia.contextMode === "reset" || cartesia.contextMode === "continue") {
+        options.contextMode = cartesia.contextMode;
+    }
+    return options;
+}

package/dist/cloud-voice.d.ts

@@ -0,0 +1,36 @@
+import type { CloudVoiceAgentConfig, CloudVoiceAgentSnapshot, CloudVoiceChannel, CloudVoiceClientToolManifest, CloudVoiceFunctionToolManifest, CloudVoiceParameterResolutionResult, CloudVoicePhonePrepareSnapshot, CloudVoiceToolBinding, CompiledCloudVoiceFlowInstructions, PreparedCloudVoiceConfig } from "./types";
+export { CLOUD_VOICE_CONFIG_VERSION, CLOUD_VOICE_PROMPT_COMPILER_VERSION, CLOUD_VOICE_PROVIDER_CAPABILITIES, DEFAULT_CLOUD_VOICE_HUMANIZATION, compileCartesiaTtsOptions, getCloudVoiceProviderCapabilities, normalizeCloudVoiceConversationProfile, normalizeCloudVoiceHumanizationConfig, normalizeCloudVoicePipelineConfig, normalizeCloudVoiceTurnDetection, resolveCloudVoiceSpeechLanguageCode, toOpenAITurnDetection, toPreparedTranscription, } from "./cloud-voice-runtime-service";
+export { buildPhoneControlRule, buildPhoneOpeningPrompt, compileCloudVoiceInstructions, resolveCloudVoiceProviderSystemPrompt, } from "./cloud-voice-prompt-service";
+export declare const CLOUD_VOICE_CHANNELS: Set<CloudVoiceChannel>;
+type CloudVoiceGraphEntryMode = "incoming" | "outgoing" | "both";
+export declare const CLOUD_VOICE_PHONE_HANGUP_TOOL: CloudVoiceFunctionToolManifest;
+export declare const CLOUD_VOICE_SIP_TRANSFER_TOOL: CloudVoiceFunctionToolManifest;
+export declare function resolveCloudVoiceChannel(value: unknown): CloudVoiceChannel;
+export declare function shouldInjectPhoneControlTools(channel?: CloudVoiceChannel): channel is "phone" | "sip" | "outbound";
+export declare function shouldInjectSipControlTools(config: Pick<CloudVoiceAgentConfig, "metadata">, channel?: CloudVoiceChannel): boolean;
+export declare function shouldPersistPhonePrepareSnapshot(channel: CloudVoiceChannel): channel is "phone" | "sip" | "outbound";
+export declare function resolveToolInputSchema(tool: CloudVoiceToolBinding): Record<string, unknown>;
+export declare const CLOUD_VOICE_FLOW_INSTRUCTION_COMPILER_VERSION = "voice-flow-paths-v1";
+export declare function compileVoiceGraphToInstructions(graphInput: unknown, options?: {
+    tools?: CloudVoiceToolBinding[];
+    entryMode?: CloudVoiceGraphEntryMode;
+    channel?: CloudVoiceChannel;
+}): CompiledCloudVoiceFlowInstructions | null;
+export declare function compileCloudVoiceGraphConfig(config: CloudVoiceAgentConfig): CloudVoiceAgentConfig;
+export declare function normalizeClientToolManifests(value: unknown): CloudVoiceClientToolManifest[];
+export declare function prepareCloudVoiceSessionConfig(config: CloudVoiceAgentConfig, input: {
+    agentName: string;
+    sessionId: string;
+    resourceId: Record<string, unknown>;
+    channel?: CloudVoiceChannel;
+    clientTools?: CloudVoiceClientToolManifest[];
+    parameters?: Record<string, unknown>;
+    parameterResolution?: CloudVoiceParameterResolutionResult;
+}): PreparedCloudVoiceConfig;
+export declare function createPhonePrepareSnapshot(input: {
+    agent: CloudVoiceAgentSnapshot;
+    channel: CloudVoiceChannel;
+    config: CloudVoiceAgentConfig;
+    prepare: PreparedCloudVoiceConfig;
+    now?: Date;
+}): CloudVoicePhonePrepareSnapshot;