@kognitivedev/telephony 0.2.29

package/.turbo/turbo-build.log

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

package/.turbo/turbo-test.log

@@ -0,0 +1,13 @@
+$ vitest run
+
+ RUN  v3.2.4 /Users/vserifsaglam/work/memory-experiment/packages/telephony
+
+ ✓ src/__tests__/registry.test.ts (2 tests) 4ms
+ ✓ src/__tests__/twilio.test.ts (4 tests) 6ms
+ ✓ src/__tests__/audio.test.ts (3 tests) 19ms
+
+ Test Files  3 passed (3)
+      Tests  9 passed (9)
+   Start at  17:30:12
+   Duration  622ms (transform 163ms, setup 0ms, collect 246ms, tests 29ms, environment 0ms, prepare 732ms)
+

package/CHANGELOG.md

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

package/README.md

@@ -0,0 +1,98 @@
+# Kognitive Telephony
+
+`@kognitivedev/telephony` is the Node-side call-control package for Kognitive voice agents. It handles phone-provider ingress, outbound dialing, media-stream message normalization, and audio codec helpers. Cloud Voice uses it underneath for PSTN/SIP channels.
+
+## Install
+
+```bash
+bun add @kognitivedev/telephony
+```
+
+## Inbound Calls
+
+```ts
+import { createTwilioInboundCallResponse } from "@kognitivedev/telephony/twilio";
+
+const result = await createTwilioInboundCallResponse({
+  service: telephony,
+  authToken: process.env.TWILIO_AUTH_TOKEN,
+  resourceId: { userId: "caller:+15550001111" },
+  buildStreamUrl: (session) =>
+    `wss://api.example.com/api/cloud/voice/telephony/twilio/media/${session.sessionId}`,
+}, {
+  url: "https://api.example.com/api/cloud/voice/telephony/twilio/inbound",
+  headers: { "x-twilio-signature": request.headers.get("x-twilio-signature") ?? "" },
+  params,
+});
+
+return new Response(result.twiml, {
+  headers: { "Content-Type": "text/xml" },
+});
+```
+
+## Outbound Calls
+
+```ts
+import { createTwilioOutboundCall } from "@kognitivedev/telephony/twilio";
+
+const call = await createTwilioOutboundCall({
+  accountSid: process.env.TWILIO_ACCOUNT_SID!,
+  authToken: process.env.TWILIO_AUTH_TOKEN!,
+  from: "+15550001111",
+  to: "+15550002222",
+  answerUrl: "https://api.example.com/api/cloud/voice/telephony/twilio/outbound-answer/session_123",
+  statusCallbackUrl: "https://api.example.com/api/cloud/voice/telephony/twilio/status",
+});
+```
+
+## Runtime Tool Calls
+
+Phone calls do not have a browser runtime. Cloud Voice phone tools should be
+normal Kognitive runtime tools, synced from the customer's Kognitive instance
+and executed by the Cloud Voice backend during the call.
+
+```ts
+import { Kognitive } from "@kognitivedev/core";
+import { createTool } from "@kognitivedev/tools";
+import { z } from "zod";
+
+const lookupOrder = createTool({
+  id: "lookup_order",
+  description: "Look up an order",
+  inputSchema: z.object({ orderNumber: z.string() }),
+  execute: async ({ orderNumber }) => db.orders.findByNumber(orderNumber),
+});
+
+export const kognitive = new Kognitive({
+  apiKey: process.env.KOGNITIVE_API_KEY,
+  baseUrl: process.env.KOGNITIVE_API_URL,
+  tools: [lookupOrder],
+});
+```
+
+The Cloud Voice media bridge owns tracing and provider tool-result delivery.
+Application code does not call `appendCloudVoiceEvent()` or `sendToolResult()`
+directly.
+
+## Phone Control Adapter
+
+Cloud Voice phone-control tools use provider adapters. Twilio call control lives
+in this package; Cloud Voice orchestration receives it as a plain structural
+adapter.
+
+```ts
+import { createTwilioPhoneControlAdapter } from "@kognitivedev/telephony/twilio";
+
+const adapter = createTwilioPhoneControlAdapter({
+  accountSid: process.env.TWILIO_ACCOUNT_SID!,
+  authToken: process.env.TWILIO_AUTH_TOKEN!,
+});
+
+await adapter.hangUpCall({
+  providerCallId: "CA...",
+  reason: "caller said goodbye",
+});
+```
+
+The adapter completes the active Twilio call through the Calls REST API with
+`Status=completed`.

package/dist/audio.d.ts

@@ -0,0 +1,4 @@
+export interface Pcm16ResampleOptions {
+    filterRadius?: number;
+}
+export declare function resamplePcm16WindowedSinc(samples: Int16Array, sourceRate: number, targetRate: number, options?: Pcm16ResampleOptions): Int16Array<ArrayBuffer>;

package/dist/audio.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resamplePcm16WindowedSinc = resamplePcm16WindowedSinc;
+const DEFAULT_FILTER_RADIUS = 18;
+const DOWNSAMPLE_CUTOFF_HEADROOM = 0.94;
+function sinc(value) {
+    if (Math.abs(value) < 1e-8)
+        return 1;
+    const radians = Math.PI * value;
+    return Math.sin(radians) / radians;
+}
+function blackmanWindow(distance, width) {
+    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) {
+    if (value > 32767)
+        return 32767;
+    if (value < -32768)
+        return -32768;
+    return Math.round(value);
+}
+function resamplePcm16WindowedSinc(samples, sourceRate, targetRate, options = {}) {
+    var _a, _b;
+    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((_a = options.filterRadius) !== null && _a !== void 0 ? _a : 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 += ((_b = samples[inputIndex]) !== null && _b !== void 0 ? _b : 0) * weight;
+            weightTotal += weight;
+        }
+        output[outputIndex] = clampPcm16(weightTotal === 0 ? 0 : weightedSum / weightTotal);
+    }
+    return output;
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+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";

package/dist/index.js

@@ -0,0 +1,24 @@
+"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 });
+exports.createVoiceTelephonyService = void 0;
+__exportStar(require("./types"), exports);
+__exportStar(require("./audio"), exports);
+__exportStar(require("./rtp"), exports);
+__exportStar(require("./twilio"), exports);
+__exportStar(require("./registry"), exports);
+var telephony_1 = require("@kognitivedev/voice/telephony");
+Object.defineProperty(exports, "createVoiceTelephonyService", { enumerable: true, get: function () { return telephony_1.createVoiceTelephonyService; } });

package/dist/registry.d.ts

@@ -0,0 +1,15 @@
+import type { TelephonyCallControlAdapter, TelephonyProvider, TelephonyProviderAdapter } from "./types";
+export interface TelephonyAdapterRegistry {
+    registerProvider(adapter: TelephonyProviderAdapter): void;
+    registerCallControl(adapter: TelephonyCallControlAdapter): void;
+    getProvider(provider: TelephonyProvider): TelephonyProviderAdapter | undefined;
+    getCallControl(provider: TelephonyProvider): TelephonyCallControlAdapter | undefined;
+    requireProvider(provider: TelephonyProvider): TelephonyProviderAdapter;
+    requireCallControl(provider: TelephonyProvider): TelephonyCallControlAdapter;
+    listProviders(): TelephonyProvider[];
+    listCallControlProviders(): TelephonyProvider[];
+}
+export declare function createTelephonyAdapterRegistry(input?: {
+    providers?: TelephonyProviderAdapter[];
+    callControls?: TelephonyCallControlAdapter[];
+}): TelephonyAdapterRegistry;

package/dist/registry.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTelephonyAdapterRegistry = createTelephonyAdapterRegistry;
+function createTelephonyAdapterRegistry(input = {}) {
+    var _a, _b;
+    const providers = new Map();
+    const callControls = new Map();
+    const registry = {
+        registerProvider(adapter) {
+            providers.set(adapter.provider, adapter);
+        },
+        registerCallControl(adapter) {
+            callControls.set(adapter.provider, adapter);
+        },
+        getProvider(provider) {
+            return providers.get(provider);
+        },
+        getCallControl(provider) {
+            return callControls.get(provider);
+        },
+        requireProvider(provider) {
+            const adapter = providers.get(provider);
+            if (!adapter)
+                throw new Error(`Telephony provider "${provider}" is not registered`);
+            return adapter;
+        },
+        requireCallControl(provider) {
+            const adapter = callControls.get(provider);
+            if (!adapter)
+                throw new Error(`Telephony call-control provider "${provider}" is not registered`);
+            return adapter;
+        },
+        listProviders() {
+            return [...providers.keys()];
+        },
+        listCallControlProviders() {
+            return [...callControls.keys()];
+        },
+    };
+    for (const adapter of (_a = input.providers) !== null && _a !== void 0 ? _a : [])
+        registry.registerProvider(adapter);
+    for (const adapter of (_b = input.callControls) !== null && _b !== void 0 ? _b : [])
+        registry.registerCallControl(adapter);
+    return registry;
+}

package/dist/rtp.d.ts

@@ -0,0 +1,28 @@
+export declare const RTP_VERSION = 2;
+export declare const RTP_PAYLOAD_TYPE_PCMU = 0;
+export declare const RTP_PAYLOAD_TYPE_PCMA = 8;
+export interface RtpPacket {
+    version: number;
+    padding: boolean;
+    extension: boolean;
+    marker: boolean;
+    payloadType: number;
+    sequenceNumber: number;
+    timestamp: number;
+    ssrc: number;
+    csrc: number[];
+    payload: Buffer;
+}
+export interface SerializeRtpPacketInput {
+    marker?: boolean;
+    payloadType?: number;
+    sequenceNumber: number;
+    timestamp: number;
+    ssrc: number;
+    payload: Buffer | Uint8Array;
+    csrc?: number[];
+}
+export declare function nextRtpSequenceNumber(value: number): number;
+export declare function nextRtpTimestamp(value: number, increment: number): number;
+export declare function parseRtpPacket(buffer: Buffer | Uint8Array): RtpPacket;
+export declare function serializeRtpPacket(input: SerializeRtpPacketInput): Buffer;

package/dist/rtp.js

@@ -0,0 +1,88 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RTP_PAYLOAD_TYPE_PCMA = exports.RTP_PAYLOAD_TYPE_PCMU = exports.RTP_VERSION = void 0;
+exports.nextRtpSequenceNumber = nextRtpSequenceNumber;
+exports.nextRtpTimestamp = nextRtpTimestamp;
+exports.parseRtpPacket = parseRtpPacket;
+exports.serializeRtpPacket = serializeRtpPacket;
+exports.RTP_VERSION = 2;
+exports.RTP_PAYLOAD_TYPE_PCMU = 0;
+exports.RTP_PAYLOAD_TYPE_PCMA = 8;
+function assertUint16(value, label) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffff) {
+        throw new Error(`${label} must be a uint16`);
+    }
+}
+function assertUint32(value, label) {
+    if (!Number.isInteger(value) || value < 0 || value > 0xffffffff) {
+        throw new Error(`${label} must be a uint32`);
+    }
+}
+function nextRtpSequenceNumber(value) {
+    return (value + 1) & 0xffff;
+}
+function nextRtpTimestamp(value, increment) {
+    assertUint32(value, "timestamp");
+    if (!Number.isInteger(increment) || increment < 0)
+        throw new Error("increment must be a non-negative integer");
+    return (value + increment) >>> 0;
+}
+function parseRtpPacket(buffer) {
+    var _a, _b;
+    const data = Buffer.isBuffer(buffer) ? buffer : Buffer.from(buffer);
+    if (data.length < 12)
+        throw new Error("RTP packet is too short");
+    const first = (_a = data[0]) !== null && _a !== void 0 ? _a : 0;
+    const version = first >> 6;
+    if (version !== exports.RTP_VERSION)
+        throw new Error(`Unsupported RTP version ${version}`);
+    const csrcCount = first & 0x0f;
+    const headerLength = 12 + csrcCount * 4;
+    if (data.length < headerLength)
+        throw new Error("RTP packet has truncated CSRC list");
+    const second = (_b = data[1]) !== null && _b !== void 0 ? _b : 0;
+    const csrc = [];
+    for (let offset = 12; offset < headerLength; offset += 4) {
+        csrc.push(data.readUInt32BE(offset));
+    }
+    return {
+        version,
+        padding: Boolean(first & 0x20),
+        extension: Boolean(first & 0x10),
+        marker: Boolean(second & 0x80),
+        payloadType: second & 0x7f,
+        sequenceNumber: data.readUInt16BE(2),
+        timestamp: data.readUInt32BE(4),
+        ssrc: data.readUInt32BE(8),
+        csrc,
+        payload: data.subarray(headerLength),
+    };
+}
+function serializeRtpPacket(input) {
+    var _a, _b, _c;
+    assertUint16(input.sequenceNumber, "sequenceNumber");
+    assertUint32(input.timestamp, "timestamp");
+    assertUint32(input.ssrc, "ssrc");
+    const payloadType = (_a = input.payloadType) !== null && _a !== void 0 ? _a : exports.RTP_PAYLOAD_TYPE_PCMU;
+    if (!Number.isInteger(payloadType) || payloadType < 0 || payloadType > 0x7f) {
+        throw new Error("payloadType must be a 7-bit integer");
+    }
+    const csrc = (_b = input.csrc) !== null && _b !== void 0 ? _b : [];
+    if (csrc.length > 15)
+        throw new Error("RTP packets can contain at most 15 CSRC entries");
+    for (const [index, value] of csrc.entries())
+        assertUint32(value, `csrc[${index}]`);
+    const payload = Buffer.isBuffer(input.payload) ? input.payload : Buffer.from(input.payload);
+    const headerLength = 12 + csrc.length * 4;
+    const packet = Buffer.alloc(headerLength + payload.length);
+    packet[0] = (exports.RTP_VERSION << 6) | csrc.length;
+    packet[1] = (input.marker ? 0x80 : 0) | payloadType;
+    packet.writeUInt16BE(input.sequenceNumber, 2);
+    packet.writeUInt32BE(input.timestamp >>> 0, 4);
+    packet.writeUInt32BE(input.ssrc >>> 0, 8);
+    for (let index = 0; index < csrc.length; index += 1) {
+        packet.writeUInt32BE((_c = csrc[index]) !== null && _c !== void 0 ? _c : 0, 12 + index * 4);
+    }
+    payload.copy(packet, headerLength);
+    return packet;
+}

package/dist/twilio.d.ts

@@ -0,0 +1,24 @@
+import { computeTwilioBodySha256, createTwilioInboundCallResponse, createTwilioMediaStreamClearMessage, createTwilioMediaStreamMarkMessage, createTwilioMediaStreamMediaMessage, createTwilioMediaStreamTwiml, decodeTwilioMulawBase64ToFloat32, decodeTwilioMulawBase64ToPcm16, encodeFloat32ToTwilioMulawBase64, encodePcm16ToTwilioMulawBase64, handleTwilioMediaStreamMessage, parseTwilioMediaStreamMessage, serializeTwilioMediaStreamMessage, validateTwilioRequestSignature, type CreateTwilioMediaStreamTwimlOptions, type TwilioInboundCallContext, type TwilioInboundCallResponse, type TwilioInboundCallResponseConfig, type TwilioInboundMediaStreamMessage, type TwilioOutboundMediaStreamMessage, type TwilioRequestSignatureValidationOptions } from "@kognitivedev/voice/telephony";
+import type { TelephonyCallControlAdapter, TelephonyCallControlResult, TelephonyOutboundCallInput, TelephonyOutboundCallResult, TelephonyProviderAdapter } from "./types";
+export { computeTwilioBodySha256, createTwilioInboundCallResponse, createTwilioMediaStreamClearMessage, createTwilioMediaStreamMarkMessage, createTwilioMediaStreamMediaMessage, createTwilioMediaStreamTwiml, decodeTwilioMulawBase64ToFloat32, decodeTwilioMulawBase64ToPcm16, encodeFloat32ToTwilioMulawBase64, encodePcm16ToTwilioMulawBase64, handleTwilioMediaStreamMessage, parseTwilioMediaStreamMessage, serializeTwilioMediaStreamMessage, validateTwilioRequestSignature, };
+export type { CreateTwilioMediaStreamTwimlOptions, TwilioInboundCallContext, TwilioInboundCallResponse, TwilioInboundCallResponseConfig, TwilioInboundMediaStreamMessage, TwilioOutboundMediaStreamMessage, TwilioRequestSignatureValidationOptions, };
+export interface TwilioOutboundCallOptions extends TelephonyOutboundCallInput {
+    accountSid: string;
+    authToken: string;
+    fetch?: typeof fetch;
+}
+export interface TwilioTelephonyProviderConfig {
+    accountSid: string;
+    authToken: string;
+    fetch?: typeof fetch;
+}
+export interface TwilioCompleteCallOptions {
+    accountSid: string;
+    authToken: string;
+    providerCallId: string;
+    fetch?: typeof fetch;
+}
+export declare function createTwilioOutboundCall(options: TwilioOutboundCallOptions): Promise<TelephonyOutboundCallResult>;
+export declare function completeTwilioCall(options: TwilioCompleteCallOptions): Promise<TelephonyCallControlResult>;
+export declare function createTwilioTelephonyProvider(config: TwilioTelephonyProviderConfig): TelephonyProviderAdapter;
+export declare function createTwilioPhoneControlAdapter(config: TwilioTelephonyProviderConfig): TelephonyCallControlAdapter;

package/dist/twilio.js

@@ -0,0 +1,136 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTwilioRequestSignature = exports.serializeTwilioMediaStreamMessage = exports.parseTwilioMediaStreamMessage = exports.handleTwilioMediaStreamMessage = exports.encodePcm16ToTwilioMulawBase64 = exports.encodeFloat32ToTwilioMulawBase64 = exports.decodeTwilioMulawBase64ToPcm16 = exports.decodeTwilioMulawBase64ToFloat32 = exports.createTwilioMediaStreamTwiml = exports.createTwilioMediaStreamMediaMessage = exports.createTwilioMediaStreamMarkMessage = exports.createTwilioMediaStreamClearMessage = exports.createTwilioInboundCallResponse = exports.computeTwilioBodySha256 = void 0;
+exports.createTwilioOutboundCall = createTwilioOutboundCall;
+exports.completeTwilioCall = completeTwilioCall;
+exports.createTwilioTelephonyProvider = createTwilioTelephonyProvider;
+exports.createTwilioPhoneControlAdapter = createTwilioPhoneControlAdapter;
+const telephony_1 = require("@kognitivedev/voice/telephony");
+Object.defineProperty(exports, "computeTwilioBodySha256", { enumerable: true, get: function () { return telephony_1.computeTwilioBodySha256; } });
+Object.defineProperty(exports, "createTwilioInboundCallResponse", { enumerable: true, get: function () { return telephony_1.createTwilioInboundCallResponse; } });
+Object.defineProperty(exports, "createTwilioMediaStreamClearMessage", { enumerable: true, get: function () { return telephony_1.createTwilioMediaStreamClearMessage; } });
+Object.defineProperty(exports, "createTwilioMediaStreamMarkMessage", { enumerable: true, get: function () { return telephony_1.createTwilioMediaStreamMarkMessage; } });
+Object.defineProperty(exports, "createTwilioMediaStreamMediaMessage", { enumerable: true, get: function () { return telephony_1.createTwilioMediaStreamMediaMessage; } });
+Object.defineProperty(exports, "createTwilioMediaStreamTwiml", { enumerable: true, get: function () { return telephony_1.createTwilioMediaStreamTwiml; } });
+Object.defineProperty(exports, "decodeTwilioMulawBase64ToFloat32", { enumerable: true, get: function () { return telephony_1.decodeTwilioMulawBase64ToFloat32; } });
+Object.defineProperty(exports, "decodeTwilioMulawBase64ToPcm16", { enumerable: true, get: function () { return telephony_1.decodeTwilioMulawBase64ToPcm16; } });
+Object.defineProperty(exports, "encodeFloat32ToTwilioMulawBase64", { enumerable: true, get: function () { return telephony_1.encodeFloat32ToTwilioMulawBase64; } });
+Object.defineProperty(exports, "encodePcm16ToTwilioMulawBase64", { enumerable: true, get: function () { return telephony_1.encodePcm16ToTwilioMulawBase64; } });
+Object.defineProperty(exports, "handleTwilioMediaStreamMessage", { enumerable: true, get: function () { return telephony_1.handleTwilioMediaStreamMessage; } });
+Object.defineProperty(exports, "parseTwilioMediaStreamMessage", { enumerable: true, get: function () { return telephony_1.parseTwilioMediaStreamMessage; } });
+Object.defineProperty(exports, "serializeTwilioMediaStreamMessage", { enumerable: true, get: function () { return telephony_1.serializeTwilioMediaStreamMessage; } });
+Object.defineProperty(exports, "validateTwilioRequestSignature", { enumerable: true, get: function () { return telephony_1.validateTwilioRequestSignature; } });
+function normalizeTwilioStatus(value) {
+    switch (value) {
+        case "queued":
+        case "ringing":
+        case "in-progress":
+            return value === "in-progress" ? "active" : value;
+        case "completed":
+        case "failed":
+        case "busy":
+        case "no-answer":
+        case "cancelled":
+            return value;
+        default:
+            return "unknown";
+    }
+}
+function assertTwilioValue(value, label) {
+    if (!(value === null || value === void 0 ? void 0 : value.trim()))
+        throw new Error(`${label} is required`);
+    return value.trim();
+}
+async function createTwilioOutboundCall(options) {
+    var _a;
+    const accountSid = assertTwilioValue(options.accountSid, "Twilio accountSid");
+    const authToken = assertTwilioValue(options.authToken, "Twilio authToken");
+    const from = assertTwilioValue(options.from, "from");
+    const to = assertTwilioValue(options.to, "to");
+    const answerUrl = assertTwilioValue(options.answerUrl, "answerUrl");
+    const fetchImpl = (_a = options.fetch) !== null && _a !== void 0 ? _a : globalThis.fetch.bind(globalThis);
+    const form = new URLSearchParams({
+        From: from,
+        To: to,
+        Url: answerUrl,
+    });
+    if (options.statusCallbackUrl) {
+        form.set("StatusCallback", options.statusCallbackUrl);
+        for (const event of ["initiated", "ringing", "answered", "completed"]) {
+            form.append("StatusCallbackEvent", event);
+        }
+    }
+    const response = await fetchImpl(`https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(accountSid)}/Calls.json`, {
+        method: "POST",
+        headers: {
+            Authorization: `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: form,
+    });
+    const raw = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        const message = typeof raw.message === "string" ? raw.message : response.statusText;
+        throw new Error(`Twilio outbound call failed: ${message}`);
+    }
+    const providerCallId = typeof raw.sid === "string" ? raw.sid : options.providerCallId;
+    if (!providerCallId) {
+        throw new Error("Twilio outbound call response did not include sid");
+    }
+    return {
+        provider: "twilio",
+        providerCallId,
+        status: normalizeTwilioStatus(raw.status),
+        from,
+        to,
+        raw,
+    };
+}
+async function completeTwilioCall(options) {
+    var _a, _b;
+    const accountSid = assertTwilioValue(options.accountSid, "Twilio accountSid");
+    const authToken = assertTwilioValue(options.authToken, "Twilio authToken");
+    const providerCallId = assertTwilioValue(options.providerCallId, "Twilio providerCallId");
+    const fetchImpl = (_a = options.fetch) !== null && _a !== void 0 ? _a : globalThis.fetch.bind(globalThis);
+    const form = new URLSearchParams({ Status: "completed" });
+    const response = await fetchImpl(`https://api.twilio.com/2010-04-01/Accounts/${encodeURIComponent(accountSid)}/Calls/${encodeURIComponent(providerCallId)}.json`, {
+        method: "POST",
+        headers: {
+            Authorization: `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`,
+            "Content-Type": "application/x-www-form-urlencoded",
+        },
+        body: form,
+    });
+    const raw = await response.json().catch(() => ({}));
+    if (!response.ok) {
+        const message = typeof raw.message === "string" ? raw.message : response.statusText;
+        throw new Error(`Twilio call completion failed: ${message}`);
+    }
+    return {
+        provider: "twilio",
+        providerCallId,
+        status: normalizeTwilioStatus((_b = raw.status) !== null && _b !== void 0 ? _b : "completed"),
+        raw,
+    };
+}
+function createTwilioTelephonyProvider(config) {
+    return {
+        provider: "twilio",
+        createOutboundCall(input) {
+            return createTwilioOutboundCall(Object.assign(Object.assign({}, input), { accountSid: config.accountSid, authToken: config.authToken, fetch: config.fetch }));
+        },
+    };
+}
+function createTwilioPhoneControlAdapter(config) {
+    return {
+        provider: "twilio",
+        hangUpCall(input) {
+            return completeTwilioCall({
+                accountSid: config.accountSid,
+                authToken: config.authToken,
+                providerCallId: input.providerCallId,
+                fetch: config.fetch,
+            });
+        },
+    };
+}