rcs-js 2.0.21 → 2.0.23-rc.1

package/dist/cjs/version.js

@@ -1,4 +1,4 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.SDK_VERSION = void 0;
-exports.SDK_VERSION = "2.0.21";
+exports.SDK_VERSION = "2.0.23-rc.1";

package/dist/cjs/wrapper/PinnacleClient.d.ts

@@ -1,9 +1,12 @@
 import { PinnacleClient as FernClient } from "../Client.js";
-import { EnhancedTools } from "./tools/Client.js";
 import { EnhancedMessages } from "./messages/Client.js";
+import { EnhancedTools } from "./tools/Client.js";
+import { EnhancedVoice } from "./voice/Client.js";
 export declare class PinnacleClient extends FernClient {
     protected _tools: EnhancedTools | undefined;
     protected _messages: EnhancedMessages | undefined;
+    protected _voice: EnhancedVoice | undefined;
     get tools(): EnhancedTools;
     get messages(): EnhancedMessages;
+    get voice(): EnhancedVoice;
 }

package/dist/cjs/wrapper/PinnacleClient.js

@@ -2,16 +2,27 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PinnacleClient = void 0;
 const Client_js_1 = require("../Client.js");
-const Client_js_2 = require("./tools/Client.js");
-const Client_js_3 = require("./messages/Client.js");
+const Client_js_2 = require("./messages/Client.js");
+const Client_js_3 = require("./tools/Client.js");
+const Client_js_4 = require("./voice/Client.js");
 class PinnacleClient extends Client_js_1.PinnacleClient {
     get tools() {
-        var _a;
-        return ((_a = this._tools) !== null && _a !== void 0 ? _a : (this._tools = new Client_js_2.EnhancedTools(this._options)));
+        if (this._tools === undefined) {
+            this._tools = new Client_js_3.EnhancedTools(this._options);
+        }
+        return this._tools;
     }
     get messages() {
-        var _a;
-        return ((_a = this._messages) !== null && _a !== void 0 ? _a : (this._messages = new Client_js_3.EnhancedMessages(this._options)));
+        if (this._messages === undefined) {
+            this._messages = new Client_js_2.EnhancedMessages(this._options);
+        }
+        return this._messages;
+    }
+    get voice() {
+        if (this._voice === undefined) {
+            this._voice = new Client_js_4.EnhancedVoice(this._options);
+        }
+        return this._voice;
     }
 }
 exports.PinnacleClient = PinnacleClient;

package/dist/cjs/wrapper/messages/Client.d.ts

@@ -8,6 +8,6 @@ interface ExpressLikeRequest {
     originalUrl?: string;
 }
 export declare class EnhancedMessages extends Messages {
-    process(req: Request | ExpressLikeRequest, secret?: string): Promise<Pinnacle.MessageEvent | Pinnacle.UserEvent | Pinnacle.FormSubmissionEvent | Pinnacle.CampaignStatusEvent>;
+    process(req: Request | ExpressLikeRequest, secret?: string): Promise<Pinnacle.MessageEvent | Pinnacle.UserEvent | Pinnacle.FormSubmissionEvent | Pinnacle.CampaignStatusEvent | Pinnacle.CallStatusEvent>;
 }
 export {};

package/dist/cjs/wrapper/voice/Client.d.ts

@@ -0,0 +1,34 @@
+import type * as Pinnacle from "../../api/index.js";
+import { Calls } from "../../api/resources/calls/client/Client.js";
+import type { BaseClientOptions } from "../../BaseClient.js";
+import { type VoiceReconnectOptions, VoiceSocket, type VoiceSocketConstructor } from "./VoiceSocket.js";
+export interface VoiceConnectOptions {
+    callId: string;
+    token?: Pinnacle.CreateStreamTokenParams;
+    protocols?: string | string[];
+    reconnect?: VoiceReconnectOptions;
+    socket?: VoiceSocketConstructor;
+}
+export interface VoiceConnectStreamOptions {
+    protocols?: string | string[];
+    reconnect?: VoiceReconnectOptions;
+    socket?: VoiceSocketConstructor;
+}
+export interface VoiceCreateAndConnectOptions extends Pinnacle.CreateCallParams {
+    token?: Pinnacle.CreateStreamTokenParams;
+    protocols?: string | string[];
+    reconnect?: VoiceReconnectOptions;
+    socket?: VoiceSocketConstructor;
+    requestOptions?: Calls.RequestOptions;
+}
+export interface VoiceConnection extends VoiceSocket {
+    call: Pinnacle.CreatedCall;
+    callId: string;
+}
+export declare class EnhancedVoice {
+    private readonly calls;
+    constructor(options: BaseClientOptions);
+    createAndConnect(options: VoiceCreateAndConnectOptions): Promise<VoiceConnection>;
+    connect(options: VoiceConnectOptions): Promise<VoiceSocket>;
+    connectStream(streamUrl: string, options?: VoiceConnectStreamOptions): VoiceSocket;
+}

package/dist/cjs/wrapper/voice/Client.js

@@ -0,0 +1,147 @@
+"use strict";
+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());
+    });
+};
+var __rest = (this && this.__rest) || function (s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) {
+            if (e.indexOf(p[i]) < 0 && Object.prototype.propertyIsEnumerable.call(s, p[i]))
+                t[p[i]] = s[p[i]];
+        }
+    return t;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.EnhancedVoice = void 0;
+const Client_js_1 = require("../../api/resources/calls/client/Client.js");
+const VoiceSocket_js_1 = require("./VoiceSocket.js");
+const DEFAULT_RECONNECT = { enabled: true };
+class EnhancedVoice {
+    constructor(options) {
+        this.calls = new Client_js_1.Calls(options);
+    }
+    createAndConnect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const { token, protocols, reconnect, socket, requestOptions } = options, callParams = __rest(options, ["token", "protocols", "reconnect", "socket", "requestOptions"]);
+            const call = yield this.calls.create(callParams, requestOptions);
+            const connection = yield this.connect({
+                callId: call.id,
+                token,
+                protocols,
+                reconnect: withDefaultReconnect(reconnect),
+                socket,
+            });
+            connection.call = call;
+            connection.callId = call.id;
+            return connection;
+        });
+    }
+    connect(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, _b;
+            const token = yield this.calls.createStreamToken(options.callId, (_a = options.token) !== null && _a !== void 0 ? _a : {});
+            const streamOptions = {};
+            if (options.protocols !== undefined) {
+                streamOptions.protocols = options.protocols;
+            }
+            if (options.socket !== undefined) {
+                streamOptions.socket = options.socket;
+            }
+            streamOptions.reconnect = withDefaultReconnect(options.reconnect);
+            const Socket = (_b = streamOptions.socket) !== null && _b !== void 0 ? _b : (yield getDefaultSocket());
+            const createSocket = () => __awaiter(this, void 0, void 0, function* () {
+                var _a;
+                const nextToken = yield this.calls.createStreamToken(options.callId, (_a = options.token) !== null && _a !== void 0 ? _a : {});
+                return new Socket(nextToken.stream_url, streamOptions.protocols);
+            });
+            return new VoiceSocket_js_1.VoiceSocket(new Socket(token.stream_url, streamOptions.protocols), createVoiceSocketOptions(createSocket, streamOptions.reconnect));
+        });
+    }
+    connectStream(streamUrl, options = {}) {
+        var _a;
+        const Socket = (_a = options.socket) !== null && _a !== void 0 ? _a : getDefaultSocketSync();
+        const createSocket = () => new Socket(streamUrl, options.protocols);
+        return new VoiceSocket_js_1.VoiceSocket(createSocket(), createVoiceSocketOptions(createSocket, options.reconnect));
+    }
+}
+exports.EnhancedVoice = EnhancedVoice;
+function createVoiceSocketOptions(createSocket, reconnect) {
+    const options = { createSocket };
+    if (reconnect !== undefined) {
+        options.reconnect = reconnect;
+    }
+    return options;
+}
+function withDefaultReconnect(reconnect) {
+    return Object.assign(Object.assign({}, DEFAULT_RECONNECT), reconnect);
+}
+function getDefaultSocket() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a;
+        const Socket = getGlobalSocket();
+        if (Socket !== undefined) {
+            return Socket;
+        }
+        const WsSocket = (_a = getWsSocketSync()) !== null && _a !== void 0 ? _a : (yield getWsSocket());
+        if (WsSocket !== undefined) {
+            return WsSocket;
+        }
+        throwMissingSocketError();
+    });
+}
+function getDefaultSocketSync() {
+    var _a;
+    const Socket = (_a = getGlobalSocket()) !== null && _a !== void 0 ? _a : getWsSocketSync();
+    if (Socket !== undefined) {
+        return Socket;
+    }
+    throwMissingSocketError("connectStream(...) is synchronous, so older ESM Node runtimes must pass { socket }.");
+}
+function getGlobalSocket() {
+    const Socket = globalThis.WebSocket;
+    if (Socket !== undefined) {
+        return Socket;
+    }
+    return undefined;
+}
+function getWsSocketSync() {
+    var _a, _b;
+    if (typeof require !== "function") {
+        return undefined;
+    }
+    try {
+        const ws = require("ws");
+        return (_b = (_a = ws.WebSocket) !== null && _a !== void 0 ? _a : ws.default) !== null && _b !== void 0 ? _b : ws;
+    }
+    catch (_c) {
+        return undefined;
+    }
+}
+function getWsSocket() {
+    return __awaiter(this, void 0, void 0, function* () {
+        var _a, _b;
+        try {
+            const ws = (yield dynamicImport("ws"));
+            return (_b = (_a = ws.WebSocket) !== null && _a !== void 0 ? _a : ws.default) !== null && _b !== void 0 ? _b : ws;
+        }
+        catch (_c) {
+            return undefined;
+        }
+    });
+}
+function dynamicImport(specifier) {
+    const importer = new Function("specifier", "return import(specifier)");
+    return importer(specifier);
+}
+function throwMissingSocketError(detail) {
+    const suffix = detail === undefined ? "" : ` ${detail}`;
+    throw new Error(`Install "ws" to use voice WebSockets in Node, or pass { socket } to client.voice.connect(...).${suffix}`);
+}

package/dist/cjs/wrapper/voice/VoiceSocket.d.ts

@@ -0,0 +1,98 @@
+import { type VoiceAudioPlayCommandParams, type VoiceAudioReduceNoiseCommandParams, type VoiceCallAnswerCommandParams, type VoiceCallEndCommandParams, type VoiceCallTransferCommandParams, type VoiceCallUpdateStateCommandParams, type VoiceClientFrame, type VoiceClientMedia, type VoiceCommandAckFrame, type VoiceCommandFrame, type VoiceDtmfSendCommandParams, type VoiceInputGetCommandParams, type VoiceServerFrame } from "./types.js";
+import type * as Pinnacle from "../../api/index.js";
+export interface VoiceSocketLike {
+    readonly readyState: number;
+    send(data: string): void;
+    close(code?: number, reason?: string): void;
+    addEventListener?: (type: string, listener: (event: unknown) => void) => void;
+    removeEventListener?: (type: string, listener: (event: unknown) => void) => void;
+    onopen?: ((event: unknown) => void) | null;
+    onmessage?: ((event: {
+        data: unknown;
+    }) => void) | null;
+    onerror?: ((event: unknown) => void) | null;
+    onclose?: ((event: unknown) => void) | null;
+}
+export type VoiceSocketConstructor = new (url: string, protocols?: string | string[]) => VoiceSocketLike;
+export type VoiceSocketFactory = () => VoiceSocketLike | Promise<VoiceSocketLike>;
+export interface VoiceReconnectOptions {
+    enabled?: boolean;
+    maxAttempts?: number;
+    initialDelayMs?: number;
+    maxDelayMs?: number;
+    backoffMultiplier?: number;
+}
+export interface VoiceSocketOptions {
+    createSocket?: VoiceSocketFactory;
+    reconnect?: VoiceReconnectOptions;
+}
+export interface VoiceReconnectEvent {
+    attempt: number;
+    delayMs: number;
+}
+export type VoiceEvent = "open" | "close" | "error" | "frame" | "ack" | "event" | "media" | "reconnecting" | "reconnected";
+export interface VoiceEvents {
+    open: unknown;
+    close: unknown;
+    error: unknown;
+    frame: VoiceServerFrame;
+    ack: VoiceCommandAckFrame;
+    event: Extract<VoiceServerFrame, {
+        event: "event";
+    }>;
+    media: Extract<VoiceServerFrame, {
+        event: "media";
+    }>;
+    reconnecting: VoiceReconnectEvent;
+    reconnected: VoiceSocketLike;
+}
+export interface VoiceAckOptions {
+    timeoutMs?: number;
+}
+export declare class VoiceSocket {
+    call: Pinnacle.CreatedCall | undefined;
+    callId: string | undefined;
+    private socket_;
+    private readonly createSocket;
+    private readonly reconnect;
+    private readonly listeners;
+    private readonly pendingAcks;
+    private closedByUser;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private reconnectPromise;
+    constructor(socket: VoiceSocketLike, options?: VoiceSocketOptions);
+    get socket(): VoiceSocketLike;
+    get readyState(): number;
+    get isOpen(): boolean;
+    waitUntilOpen(timeoutMs?: number): Promise<void>;
+    connect(): Promise<void>;
+    private bindSocket;
+    on<Event extends VoiceEvent>(event: Event, listener: (payload: VoiceEvents[Event]) => void): () => void;
+    send(frame: VoiceClientFrame): void;
+    command(frame: VoiceCommandFrame): string;
+    commandAndWait(frame: VoiceCommandFrame, options?: VoiceAckOptions): Promise<VoiceCommandAckFrame>;
+    answer(params?: VoiceCallAnswerCommandParams, commandId?: string): string;
+    end(params?: VoiceCallEndCommandParams, commandId?: string): string;
+    transfer(params: VoiceCallTransferCommandParams, commandId?: string): string;
+    startRecording(commandId?: string): string;
+    stopRecording(commandId?: string): string;
+    playAudio(params: VoiceAudioPlayCommandParams, commandId?: string): string;
+    stopAudio(commandId?: string): string;
+    reduceNoise(params: VoiceAudioReduceNoiseCommandParams, commandId?: string): string;
+    getInput(params?: VoiceInputGetCommandParams, commandId?: string): string;
+    cancelInput(commandId?: string): string;
+    sendDtmf(params: VoiceDtmfSendCommandParams, commandId?: string): string;
+    updateState(params: VoiceCallUpdateStateCommandParams, commandId?: string): string;
+    sendMedia(media: VoiceClientMedia): void;
+    waitForAck(commandId: string, options?: VoiceAckOptions): Promise<VoiceCommandAckFrame>;
+    close(code?: number, reason?: string): void;
+    reconnectNow(): Promise<this>;
+    private bind;
+    private handleMessage;
+    private resolvePendingAck;
+    private rejectPendingAcks;
+    private emit;
+    private scheduleReconnect;
+}
+export declare function createVoiceCommandId(): string;