@guava-ai/guava-sdk 0.22.0 → 0.24.0

package/dist/src/agent.js

@@ -124,20 +124,21 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const ws_1 = __importDefault(require("ws"));
-const index_ts_1 = require("./index.js");
-const logging_ts_1 = require("./logging.js");
-const utils_ts_1 = require("./utils.js");
-const webrtc_helper_ts_1 = require("./webrtc-helper.js");
 const commands_ts_1 = require("./commands.js");
 const events_ts_1 = require("./events.js");
-const telemetry_ts_1 = require("./telemetry.js");
-const client_ts_1 = require("./socket/client.js");
 const guavadialer_events_ts_1 = require("./guavadialer-events.js");
+const health_ts_1 = require("./health.js");
+const llm_ts_1 = require("./helpers/llm.js");
+const index_ts_1 = require("./index.js");
+const logging_ts_1 = require("./logging.js");
+const client_ts_1 = require("./socket/client.js");
 const ListenInbound = __importStar(require("./socket/listen-inbound.js"));
-const session_ts_1 = require("./testing/session.js");
-const protocol_ts_1 = require("./testing/protocol.js");
+const telemetry_ts_1 = require("./telemetry.js");
 const chat_ts_1 = require("./testing/chat.js");
-const llm_ts_1 = require("./helpers/llm.js");
+const protocol_ts_1 = require("./testing/protocol.js");
+const session_ts_1 = require("./testing/session.js");
+const utils_ts_1 = require("./utils.js");
+const webrtc_helper_ts_1 = require("./webrtc-helper.js");
 let Agent = (() => {
     let _classDecorators = [telemetry_ts_1.telemetryClient.trackClass()];
     let _classDescriptor;
@@ -155,6 +156,8 @@ let Agent = (() => {
         _name;
         _organization;
         _purpose;
+        _voice;
+        _acceptDtmfForNumbers;
         _logger;
         _client = new index_ts_1.Client();
         _onCallReceived = async () => ({
@@ -170,12 +173,16 @@ let Agent = (() => {
         _onActionRequested;
         _onActionGeneric;
         _onActionHandlers = {};
+        _onValidateHandlers = {};
         _onSessionEnd;
+        _onEscalate;
         _onDtmf;
         constructor(args) {
             this._name = args?.name;
             this._organization = args?.organization;
             this._purpose = args?.purpose;
+            this._voice = args?.voice;
+            this._acceptDtmfForNumbers = args?.acceptDtmf ?? true;
             this._logger = (0, logging_ts_1.getDefaultLogger)();
         }
         onCallReceived(callback) {
@@ -206,6 +213,9 @@ let Agent = (() => {
                 this._onTaskCompleteGeneric = callbackOrTaskName;
             }
         }
+        onValidate(fieldKey, callback) {
+            this._onValidateHandlers[fieldKey] = callback;
+        }
         onSearchQuery(fieldKey, callback) {
             this._searchQueryHandlers[fieldKey] = callback;
         }
@@ -228,6 +238,9 @@ let Agent = (() => {
         onSessionEnd(callback) {
             this._onSessionEnd = callback;
         }
+        onEscalate(callback) {
+            this._onEscalate = callback;
+        }
         onDtmf(callback) {
             this._onDtmf = callback;
         }
@@ -292,18 +305,64 @@ let Agent = (() => {
             });
         }
         async listenPhone(phoneNumber) {
-            return this._listenInbound({ agent_number: phoneNumber });
+            const env_1 = { stack: [], error: void 0, hasError: false };
+            try {
+                const healthCtx = new health_ts_1.HealthContext();
+                const _server = __addDisposableResource(env_1, await (0, health_ts_1.getHealthServer)(healthCtx), true);
+                return this._listenInbound(healthCtx, { agent_number: phoneNumber });
+            }
+            catch (e_1) {
+                env_1.error = e_1;
+                env_1.hasError = true;
+            }
+            finally {
+                const result_1 = __disposeResources(env_1);
+                if (result_1)
+                    await result_1;
+            }
         }
         async listenWebrtc(webrtcCode) {
-            if (!webrtcCode) {
-                this._logger.info("No WebRTC code provided. Creating a temporary one.");
-                webrtcCode = await this._client.createWebrtcAgent(3600);
+            const env_2 = { stack: [], error: void 0, hasError: false };
+            try {
+                if (!webrtcCode) {
+                    this._logger.info("No WebRTC code provided. Creating a temporary one.");
+                    webrtcCode = await this._client.createWebrtcAgent(3600);
+                }
+                const healthCtx = new health_ts_1.HealthContext();
+                const _server = __addDisposableResource(env_2, await (0, health_ts_1.getHealthServer)(healthCtx), true);
+                return this._listenInbound(healthCtx, { webrtc_code: webrtcCode });
+            }
+            catch (e_2) {
+                env_2.error = e_2;
+                env_2.hasError = true;
+            }
+            finally {
+                const result_2 = __disposeResources(env_2);
+                if (result_2)
+                    await result_2;
+            }
+        }
+        async listenSip(sipCode) {
+            const env_3 = { stack: [], error: void 0, hasError: false };
+            try {
+                const healthCtx = new health_ts_1.HealthContext();
+                const _server = __addDisposableResource(env_3, await (0, health_ts_1.getHealthServer)(healthCtx), true);
+                return this._listenInbound(healthCtx, { sip_code: sipCode });
+            }
+            catch (e_3) {
+                env_3.error = e_3;
+                env_3.hasError = true;
+            }
+            finally {
+                const result_3 = __disposeResources(env_3);
+                if (result_3)
+                    await result_3;
             }
-            return this._listenInbound({ webrtc_code: webrtcCode });
         }
         async callLocal() {
             const webrtcCode = await this._client.createWebrtcAgent(300);
-            this._listenInbound({ webrtc_code: webrtcCode }).catch((err) => {
+            // No health-server for call_local.
+            this._listenInbound(new health_ts_1.HealthContext(), { webrtc_code: webrtcCode }).catch((err) => {
                 this._logger.error("Listen loop error: %s", err);
             });
             await (0, webrtc_helper_ts_1.runWebrtcHelper)(webrtcCode, (0, utils_ts_1.getBaseUrl)());
@@ -320,15 +379,31 @@ let Agent = (() => {
                 }
             }
             else if (event.event_type === "task-done") {
-                this._logger.info(`Task ${event.task_id} completed.`);
-                if (this._onTaskCompleteGeneric !== undefined) {
-                    await this._onTaskCompleteGeneric(call, event.task_id);
+                const errors = [];
+                for (const fieldKey of call._fieldKeysByTaskId[event.task_id] ?? []) {
+                    const handler = this._onValidateHandlers[fieldKey];
+                    if (handler) {
+                        const result = await handler(call, await call.getField(fieldKey));
+                        if (result !== true) {
+                            const [, error] = result;
+                            errors.push(error);
+                        }
+                    }
                 }
-                else if (event.task_id in this._onTaskCompleteHandlers) {
-                    await this._onTaskCompleteHandlers[event.task_id](call);
+                if (errors.length > 0) {
+                    await call.retryTask(errors.join(" "));
                 }
                 else {
-                    this._logger.warn(`No handler registered for completion of task '${event.task_id}'`);
+                    this._logger.info(`Task ${event.task_id} completed.`);
+                    if (this._onTaskCompleteGeneric !== undefined) {
+                        await this._onTaskCompleteGeneric(call, event.task_id);
+                    }
+                    else if (event.task_id in this._onTaskCompleteHandlers) {
+                        await this._onTaskCompleteHandlers[event.task_id](call);
+                    }
+                    else {
+                        this._logger.warn(`No handler registered for completion of task '${event.task_id}'`);
+                    }
                 }
             }
             else if (event.event_type === "agent-question") {
@@ -379,15 +454,20 @@ let Agent = (() => {
             }
             else if (event.event_type === "action-request") {
                 this._logger.info(`Received action request ${event.intent_id}: ${event.intent_summary}`);
-                let suggestion;
+                let suggestions = [];
                 if (this._onActionRequested !== undefined) {
-                    suggestion = await this._onActionRequested(call, event.intent_summary);
+                    const result = await this._onActionRequested(call, event.intent_summary);
+                    if (Array.isArray(result)) {
+                        suggestions = result;
+                    }
+                    else if (result !== null && result !== undefined) {
+                        suggestions = [result];
+                    }
                 }
                 await call.sendCommand(commands_ts_1.ActionSuggestionCommand, {
                     command_type: "action-suggestion",
                     intent_id: event.intent_id,
-                    action_key: suggestion?.key ?? null,
-                    action_description: suggestion?.description ?? "",
+                    actions: suggestions.map((s) => ({ key: s.key, description: s.description ?? "" })),
                 });
             }
             else if (event.event_type === "execute-action") {
@@ -421,6 +501,17 @@ let Agent = (() => {
                     await this._onDtmf(call, event);
                 }
             }
+            else if (event.event_type === "escalate") {
+                if (this._onEscalate !== undefined) {
+                    await this._onEscalate(call, event);
+                }
+                else if (event.requested_by === "agent") {
+                    await call.sendInstruction("No escalation target set. Apologize for not being able to help, ask them to try calling another time, and hang up the call immediately.");
+                }
+                else {
+                    await call.sendInstruction("Let them know there are no representatives available to take their call. Ask them if they would prefer to continue or to call another time.");
+                }
+            }
             else if (event.event_type === "error") {
                 this._logger.error(`The Guava agent reported an error: ${event.content}`);
             }
@@ -428,30 +519,33 @@ let Agent = (() => {
                 this._logger.warn(`The Guava agent reported a warning: ${event.content}`);
             }
         }
-        async _initCall(variables = {}) {
-            const call = new index_ts_1.Call(variables);
+        async _initCall(callId, callInfo, variables = {}) {
+            const call = new index_ts_1.Call(callId, callInfo, variables);
             await call.setPersona({
                 agentName: this._name,
                 agentPurpose: this._purpose,
                 organizationName: this._organization,
+                voice: this._voice,
             });
             await call.sendCommand(commands_ts_1.RegisteredHooksCommand, {
                 command_type: "registered-hooks",
                 has_on_question: this._onQuestion !== undefined,
                 has_on_intent: false,
                 has_on_action_requested: this._onActionRequested !== undefined,
+                has_on_escalate: this._onEscalate !== undefined,
+                accept_dtmf_for_numbers: this._acceptDtmfForNumbers,
             });
             if (this._onCallStart !== undefined) {
                 await this._onCallStart(call);
             }
             return call;
         }
-        async _attachToCall(callId, initialVariables = {}, testSession, route = "v2/connect-call") {
-            const env_1 = { stack: [], error: void 0, hasError: false };
+        async _attachToCall(callId, callInfo, initialVariables = {}, testSession, route = "v2/connect-call") {
+            const env_4 = { stack: [], error: void 0, hasError: false };
             try {
-                const call = await this._initCall(initialVariables);
+                const call = await this._initCall(callId, callInfo, initialVariables);
                 const url = new URL(`${route}/${callId}`, this._client.getWebsocketBase());
-                const socket = __addDisposableResource(env_1, await new client_ts_1.GuavaSocket(`call-connection-${callId}`, url.toString(), this._client, (cmd) => cmd, (payload) => (0, events_ts_1.decodeEventDict)(payload), 18000).connect(), true);
+                const socket = __addDisposableResource(env_4, await new client_ts_1.GuavaSocket(`call-connection-${callId}`, url.toString(), this._client, (cmd) => cmd, (payload) => (0, events_ts_1.decodeEventDict)(payload), 18000).connect(), true);
                 await call.setDrain(async (commands) => {
                     for (const command of commands.splice(0)) {
                         socket.send(command);
@@ -473,67 +567,79 @@ let Agent = (() => {
                         throw e;
                 }
             }
-            catch (e_1) {
-                env_1.error = e_1;
-                env_1.hasError = true;
+            catch (e_4) {
+                env_4.error = e_4;
+                env_4.hasError = true;
             }
             finally {
-                const result_1 = __disposeResources(env_1);
-                if (result_1)
-                    await result_1;
+                const result_4 = __disposeResources(env_4);
+                if (result_4)
+                    await result_4;
             }
         }
-        async _listenInbound(conn) {
-            const env_2 = { stack: [], error: void 0, hasError: false };
+        async _listenInbound(healthCtx, conn) {
+            const url = new URL("v2/listen-inbound", this._client.getWebsocketBase());
+            if ("agent_number" in conn) {
+                url.searchParams.set("phone_number", conn.agent_number);
+            }
+            else if ("webrtc_code" in conn) {
+                url.searchParams.set("webrtc_code", conn.webrtc_code);
+            }
+            else {
+                url.searchParams.set("sip_code", conn.sip_code);
+            }
             try {
-                const url = new URL("v2/listen-inbound", this._client.getWebsocketBase());
-                if ("agent_number" in conn) {
-                    url.searchParams.set("phone_number", conn.agent_number);
-                }
-                else {
-                    url.searchParams.set("webrtc_code", conn.webrtc_code);
-                }
-                const socket = __addDisposableResource(env_2, await new client_ts_1.GuavaSocket("listen-inbound", url.toString(), this._client, (msg) => msg, ListenInbound.decodeServerMessage).connect(), true);
+                const env_5 = { stack: [], error: void 0, hasError: false };
                 try {
-                    for await (const msg of socket) {
-                        switch (msg.message_type) {
-                            case "listen-started":
-                                if ("agent_number" in conn) {
-                                    this._logger.info("Listening on %s (%d other listeners).", conn.agent_number, msg.other_listeners);
-                                }
-                                else {
-                                    this._logger.info("Listening on WebRTC code %s (%d other listeners).", conn.webrtc_code, msg.other_listeners);
-                                    const debugUrl = new URL(`debug-webrtc?webrtc_code=${conn.webrtc_code}`, this._client.getHttpBase());
-                                    this._logger.info("Call your agent at: %s", debugUrl);
+                    const socket = __addDisposableResource(env_5, await new client_ts_1.GuavaSocket("listen-inbound", url.toString(), this._client, (msg) => msg, ListenInbound.decodeServerMessage).connect(), true);
+                    try {
+                        for await (const msg of socket) {
+                            switch (msg.message_type) {
+                                case "listen-started":
+                                    healthCtx.ready();
+                                    if ("agent_number" in conn) {
+                                        this._logger.info("Listening on %s (%d other listeners).", conn.agent_number, msg.other_listeners);
+                                    }
+                                    else if ("webrtc_code" in conn) {
+                                        this._logger.info("Listening on WebRTC code %s (%d other listeners).", conn.webrtc_code, msg.other_listeners);
+                                        const debugUrl = new URL(`debug-webrtc?webrtc_code=${conn.webrtc_code}`, this._client.getHttpBase());
+                                        this._logger.info("Call your agent at: %s", debugUrl);
+                                    }
+                                    else {
+                                        this._logger.info("Listening on SIP code %s (%d other listeners).", conn.sip_code, msg.other_listeners);
+                                    }
+                                    break;
+                                case "incoming-call":
+                                    socket.send({ message_type: "claim-call", call_id: msg.call_id });
+                                    break;
+                                case "assign-call": {
+                                    const { call_id, call_info } = msg;
+                                    this._logger.info("Received call (session ID: %s)", call_id);
+                                    this._handleAssignedCall(call_id, call_info, socket).catch((err) => {
+                                        this._logger.error("Error handling assigned call %s: %s", call_id, err);
+                                    });
+                                    break;
                                 }
-                                break;
-                            case "incoming-call":
-                                socket.send({ message_type: "claim-call", call_id: msg.call_id });
-                                break;
-                            case "assign-call": {
-                                const { call_id, call_info } = msg;
-                                this._logger.info("Received call (session ID: %s)", call_id);
-                                this._handleAssignedCall(call_id, call_info, socket).catch((err) => {
-                                    this._logger.error("Error handling assigned call %s: %s", call_id, err);
-                                });
-                                break;
                             }
                         }
                     }
+                    catch (e) {
+                        if (!(e instanceof client_ts_1.GuavaSocketClosedError))
+                            throw e;
+                    }
                 }
-                catch (e) {
-                    if (!(e instanceof client_ts_1.GuavaSocketClosedError))
-                        throw e;
+                catch (e_5) {
+                    env_5.error = e_5;
+                    env_5.hasError = true;
+                }
+                finally {
+                    const result_5 = __disposeResources(env_5);
+                    if (result_5)
+                        await result_5;
                 }
-            }
-            catch (e_2) {
-                env_2.error = e_2;
-                env_2.hasError = true;
             }
             finally {
-                const result_2 = __disposeResources(env_2);
-                if (result_2)
-                    await result_2;
+                healthCtx.stopped();
             }
         }
         async _handleAssignedCall(callId, callInfo, socket, initialVariables = {}) {
@@ -545,7 +651,7 @@ let Agent = (() => {
             else {
                 this._logger.info("Accepting call %s.", callId);
                 socket.send({ message_type: "answer-call", call_id: callId });
-                await this._attachToCall(callId, initialVariables);
+                await this._attachToCall(callId, callInfo, initialVariables);
             }
         }
         /**
@@ -562,7 +668,13 @@ let Agent = (() => {
             });
             const { call_id } = (await response.json());
             this._logger.info("Outbound call created with session ID: %s", call_id);
-            await this._attachToCall(call_id, variables);
+            const callInfo = {
+                call_type: "pstn",
+                from_number: fromNumber ?? null,
+                to_number: toNumber,
+                caller_id: null,
+            };
+            await this._attachToCall(call_id, callInfo, variables);
         }
         /**
          * Run the agent against a live test session.
@@ -594,7 +706,13 @@ let Agent = (() => {
             });
             const sessionStarted = protocol_ts_1.SessionStarted.parse(JSON.parse(rawFirst));
             const testSession = new session_ts_1.TestSession(ws, this._client);
-            const attachPromise = this._attachToCall(sessionStarted.session_id, variables, testSession).catch((err) => {
+            const testCallInfo = {
+                call_type: "pstn",
+                from_number: null,
+                to_number: "+15555555555",
+                caller_id: null,
+            };
+            const attachPromise = this._attachToCall(sessionStarted.session_id, testCallInfo, variables, testSession).catch((err) => {
                 this._logger.error("Error in _attachToCall during test: %s", err);
             });
             try {
@@ -620,12 +738,12 @@ let Agent = (() => {
          *   pass/fail criteria, or `session.getTranscript()` to inspect the conversation.
          *
          * @example
-         * const session = await agent.testRoleplay(
+         * const session = await agent.roleplay(
          *   "You are a caller trying to buy a new table.",
          * );
          * assert(session.executedActions.includes("sales"));
          */
-        async testRoleplay(roleplayPrompt, variables = {}) {
+        async roleplay(roleplayPrompt, variables = {}) {
             const roleplaySchema = {
                 type: "object",
                 properties: {
@@ -682,6 +800,10 @@ Choose "speak" and provide your next utterance, or choose "hangup" if the conver
                 }
             }, variables);
         }
+        /** @deprecated Use {@link roleplay} instead. */
+        async testRoleplay(roleplayPrompt, variables = {}) {
+            return this.roleplay(roleplayPrompt, variables);
+        }
         /**
          * Start an interactive terminal chat session with the agent.
          *
@@ -712,6 +834,8 @@ Choose "speak" and provide your next utterance, or choose "hangup" if the conver
                 name: this._name,
                 organization: this._organization,
                 purpose: this._purpose,
+                voice: this._voice,
+                acceptDtmf: this._acceptDtmfForNumbers,
             });
             cloned._onCallReceived = this._onCallReceived;
             cloned._onCallStart = this._onCallStart;
@@ -721,61 +845,75 @@ Choose "speak" and provide your next utterance, or choose "hangup" if the conver
             cloned._onTaskCompleteGeneric = this._onTaskCompleteGeneric;
             cloned._onTaskCompleteHandlers = { ...this._onTaskCompleteHandlers };
             cloned._searchQueryHandlers = { ...this._searchQueryHandlers };
+            cloned._onValidateHandlers = { ...this._onValidateHandlers };
             cloned._onActionRequested = this._onActionRequested;
             cloned._onActionGeneric = this._onActionGeneric;
             cloned._onActionHandlers = { ...this._onActionHandlers };
             cloned._onSessionEnd = this._onSessionEnd;
+            cloned._onEscalate = this._onEscalate;
             cloned._onDtmf = this._onDtmf;
             return cloned;
         }
-        async _serveCampaign(campaignCode) {
-            const env_3 = { stack: [], error: void 0, hasError: false };
+        async _serveCampaign(healthCtx, campaignCode) {
             try {
-                const campaignUrl = new URL(`v1/campaigns/${campaignCode}`, this._client.getHttpBase());
-                const campaignResponse = await (0, utils_ts_1.fetchOrThrow)(campaignUrl, {
-                    headers: await this._client.headers(),
-                });
-                const campaign = (await campaignResponse.json());
-                const wsUrl = new URL(`v1/serve-campaign/${campaign.id}`, this._client.getWebsocketBase());
-                this._logger.info("Connecting to campaign '%s' (id: %s).", campaign.name, campaign.id);
-                const socket = __addDisposableResource(env_3, await new client_ts_1.GuavaSocket("serve-campaign", wsUrl.toString(), this._client, (msg) => msg, guavadialer_events_ts_1.decodeServerMessage).connect(), true);
-                const activeCalls = [];
+                const env_6 = { stack: [], error: void 0, hasError: false };
                 try {
-                    for await (const msg of socket) {
-                        switch (msg.message_type) {
-                            case "listen-started":
-                                this._logger.info("Listening for calls on campaign '%s'. Ready.", campaign.name);
-                                break;
-                            case "initiate-and-assign-call": {
-                                const { call_id, contact_data } = msg;
-                                const data = contact_data;
-                                const logPhone = data?.phone_number ?? "?";
-                                this._logger.info("Ready to make call, id %s — initiating call setup and dispatch for contact %s.", call_id, logPhone);
-                                activeCalls.push((async () => {
-                                    socket.send({ message_type: "controller-ready", call_id });
-                                    const variables = data?.data ?? {};
-                                    await this._attachToCall(call_id, variables, undefined, "v2/connect-campaign-call");
-                                })());
-                                break;
+                    const campaignUrl = new URL(`v1/campaigns/${campaignCode}`, this._client.getHttpBase());
+                    const campaignResponse = await (0, utils_ts_1.fetchOrThrow)(campaignUrl, {
+                        headers: await this._client.headers(),
+                    });
+                    const campaign = (await campaignResponse.json());
+                    const wsUrl = new URL(`v1/serve-campaign/${campaign.id}`, this._client.getWebsocketBase());
+                    this._logger.info("Connecting to campaign '%s' (id: %s).", campaign.name, campaign.id);
+                    const socket = __addDisposableResource(env_6, await new client_ts_1.GuavaSocket("serve-campaign", wsUrl.toString(), this._client, (msg) => msg, guavadialer_events_ts_1.decodeServerMessage).connect(), true);
+                    const activeCalls = [];
+                    try {
+                        for await (const msg of socket) {
+                            switch (msg.message_type) {
+                                case "listen-started":
+                                    this._logger.info("Listening for calls on campaign '%s'. Ready.", campaign.name);
+                                    healthCtx.ready();
+                                    break;
+                                case "initiate-and-assign-call": {
+                                    const { call_id, contact_data } = msg;
+                                    const data = contact_data;
+                                    const logPhone = data?.phone_number ?? "?";
+                                    this._logger.info("Ready to make call, id %s — initiating call setup and dispatch for contact %s.", call_id, logPhone);
+                                    activeCalls.push((async () => {
+                                        socket.send({ message_type: "controller-ready", call_id });
+                                        const variables = data?.data ?? {};
+                                        const campaignCallInfo = {
+                                            call_type: "pstn",
+                                            from_number: null,
+                                            to_number: data?.phone_number ?? "",
+                                            caller_id: null,
+                                        };
+                                        await this._attachToCall(call_id, campaignCallInfo, variables, undefined, "v2/connect-campaign-call");
+                                    })());
+                                    break;
+                                }
                             }
                         }
                     }
+                    catch (e) {
+                        if (!(e instanceof client_ts_1.GuavaSocketClosedError))
+                            throw e;
+                        this._logger.info("Campaign '%s' disconnected.", campaign.name);
+                    }
+                    await Promise.all(activeCalls);
                 }
-                catch (e) {
-                    if (!(e instanceof client_ts_1.GuavaSocketClosedError))
-                        throw e;
-                    this._logger.info("Campaign '%s' disconnected.", campaign.name);
+                catch (e_6) {
+                    env_6.error = e_6;
+                    env_6.hasError = true;
+                }
+                finally {
+                    const result_6 = __disposeResources(env_6);
+                    if (result_6)
+                        await result_6;
                 }
-                await Promise.all(activeCalls);
-            }
-            catch (e_3) {
-                env_3.error = e_3;
-                env_3.hasError = true;
             }
             finally {
-                const result_3 = __disposeResources(env_3);
-                if (result_3)
-                    await result_3;
+                healthCtx.stopped();
             }
         }
         /**
@@ -790,7 +928,21 @@ Choose "speak" and provide your next utterance, or choose "hangup" if the conver
          * await agent.attachCampaign("gcmp-abc123");
          */
         async attachCampaign(campaignCode) {
-            return this._serveCampaign(campaignCode);
+            const env_7 = { stack: [], error: void 0, hasError: false };
+            try {
+                const healthCtx = new health_ts_1.HealthContext();
+                const _server = __addDisposableResource(env_7, await (0, health_ts_1.getHealthServer)(healthCtx), true);
+                return this._serveCampaign(healthCtx, campaignCode);
+            }
+            catch (e_7) {
+                env_7.error = e_7;
+                env_7.hasError = true;
+            }
+            finally {
+                const result_7 = __disposeResources(env_7);
+                if (result_7)
+                    await result_7;
+            }
         }
         /* ===== Aliases to be removed at some point. ===== */
         /** @deprecated Use {@link listenPhone} instead. */