@kognitivedev/voice-media-bridge 0.2.29

package/.turbo/turbo-build.log

@@ -0,0 +1,2 @@
+
+$ tsc

package/CHANGELOG.md

@@ -0,0 +1,10 @@
+# @kognitivedev/voice-media-bridge
+
+## 0.2.29
+
+### Patch Changes
+
+- release
+
+- Updated dependencies []:
+  - @kognitivedev/telephony@0.2.29

package/dist/audio.d.ts

@@ -0,0 +1,34 @@
+import type { PhoneMediaProfile } from "./profiles";
+import type { PhoneAudioRoute } from "./routes";
+export interface PcmSignalSummary {
+    samples: number;
+    peakAbs: number;
+    rms: number;
+    clippedSamples: number;
+    clippingRatio: number;
+    bytes: number;
+}
+export interface CarrierAudioOutput {
+    payload: string;
+    durationMs: number;
+    signal: PcmSignalSummary;
+    samples: Int16Array;
+}
+export declare const OPENAI_PCM_SAMPLE_RATE = 24000;
+export declare function pcm16ToBase64Le(samples: Int16Array): string;
+export declare function base64ToPcm16Le(data: string): Int16Array;
+export declare function pcm16ToBase64Be(samples: Int16Array): string;
+export declare function base64ToPcm16Be(data: string): Int16Array;
+export declare function summarizePcm16Signal(samples: Int16Array, bytes?: number): PcmSignalSummary;
+export declare function frameDurationMs(sampleCount: number, sampleRate: number): number;
+export declare function decodeCarrierPayload(profile: PhoneMediaProfile, payload: string): Int16Array;
+export declare function encodeCarrierPayload(profile: PhoneMediaProfile, samples: Int16Array): string;
+export declare function summarizeCarrierPayload(profile: PhoneMediaProfile, payload: string): PcmSignalSummary;
+export declare function toOpenAIInputAudio(profile: PhoneMediaProfile, payload: string): string;
+export declare function fromOpenAIOutputAudio(profile: PhoneMediaProfile, delta: string): CarrierAudioOutput;
+export declare function toAiInputAudio(route: PhoneAudioRoute, payload: string): string;
+export declare function fromAiOutputAudio(route: PhoneAudioRoute, delta: string, sourceRate?: 8000 | 16000 | 24000): CarrierAudioOutput;
+export declare function isLikelySpeechPayload(profile: PhoneMediaProfile, payload: string, input?: {
+    rms?: number;
+    peakAbs?: number;
+}): boolean;

package/dist/audio.js

@@ -0,0 +1,163 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OPENAI_PCM_SAMPLE_RATE = void 0;
+exports.pcm16ToBase64Le = pcm16ToBase64Le;
+exports.base64ToPcm16Le = base64ToPcm16Le;
+exports.pcm16ToBase64Be = pcm16ToBase64Be;
+exports.base64ToPcm16Be = base64ToPcm16Be;
+exports.summarizePcm16Signal = summarizePcm16Signal;
+exports.frameDurationMs = frameDurationMs;
+exports.decodeCarrierPayload = decodeCarrierPayload;
+exports.encodeCarrierPayload = encodeCarrierPayload;
+exports.summarizeCarrierPayload = summarizeCarrierPayload;
+exports.toOpenAIInputAudio = toOpenAIInputAudio;
+exports.fromOpenAIOutputAudio = fromOpenAIOutputAudio;
+exports.toAiInputAudio = toAiInputAudio;
+exports.fromAiOutputAudio = fromAiOutputAudio;
+exports.isLikelySpeechPayload = isLikelySpeechPayload;
+const telephony_1 = require("@kognitivedev/telephony");
+exports.OPENAI_PCM_SAMPLE_RATE = 24000;
+const CLIP_THRESHOLD = 32760;
+function pcm16ToBase64Le(samples) {
+    var _a;
+    const buffer = Buffer.alloc(samples.length * 2);
+    for (let index = 0; index < samples.length; index += 1) {
+        buffer.writeInt16LE((_a = samples[index]) !== null && _a !== void 0 ? _a : 0, index * 2);
+    }
+    return buffer.toString("base64");
+}
+function base64ToPcm16Le(data) {
+    const buffer = Buffer.from(data, "base64");
+    const samples = new Int16Array(Math.floor(buffer.length / 2));
+    for (let index = 0; index < samples.length; index += 1) {
+        samples[index] = buffer.readInt16LE(index * 2);
+    }
+    return samples;
+}
+function pcm16ToBase64Be(samples) {
+    var _a;
+    const buffer = Buffer.alloc(samples.length * 2);
+    for (let index = 0; index < samples.length; index += 1) {
+        buffer.writeInt16BE((_a = samples[index]) !== null && _a !== void 0 ? _a : 0, index * 2);
+    }
+    return buffer.toString("base64");
+}
+function base64ToPcm16Be(data) {
+    const buffer = Buffer.from(data, "base64");
+    const samples = new Int16Array(Math.floor(buffer.length / 2));
+    for (let index = 0; index < samples.length; index += 1) {
+        samples[index] = buffer.readInt16BE(index * 2);
+    }
+    return samples;
+}
+function summarizePcm16Signal(samples, bytes = samples.length * 2) {
+    if (samples.length === 0) {
+        return { samples: 0, peakAbs: 0, rms: 0, clippedSamples: 0, clippingRatio: 0, bytes };
+    }
+    let peakAbs = 0;
+    let squareSum = 0;
+    let clippedSamples = 0;
+    for (const sample of samples) {
+        const abs = Math.abs(sample);
+        if (abs > peakAbs)
+            peakAbs = abs;
+        if (abs >= CLIP_THRESHOLD)
+            clippedSamples += 1;
+        squareSum += sample * sample;
+    }
+    return {
+        samples: samples.length,
+        peakAbs,
+        rms: Math.round(Math.sqrt(squareSum / samples.length)),
+        clippedSamples,
+        clippingRatio: clippedSamples / samples.length,
+        bytes,
+    };
+}
+function frameDurationMs(sampleCount, sampleRate) {
+    if (sampleRate <= 0)
+        return 0;
+    return Math.round((sampleCount / sampleRate) * 1000);
+}
+function decodeCarrierPayload(profile, payload) {
+    if (profile.codec === "pcmu")
+        return (0, telephony_1.decodeTwilioMulawBase64ToPcm16)(payload);
+    return profile.carrierByteOrder === "le" ? base64ToPcm16Le(payload) : base64ToPcm16Be(payload);
+}
+function encodeCarrierPayload(profile, samples) {
+    if (profile.codec === "pcmu")
+        return (0, telephony_1.encodePcm16ToTwilioMulawBase64)(samples);
+    return profile.carrierByteOrder === "le" ? pcm16ToBase64Le(samples) : pcm16ToBase64Be(samples);
+}
+function summarizeCarrierPayload(profile, payload) {
+    const bytes = Buffer.byteLength(payload, "base64");
+    return summarizePcm16Signal(decodeCarrierPayload(profile, payload), bytes);
+}
+function toOpenAIInputAudio(profile, payload) {
+    if (profile.openAIFormat === "audio/pcmu")
+        return payload;
+    const carrierPcm = decodeCarrierPayload(profile, payload);
+    const openAIPcm = (0, telephony_1.resamplePcm16WindowedSinc)(carrierPcm, profile.carrierSampleRate, profile.openAISampleRate);
+    return pcm16ToBase64Le(openAIPcm);
+}
+function fromOpenAIOutputAudio(profile, delta) {
+    if (profile.openAIFormat === "audio/pcmu") {
+        const samples = decodeCarrierPayload(profile, delta);
+        return {
+            payload: delta,
+            durationMs: frameDurationMs(samples.length, profile.carrierSampleRate),
+            signal: summarizePcm16Signal(samples, Buffer.byteLength(delta, "base64")),
+            samples,
+        };
+    }
+    const openAIPcm = base64ToPcm16Le(delta);
+    const carrierPcm = (0, telephony_1.resamplePcm16WindowedSinc)(openAIPcm, profile.openAISampleRate, profile.carrierSampleRate);
+    const payload = encodeCarrierPayload(profile, carrierPcm);
+    return {
+        payload,
+        durationMs: frameDurationMs(carrierPcm.length, profile.carrierSampleRate),
+        signal: summarizePcm16Signal(carrierPcm, Buffer.byteLength(payload, "base64")),
+        samples: carrierPcm,
+    };
+}
+function toAiInputAudio(route, payload) {
+    if (route.carrier.codec === "pcmu"
+        && route.aiInput.codec === "pcmu"
+        && route.carrier.carrierSampleRate === route.aiInput.sampleRate) {
+        return payload;
+    }
+    const carrierPcm = decodeCarrierPayload(route.carrier, payload);
+    const aiPcm = route.carrier.carrierSampleRate === route.aiInput.sampleRate
+        ? carrierPcm
+        : (0, telephony_1.resamplePcm16WindowedSinc)(carrierPcm, route.carrier.carrierSampleRate, route.aiInput.sampleRate);
+    return pcm16ToBase64Le(aiPcm);
+}
+function fromAiOutputAudio(route, delta, sourceRate = route.aiOutput.sampleRate) {
+    if (route.carrier.codec === "pcmu"
+        && route.aiOutput.codec === "pcmu"
+        && route.carrier.carrierSampleRate === route.aiOutput.sampleRate) {
+        const samples = decodeCarrierPayload(route.carrier, delta);
+        return {
+            payload: delta,
+            durationMs: frameDurationMs(samples.length, route.carrier.carrierSampleRate),
+            signal: summarizePcm16Signal(samples, Buffer.byteLength(delta, "base64")),
+            samples,
+        };
+    }
+    const aiPcm = base64ToPcm16Le(delta);
+    const carrierPcm = sourceRate === route.carrier.carrierSampleRate
+        ? aiPcm
+        : (0, telephony_1.resamplePcm16WindowedSinc)(aiPcm, sourceRate, route.carrier.carrierSampleRate);
+    const payload = encodeCarrierPayload(route.carrier, carrierPcm);
+    return {
+        payload,
+        durationMs: frameDurationMs(carrierPcm.length, route.carrier.carrierSampleRate),
+        signal: summarizePcm16Signal(carrierPcm, Buffer.byteLength(payload, "base64")),
+        samples: carrierPcm,
+    };
+}
+function isLikelySpeechPayload(profile, payload, input = {}) {
+    var _a, _b;
+    const signal = summarizeCarrierPayload(profile, payload);
+    return signal.rms >= ((_a = input.rms) !== null && _a !== void 0 ? _a : 400) || signal.peakAbs >= ((_b = input.peakAbs) !== null && _b !== void 0 ? _b : 2500);
+}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export * from "./audio";
+export * from "./openai";
+export * from "./profiles";
+export * from "./routes";

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./audio"), exports);
+__exportStar(require("./openai"), exports);
+__exportStar(require("./profiles"), exports);
+__exportStar(require("./routes"), exports);

package/dist/openai.d.ts

@@ -0,0 +1,62 @@
+import type { PhoneMediaProfile } from "./profiles";
+import type { PhoneAudioRoute } from "./routes";
+export declare function openAIRealtimeAudioFormat(profile: PhoneMediaProfile): {
+    type: string;
+    rate?: undefined;
+} | {
+    type: string;
+    rate: 8000 | 24000;
+};
+export declare function realtimeAudioFormatForRoute(route: PhoneAudioRoute): {
+    type: string;
+    rate?: undefined;
+} | {
+    type: string;
+    rate: 8000 | 16000 | 24000;
+};
+export declare function realtimeOutputAudioFormatForRoute(route: PhoneAudioRoute): {
+    type: string;
+    rate?: undefined;
+} | {
+    type: string;
+    rate: 8000 | 16000 | 24000;
+};
+export declare function isOpenAIRealtimeAudioReady(event: unknown, profile?: PhoneMediaProfile): boolean;
+export declare function isRealtimeAudioReadyForRoute(event: unknown, route: PhoneAudioRoute): boolean;
+export declare function createCarrierMediaMessage(profile: PhoneMediaProfile, streamSid: string | null, payload: string): {
+    event: string;
+    media: {
+        payload: string;
+    };
+    streamSid?: undefined;
+} | {
+    event: string;
+    streamSid: string;
+    media: {
+        payload: string;
+    };
+} | null;
+export declare function createCarrierMarkMessage(profile: PhoneMediaProfile, streamSid: string | null, markName: string): {
+    event: string;
+    mark: {
+        name: string;
+    };
+    streamSid?: undefined;
+} | {
+    event: string;
+    streamSid: string;
+    mark: {
+        name: string;
+    };
+} | null;
+export declare function createCarrierClearMessage(profile: PhoneMediaProfile, streamSid: string | null): {
+    event: string;
+    streamSid?: undefined;
+} | {
+    event: string;
+    streamSid: string;
+} | null;
+export interface CreateOpenAIPhoneRealtimeBridgeInput {
+    profile: PhoneMediaProfile;
+}
+export declare function createOpenAIPhoneRealtimeBridge(_input: CreateOpenAIPhoneRealtimeBridgeInput): never;

package/dist/openai.js

@@ -0,0 +1,130 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.openAIRealtimeAudioFormat = openAIRealtimeAudioFormat;
+exports.realtimeAudioFormatForRoute = realtimeAudioFormatForRoute;
+exports.realtimeOutputAudioFormatForRoute = realtimeOutputAudioFormatForRoute;
+exports.isOpenAIRealtimeAudioReady = isOpenAIRealtimeAudioReady;
+exports.isRealtimeAudioReadyForRoute = isRealtimeAudioReadyForRoute;
+exports.createCarrierMediaMessage = createCarrierMediaMessage;
+exports.createCarrierMarkMessage = createCarrierMarkMessage;
+exports.createCarrierClearMessage = createCarrierClearMessage;
+exports.createOpenAIPhoneRealtimeBridge = createOpenAIPhoneRealtimeBridge;
+const profiles_1 = require("./profiles");
+function getRecord(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function getString(value, fallback = "") {
+    return typeof value === "string" && value.trim() ? value.trim() : fallback;
+}
+function summarizeOpenAIAudioFormat(value) {
+    if (typeof value === "string")
+        return value;
+    const record = getRecord(value);
+    const type = getString(record.type, "");
+    const rate = typeof record.rate === "number" ? record.rate : undefined;
+    return type ? Object.assign({ type }, (rate ? { rate } : {})) : null;
+}
+function openAIRealtimeAudioFormat(profile) {
+    return profile.openAIFormat === "audio/pcmu"
+        ? { type: "audio/pcmu" }
+        : { type: "audio/pcm", rate: profile.openAISampleRate };
+}
+function realtimeAudioFormatForRoute(route) {
+    return route.aiInput.format === "audio/pcmu"
+        ? { type: "audio/pcmu" }
+        : { type: "audio/pcm", rate: route.aiInput.sampleRate };
+}
+function realtimeOutputAudioFormatForRoute(route) {
+    return route.aiOutput.format === "audio/pcmu"
+        ? { type: "audio/pcmu" }
+        : { type: "audio/pcm", rate: route.aiOutput.sampleRate };
+}
+function isOpenAIRealtimeAudioReady(event, profile = (0, profiles_1.getPhoneMediaProfile)("twilio-pcmu-8k")) {
+    const record = getRecord(event);
+    if (record.type !== "session.updated")
+        return false;
+    const audio = getRecord(getRecord(record.session).audio);
+    const inputFormat = summarizeOpenAIAudioFormat(getRecord(audio.input).format);
+    const outputFormat = summarizeOpenAIAudioFormat(getRecord(audio.output).format);
+    const inputRecord = getRecord(inputFormat);
+    const outputRecord = getRecord(outputFormat);
+    const expected = openAIRealtimeAudioFormat(profile);
+    const expectedType = expected.type;
+    const expectedRate = "rate" in expected ? expected.rate : undefined;
+    const inputType = typeof inputFormat === "string" ? inputFormat : getString(inputRecord.type, "");
+    const outputType = typeof outputFormat === "string" ? outputFormat : getString(outputRecord.type, "");
+    const inputRate = typeof inputRecord.rate === "number" ? inputRecord.rate : undefined;
+    const outputRate = typeof outputRecord.rate === "number" ? outputRecord.rate : undefined;
+    if (inputType !== expectedType || outputType !== expectedType)
+        return false;
+    if (expectedRate && inputRate && inputRate !== expectedRate)
+        return false;
+    if (expectedRate && outputRate && outputRate !== expectedRate)
+        return false;
+    return true;
+}
+function isRealtimeAudioReadyForRoute(event, route) {
+    const record = getRecord(event);
+    if (record.type !== "session.updated")
+        return false;
+    const audio = getRecord(getRecord(record.session).audio);
+    const inputFormat = summarizeOpenAIAudioFormat(getRecord(audio.input).format);
+    const outputFormat = summarizeOpenAIAudioFormat(getRecord(audio.output).format);
+    const inputRecord = getRecord(inputFormat);
+    const outputRecord = getRecord(outputFormat);
+    const expectedInput = realtimeAudioFormatForRoute(route);
+    const expectedOutput = realtimeOutputAudioFormatForRoute(route);
+    const inputType = typeof inputFormat === "string" ? inputFormat : getString(inputRecord.type, "");
+    const outputType = typeof outputFormat === "string" ? outputFormat : getString(outputRecord.type, "");
+    const inputRate = typeof inputRecord.rate === "number" ? inputRecord.rate : undefined;
+    const outputRate = typeof outputRecord.rate === "number" ? outputRecord.rate : undefined;
+    if (inputType !== expectedInput.type || outputType !== expectedOutput.type)
+        return false;
+    if ("rate" in expectedInput && inputRate && inputRate !== expectedInput.rate)
+        return false;
+    if ("rate" in expectedOutput && outputRate && outputRate !== expectedOutput.rate)
+        return false;
+    return true;
+}
+function createCarrierMediaMessage(profile, streamSid, payload) {
+    if (profile.provider === "telnyx") {
+        return { event: "media", media: { payload } };
+    }
+    if (profile.provider === "sip") {
+        return { event: "media", streamSid: streamSid !== null && streamSid !== void 0 ? streamSid : "sip", media: { payload } };
+    }
+    if (!streamSid)
+        return null;
+    return {
+        event: "media",
+        streamSid,
+        media: { payload },
+    };
+}
+function createCarrierMarkMessage(profile, streamSid, markName) {
+    if (profile.provider === "telnyx") {
+        return { event: "mark", mark: { name: markName } };
+    }
+    if (profile.provider === "sip") {
+        return { event: "mark", streamSid: streamSid !== null && streamSid !== void 0 ? streamSid : "sip", mark: { name: markName } };
+    }
+    if (!streamSid)
+        return null;
+    return {
+        event: "mark",
+        streamSid,
+        mark: { name: markName },
+    };
+}
+function createCarrierClearMessage(profile, streamSid) {
+    if (profile.provider === "telnyx")
+        return { event: "clear" };
+    if (profile.provider === "sip")
+        return { event: "clear", streamSid: streamSid !== null && streamSid !== void 0 ? streamSid : "sip" };
+    if (!streamSid)
+        return null;
+    return { event: "clear", streamSid };
+}
+function createOpenAIPhoneRealtimeBridge(_input) {
+    throw new Error("createOpenAIPhoneRealtimeBridge is hosted by the backend-cloud phone runtime in this release");
+}

package/dist/profiles.d.ts

@@ -0,0 +1,38 @@
+export type PhoneMediaProvider = "twilio" | "telnyx" | "sip";
+export type PhoneMediaProfileId = "twilio-pcmu-8k" | "telnyx-pcmu-8k" | "telnyx-l16-16k" | "sip-pcmu-8k";
+export type PhoneMediaCodecPreference = "auto" | "l16_16k" | "pcmu_8k";
+export type PhoneMediaL16ByteOrder = "be" | "le";
+export interface PhoneMediaProfile {
+    id: PhoneMediaProfileId;
+    provider: PhoneMediaProvider;
+    codec: "pcmu" | "l16";
+    carrierCodec: "PCMU" | "L16";
+    carrierSampleRate: 8000 | 16000;
+    carrierByteOrder?: PhoneMediaL16ByteOrder;
+    openAIFormat: "audio/pcmu" | "audio/pcm";
+    openAISampleRate: 8000 | 24000;
+    source: "auto" | "forced" | "fallback";
+}
+export interface PhoneMediaFallbackState {
+    forcePcmu?: boolean;
+}
+export interface ResolvePhoneMediaProfileInput {
+    provider: PhoneMediaProvider;
+    requestedCodec?: PhoneMediaCodecPreference | string | null;
+    l16ByteOrder?: PhoneMediaL16ByteOrder | string | null;
+    fallbackState?: PhoneMediaFallbackState | null;
+}
+export declare function getPhoneMediaProfile(id: PhoneMediaProfileId): PhoneMediaProfile;
+export declare function normalizePhoneMediaCodecPreference(value: unknown): PhoneMediaCodecPreference;
+export declare function normalizePhoneMediaL16ByteOrder(value: unknown): PhoneMediaL16ByteOrder;
+export declare function resolvePhoneMediaProfile(input: ResolvePhoneMediaProfileInput): PhoneMediaProfile;
+export declare function phoneMediaProfileMetadata(profile: PhoneMediaProfile): {
+    openAIFormat: "audio/pcmu" | "audio/pcm";
+    openAISampleRate: 8000 | 24000;
+    source: "auto" | "forced" | "fallback";
+    byteOrder?: PhoneMediaL16ByteOrder | undefined;
+    id: PhoneMediaProfileId;
+    provider: PhoneMediaProvider;
+    codec: "PCMU" | "L16";
+    sampleRate: 8000 | 16000;
+};

package/dist/profiles.js

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPhoneMediaProfile = getPhoneMediaProfile;
+exports.normalizePhoneMediaCodecPreference = normalizePhoneMediaCodecPreference;
+exports.normalizePhoneMediaL16ByteOrder = normalizePhoneMediaL16ByteOrder;
+exports.resolvePhoneMediaProfile = resolvePhoneMediaProfile;
+exports.phoneMediaProfileMetadata = phoneMediaProfileMetadata;
+const TWILIO_PCMU_8K = {
+    id: "twilio-pcmu-8k",
+    provider: "twilio",
+    codec: "pcmu",
+    carrierCodec: "PCMU",
+    carrierSampleRate: 8000,
+    openAIFormat: "audio/pcmu",
+    openAISampleRate: 8000,
+    source: "forced",
+};
+const TELNYX_PCMU_8K = {
+    id: "telnyx-pcmu-8k",
+    provider: "telnyx",
+    codec: "pcmu",
+    carrierCodec: "PCMU",
+    carrierSampleRate: 8000,
+    openAIFormat: "audio/pcmu",
+    openAISampleRate: 8000,
+    source: "forced",
+};
+const TELNYX_L16_16K = {
+    id: "telnyx-l16-16k",
+    provider: "telnyx",
+    codec: "l16",
+    carrierCodec: "L16",
+    carrierSampleRate: 16000,
+    carrierByteOrder: "le",
+    openAIFormat: "audio/pcm",
+    openAISampleRate: 24000,
+    source: "auto",
+};
+const SIP_PCMU_8K = {
+    id: "sip-pcmu-8k",
+    provider: "sip",
+    codec: "pcmu",
+    carrierCodec: "PCMU",
+    carrierSampleRate: 8000,
+    openAIFormat: "audio/pcmu",
+    openAISampleRate: 8000,
+    source: "forced",
+};
+function getPhoneMediaProfile(id) {
+    switch (id) {
+        case "twilio-pcmu-8k":
+            return Object.assign({}, TWILIO_PCMU_8K);
+        case "telnyx-pcmu-8k":
+            return Object.assign({}, TELNYX_PCMU_8K);
+        case "telnyx-l16-16k":
+            return Object.assign({}, TELNYX_L16_16K);
+        case "sip-pcmu-8k":
+            return Object.assign({}, SIP_PCMU_8K);
+    }
+}
+function normalizePhoneMediaCodecPreference(value) {
+    if (value === "l16_16k" || value === "pcmu_8k" || value === "auto")
+        return value;
+    if (value === "L16" || value === "l16" || value === "telnyx-l16-16k")
+        return "l16_16k";
+    if (value === "PCMU" || value === "pcmu" || value === "telnyx-pcmu-8k" || value === "twilio-pcmu-8k")
+        return "pcmu_8k";
+    return "auto";
+}
+function normalizePhoneMediaL16ByteOrder(value) {
+    return value === "le" || value === "little" || value === "little-endian" ? "le" : "be";
+}
+function resolveL16ByteOrder(value, fallback) {
+    return value === undefined || value === null || value === "" ? fallback : normalizePhoneMediaL16ByteOrder(value);
+}
+function resolvePhoneMediaProfile(input) {
+    var _a, _b;
+    if (input.provider === "twilio")
+        return getPhoneMediaProfile("twilio-pcmu-8k");
+    if (input.provider === "sip")
+        return getPhoneMediaProfile("sip-pcmu-8k");
+    const requested = normalizePhoneMediaCodecPreference(input.requestedCodec);
+    if ((_a = input.fallbackState) === null || _a === void 0 ? void 0 : _a.forcePcmu) {
+        return Object.assign(Object.assign({}, getPhoneMediaProfile("telnyx-pcmu-8k")), { source: "fallback" });
+    }
+    if (requested === "pcmu_8k") {
+        return Object.assign(Object.assign({}, getPhoneMediaProfile("telnyx-pcmu-8k")), { source: "forced" });
+    }
+    if (requested === "l16_16k") {
+        const profile = getPhoneMediaProfile("telnyx-l16-16k");
+        return Object.assign(Object.assign({}, profile), { carrierByteOrder: resolveL16ByteOrder(input.l16ByteOrder, (_b = profile.carrierByteOrder) !== null && _b !== void 0 ? _b : "le"), source: "forced" });
+    }
+    return Object.assign(Object.assign({}, getPhoneMediaProfile("telnyx-pcmu-8k")), { source: "auto" });
+}
+function phoneMediaProfileMetadata(profile) {
+    return Object.assign(Object.assign({ id: profile.id, provider: profile.provider, codec: profile.carrierCodec, sampleRate: profile.carrierSampleRate }, (profile.carrierByteOrder ? { byteOrder: profile.carrierByteOrder } : {})), { openAIFormat: profile.openAIFormat, openAISampleRate: profile.openAISampleRate, source: profile.source });
+}

package/dist/routes.d.ts

@@ -0,0 +1,51 @@
+import { type PhoneMediaFallbackState, type PhoneMediaL16ByteOrder, type PhoneMediaProfile, type PhoneMediaProvider } from "./profiles";
+export type PhoneAiProvider = "openai-realtime" | "xai-realtime" | "gemini-live";
+export type PhoneAudioCodec = "pcmu" | "pcm";
+export type PhoneAudioFormat = "audio/pcmu" | "audio/pcm";
+export interface PhoneAiAudioLeg {
+    codec: PhoneAudioCodec;
+    format: PhoneAudioFormat;
+    sampleRate: 8000 | 16000 | 24000;
+    mimeType: string;
+}
+export interface PhoneAudioRoute {
+    id: string;
+    carrierProvider: PhoneMediaProvider;
+    aiProvider: PhoneAiProvider;
+    carrier: PhoneMediaProfile;
+    aiInput: PhoneAiAudioLeg;
+    aiOutput: PhoneAiAudioLeg;
+    inputTranscoding: "none" | "decode-resample";
+    outputTranscoding: "none" | "resample-encode";
+    stable: boolean;
+}
+export interface ResolvePhoneAudioRouteInput {
+    carrierProvider: PhoneMediaProvider;
+    aiProvider: PhoneAiProvider | string | null | undefined;
+    requestedCodec?: string | null;
+    l16ByteOrder?: PhoneMediaL16ByteOrder | string | null;
+    fallbackState?: PhoneMediaFallbackState | null;
+}
+export declare function createPhoneAudioRoute(carrier: PhoneMediaProfile, aiProviderInput: PhoneAiProvider | string | null | undefined): PhoneAudioRoute;
+export declare function resolvePhoneAudioRoute(input: ResolvePhoneAudioRouteInput): PhoneAudioRoute;
+export declare function phoneAudioRouteMetadata(route: PhoneAudioRoute): {
+    id: string;
+    carrierProvider: PhoneMediaProvider;
+    aiProvider: PhoneAiProvider;
+    carrier: {
+        openAIFormat: "audio/pcmu" | "audio/pcm";
+        openAISampleRate: 8000 | 24000;
+        source: "auto" | "forced" | "fallback";
+        byteOrder?: PhoneMediaL16ByteOrder | undefined;
+        id: import("./profiles").PhoneMediaProfileId;
+        provider: PhoneMediaProvider;
+        codec: "PCMU" | "L16";
+        sampleRate: 8000 | 16000;
+    };
+    aiInput: PhoneAiAudioLeg;
+    aiOutput: PhoneAiAudioLeg;
+    inputTranscoding: "none" | "decode-resample";
+    outputTranscoding: "none" | "resample-encode";
+    stable: boolean;
+};
+export declare function getStableCarrierProfile(provider: PhoneMediaProvider): PhoneMediaProfile;