rcs-js 2.0.21 → 2.0.23-rc.1

package/dist/esm/wrapper/voice/VoiceSocket.mjs

@@ -0,0 +1,366 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { VoiceCommandAction, } from "./types.mjs";
+export class VoiceSocket {
+    constructor(socket, options = {}) {
+        this.listeners = new Map();
+        this.pendingAcks = new Map();
+        this.closedByUser = false;
+        this.reconnectAttempts = 0;
+        this.socket_ = socket;
+        this.createSocket = options.createSocket;
+        this.reconnect = normalizeReconnectOptions(options.reconnect);
+        this.bindSocket();
+    }
+    get socket() {
+        return this.socket_;
+    }
+    get readyState() {
+        return this.socket.readyState;
+    }
+    get isOpen() {
+        return this.socket.readyState === 1;
+    }
+    waitUntilOpen(timeoutMs = 10000) {
+        if (this.isOpen) {
+            return Promise.resolve();
+        }
+        return new Promise((resolve, reject) => {
+            const timeout = timeoutMs > 0
+                ? setTimeout(() => {
+                    cleanup();
+                    reject(new Error("Timed out waiting for voice socket to open."));
+                }, timeoutMs)
+                : undefined;
+            const cleanup = () => {
+                if (timeout !== undefined) {
+                    clearTimeout(timeout);
+                }
+                offOpen();
+                offClose();
+                offError();
+            };
+            const offOpen = this.on("open", () => {
+                cleanup();
+                resolve();
+            });
+            const offClose = this.on("close", () => {
+                cleanup();
+                reject(new Error("Voice socket closed before opening."));
+            });
+            const offError = this.on("error", (error) => {
+                cleanup();
+                reject(toError(error));
+            });
+        });
+    }
+    connect() {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.waitUntilOpen();
+        });
+    }
+    bindSocket() {
+        this.bind("open", (event) => this.emit("open", event));
+        this.bind("close", (event) => {
+            this.rejectPendingAcks(new Error("Voice socket closed before an ack was received."));
+            this.emit("close", event);
+            this.scheduleReconnect();
+        });
+        this.bind("error", (event) => this.emit("error", event));
+        this.bind("message", (event) => this.handleMessage(event.data));
+    }
+    on(event, listener) {
+        var _a;
+        const listeners = (_a = this.listeners.get(event)) !== null && _a !== void 0 ? _a : new Set();
+        listeners.add(listener);
+        this.listeners.set(event, listeners);
+        return () => {
+            listeners.delete(listener);
+            if (listeners.size === 0) {
+                this.listeners.delete(event);
+            }
+        };
+    }
+    send(frame) {
+        this.socket.send(JSON.stringify(frame));
+    }
+    command(frame) {
+        this.send(frame);
+        return frame.command_id;
+    }
+    commandAndWait(frame_1) {
+        return __awaiter(this, arguments, void 0, function* (frame, options = {}) {
+            const ack = this.waitForAck(frame.command_id, options);
+            this.command(frame);
+            return ack;
+        });
+    }
+    answer(params, commandId = createVoiceCommandId()) {
+        return this.command(withOptionalParams({ event: "command", command_id: commandId, action: "call.answer" }, params));
+    }
+    end(params, commandId = createVoiceCommandId()) {
+        return this.command(withOptionalParams({ event: "command", command_id: commandId, action: "call.end" }, params));
+    }
+    transfer(params, commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.CallTransfer,
+            params,
+        });
+    }
+    startRecording(commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.RecordingStart,
+        });
+    }
+    stopRecording(commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.RecordingStop,
+        });
+    }
+    playAudio(params, commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.AudioPlay,
+            params,
+        });
+    }
+    stopAudio(commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.AudioStop,
+        });
+    }
+    reduceNoise(params, commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.AudioReduceNoise,
+            params,
+        });
+    }
+    getInput(params, commandId = createVoiceCommandId()) {
+        return this.command(withOptionalParams({ event: "command", command_id: commandId, action: "input.get" }, params));
+    }
+    cancelInput(commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.InputCancel,
+        });
+    }
+    sendDtmf(params, commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.DtmfSend,
+            params,
+        });
+    }
+    updateState(params, commandId = createVoiceCommandId()) {
+        return this.command({
+            event: "command",
+            command_id: commandId,
+            action: VoiceCommandAction.CallUpdateState,
+            params,
+        });
+    }
+    sendMedia(media) {
+        this.send({ event: "media", media });
+    }
+    waitForAck(commandId, options = {}) {
+        const existing = this.pendingAcks.get(commandId);
+        if (existing !== undefined) {
+            throw new Error(`Already waiting for ack ${commandId}.`);
+        }
+        return new Promise((resolve, reject) => {
+            var _a;
+            const timeoutMs = (_a = options.timeoutMs) !== null && _a !== void 0 ? _a : 10000;
+            const pending = {
+                resolve,
+                reject,
+                timeout: timeoutMs > 0
+                    ? setTimeout(() => {
+                        this.pendingAcks.delete(commandId);
+                        reject(new Error(`Timed out waiting for ack ${commandId}.`));
+                    }, timeoutMs)
+                    : undefined,
+            };
+            this.pendingAcks.set(commandId, pending);
+        });
+    }
+    close(code, reason) {
+        this.closedByUser = true;
+        if (this.reconnectTimer !== undefined) {
+            clearTimeout(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        this.socket.close(code, reason);
+    }
+    reconnectNow() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (this.createSocket === undefined) {
+                throw new Error("Voice socket was not configured with a reconnect factory.");
+            }
+            if (this.reconnectPromise !== undefined) {
+                return this.reconnectPromise;
+            }
+            this.reconnectPromise = Promise.resolve()
+                .then(() => { var _a; return (_a = this.createSocket) === null || _a === void 0 ? void 0 : _a.call(this); })
+                .then((socket) => {
+                if (socket === undefined) {
+                    throw new Error("Voice socket reconnect factory did not return a socket.");
+                }
+                this.closedByUser = false;
+                this.socket_ = socket;
+                this.bindSocket();
+                this.reconnectAttempts = 0;
+                this.emit("reconnected", socket);
+                return this;
+            })
+                .finally(() => {
+                this.reconnectPromise = undefined;
+            });
+            return this.reconnectPromise;
+        });
+    }
+    bind(type, listener) {
+        if (this.socket.addEventListener !== undefined) {
+            this.socket.addEventListener(type, listener);
+            return;
+        }
+        if (type === "open") {
+            this.socket.onopen = listener;
+        }
+        else if (type === "message") {
+            this.socket.onmessage = listener;
+        }
+        else if (type === "error") {
+            this.socket.onerror = listener;
+        }
+        else if (type === "close") {
+            this.socket.onclose = listener;
+        }
+    }
+    handleMessage(data) {
+        try {
+            const frame = parseVoiceFrame(data);
+            this.emit("frame", frame);
+            if (frame.event === "ack") {
+                this.resolvePendingAck(frame);
+                this.emit("ack", frame);
+            }
+            else if (frame.event === "event") {
+                this.emit("event", frame);
+            }
+            else if (frame.event === "media") {
+                this.emit("media", frame);
+            }
+            else if (frame.event === "connected") {
+                return;
+            }
+            else {
+                throw new Error("Voice socket received an unknown frame event.");
+            }
+        }
+        catch (error) {
+            this.emit("error", error);
+        }
+    }
+    resolvePendingAck(ack) {
+        const pending = this.pendingAcks.get(ack.command_id);
+        if (pending === undefined) {
+            return;
+        }
+        this.pendingAcks.delete(ack.command_id);
+        if (pending.timeout !== undefined) {
+            clearTimeout(pending.timeout);
+        }
+        pending.resolve(ack);
+    }
+    rejectPendingAcks(error) {
+        for (const [commandId, pending] of this.pendingAcks.entries()) {
+            this.pendingAcks.delete(commandId);
+            if (pending.timeout !== undefined) {
+                clearTimeout(pending.timeout);
+            }
+            pending.reject(error);
+        }
+    }
+    emit(event, payload) {
+        var _a;
+        for (const listener of (_a = this.listeners.get(event)) !== null && _a !== void 0 ? _a : []) {
+            listener(payload);
+        }
+    }
+    scheduleReconnect() {
+        if (this.closedByUser || !this.reconnect.enabled || this.createSocket === undefined) {
+            return;
+        }
+        if (this.reconnectTimer !== undefined || this.reconnectPromise !== undefined) {
+            return;
+        }
+        if (this.reconnectAttempts >= this.reconnect.maxAttempts) {
+            this.emit("error", new Error("Voice socket reconnect attempts exhausted."));
+            return;
+        }
+        this.reconnectAttempts += 1;
+        const delayMs = getReconnectDelay(this.reconnect, this.reconnectAttempts);
+        this.emit("reconnecting", { attempt: this.reconnectAttempts, delayMs });
+        this.reconnectTimer = setTimeout(() => {
+            this.reconnectTimer = undefined;
+            void this.reconnectNow().catch((error) => {
+                this.emit("error", error);
+                this.scheduleReconnect();
+            });
+        }, delayMs);
+    }
+}
+export function createVoiceCommandId() {
+    const random = typeof crypto !== "undefined" && "randomUUID" in crypto
+        ? crypto.randomUUID()
+        : `${Date.now().toString(36)}-${Math.random().toString(36).slice(2)}`;
+    return `cmd_${random}`;
+}
+function parseVoiceFrame(data) {
+    if (typeof data !== "string") {
+        throw new Error("Voice socket received a non-string frame.");
+    }
+    return JSON.parse(data);
+}
+function withOptionalParams(frame, params) {
+    if (params === undefined) {
+        return frame;
+    }
+    return Object.assign(Object.assign({}, frame), { params });
+}
+function normalizeReconnectOptions(options = {}) {
+    var _a, _b, _c, _d, _e;
+    return {
+        enabled: (_a = options.enabled) !== null && _a !== void 0 ? _a : false,
+        maxAttempts: (_b = options.maxAttempts) !== null && _b !== void 0 ? _b : 5,
+        initialDelayMs: (_c = options.initialDelayMs) !== null && _c !== void 0 ? _c : 250,
+        maxDelayMs: (_d = options.maxDelayMs) !== null && _d !== void 0 ? _d : 5000,
+        backoffMultiplier: (_e = options.backoffMultiplier) !== null && _e !== void 0 ? _e : 2,
+    };
+}
+function getReconnectDelay(options, attempt) {
+    return Math.min(options.initialDelayMs * Math.pow(options.backoffMultiplier, Math.max(0, attempt - 1)), options.maxDelayMs);
+}
+function toError(error) {
+    return error instanceof Error ? error : new Error("Voice socket error.");
+}

package/dist/esm/wrapper/voice/types.d.mts

@@ -0,0 +1,199 @@
+export declare const VoiceCommandAction: {
+    readonly CallAnswer: "call.answer";
+    readonly CallEnd: "call.end";
+    readonly CallTransfer: "call.transfer";
+    readonly RecordingStart: "recording.start";
+    readonly RecordingStop: "recording.stop";
+    readonly AudioPlay: "audio.play";
+    readonly AudioStop: "audio.stop";
+    readonly AudioReduceNoise: "audio.reduce_noise";
+    readonly InputGet: "input.get";
+    readonly InputCancel: "input.cancel";
+    readonly DtmfSend: "dtmf.send";
+    readonly CallUpdateState: "call.update_state";
+};
+export type VoiceCommandAction = (typeof VoiceCommandAction)[keyof typeof VoiceCommandAction];
+export declare const VoiceCallEndCause: {
+    readonly UserBusy: "user_busy";
+    readonly CallRejected: "call_rejected";
+};
+export type VoiceCallEndCause = (typeof VoiceCallEndCause)[keyof typeof VoiceCallEndCause];
+export declare const VoiceNoiseReductionEngine: {
+    readonly Default: "default";
+    readonly Krisp: "krisp";
+    readonly AiCoustics: "aicoustics";
+};
+export type VoiceNoiseReductionEngine = (typeof VoiceNoiseReductionEngine)[keyof typeof VoiceNoiseReductionEngine];
+export declare const VoiceNoiseReductionDirection: {
+    readonly Inbound: "inbound";
+    readonly Outbound: "outbound";
+    readonly Both: "both";
+};
+export type VoiceNoiseReductionDirection = (typeof VoiceNoiseReductionDirection)[keyof typeof VoiceNoiseReductionDirection];
+export declare const VoiceMediaTrack: {
+    readonly Inbound: "inbound";
+    readonly Outbound: "outbound";
+};
+export type VoiceMediaTrack = (typeof VoiceMediaTrack)[keyof typeof VoiceMediaTrack];
+export type VoiceCallMetadata = Record<string, string>;
+export interface VoiceCallAnswerCommandParams {
+    as?: string;
+}
+export interface VoiceCallEndCommandParams {
+    cause?: VoiceCallEndCause;
+}
+export interface VoiceCallTransferDialParams {
+    to: string;
+    from?: string;
+    as?: string;
+    custom_headers?: Record<string, string>;
+}
+export interface VoiceCallTransferBridgeParams {
+    /** Pinnacle call ID. Provider call-control IDs are not accepted. */
+    call_id: string;
+    as?: string;
+}
+export type VoiceCallTransferCommandParams = VoiceCallTransferDialParams | VoiceCallTransferBridgeParams;
+export type VoiceAudioPlayCommandParams = {
+    url: string;
+    loop?: number;
+    overlay?: boolean;
+} | {
+    text: string;
+    voice?: string;
+    language?: string;
+};
+export interface VoiceAudioReduceNoiseCommandParams {
+    enabled: boolean;
+    engine?: VoiceNoiseReductionEngine;
+    direction?: VoiceNoiseReductionDirection;
+}
+export type VoicePrompt = {
+    url: string;
+} | {
+    text: string;
+    voice?: string;
+    language?: string;
+};
+export interface VoiceAiExtraction {
+    extract: Record<string, unknown>;
+    instructions?: string;
+}
+export interface VoiceInputGetCommandParams {
+    prompt?: VoicePrompt;
+    maxDigits?: number;
+    minDigits?: number;
+    terminatingDigit?: string;
+    validDigits?: string;
+    timeoutMs?: number;
+    interDigitTimeoutMs?: number;
+    ai?: VoiceAiExtraction;
+}
+export interface VoiceDtmfSendCommandParams {
+    digits: string;
+    duration_ms?: number;
+}
+export interface VoiceCallUpdateStateCommandParams {
+    metadata: VoiceCallMetadata;
+}
+export type VoiceCommandFrame = {
+    event: "command";
+    command_id: string;
+    action: "call.answer";
+    params?: VoiceCallAnswerCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "call.end";
+    params?: VoiceCallEndCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "call.transfer";
+    params: VoiceCallTransferCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "recording.start";
+    params?: undefined;
+} | {
+    event: "command";
+    command_id: string;
+    action: "recording.stop";
+    params?: undefined;
+} | {
+    event: "command";
+    command_id: string;
+    action: "audio.play";
+    params: VoiceAudioPlayCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "audio.stop";
+    params?: undefined;
+} | {
+    event: "command";
+    command_id: string;
+    action: "audio.reduce_noise";
+    params: VoiceAudioReduceNoiseCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "input.get";
+    params?: VoiceInputGetCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "input.cancel";
+    params?: undefined;
+} | {
+    event: "command";
+    command_id: string;
+    action: "dtmf.send";
+    params: VoiceDtmfSendCommandParams;
+} | {
+    event: "command";
+    command_id: string;
+    action: "call.update_state";
+    params: VoiceCallUpdateStateCommandParams;
+};
+export interface VoiceClientMedia {
+    track?: VoiceMediaTrack;
+    payload: string;
+    chunk?: number;
+    timestamp?: string;
+}
+export interface VoiceClientMediaFrame {
+    event: "media";
+    media: VoiceClientMedia;
+}
+export type VoiceClientFrame = VoiceCommandFrame | VoiceClientMediaFrame;
+export interface VoiceCommandAckFrame {
+    event: "ack";
+    command_id: string;
+    action: VoiceCommandAction;
+    status: "ok" | "error";
+    message?: string;
+    [key: string]: unknown;
+}
+export interface VoiceConnectedFrame {
+    event: "connected";
+    stream_sid: string;
+    sequence_number?: number;
+}
+export interface VoiceServerEventFrame {
+    event: "event";
+    type: string;
+    stream_sid: string;
+    call_session_id?: string;
+    sequence_number: number;
+    payload: Record<string, unknown>;
+}
+export interface VoiceServerMediaFrame {
+    event: "media";
+    stream_sid?: string;
+    call_session_id?: string;
+    sequence_number?: number;
+    media: VoiceClientMedia;
+}
+export type VoiceServerFrame = VoiceConnectedFrame | VoiceCommandAckFrame | VoiceServerEventFrame | VoiceServerMediaFrame;

package/dist/esm/wrapper/voice/types.mjs

@@ -0,0 +1,32 @@
+export const VoiceCommandAction = {
+    CallAnswer: "call.answer",
+    CallEnd: "call.end",
+    CallTransfer: "call.transfer",
+    RecordingStart: "recording.start",
+    RecordingStop: "recording.stop",
+    AudioPlay: "audio.play",
+    AudioStop: "audio.stop",
+    AudioReduceNoise: "audio.reduce_noise",
+    InputGet: "input.get",
+    InputCancel: "input.cancel",
+    DtmfSend: "dtmf.send",
+    CallUpdateState: "call.update_state",
+};
+export const VoiceCallEndCause = {
+    UserBusy: "user_busy",
+    CallRejected: "call_rejected",
+};
+export const VoiceNoiseReductionEngine = {
+    Default: "default",
+    Krisp: "krisp",
+    AiCoustics: "aicoustics",
+};
+export const VoiceNoiseReductionDirection = {
+    Inbound: "inbound",
+    Outbound: "outbound",
+    Both: "both",
+};
+export const VoiceMediaTrack = {
+    Inbound: "inbound",
+    Outbound: "outbound",
+};

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rcs-js",
-    "version": "2.0.21",
+    "version": "2.0.23-rc.1",
     "private": false,
     "repository": "github:pinnacle-dev/rcs-js",
     "type": "commonjs",
@@ -43,17 +43,18 @@
         "test:wire": "vitest --project wire"
     },
     "dependencies": {
-        "mime-types": "^3.0.1"
+        "mime-types": "^3.0.1",
+        "ws": "^8.21.0"
     },
     "devDependencies": {
-        "webpack": "^5.104.1",
-        "ts-loader": "^9.5.1",
-        "vitest": "^3.2.4",
-        "msw": "2.11.2",
+        "@biomejs/biome": "2.3.1",
+        "@types/mime-types": "^3.0.1",
         "@types/node": "^18.19.70",
+        "msw": "2.11.2",
+        "ts-loader": "^9.5.1",
         "typescript": "~5.7.2",
-        "@biomejs/biome": "2.3.1",
-        "@types/mime-types": "^3.0.1"
+        "vitest": "^3.2.4",
+        "webpack": "^5.104.1"
     },
     "browser": {
         "fs": false,