@guava-ai/guava-sdk 0.25.0 → 0.27.0

package/examples/README.md

@@ -1,8 +1,9 @@
 # Examples
 
-- [example.test.ts](./example.test.ts) - Agent testing example demonstrating `agent.test()`, `agent.testRoleplay()`, `agent.patch()`, and `session.evaluate()` for unit testing handlers, scripted conversation flows, LLM-driven roleplay, and natural-language pass/fail evaluation.
-- [help-desk.ts](./help-desk.ts) - An inbound call agent for a furniture retailer that uses `DocumentQA` for RAG-based question answering and `IntentRecognizer` to classify caller intent and route to the appropriate department.
-- [polling-campaign.ts](./polling-campaign.ts) - Attaches a political polling agent to an existing Guava campaign via `attachCampaign()`, uses `reachPerson()` to confirm availability, then conducts a structured poll with text and multiple-choice fields.
-- [property-insurance.ts](./property-insurance.ts) - A simple inbound call agent that uses `DocumentQA` and RAG to answer questions about a property insurance policy.
-- [restaurant-waitlist.ts](./restaurant-waitlist.ts) - An inbound call agent that collects a caller's name, party size, and phone number to add them to a restaurant waitlist using a structured task checklist.
-- [scheduling-outbound.ts](./scheduling-outbound.ts) - An outbound call agent for a dental office that calls patients to schedule appointments, using `reachPerson()` for human detection and `DatetimeFilter` for searchable calendar slot availability.
+- [agent-testing.test.ts](./agent-testing.test.ts) - Test suite for the help-desk agent demonstrating `agent.test()`, `agent.testRoleplay()`, `agent.patch()`, handler unit tests with `MockCall`, and LLM-evaluated assertions with `session.evaluate()`.
+- [help-desk.ts](./help-desk.ts) - Inbound call agent for a furniture retailer that uses `DocumentQA` for RAG-backed question answering and `IntentRecognizer` to route callers to the correct department (sales, delivery, account management).
+- [multiple-agents.ts](./multiple-agents.ts) - Demonstrates running two independent agents simultaneously on different connection types (phone and WebRTC) using a shared `Runner`.
+- [polling-campaign.ts](./polling-campaign.ts) - Outbound campaign agent that conducts a non-partisan political opinion poll, uses `reachPerson` to confirm contact availability, and collects structured responses via a task checklist.
+- [property-insurance.ts](./property-insurance.ts) - Inbound call agent for a property insurance company that uses `DocumentQA` to answer policy questions from a knowledge base.
+- [restaurant-waitlist.ts](./restaurant-waitlist.ts) - Inbound call agent for a restaurant that collects caller name, party size, and phone number to add callers to a waitlist using a structured task.
+- [scheduling-outbound.ts](./scheduling-outbound.ts) - Outbound call agent for a dental office that uses `reachPerson` to confirm contact availability, then schedules appointments using a searchable calendar-slot field backed by `DatetimeFilter`.

package/package.json

@@ -2,7 +2,7 @@
   "name": "@guava-ai/guava-sdk",
   "description": "The official TypeScript SDK for building Guava voice agents.",
   "homepage": "https://docs.goguava.ai/typescript-sdk/",
-  "version": "0.25.0",
+  "version": "0.27.0",
   "type": "commonjs",
   "main": "dist/src/index.js",
   "types": "dist/src/index.d.ts",

package/src/agent.ts

@@ -4,6 +4,7 @@ import {
   AnswerQuestionCommand,
   ChoiceResultCommand,
   type Command,
+  ExpertErrorCommand,
   RegisteredHooksCommand,
 } from "./commands.ts";
 import {
@@ -13,6 +14,7 @@ import {
   type DTMFPressedEvent,
   type EscalateEvent,
   type GuavaEvent,
+  type OutboundCallFailed,
   decodeEventDict,
 } from "./events.ts";
 import {
@@ -91,6 +93,7 @@ export class Agent {
   private _onSessionEnd?: (call: Call, event: BotSessionEnded) => Promise<void>;
   private _onEscalate?: (call: Call, event: EscalateEvent) => Promise<void>;
   private _onDtmf?: (call: Call, event: DTMFPressedEvent) => Promise<void>;
+  private _onOutboundFailed?: (event: OutboundCallFailed) => Promise<void>;
 
   constructor(args?: {
     name?: string;
@@ -194,6 +197,10 @@ export class Agent {
     this._onDtmf = callback;
   }
 
+  onOutboundFailed(callback: (event: OutboundCallFailed) => Promise<void>): void {
+    this._onOutboundFailed = callback;
+  }
+
   get handlers() {
     return {
       onCallReceived: (callInfo: CallInfo) => this._onCallReceived(callInfo),
@@ -278,14 +285,37 @@ export class Agent {
     await runWebrtcHelper(webrtcCode, getBaseUrl());
   }
 
+  private async _invokeHandler(
+    call: Call,
+    name: string,
+    informAgent: boolean,
+    handler: () => Promise<void>,
+  ): Promise<void> {
+    try {
+      await handler();
+    } catch (err) {
+      this._logger.error(`An error occurred in the ${name} handler.`, err);
+      if (informAgent) {
+        await call.sendCommand(ExpertErrorCommand, {
+          command_type: "expert-error",
+          message: `The expert encountered an error while processing ${name}`,
+        });
+      }
+    }
+  }
+
   private async _dispatchEvent(call: Call, event: GuavaEvent, testSession?: TestSession) {
     if (event.event_type === "caller-speech") {
       if (this._onCallerSpeech !== undefined) {
-        await this._onCallerSpeech(call, event);
+        await this._invokeHandler(call, "onCallerSpeech", false, () =>
+          this._onCallerSpeech!(call, event),
+        );
       }
     } else if (event.event_type === "agent-speech") {
       if (this._onAgentSpeech !== undefined) {
-        await this._onAgentSpeech(call, event);
+        await this._invokeHandler(call, "onAgentSpeech", false, () =>
+          this._onAgentSpeech!(call, event),
+        );
       }
     } else if (event.event_type === "task-done") {
       const errors: string[] = [];
@@ -304,17 +334,28 @@ export class Agent {
         await call.retryTask(errors.join(" "));
       } else {
         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}'`);
+        try {
+          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}'`);
+          }
+        } catch (err) {
+          this._logger.error(
+            `An error occurred in the on_task_complete('${event.task_id}') handler.`,
+            err,
+          );
+          await call.sendCommand(ExpertErrorCommand, {
+            command_type: "expert-error",
+            message: `The expert encountered an error while processing on_task_complete('${event.task_id}') - the task has failed.`,
+          });
         }
       }
     } else if (event.event_type === "agent-question") {
+      this._logger.info(`Received question from bot: ${event.question}`);
       if (this._onQuestion !== undefined) {
-        this._logger.info(`Received question from bot: ${event.question}`);
         let answer: string;
         try {
           answer = await this._onQuestion(call, event.question);
@@ -339,6 +380,9 @@ export class Agent {
       }
     } else if (event.event_type === "action-item-done") {
       call._fieldValues[event.key] = event.payload;
+      if (event.key && event.payload) {
+        this._logger.info(`Field ${event.key} updated.`);
+      }
     } else if (event.event_type === "choice-query") {
       this._logger.info(`Received search query for field '${event.field_key}': ${event.query}`);
       const handler = this._searchQueryHandlers[event.field_key];
@@ -346,25 +390,49 @@ export class Agent {
         this._logger.warn(
           `Search query arrived for field '${event.field_key}' with no handler attached.`,
         );
-      } else {
-        const [matchedChoices, otherChoices] = await handler(call, event.query);
-        await call.sendCommand(ChoiceResultCommand, {
-          command_type: "choice-query-result",
-          field_key: event.field_key,
-          query_id: event.query_id,
-          matched_choices: matchedChoices,
-          other_choices: otherChoices,
+        await call.sendCommand(ExpertErrorCommand, {
+          command_type: "expert-error",
+          message: `The expert failed to handle on_search_query('${event.field_key}'). No results will be forthcoming.`,
         });
+      } else {
+        try {
+          const [matchedChoices, otherChoices] = await handler(call, event.query);
+          await call.sendCommand(ChoiceResultCommand, {
+            command_type: "choice-query-result",
+            field_key: event.field_key,
+            query_id: event.query_id,
+            matched_choices: matchedChoices,
+            other_choices: otherChoices,
+          });
+        } catch (err) {
+          this._logger.error(
+            `An error occurred in the on_search_query('${event.field_key}') handler.`,
+            err,
+          );
+          await call.sendCommand(ExpertErrorCommand, {
+            command_type: "expert-error",
+            message: `The expert encountered an error while processing the on_search_query('${event.field_key}') handler. No results will be forthcoming.`,
+          });
+        }
       }
     } else if (event.event_type === "action-request") {
       this._logger.info(`Received action request ${event.intent_id}: ${event.intent_summary}`);
       let suggestions: SuggestedAction[] = [];
       if (this._onActionRequested !== undefined) {
-        const result = await this._onActionRequested(call, event.intent_summary);
-        if (Array.isArray(result)) {
-          suggestions = result;
-        } else if (result !== null && result !== undefined) {
-          suggestions = [result];
+        try {
+          const result = await this._onActionRequested(call, event.intent_summary);
+          if (Array.isArray(result)) {
+            suggestions = result;
+          } else if (result !== null && result !== undefined) {
+            suggestions = [result];
+          }
+        } catch (err) {
+          this._logger.error("An error occurred in the onActionRequest handler.", err);
+          await call.sendCommand(ExpertErrorCommand, {
+            command_type: "expert-error",
+            message:
+              "The expert encountered an error while processing the on_action_request handler.",
+          });
         }
       }
       await call.sendCommand(ActionSuggestionCommand, {
@@ -384,7 +452,18 @@ export class Agent {
         onActionFunc = () => this._onActionHandlers[event.action_key](call);
       }
       if (onActionFunc !== undefined) {
-        await onActionFunc();
+        try {
+          await onActionFunc();
+        } catch (err) {
+          this._logger.error(
+            `An error occurred in the on_action('${event.action_key}') handler.`,
+            err,
+          );
+          await call.sendCommand(ExpertErrorCommand, {
+            command_type: "expert-error",
+            message: `The expert encountered an error while processing the on_action('${event.action_key}') handler.`,
+          });
+        }
       } else {
         this._logger.warn(`No handler registered for action '${event.action_key}'`);
       }
@@ -393,14 +472,18 @@ export class Agent {
       if (testSession) {
         testSession.terminationReason = event.termination_reason;
       }
-      await this._onSessionEnd?.(call, event);
+      if (this._onSessionEnd !== undefined) {
+        await this._invokeHandler(call, "onSessionEnd", false, () =>
+          this._onSessionEnd!(call, event),
+        );
+      }
     } else if (event.event_type === "dtmf") {
       if (this._onDtmf !== undefined) {
-        await this._onDtmf(call, event);
+        await this._invokeHandler(call, "onDtmf", false, () => this._onDtmf!(call, event));
       }
     } else if (event.event_type === "escalate") {
       if (this._onEscalate !== undefined) {
-        await this._onEscalate(call, event);
+        await this._invokeHandler(call, "onEscalate", true, () => 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.",
@@ -410,6 +493,13 @@ export class Agent {
           "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 === "outbound-call-failed") {
+      this._logger.error(`Outbound call failed: ${event.error_reason}`);
+      if (this._onOutboundFailed !== undefined) {
+        await this._invokeHandler(call, "onOutboundFailed", false, () =>
+          this._onOutboundFailed!(event),
+        );
+      }
     } else if (event.event_type === "error") {
       this._logger.error(`The Guava agent reported an error: ${event.content}`);
     } else if (event.event_type === "warning") {
@@ -796,6 +886,7 @@ Choose "speak" and provide your next utterance, or choose "hangup" if the conver
     cloned._onSessionEnd = this._onSessionEnd;
     cloned._onEscalate = this._onEscalate;
     cloned._onDtmf = this._onDtmf;
+    cloned._onOutboundFailed = this._onOutboundFailed;
     return cloned;
   }
 

package/src/call.ts

@@ -10,7 +10,9 @@ import {
   ReadScriptCommand,
   RetryTaskCommand,
   SetAgentDTMFCommand,
+  SendAgentDTMFCommand,
 } from "./commands.ts";
+import { DTMF_DIGITS, type DTMFDigit } from "./events.ts";
 import type * as z from "zod";
 import type {
   ActionItem,
@@ -133,12 +135,35 @@ export class Call {
   }
 
   async setAgentDtmf(enabled: boolean) {
+    if (this._callInfo.call_type === "webrtc") {
+      throw new Error("WebRTC calls do not support sending DTMF.");
+    }
     await this.sendCommand(SetAgentDTMFCommand, {
       command_type: "set-agent-dtmf",
       enabled,
     });
   }
 
+  async sendDtmf(digits: DTMFDigit[] | string) {
+    if (this._callInfo.call_type === "webrtc") {
+      throw new Error("WebRTC calls do not support sending DTMF.");
+    }
+
+    const digitsList = (typeof digits === "string" ? [...digits] : digits) as DTMFDigit[];
+
+    const validSet = new Set<string>(DTMF_DIGITS);
+    if (!digitsList.every((d) => validSet.has(d))) {
+      throw new Error(
+        `Please input a valid set of DTMF digits. The valid DTMF digits are: ${JSON.stringify(DTMF_DIGITS)}.`,
+      );
+    }
+
+    await this.sendCommand(SendAgentDTMFCommand, {
+      command_type: "send-agent-dtmf",
+      digits: digitsList,
+    });
+  }
+
   async setLanguageMode(args: { primary?: Language; secondary?: Language[] }) {
     await this.sendCommand(SetLanguageModeCommand, {
       command_type: "set-language-mode",

package/src/client.ts

@@ -1,19 +1,10 @@
-import WebSocket from "ws";
 import { type Logger, getDefaultLogger } from "./logging.ts";
-import {
-  StartOutboundCallCommand,
-  ListenInboundCommand,
-  InboundTunnelCommand,
-} from "./commands.ts";
-import * as z from "zod";
-import { ErrorEvent, SessionStartedEvent, decodeEvent, InboundTunnelEvent } from "./events.ts";
 import { SDK_VERSION } from "./version.ts";
 import os from "node:os";
 import * as fs from "node:fs";
 import { getBaseUrl, fetchOrThrow, sleep } from "./utils.ts";
 import { SmsMessage } from "./sms.ts";
 import { telemetryClient } from "./telemetry.ts";
-import type { CallController } from "./call-controller.ts";
 import {
   type AuthStrategy,
   APIKeyAuth,
@@ -35,10 +26,6 @@ export interface ClientOptions {
 
 let firstClient = false;
 
-function stringifyZod<Schema extends z.ZodType>(schema: Schema, data: z.input<Schema>): string {
-  return JSON.stringify(schema.parse(data));
-}
-
 export type InboundConnection = { agent_number: string } | { webrtc_code: string };
 
 const http_start = /^http:\/\//;
@@ -49,9 +36,6 @@ export class Client {
   private _auth: AuthStrategy;
   private _baseUrl: string;
   private _logger: Logger;
-  private _ws?: WebSocket;
-  private _controller?: CallController;
-  private messageHandler?: (_: WebSocket.MessageEvent) => void;
 
   constructor({
     apiKey,
@@ -245,185 +229,4 @@ export class Client {
       await sleep(Math.min(pollIntervalMs, remaining));
     }
   }
-
-  /**
-   * @description use the Guava API to call out to a number
-   */
-  async createOutbound(
-    fromNumber: string | undefined,
-    toNumber: string,
-    callController: CallController,
-  ) {
-    const url = new URL("v1/create-outbound", this.getWebsocketBase());
-    const ws = new WebSocket(url, {
-      headers: await 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));
-  }
-
-  private replaceHandler(newHandler?: (_: WebSocket.MessageEvent) => void) {
-    if (this.messageHandler) {
-      this._ws?.removeEventListener("message", this.messageHandler);
-    }
-    if (newHandler) {
-      this._ws?.addEventListener("message", newHandler);
-    }
-    this.messageHandler = newHandler;
-  }
-
-  // eventlistener handlers for server events
-  // (a state machine in functions)
-  private uninitializedOutbound(ev: WebSocket.MessageEvent) {
-    // 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));
-    }
-  }
-
-  private async initializedOutbound(ev: WebSocket.MessageEvent) {
-    // for correctness (and type correctness)
-    if (!this._ws) {
-      throw new Error("[internal] Uninitialized WebSocket");
-    }
-
-    // handle the received event
-    const event = decodeEvent(ev.data);
-    if (event) {
-      if (this._controller) {
-        await this._controller.onEvent(event);
-      }
-      if (event.event_type === "outbound-call-failed" || event.event_type === "bot-session-ended") {
-        // shutdown the websocket
-        this._ws.close();
-      }
-    }
-  }
-
-  /**
-   * @description use the Guava API to receive calls at a given number
-   */
-  async listenInbound<U extends CallController>(
-    conn: InboundConnection,
-    controllerClassFactory: (logger: Logger) => U,
-  ): Promise<InboundListener> {
-    const callControllers: Record<string, U> = {};
-
-    // return a way to *stop* listening
-    const url = new URL("v1/listen-inbound", this.getWebsocketBase());
-    const ws = new WebSocket(url, {
-      headers: await this.headers(),
-    });
-    let agent_number: string | undefined;
-    let webrtc_code: string | undefined;
-    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 ?? 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);
-  }
-}
-
-class InboundListener {
-  private ws: WebSocket;
-  constructor(ws: WebSocket) {
-    this.ws = ws;
-  }
-
-  close() {
-    this.ws.close();
-  }
 }

package/src/commands.ts

@@ -1,5 +1,6 @@
 import * as z from "zod";
 import { ActionItem } from "./action-item.ts";
+import { DTMF_DIGITS } from "./events.ts";
 
 export const StartOutboundCallCommand = z.strictObject({
   command_type: z.literal("start-outbound"),
@@ -133,6 +134,18 @@ export const SetAgentDTMFCommand = z.strictObject({
 });
 export type SetAgentDTMFCommand = z.input<typeof SetAgentDTMFCommand>;
 
+export const SendAgentDTMFCommand = z.strictObject({
+  command_type: z.literal("send-agent-dtmf"),
+  digits: z.array(z.enum(DTMF_DIGITS)),
+});
+export type SendAgentDTMFCommand = z.input<typeof SendAgentDTMFCommand>;
+
+export const ExpertErrorCommand = z.strictObject({
+  command_type: z.literal("expert-error"),
+  message: z.string(),
+});
+export type ExpertErrorCommand = z.input<typeof ExpertErrorCommand>;
+
 export const AnyCommand = z.union([
   StartOutboundCallCommand,
   ListenInboundCommand,
@@ -150,6 +163,8 @@ export const AnyCommand = z.union([
   ActionSuggestionCommand,
   RetryTaskCommand,
   SetAgentDTMFCommand,
+  SendAgentDTMFCommand,
+  ExpertErrorCommand,
 ]);
 export type Command = z.input<typeof AnyCommand>;
 

package/src/events.ts

@@ -126,27 +126,29 @@ export const ExecuteActionEvent = z.object({
 });
 export type ExecuteActionEvent = z.infer<typeof ExecuteActionEvent>;
 
-export type DTMFDigit =
-  | "0"
-  | "1"
-  | "2"
-  | "3"
-  | "4"
-  | "5"
-  | "6"
-  | "7"
-  | "8"
-  | "9"
-  | "*"
-  | "#"
-  | "A"
-  | "B"
-  | "C"
-  | "D";
+export const DTMF_DIGITS = [
+  "0",
+  "1",
+  "2",
+  "3",
+  "4",
+  "5",
+  "6",
+  "7",
+  "8",
+  "9",
+  "*",
+  "#",
+  "A",
+  "B",
+  "C",
+  "D",
+] as const;
+export type DTMFDigit = (typeof DTMF_DIGITS)[number];
 
 export const DTMFPressedEvent = z.object({
   event_type: z.literal("dtmf"),
-  digit: z.enum(["0", "1", "2", "3", "4", "5", "6", "7", "8", "9", "*", "#", "A", "B", "C", "D"]),
+  digit: z.enum(DTMF_DIGITS),
   recent_digits: z.string().default(""),
 });
 export type DTMFPressedEvent = z.infer<typeof DTMFPressedEvent>;

package/src/index.ts

@@ -1,7 +1,6 @@
 export { Client, type InboundConnection } from "./client.ts";
 export { Runner } from "./runner.ts";
 export type { SmsMessage } from "./sms.ts";
-export { CallController, type TaskObjective } from "./call-controller.ts";
 export { Say, Field } from "./action-item.ts";
 export { Logger, getConsoleLogger, getDefaultLogger } from "./logging.ts";
 export { Agent, CallInfo } from "./agent.ts";

package/src/socket/client.ts

@@ -1,4 +1,5 @@
 import WebSocket from "ws";
+import type { IncomingMessage } from "node:http";
 import { randomBytes } from "node:crypto";
 import * as z from "zod";
 import type { Client } from "../client.ts";
@@ -134,6 +135,12 @@ export class GuavaSocket<SendT, RecvT> {
       const headers = await this._client.headers();
 
       try {
+        this._logger.debug(
+          "Connecting to %s (attempt %d/%d)...",
+          this._connectionUrl,
+          attempt,
+          MAX_RECONNECT_ATTEMPTS,
+        );
         const ws = await new Promise<WebSocket>((resolve, reject) => {
           const socket = new WebSocket(this._connectionUrl, { headers });
           let settled = false;
@@ -147,6 +154,21 @@ export class GuavaSocket<SendT, RecvT> {
           };
 
           socket.once("error", (err) => settle(() => reject(err)));
+          socket.once("unexpected-response", (_req, res: IncomingMessage) => {
+            let body = "";
+            res.on("data", (chunk: Buffer) => {
+              body += chunk.toString();
+            });
+            res.on("end", () => {
+              settle(() =>
+                reject(
+                  new Error(
+                    `Unexpected server response: ${res.statusCode}. Body: ${body || "<empty>"}`,
+                  ),
+                ),
+              );
+            });
+          });
           socket.once("close", () =>
             settle(() => reject(new Error("Connection closed before open-ack"))),
           );