@kognitivedev/telephony 0.2.29

package/dist/types.d.ts

@@ -0,0 +1,242 @@
+export type TelephonyProvider = "twilio" | "telnyx" | "cm_com" | "didww" | "sinch" | "bird" | "sip_custom";
+export type TelephonyConnectionMode = "provider_managed" | "byoc_trunk" | "sip_uri" | "pbx_extension";
+export type TelephonyTransport = "udp" | "tcp" | "tls";
+export type TelephonyMediaEncryption = "none" | "srtp";
+export type TelephonyRegion = "eu" | "de" | "nl" | "uk" | "fr" | "tr" | "us" | "global" | string;
+export type TelephonyCallDirection = "inbound" | "outbound";
+export type TelephonyCallStatus = "queued" | "ringing" | "created" | "active" | "completed" | "failed" | "busy" | "no-answer" | "cancelled" | "unknown";
+export interface TelephonyNumberCapabilities {
+    voice?: boolean;
+    sms?: boolean;
+    mms?: boolean;
+    sip?: boolean;
+}
+export interface TelephonyProviderCapabilities {
+    inboundPstn?: boolean;
+    outboundPstn?: boolean;
+    inboundSip?: boolean;
+    outboundSip?: boolean;
+    sipRefer?: boolean;
+    bridgeTransfer?: boolean;
+    blindTransfer?: boolean;
+    attendedTransfer?: boolean;
+    warmTransfer?: boolean;
+    hold?: boolean;
+    resume?: boolean;
+    conference?: boolean;
+    dtmf?: boolean;
+    recording?: boolean;
+    statusCallbacks?: boolean;
+    regions?: TelephonyRegion[];
+    transports?: TelephonyTransport[];
+    mediaEncryption?: TelephonyMediaEncryption[];
+    codecs?: string[];
+}
+export interface TelephonyConnection {
+    id: string;
+    provider: TelephonyProvider;
+    name: string;
+    mode: TelephonyConnectionMode;
+    status?: "draft" | "active" | "disabled" | "error";
+    inboundUri?: string;
+    outboundProxy?: string;
+    authMode?: "ip_acl" | "credentials" | "none";
+    username?: string;
+    secretRef?: string;
+    allowedIps?: string[];
+    transport?: TelephonyTransport;
+    mediaEncryption?: TelephonyMediaEncryption;
+    codecs?: string[];
+    region?: TelephonyRegion;
+    capabilities?: TelephonyProviderCapabilities;
+    metadata?: Record<string, unknown>;
+}
+export type TelephonyDestination = {
+    type: "phone_number";
+    phoneNumber: string;
+    connectionId?: string;
+    callerId?: string;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "sip_uri";
+    uri: string;
+    connectionId?: string;
+    transport?: TelephonyTransport;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "extension";
+    extension: string;
+    connectionId: string;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "queue";
+    queueId: string;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "browser_queue";
+    queueId?: string;
+    label?: string;
+    metadata?: Record<string, unknown>;
+};
+export type TelephonyTransferMode = "blind" | "attended" | "warm";
+export type TelephonyTransferFallback = "return_to_ai" | "alternate_destination" | "voicemail" | "hangup";
+export interface TelephonyTransferPolicy {
+    mode?: TelephonyTransferMode;
+    timeoutSeconds?: number;
+    fallback?: TelephonyTransferFallback;
+    fallbackDestination?: TelephonyDestination;
+    announceBeforeTransfer?: boolean;
+    allowSipRefer?: boolean;
+}
+export type TelephonyCallControlAction = "answer" | "reject" | "originate" | "bridge" | "transfer" | "hold" | "resume" | "conference" | "send_dtmf" | "hangup";
+export interface TelephonyPhoneNumber {
+    id?: string;
+    provider: TelephonyProvider;
+    phoneNumber: string;
+    label?: string | null;
+    providerNumberId?: string | null;
+    capabilities?: TelephonyNumberCapabilities;
+    inboundEnabled?: boolean;
+    outboundEnabled?: boolean;
+    metadata?: Record<string, unknown>;
+}
+export interface TelephonyInboundCallInput {
+    provider: TelephonyProvider;
+    providerCallId: string;
+    from: string;
+    to: string;
+    accountId?: string;
+    direction?: "inbound" | "outbound" | "unknown";
+    raw?: Record<string, unknown>;
+}
+export interface TelephonyOutboundCallInput {
+    from: string;
+    to: string;
+    answerUrl: string;
+    statusCallbackUrl?: string;
+    providerCallId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TelephonyOutboundCallResult {
+    provider: TelephonyProvider;
+    providerCallId: string;
+    status: TelephonyCallStatus;
+    from: string;
+    to: string;
+    raw?: unknown;
+}
+export interface TelephonyCallControlResult {
+    provider: TelephonyProvider;
+    providerCallId: string;
+    status: TelephonyCallStatus;
+    raw?: unknown;
+}
+export interface TelephonyBaseCallControlInput {
+    providerCallId: string;
+    connectionId?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TelephonyAnswerCallInput extends TelephonyBaseCallControlInput {
+}
+export interface TelephonyRejectCallInput extends TelephonyBaseCallControlInput {
+    reason?: string;
+}
+export interface TelephonyOriginateCallInput {
+    from?: TelephonyDestination;
+    to: TelephonyDestination;
+    connectionId?: string;
+    answerUrl?: string;
+    statusCallbackUrl?: string;
+    metadata?: Record<string, unknown>;
+}
+export interface TelephonyOriginateCallResult {
+    provider: TelephonyProvider;
+    providerCallId: string;
+    status: TelephonyCallStatus;
+    from?: TelephonyDestination;
+    to: TelephonyDestination;
+    raw?: unknown;
+}
+export interface TelephonyBridgeCallInput extends TelephonyBaseCallControlInput {
+    target: TelephonyDestination | {
+        providerCallId: string;
+    };
+    policy?: TelephonyTransferPolicy;
+}
+export interface TelephonyTransferCallInput extends TelephonyBaseCallControlInput {
+    destination: TelephonyDestination;
+    mode?: TelephonyTransferMode;
+    reason?: string;
+    policy?: TelephonyTransferPolicy;
+}
+export interface TelephonyTransferCallResult extends TelephonyCallControlResult {
+    destination: TelephonyDestination;
+    mode: TelephonyTransferMode;
+    transferId?: string;
+}
+export interface TelephonyHoldCallInput extends TelephonyBaseCallControlInput {
+    reason?: string;
+}
+export interface TelephonyResumeCallInput extends TelephonyBaseCallControlInput {
+    reason?: string;
+}
+export interface TelephonyHangUpCallInput extends TelephonyBaseCallControlInput {
+    reason?: string;
+}
+export interface TelephonySendDtmfInput extends TelephonyBaseCallControlInput {
+    digits: string;
+}
+export type TelephonyCallEvent = {
+    type: "call.created" | "call.ringing" | "call.answered" | "call.ended";
+    provider: TelephonyProvider;
+    providerCallId: string;
+    connectionId?: string;
+    at?: string;
+    metadata?: Record<string, unknown>;
+} | {
+    type: "call.transfer.started" | "call.transfer.completed" | "call.transfer.failed";
+    provider: TelephonyProvider;
+    providerCallId: string;
+    transferId?: string;
+    destination?: TelephonyDestination;
+    reason?: string;
+    at?: string;
+    metadata?: Record<string, unknown>;
+};
+export interface ResolvedTelephonyConnection {
+    connection: TelephonyConnection;
+    provider: TelephonyProvider;
+    capabilities: TelephonyProviderCapabilities;
+    metadata?: Record<string, unknown>;
+}
+export interface TelephonyConnectionResolver {
+    resolveConnection(input: {
+        projectId: string;
+        accountId?: string;
+        agentId?: string;
+        destination?: TelephonyDestination;
+        channel?: "phone" | "sip" | "outbound";
+        metadata?: Record<string, unknown>;
+    }): Promise<ResolvedTelephonyConnection>;
+}
+export interface TelephonyProviderAdapter {
+    provider: TelephonyProvider;
+    createOutboundCall(input: TelephonyOutboundCallInput): Promise<TelephonyOutboundCallResult>;
+}
+export interface TelephonyCallControlAdapter {
+    provider: TelephonyProvider;
+    capabilities?(): TelephonyProviderCapabilities;
+    answerCall?(input: TelephonyAnswerCallInput): Promise<TelephonyCallControlResult>;
+    rejectCall?(input: TelephonyRejectCallInput): Promise<TelephonyCallControlResult>;
+    originateCall?(input: TelephonyOriginateCallInput): Promise<TelephonyOriginateCallResult>;
+    bridgeCall?(input: TelephonyBridgeCallInput): Promise<TelephonyCallControlResult>;
+    transferCall?(input: TelephonyTransferCallInput): Promise<TelephonyTransferCallResult>;
+    holdCall?(input: TelephonyHoldCallInput): Promise<TelephonyCallControlResult>;
+    resumeCall?(input: TelephonyResumeCallInput): Promise<TelephonyCallControlResult>;
+    sendDtmf?(input: TelephonySendDtmfInput): Promise<TelephonyCallControlResult>;
+    hangUpCall(input: {
+        providerCallId: string;
+        reason?: string;
+        metadata?: Record<string, unknown>;
+    }): Promise<TelephonyCallControlResult>;
+}

package/dist/types.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@kognitivedev/telephony",
+  "version": "0.2.29",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./audio": {
+      "types": "./dist/audio.d.ts",
+      "default": "./dist/audio.js"
+    },
+    "./rtp": {
+      "types": "./dist/rtp.d.ts",
+      "default": "./dist/rtp.js"
+    },
+    "./twilio": {
+      "types": "./dist/twilio.d.ts",
+      "default": "./dist/twilio.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc -w --noCheck",
+    "test": "vitest run",
+    "prepublishOnly": "npm run build"
+  },
+  "dependencies": {
+    "@kognitivedev/voice": "^0.2.29"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^3.0.0"
+  },
+  "description": "Telephony call-control adapters for Kognitive voice agents",
+  "keywords": [
+    "kognitive",
+    "telephony",
+    "twilio",
+    "voice",
+    "calls"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kognitivedev/kognitive",
+    "directory": "packages/telephony"
+  },
+  "homepage": "https://kognitive.dev"
+}

package/src/__tests__/audio.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from "vitest";
+import { resamplePcm16WindowedSinc } from "../audio";
+
+function sinePcm16(sampleRate: number, frequency: number, durationMs: number, amplitude = 12000) {
+    const length = Math.round((sampleRate * durationMs) / 1000);
+    const samples = new Int16Array(length);
+    for (let index = 0; index < length; index += 1) {
+        samples[index] = Math.round(Math.sin((2 * Math.PI * frequency * index) / sampleRate) * amplitude);
+    }
+    return samples;
+}
+
+function rms(samples: Int16Array) {
+    if (samples.length === 0) return 0;
+    let sum = 0;
+    for (const sample of samples) sum += sample * sample;
+    return Math.sqrt(sum / samples.length);
+}
+
+function resamplePcm16Linear(samples: Int16Array, sourceRate: number, targetRate: number) {
+    const outputLength = Math.max(1, Math.round((samples.length * targetRate) / sourceRate));
+    const output = new Int16Array(outputLength);
+    const ratio = sourceRate / targetRate;
+    for (let index = 0; index < outputLength; index += 1) {
+        const position = index * ratio;
+        const leftIndex = Math.floor(position);
+        const rightIndex = Math.min(leftIndex + 1, samples.length - 1);
+        const fraction = position - leftIndex;
+        const left = samples[leftIndex] ?? 0;
+        const right = samples[rightIndex] ?? left;
+        output[index] = Math.round(left + ((right - left) * fraction));
+    }
+    return output;
+}
+
+describe("PCM audio helpers", () => {
+    it("resamples PCM to the requested duration", () => {
+        const source = new Int16Array(480);
+        expect(resamplePcm16WindowedSinc(source, 24000, 8000)).toHaveLength(160);
+        expect(resamplePcm16WindowedSinc(source, 24000, 16000)).toHaveLength(320);
+    });
+
+    it("attenuates out-of-band aliases better than linear interpolation when downsampling", () => {
+        const outOfBand = sinePcm16(24000, 5200, 120);
+        const linear = resamplePcm16Linear(outOfBand, 24000, 8000);
+        const sinc = resamplePcm16WindowedSinc(outOfBand, 24000, 8000);
+
+        expect(rms(sinc)).toBeLessThan(rms(linear) * 0.4);
+    });
+
+    it("preserves in-band speech frequencies while downsampling", () => {
+        const speechTone = sinePcm16(24000, 1000, 120);
+        const sinc = resamplePcm16WindowedSinc(speechTone, 24000, 8000);
+
+        expect(rms(sinc)).toBeGreaterThan(6000);
+    });
+});
+

package/src/__tests__/registry.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it } from "vitest";
+import { createTelephonyAdapterRegistry } from "../registry";
+
+describe("@kognitivedev/telephony adapter registry", () => {
+    it("registers provider and call-control adapters independently", async () => {
+        const registry = createTelephonyAdapterRegistry({
+            providers: [{
+                provider: "telnyx",
+                async createOutboundCall(input) {
+                    return {
+                        provider: "telnyx",
+                        providerCallId: "call_1",
+                        status: "queued",
+                        from: input.from,
+                        to: input.to,
+                    };
+                },
+            }],
+        });
+
+        registry.registerCallControl({
+            provider: "telnyx",
+            capabilities: () => ({ inboundSip: true, outboundSip: true, bridgeTransfer: true }),
+            async transferCall(input) {
+                return {
+                    provider: "telnyx",
+                    providerCallId: input.providerCallId,
+                    status: "active",
+                    destination: input.destination,
+                    mode: input.mode ?? "blind",
+                    transferId: "transfer_1",
+                };
+            },
+            async hangUpCall(input) {
+                return {
+                    provider: "telnyx",
+                    providerCallId: input.providerCallId,
+                    status: "completed",
+                };
+            },
+        });
+
+        expect(registry.listProviders()).toEqual(["telnyx"]);
+        expect(registry.listCallControlProviders()).toEqual(["telnyx"]);
+        expect(registry.requireCallControl("telnyx").capabilities?.()).toEqual({
+            inboundSip: true,
+            outboundSip: true,
+            bridgeTransfer: true,
+        });
+        await expect(registry.requireCallControl("telnyx").transferCall?.({
+            providerCallId: "call_1",
+            destination: { type: "sip_uri", uri: "sip:support@example.com" },
+        })).resolves.toMatchObject({
+            provider: "telnyx",
+            providerCallId: "call_1",
+            mode: "blind",
+            transferId: "transfer_1",
+        });
+    });
+
+    it("throws clear errors for missing adapters", () => {
+        const registry = createTelephonyAdapterRegistry();
+
+        expect(() => registry.requireProvider("cm_com")).toThrow('Telephony provider "cm_com" is not registered');
+        expect(() => registry.requireCallControl("cm_com")).toThrow('Telephony call-control provider "cm_com" is not registered');
+    });
+});

package/src/__tests__/rtp.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, it } from "vitest";
+import {
+    nextRtpSequenceNumber,
+    nextRtpTimestamp,
+    parseRtpPacket,
+    RTP_PAYLOAD_TYPE_PCMU,
+    serializeRtpPacket,
+} from "../rtp";
+
+describe("@kognitivedev/telephony RTP helpers", () => {
+    it("serializes and parses PCMU RTP packets", () => {
+        const payload = Buffer.from([1, 2, 3, 4]);
+        const packet = serializeRtpPacket({
+            marker: true,
+            payloadType: RTP_PAYLOAD_TYPE_PCMU,
+            sequenceNumber: 65535,
+            timestamp: 123456,
+            ssrc: 42,
+            payload,
+        });
+
+        expect(parseRtpPacket(packet)).toMatchObject({
+            version: 2,
+            marker: true,
+            payloadType: 0,
+            sequenceNumber: 65535,
+            timestamp: 123456,
+            ssrc: 42,
+            payload,
+        });
+    });
+
+    it("wraps RTP sequence numbers and timestamps", () => {
+        expect(nextRtpSequenceNumber(65535)).toBe(0);
+        expect(nextRtpTimestamp(0xffffffff, 160)).toBe(159);
+    });
+
+    it("rejects malformed packets", () => {
+        expect(() => parseRtpPacket(Buffer.alloc(2))).toThrow("too short");
+        expect(() => parseRtpPacket(Buffer.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]))).toThrow("Unsupported RTP version");
+    });
+});

package/src/__tests__/twilio.test.ts

@@ -0,0 +1,110 @@
+import { describe, expect, it } from "vitest";
+import { completeTwilioCall, createTwilioOutboundCall, createTwilioPhoneControlAdapter, createTwilioTelephonyProvider } from "../twilio";
+
+describe("@kognitivedev/telephony twilio", () => {
+    it("creates outbound calls through Twilio REST", async () => {
+        const calls: Array<{ url: string; init?: RequestInit }> = [];
+        const fetchImpl = async (input: RequestInfo | URL, init?: RequestInit) => {
+            calls.push({ url: String(input), init });
+            return new Response(JSON.stringify({ sid: "CA123", status: "queued" }), {
+                status: 201,
+                headers: { "Content-Type": "application/json" },
+            });
+        };
+
+        const result = await createTwilioOutboundCall({
+            accountSid: "AC123",
+            authToken: "secret",
+            from: "+15550001111",
+            to: "+15550002222",
+            answerUrl: "https://example.com/answer",
+            statusCallbackUrl: "https://example.com/status",
+            fetch: fetchImpl as typeof fetch,
+        });
+
+        expect(result).toMatchObject({
+            provider: "twilio",
+            providerCallId: "CA123",
+            status: "queued",
+            from: "+15550001111",
+            to: "+15550002222",
+        });
+        expect(calls[0].url).toBe("https://api.twilio.com/2010-04-01/Accounts/AC123/Calls.json");
+        expect(new Headers(calls[0].init?.headers).get("Authorization")).toMatch(/^Basic /);
+        const form = new URLSearchParams(String(calls[0].init?.body));
+        expect(form.get("Url")).toBe("https://example.com/answer");
+        expect(form.get("StatusCallback")).toBe("https://example.com/status");
+        expect(form.getAll("StatusCallbackEvent")).toEqual(["initiated", "ringing", "answered", "completed"]);
+    });
+
+    it("exposes a provider adapter", async () => {
+        const provider = createTwilioTelephonyProvider({
+            accountSid: "AC123",
+            authToken: "secret",
+            fetch: async () => new Response(JSON.stringify({ sid: "CA456", status: "in-progress" }), {
+                status: 201,
+                headers: { "Content-Type": "application/json" },
+            }),
+        });
+
+        await expect(provider.createOutboundCall({
+            from: "+15550001111",
+            to: "+15550002222",
+            answerUrl: "https://example.com/answer",
+        })).resolves.toMatchObject({ providerCallId: "CA456", status: "active" });
+    });
+
+    it("completes active Twilio calls through REST", async () => {
+        const calls: Array<{ url: string; init?: RequestInit }> = [];
+        const fetchImpl = async (input: RequestInfo | URL, init?: RequestInit) => {
+            calls.push({ url: String(input), init });
+            return new Response(JSON.stringify({ sid: "CA789", status: "completed" }), {
+                status: 200,
+                headers: { "Content-Type": "application/json" },
+            });
+        };
+
+        await expect(completeTwilioCall({
+            accountSid: "AC123",
+            authToken: "secret",
+            providerCallId: "CA789",
+            fetch: fetchImpl as typeof fetch,
+        })).resolves.toMatchObject({
+            provider: "twilio",
+            providerCallId: "CA789",
+            status: "completed",
+        });
+
+        expect(calls[0].url).toBe("https://api.twilio.com/2010-04-01/Accounts/AC123/Calls/CA789.json");
+        expect(new Headers(calls[0].init?.headers).get("Authorization")).toMatch(/^Basic /);
+        const form = new URLSearchParams(String(calls[0].init?.body));
+        expect(form.get("Status")).toBe("completed");
+    });
+
+    it("exposes a phone control adapter for hangup", async () => {
+        const calls: Array<{ url: string; init?: RequestInit }> = [];
+        const adapter = createTwilioPhoneControlAdapter({
+            accountSid: "AC123",
+            authToken: "secret",
+            fetch: async (input, init) => {
+                calls.push({ url: String(input), init });
+                return new Response(JSON.stringify({ sid: "CA999", status: "completed" }), {
+                    status: 200,
+                    headers: { "Content-Type": "application/json" },
+                });
+            },
+        });
+
+        await expect(adapter.hangUpCall({
+            providerCallId: "CA999",
+            reason: "done",
+        })).resolves.toMatchObject({
+            provider: "twilio",
+            providerCallId: "CA999",
+            status: "completed",
+        });
+
+        expect(calls[0].url).toBe("https://api.twilio.com/2010-04-01/Accounts/AC123/Calls/CA999.json");
+        expect(new URLSearchParams(String(calls[0].init?.body)).get("Status")).toBe("completed");
+    });
+});

package/src/audio.ts

@@ -0,0 +1,63 @@
+export interface Pcm16ResampleOptions {
+    filterRadius?: number;
+}
+
+const DEFAULT_FILTER_RADIUS = 18;
+const DOWNSAMPLE_CUTOFF_HEADROOM = 0.94;
+
+function sinc(value: number) {
+    if (Math.abs(value) < 1e-8) return 1;
+    const radians = Math.PI * value;
+    return Math.sin(radians) / radians;
+}
+
+function blackmanWindow(distance: number, width: number) {
+    if (width <= 0 || distance > width) return 0;
+    const ratio = distance / width;
+    return 0.42 + (0.5 * Math.cos(Math.PI * ratio)) + (0.08 * Math.cos(2 * Math.PI * ratio));
+}
+
+function clampPcm16(value: number) {
+    if (value > 32767) return 32767;
+    if (value < -32768) return -32768;
+    return Math.round(value);
+}
+
+export function resamplePcm16WindowedSinc(
+    samples: Int16Array,
+    sourceRate: number,
+    targetRate: number,
+    options: Pcm16ResampleOptions = {},
+) {
+    if (sourceRate <= 0 || targetRate <= 0) throw new Error("Sample rates must be positive");
+    if (samples.length === 0 || sourceRate === targetRate) return new Int16Array(samples);
+
+    const outputLength = Math.max(1, Math.round((samples.length * targetRate) / sourceRate));
+    const output = new Int16Array(outputLength);
+    const sourcePerTarget = sourceRate / targetRate;
+    const cutoff = Math.min(1, targetRate / sourceRate) * DOWNSAMPLE_CUTOFF_HEADROOM;
+    const filterRadius = Math.max(4, Math.round(options.filterRadius ?? DEFAULT_FILTER_RADIUS));
+    const kernelWidth = filterRadius / cutoff;
+
+    for (let outputIndex = 0; outputIndex < outputLength; outputIndex += 1) {
+        const sourcePosition = outputIndex * sourcePerTarget;
+        const firstInputIndex = Math.max(0, Math.ceil(sourcePosition - kernelWidth));
+        const lastInputIndex = Math.min(samples.length - 1, Math.floor(sourcePosition + kernelWidth));
+
+        let weightedSum = 0;
+        let weightTotal = 0;
+        for (let inputIndex = firstInputIndex; inputIndex <= lastInputIndex; inputIndex += 1) {
+            const distance = sourcePosition - inputIndex;
+            const window = blackmanWindow(Math.abs(distance), kernelWidth);
+            if (window === 0) continue;
+            const weight = cutoff * sinc(cutoff * distance) * window;
+            weightedSum += (samples[inputIndex] ?? 0) * weight;
+            weightTotal += weight;
+        }
+
+        output[outputIndex] = clampPcm16(weightTotal === 0 ? 0 : weightedSum / weightTotal);
+    }
+
+    return output;
+}
+

package/src/index.ts

@@ -0,0 +1,22 @@
+export * from "./types";
+export * from "./audio";
+export * from "./rtp";
+export * from "./twilio";
+export * from "./registry";
+export {
+    createVoiceTelephonyService,
+    type CreateVoiceTelephonySessionRequest,
+    type EndVoiceTelephonySessionOptions,
+    type UpdateVoiceTelephonySessionOptions,
+    type VoiceCallContext,
+    type VoiceCallDirection,
+    type VoiceCallProvider,
+    type VoiceCallTransport,
+    type VoiceTelephonyAgentResolutionContext,
+    type VoiceTelephonyAgentResolver,
+    type VoiceTelephonyAudioFrame,
+    type VoiceTelephonyProviderEvent,
+    type VoiceTelephonyService,
+    type VoiceTelephonyServiceConfig,
+    type VoiceTelephonySessionRecord,
+} from "@kognitivedev/voice/telephony";