@guava-ai/guava-sdk 0.2.0 → 0.4.0

package/dist/src/index.js

@@ -1,447 +1,226 @@
-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 __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
 };
 import WebSocket from "ws";
-import { getConsoleLogger } from "./logging.js";
-import { acceptInboundCallCommand, startOutboundCallCommand, setPersona, setTaskCommand, answerQuestionCommand, sendInstructionCommand, readScriptCommand, rejectInboundCallCommand, transferCommand, listenInboundCommand, inboundTunnelCommand, } from "./commands.js";
+import { getDefaultLogger } from "./logging.js";
+import { StartOutboundCallCommand, ListenInboundCommand, InboundTunnelCommand, } from "./commands.js";
 import * as z from "zod";
-import { errorEvent, sessionStartedEvent, decodeEvent, inboundTunnelEvent, } from "./events.js";
+import { ErrorEvent, SessionStartedEvent, decodeEvent, InboundTunnelEvent } from "./events.js";
 import pkgdata from "../package.json" with { type: "json" };
 import os from "node:os";
-const DEFAULT_BASE_URL = "https://guava-dev.gridspace.com/";
-const DEFAULT_LOG_LEVEL = "debug";
+import { getBaseUrl, fetchOrThrow } from "./utils.js";
+import { telemetryClient } from "./telemetry.js";
+export { CallController } from "./call-controller.js";
+export { Say, Field } from "./action_item.js";
+const SDK_NAME = "typescript-sdk";
+let firstClient = false;
 /**
  * @description convenience function for stringifying data according to a schema
  */
 function stringifyZod(schema, data) {
     return JSON.stringify(schema.parse(data));
 }
-/**
- * Interface between Guava services and user-supplied code
- */
-export class CallController {
-    constructor(logger) {
-        this._commandQueue = [];
-        this._fieldValues = {};
-        // Set up the default logger.
-        this.logger = logger;
-    }
-    /**
-     * @description Supply a function used to consume commands from the internal command queue.
-     *
-     * The function is expected to remove from the argument array commands that it has handled (iterating
-     * through the result of `Array.splice(0)` is sufficient)
-     */
-    setDrain(newDrain) {
-        this._drain = newDrain;
-        this.flush();
-    }
-    /**
-     * @description [inbound] receive a call, and process further.
-     */
-    acceptCall() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendCommand(acceptInboundCallCommand, {
-                command_type: "accept-inbound",
-            });
-        });
-    }
-    /**
-     * @description read a span of text verbatim
-     */
-    readScript(script) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendCommand(readScriptCommand, {
-                command_type: "read-script",
-                script: script,
-            });
-        });
-    }
-    /**
-     * @description [inbound] reject a call
-     */
-    rejectCall() {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendCommand(rejectInboundCallCommand, {
-                command_type: "reject-inbound",
-            });
-        });
-    }
-    addInfo(_info) {
-        return __awaiter(this, void 0, void 0, function* () {
-            throw new Error("not implemeneted");
-        });
-    }
-    /**
-     * @description read a span of text non-verbatim
-     */
-    sendInstruction(instruction) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendCommand(sendInstructionCommand, {
-                command_type: "send-instruction",
-                instruction: instruction,
-            });
-        });
-    }
-    /**
-     * @description provide identifiers the agent will use to identify the virtual agent
-     */
-    setPersona(args) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.sendCommand(setPersona, {
-                command_type: "set-persona",
-                organization_name: args.organizationName,
-                agent_name: args.agentName,
-                agent_purpose: args.agentPurpose,
-            });
-        });
-    }
-    /**
-     * @description direct the agent to collect information
-     * @param goal {} an objective string and/or a checklist of information to collect
-     * @param on_complete {} a callback to call once the information is available from the agent
-     * @param args {} arguments to pass through to the `on_complete` callback
-     */
-    setTask(goal, on_complete = () => { }, ...args) {
-        var _a;
-        this._current_task_id = Math.random().toString(16).substring(2, 8);
-        this._on_complete_current_task = on_complete.bind(this, ...args);
-        if (!("checklist" in goal)) {
-            this.sendCommand(setTaskCommand, {
-                command_type: "set-task",
-                task_id: this._current_task_id,
-                objective: goal.objective,
-                action_items: [],
-            });
-        }
-        else {
-            const action_items = goal.checklist.map((item) => typeof item == "string"
-                ? {
-                    item_type: "todo",
-                    description: item,
-                }
-                : item);
-            this.sendCommand(setTaskCommand, {
-                command_type: "set-task",
-                task_id: this._current_task_id,
-                objective: (_a = goal.objective) !== null && _a !== void 0 ? _a : "",
-                action_items,
-            });
-        }
-    }
-    /**
-     * @description direct the agent to collect information, continuing execution once the agent has collected the information
-     * @param goal {} an objective string and/or a checklist of information to collect
-     */
-    awaitTask(goal) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return new Promise((resolve) => {
-                this.setTask(goal, (_args) => {
-                    resolve();
-                });
-            });
-        });
-    }
-    /**
-     * @description retrieve a piece of information that the agent has collected
-     * @param key {string} key of the field checklist item
-     */
-    getField(key) {
-        if (key in this._fieldValues) {
-            return this._fieldValues[key];
-        }
-        else {
-            return null;
+const http_start = /^http:\/\//;
+const https_start = /^https:\/\//;
+let Client = (() => {
+    let _classDecorators = [telemetryClient.trackClass()];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var Client = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            Client = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
         }
-    }
-    /**
-     * @description [inbound] hang up an accepted call
-     */
-    hangup() {
-        return __awaiter(this, arguments, void 0, function* (final_instructions = "") {
-            let instructions;
-            if (final_instructions) {
-                instructions = `Start ending the conversation. Here are your final instructions: ${final_instructions} Once you've completed the final instructions, naturally end the conversation and hang up the call.`;
+        _apiKey;
+        _baseUrl;
+        _logger;
+        _ws;
+        _controller;
+        messageHandler;
+        constructor(apiKey, baseUrl, logger, captureWarnings = true) {
+            // Set up the default logger.
+            if (logger) {
+                this._logger = logger;
             }
             else {
-                instructions = "Naturally end the conversation and hang up the call.";
+                this._logger = getDefaultLogger();
             }
-            this.sendInstruction(instructions);
-        });
-    }
-    /**
-     * @description transfer an accepted call
-     */
-    transfer(to_number, transfer_message) {
-        const message = transfer_message !== null && transfer_message !== void 0 ? transfer_message : "I'm transferring you now";
-        this.sendCommand(transferCommand, {
-            command_type: "transfer-call",
-            transfer_message: message,
-            to_number: to_number,
-        });
-    }
-    sendCommand(schema, data) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const command = schema.parse(data);
-            this._commandQueue.push(command);
-            this.logger.debug(`Command queued: ${JSON.stringify(command)}`);
-            yield this.flush();
-        });
-    }
-    flush() {
-        return __awaiter(this, void 0, void 0, function* () {
-            var _a;
-            yield ((_a = this._drain) === null || _a === void 0 ? void 0 : _a.call(this, this._commandQueue));
-        });
-    }
-    onEvent(event) {
-        return __awaiter(this, void 0, void 0, function* () {
-            if (event.event_type == "caller-speech") {
-                this.onCallerSpeech(event);
+            // Resolve the API base URL.
+            if (baseUrl) {
+                this._baseUrl = baseUrl;
             }
-            else if (event.event_type == "agent-speech") {
-                this.onAgentSpeech(event);
+            else {
+                this._baseUrl = getBaseUrl();
             }
-            else if (event.event_type == "agent-question") {
-                try {
-                    this.logger.info(`Received question from bot: ${event.question}`);
-                    const answer = yield this.onQuestion(event.question);
-                    yield this.sendCommand(answerQuestionCommand, {
-                        command_type: "answer-question",
-                        question_id: event.question_id,
-                        answer: answer,
-                    });
-                }
-                catch (e) {
-                    this.logger.error("Error occured while answering question.");
-                    yield this.sendCommand(answerQuestionCommand, {
-                        command_type: "answer-question",
-                        question_id: event.question_id,
-                        answer: "An error occured and the question could not be answered.",
-                    });
-                }
+            // Resolve the API key.
+            if (apiKey) {
+                this._apiKey = apiKey;
             }
-            else if (event.event_type == "intent") {
-                this.logger.info(`Received intent ${event.intent_id} from bot: ${event.intent_summary}`);
-                const intent_response = yield this.onIntent(event.intent_summary);
-                if (intent_response) {
-                    const response_str = `Responding to intent ${event.intent_id}: ${intent_response}`;
-                    this.logger.info(response_str);
-                    this.sendInstruction(intent_response);
-                }
+            else if (process.env.GUAVA_API_KEY) {
+                this._apiKey = process.env.GUAVA_API_KEY;
             }
-            else if (event.event_type == "task-done") {
-                // ignore obsolete task_completed events
-                if (event.task_id == this._current_task_id) {
-                    // assertion is implied
-                    const on_complete = this._on_complete_current_task;
-                    this._on_complete_current_task = undefined;
-                    if (on_complete) {
-                        on_complete();
-                    }
-                }
+            else {
+                throw new Error("Guava API key must be provided either as argument to client constructor, or in environment variable GUAVA_API_KEY.");
             }
-            else if (event.event_type == "action-item-done") {
-                this._fieldValues[event.key] = event.payload;
-                if (event.key && event.payload) {
-                    this.logger.info(`Field ${event.key} updated with value: ${event.payload}`);
+            if (!firstClient) {
+                firstClient = true;
+                if (captureWarnings) {
+                    process.on("warning", (warning) => {
+                        this._logger.warn(warning.toString());
+                    });
                 }
+                telemetryClient.setSdkHeaders(this.headers());
+                this._checkSdkDeprecation();
             }
-            else if (event.event_type == "inbound-call") {
-                this.onIncomingCall(event.caller_number);
-            }
-            else if (event.event_type == "outbound-call-connected" ||
-                event.event_type == "bot-session-ended") {
-                // no-op, don't warn
+        }
+        getWebsocketBase() {
+            if (http_start.test(this._baseUrl)) {
+                return `ws://${this._baseUrl.substring("ws://".length)}`;
             }
-            else if (event.event_type == "error") {
-                this.logger.error(`The Guava agent reported an error: ${event.content}`);
+            else if (https_start.test(this._baseUrl)) {
+                return `wss://${this._baseUrl.substring("wss://".length)}`;
             }
             else {
-                this.logger.warn(`Unhandled event: ${JSON.stringify(event)}`);
+                throw new Error(`Invalid base URL: ${this._baseUrl}}`);
             }
-        });
-    }
-    // callbacks
-    /**
-     * @abstract
-     * @description called when an inbound call is received. The overriding function must start
-     * with `await super.onIncomingCall(from_number)`
-     */
-    onIncomingCall(from_number) {
-        return __awaiter(this, void 0, void 0, function* () {
-            yield this.onCallStart();
-        });
-    }
-    /**
-     * @abstract
-     * @description called when a call is connected by the API, whether inbound or outbound
-     */
-    onCallStart() {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    /**
-     * @abstract
-     * @description called when the caller speaks to the agent.
-     */
-    onCallerSpeech(event) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    /**
-     * @abstract
-     * @description called when the agent speaks to the caller.
-     */
-    onAgentSpeech(event) {
-        return __awaiter(this, void 0, void 0, function* () { });
-    }
-    /**
-     * @abstract
-     * @description called when the caller expresses a task they wish to execute
-     */
-    onIntent(intent) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return "Unfortunately I'm not able to help with that.";
-        });
-    }
-    /**
-     * @abstract
-     * @description called when the agent needs to respond to a question that it doesn't know
-     * the answer to.
-     */
-    onQuestion(question) {
-        return __awaiter(this, void 0, void 0, function* () {
-            return "I don't have an answer to that question.";
-        });
-    }
-}
-const http_start = /^http:\/\//;
-const https_start = /^https:\/\//;
-export class Client {
-    constructor(apiKey, baseUrl, logger) {
-        // Set up the default logger.
-        if (logger) {
-            this._logger = logger;
         }
-        else {
-            this._logger = getConsoleLogger(DEFAULT_LOG_LEVEL);
+        getHttpBase() {
+            return this._baseUrl;
         }
-        // Resolve the API base URL.
-        if (baseUrl) {
-            this._baseUrl = baseUrl;
+        headers() {
+            return {
+                Authorization: `Bearer ${this._apiKey}`,
+                "x-guava-platform": os.platform(),
+                "x-guava-runtime": process.release.name,
+                "x-guava-runtime-version": process.version,
+                "x-guava-sdk": SDK_NAME,
+                "x-guava-sdk-version": pkgdata.version,
+            };
         }
-        else if (process.env.GUAVA_BASE_URL) {
-            this._baseUrl = process.env.GUAVA_BASE_URL;
-        }
-        else {
-            this._baseUrl = DEFAULT_BASE_URL;
-        }
-        // Resolve the API key.
-        if (apiKey) {
-            this._apiKey = apiKey;
-        }
-        else if (process.env.GUAVA_API_KEY) {
-            this._apiKey = process.env.GUAVA_API_KEY;
-        }
-        else {
-            throw new Error("Guava API key must be provided either as argument to client constructor, or in environment variable GUAVA_API_KEY.");
-        }
-    }
-    getWebsocketBase() {
-        if (http_start.test(this._baseUrl)) {
-            return `ws://${this._baseUrl.substring("ws://".length)}`;
-        }
-        else if (https_start.test(this._baseUrl)) {
-            return `wss://${this._baseUrl.substring("wss://".length)}`;
-        }
-        else {
-            throw new Error(`Invalid base URL: ${this._baseUrl}}`);
-        }
-    }
-    getHttpBase() {
-        return this._baseUrl;
-    }
-    headers() {
-        return {
-            Authorization: `Bearer ${this._apiKey}`,
-            "x-guava-platform": os.platform(),
-            "x-guava-runtime": process.release.name,
-            "x-guava-runtime-version": process.version,
-            "x-guava-sdk": "typescript-sdk",
-            "x-guava-sdk-version": pkgdata.version,
-        };
-    }
-    /**
-     * @description use the Guava API to call out to a number
-     */
-    createOutbound(fromNumber, toNumber, callControllerFactory) {
-        const url = new URL("v1/create-outbound", this.getWebsocketBase());
-        const ws = new WebSocket(url, {
-            headers: this.headers(),
-        });
-        const callController = (callControllerFactory !== null && callControllerFactory !== void 0 ? callControllerFactory : ((_) => undefined))(this._logger);
-        ws.addEventListener("open", (_ev) => __awaiter(this, void 0, void 0, function* () {
-            ws.send(stringifyZod(startOutboundCallCommand, {
-                command_type: "start-outbound",
-                to_number: toNumber,
-                from_number: fromNumber,
-            }));
-            yield (callController === null || callController === void 0 ? void 0 : callController.onCallStart());
-        }));
-        ws.addEventListener("close", (_ev) => {
-            // we are closing the socket, so don't trigger any other listeners
-            ws.removeAllListeners();
-            this._ws = undefined;
-            this._controller = undefined;
-        });
-        this._ws = ws;
-        this._controller = callController;
-        this.replaceHandler(this.uninitializedOutbound.bind(this));
-        // set the callController drain function to send all commands
-        // through the websocket
-        callController === null || callController === void 0 ? void 0 : callController.setDrain((commands) => __awaiter(this, void 0, void 0, function* () {
-            for (const command of commands.splice(0)) {
-                this._logger.debug(`Sending command ${JSON.stringify(command)}`);
-                ws.send(JSON.stringify(command));
+        async _checkSdkDeprecation() {
+            this._logger.debug(`Checking deprecation for SDK ${SDK_NAME}, ${pkgdata.version}.`);
+            try {
+                const url = new URL("v1/check-sdk-deprecation", this.getHttpBase());
+                url.searchParams.set("sdk_name", SDK_NAME);
+                url.searchParams.set("sdk_version", pkgdata.version);
+                const response = await fetchOrThrow(url, {
+                    method: "POST",
+                    headers: this.headers(),
+                });
+                const body = (await response.json());
+                if (body.deprecation_status === "supported") {
+                    this._logger.info("SDK version still supported.");
+                }
+                else if (body.deprecation_status === "deprecated") {
+                    process.emitWarning("This SDK version is deprecated. Please update to a newer version of the SDK.");
+                }
+                else {
+                    this._logger.warn("SDK deprecation status unknown.");
+                }
+            }
+            catch (e) {
+                this._logger.error("Encountered issue while checking for deprecation.");
             }
-        }));
-    }
-    replaceHandler(newHandler) {
-        var _a, _b;
-        if (this.messageHandler) {
-            (_a = this._ws) === null || _a === void 0 ? void 0 : _a.removeEventListener("message", this.messageHandler);
-        }
-        if (newHandler) {
-            (_b = this._ws) === null || _b === void 0 ? void 0 : _b.addEventListener("message", newHandler);
         }
-        this.messageHandler = newHandler;
-    }
-    // eventlistener handlers for server events
-    // (a state machine in functions)
-    uninitializedOutbound(ev) {
-        // for correctness (and type correctness)
-        if (!this._ws) {
-            throw new Error("[internal] Uninitialized WebSocket");
+        /**
+         * @description use the Guava API to call out to a number
+         */
+        createOutbound(fromNumber, toNumber, callController) {
+            const url = new URL("v1/create-outbound", this.getWebsocketBase());
+            const ws = new WebSocket(url, {
+                headers: this.headers(),
+            });
+            ws.addEventListener("open", async (_ev) => {
+                ws.send(stringifyZod(StartOutboundCallCommand, {
+                    command_type: "start-outbound",
+                    to_number: toNumber,
+                    from_number: fromNumber,
+                }));
+                // set the callController drain function to send all commands
+                // through the now open websocket
+                callController.setDrain(async (commands) => {
+                    for (const command of commands.splice(0)) {
+                        this._logger.debug(`Sending command ${JSON.stringify(command)}`);
+                        ws.send(JSON.stringify(command));
+                    }
+                });
+                await callController.onCallStart();
+            });
+            ws.addEventListener("close", (_ev) => {
+                // we are closing the socket, so don't trigger any other listeners
+                ws.removeAllListeners();
+                this._ws = undefined;
+                this._controller = undefined;
+            });
+            this._ws = ws;
+            this._controller = callController;
+            this.replaceHandler(this.uninitializedOutbound.bind(this));
         }
-        const session_started = z
-            .union([sessionStartedEvent, errorEvent])
-            .parse(JSON.parse(ev.data.toString("utf8")));
-        if (session_started.event_type == "error") {
-            throw new Error(`Outbound call failed: ${session_started.content}`);
+        replaceHandler(newHandler) {
+            if (this.messageHandler) {
+                this._ws?.removeEventListener("message", this.messageHandler);
+            }
+            if (newHandler) {
+                this._ws?.addEventListener("message", newHandler);
+            }
+            this.messageHandler = newHandler;
         }
-        else {
-            this._logger.info(`Started session with ID: ${session_started.session_id}`);
-            // move to next state
-            this.replaceHandler(this.initializedOutbound.bind(this));
+        // eventlistener handlers for server events
+        // (a state machine in functions)
+        uninitializedOutbound(ev) {
+            // for correctness (and type correctness)
+            if (!this._ws) {
+                throw new Error("[internal] Uninitialized WebSocket");
+            }
+            const session_started = z
+                .union([SessionStartedEvent, ErrorEvent])
+                .parse(JSON.parse(ev.data.toString("utf8")));
+            if (session_started.event_type === "error") {
+                throw new Error(`Outbound call failed: ${session_started.content}`);
+            }
+            else {
+                this._logger.info(`Started session with ID: ${session_started.session_id}`);
+                // move to next state
+                this.replaceHandler(this.initializedOutbound.bind(this));
+            }
         }
-    }
-    initializedOutbound(ev) {
-        return __awaiter(this, void 0, void 0, function* () {
+        async initializedOutbound(ev) {
             // for correctness (and type correctness)
             if (!this._ws) {
                 throw new Error("[internal] Uninitialized WebSocket");
@@ -450,90 +229,77 @@ export class Client {
             const event = decodeEvent(ev.data);
             if (event) {
                 if (this._controller) {
-                    yield this._controller.onEvent(event);
+                    await this._controller.onEvent(event);
                 }
-                if (event.event_type == "outbound-call-failed" ||
-                    event.event_type == "bot-session-ended") {
+                if (event.event_type === "outbound-call-failed" || event.event_type === "bot-session-ended") {
                     // shutdown the websocket
                     this._ws.close();
                 }
             }
-        });
-    }
-    setInboundHandler(agent_number, public_url, inbound_token) {
-        return __awaiter(this, void 0, void 0, function* () {
-            const response = yield fetch(new URL(`v1/inbound-handler/${agent_number}`, this.getHttpBase()), {
-                method: "PUT",
+        }
+        /**
+         * @description use the Guava API to receive calls at a given number
+         */
+        listenInbound(conn, controllerClassFactory) {
+            const callControllers = {};
+            // return a way to *stop* listening
+            const url = new URL("v1/listen-inbound", this.getWebsocketBase());
+            const ws = new WebSocket(url, {
                 headers: this.headers(),
-                body: JSON.stringify({
-                    handler_url: public_url,
-                    handler_token: inbound_token,
-                }),
             });
-            if (!response.ok) {
-                throw new Error("Failed to set inbound handler");
-            }
-        });
-    }
-    /**
-     * @description use the Guava API to receive calls at a given number
-     */
-    listenInbound(conn, controllerClassFactory) {
-        const callControllers = {};
-        // return a way to *stop* listening
-        const url = new URL("v1/listen-inbound", this.getWebsocketBase());
-        const ws = new WebSocket(url, {
-            headers: this.headers(),
-        });
-        let agent_number;
-        let webrtc_code;
-        if ("agent_number" in conn) {
-            agent_number = conn.agent_number;
-        }
-        else {
-            webrtc_code = conn.webrtc_code;
-        }
-        this._logger.info(`Listening for calls to ${agent_number !== null && agent_number !== void 0 ? agent_number : webrtc_code}`);
-        if (webrtc_code) {
-            const debugurl = new URL(`debug-webrtc?webrtc_code=${webrtc_code}`, this.getHttpBase());
-            this._logger.debug(`WebRTC DebugURL: ${debugurl}`);
-        }
-        ws.addEventListener("open", (_ev) => {
-            ws.send(stringifyZod(listenInboundCommand, {
-                command_type: "listen-inbound",
-                agent_number: agent_number,
-                webrtc_code: webrtc_code,
-            }));
-        });
-        ws.addEventListener("close", (_ev) => {
-            ws.removeAllListeners();
-        });
-        ws.addEventListener("message", (ev) => {
-            const tunnel_event = inboundTunnelEvent.parse(JSON.parse(ev.data.toString("utf8")));
-            if (!(tunnel_event.call_id in callControllers)) {
-                this._logger.info(`Received tunnel event for new call ID: ${tunnel_event.call_id}. Creating call controller.`);
-                const newController = controllerClassFactory(this._logger);
-                newController.setDrain((commands) => __awaiter(this, void 0, void 0, function* () {
-                    for (const command of commands.splice(0)) {
-                        this._logger.debug(`Sending command: ${JSON.stringify(command)} for call ID: ${tunnel_event.call_id}`);
-                        ws.send(stringifyZod(inboundTunnelCommand, {
-                            call_id: tunnel_event.call_id,
-                            command,
-                        }));
-                    }
-                }));
-                callControllers[tunnel_event.call_id] = newController;
-                newController.onEvent(tunnel_event.event);
+            let agent_number;
+            let webrtc_code;
+            if ("agent_number" in conn) {
+                agent_number = conn.agent_number;
             }
             else {
-                // no threading, so manually forward to onEvent!
-                callControllers[tunnel_event.call_id].onEvent(tunnel_event.event);
+                webrtc_code = conn.webrtc_code;
             }
-        });
-        return new InboundListener(ws);
-    }
-}
+            this._logger.info(`Listening for calls to ${agent_number ?? webrtc_code}`);
+            if (webrtc_code) {
+                const debugurl = new URL(`debug-webrtc?webrtc_code=${webrtc_code}`, this.getHttpBase());
+                this._logger.debug(`WebRTC DebugURL: ${debugurl}`);
+            }
+            ws.addEventListener("open", (_ev) => {
+                ws.send(stringifyZod(ListenInboundCommand, {
+                    command_type: "listen-inbound",
+                    agent_number: agent_number,
+                    webrtc_code: webrtc_code,
+                }));
+            });
+            ws.addEventListener("close", (_ev) => {
+                ws.removeAllListeners();
+            });
+            ws.addEventListener("message", (ev) => {
+                const tunnel_event = InboundTunnelEvent.parse(JSON.parse(ev.data.toString("utf8")));
+                if (!(tunnel_event.call_id in callControllers)) {
+                    this._logger.info(`Received tunnel event for new call ID: ${tunnel_event.call_id}. Creating call controller.`);
+                    const newController = controllerClassFactory(this._logger);
+                    newController.setDrain(async (commands) => {
+                        for (const command of commands.splice(0)) {
+                            this._logger.debug(`Sending command: ${JSON.stringify(command)} for call ID: ${tunnel_event.call_id}`);
+                            ws.send(stringifyZod(InboundTunnelCommand, {
+                                call_id: tunnel_event.call_id,
+                                command,
+                            }));
+                        }
+                    });
+                    callControllers[tunnel_event.call_id] = newController;
+                    newController.onEvent(tunnel_event.event);
+                }
+                else {
+                    // no threading, so manually forward to onEvent!
+                    callControllers[tunnel_event.call_id].onEvent(tunnel_event.event);
+                }
+            });
+            return new InboundListener(ws);
+        }
+    };
+    return Client = _classThis;
+})();
+export { Client };
 class InboundListener {
+    ws;
     constructor(ws) {
         this.ws = ws;
     }