@guava-ai/guava-sdk 0.43.0 → 0.44.0

package/src/commands.ts

@@ -111,6 +111,12 @@ export const TransferCommand = z.strictObject({
 });
 export type TransferCommand = z.input<typeof TransferCommand>;
 
+export const HangupCommand = z.strictObject({
+  command_type: z.literal("hangup-call"),
+  final_script: z.string().nullish().default(null),
+});
+export type HangupCommand = z.input<typeof HangupCommand>;
+
 export const RegisteredHooksCommand = z.strictObject({
   command_type: z.literal("registered-hooks"),
   has_on_question: z.boolean(),
@@ -150,6 +156,13 @@ export const RetryTaskCommand = z.strictObject({
 });
 export type RetryTaskCommand = z.input<typeof RetryTaskCommand>;
 
+export const SetVariableCommand = z.strictObject({
+  command_type: z.literal("set-variable"),
+  key: z.string(),
+  value: z.json(),
+});
+export type SetVariableCommand = z.input<typeof SetVariableCommand>;
+
 export const SetAgentDTMFCommand = z.strictObject({
   command_type: z.literal("set-agent-dtmf"),
   enabled: z.boolean(),
@@ -162,6 +175,12 @@ export const SendAgentDTMFCommand = z.strictObject({
 });
 export type SendAgentDTMFCommand = z.input<typeof SendAgentDTMFCommand>;
 
+export const SendWebRTCMessageCommand = z.strictObject({
+  command_type: z.literal("send-webrtc-message"),
+  payload: z.record(z.string(), z.json()).default({}),
+});
+export type SendWebRTCMessageCommand = z.input<typeof SendWebRTCMessageCommand>;
+
 export const ExpertErrorCommand = z.strictObject({
   command_type: z.literal("expert-error"),
   message: z.string(),
@@ -180,12 +199,15 @@ export const AnyCommand = z.union([
   SetLanguageModeCommand,
   SendInstructionCommand,
   TransferCommand,
+  HangupCommand,
   RegisteredHooksCommand,
   ChoiceResultCommand,
   ActionSuggestionCommand,
   RetryTaskCommand,
+  SetVariableCommand,
   SetAgentDTMFCommand,
   SendAgentDTMFCommand,
+  SendWebRTCMessageCommand,
   ExpertErrorCommand,
 ]);
 export type Command = z.input<typeof AnyCommand>;

package/src/events.ts

@@ -165,6 +165,13 @@ export const AgentDTMFSentEvent = z.object({
 });
 export type AgentDTMFSentEvent = z.infer<typeof AgentDTMFSentEvent>;
 
+/** A message sent by a connected WebRTC client. */
+export const WebRTCMessageEvent = z.object({
+  event_type: z.literal("webrtc-message"),
+  payload: z.record(z.string(), z.json()).default({}),
+});
+export type WebRTCMessageEvent = z.infer<typeof WebRTCMessageEvent>;
+
 export const EscalateEvent = z.object({
   event_type: z.literal("escalate"),
   requested_by: z.enum(["human", "agent"]).default("human"),
@@ -191,6 +198,7 @@ export const GuavaEvent = z.discriminatedUnion("event_type", [
   EscalateEvent,
   DTMFPressedEvent,
   AgentDTMFSentEvent,
+  WebRTCMessageEvent,
 ]);
 export type GuavaEvent = z.infer<typeof GuavaEvent>;
 

package/src/index.ts

@@ -14,7 +14,7 @@ export { Logger, getConsoleLogger, getDefaultLogger } from "./logging.ts";
 export { Agent, CallInfo } from "./agent.ts";
 export { SIPCallInfo } from "./socket/call-info.ts";
 export { SipUri } from "./sip.ts";
-export { Call, DEFAULT_REACH_PERSON_OUTCOMES } from "./call.ts";
+export { BaseCall, Call, RemoteCall, DEFAULT_REACH_PERSON_OUTCOMES } from "./call.ts";
 export type { ReachPersonOutcome } from "./call.ts";
 export type { SpeedPreset, Language } from "./commands.ts";
 export type {
@@ -24,6 +24,7 @@ export type {
   AgentDTMFSentEvent,
   DTMFDigit,
   OutboundCallFailed,
+  WebRTCMessageEvent,
 } from "./events.ts";
 export { TestSession } from "./testing/session.ts";
 export { MockCall } from "./testing/mocks.ts";

package/src/runner.ts

@@ -28,7 +28,9 @@ export class Runner {
   listenWebrtc(agent: Agent, webrtcCode?: string): this {
     const ctx = this._healthCtx.createCtx();
     this._tasks.push(async () => {
-      const code = webrtcCode ?? (await agent._client.createWebrtcAgent(3600));
+      // Unlike the Python SDK, code creation happens here to prevent Runner.listen_webrtc from becoming async.
+      if (!webrtcCode) this._logger.info("No WebRTC code provided. Creating a temporary one.");
+      const code = webrtcCode || (await agent._client.createWebrtcAgent(3600));
       return agent._listenInbound(ctx, { webrtc_code: code }, {}, this._drainController.signal);
     });
     return this;
@@ -56,7 +58,14 @@ export class Runner {
           this._drainController.abort();
         })
       : nullDisposable;
-    await Promise.all(this._tasks.map((task) => task()));
+    // Wait for every task, so one failing doesn't tear down signal handling and
+    // the health server while others are still draining.
+    const results = await Promise.allSettled(this._tasks.map((task) => task()));
     this._logger.info("All tasks done.");
+
+    const errors = results.flatMap((r) => (r.status === "rejected" ? [r.reason] : []));
+    if (errors.length === 1) throw errors[0];
+    if (errors.length > 1)
+      throw new AggregateError(errors, `${errors.length} runner tasks failed.`);
   }
 }

package/src/utils.ts

@@ -64,11 +64,58 @@ export async function fetchOrThrow(
   return res;
 }
 
+/**
+ * Whether `e` is a fetch network failure. Bad input (e.g. an invalid URL) is
+ * also a TypeError, but with a different message. Avoids `instanceof`, since
+ * fetch errors can come from another realm (e.g. under Jest).
+ */
+function isNetworkError(e: unknown): boolean {
+  const { name, message } = (e ?? {}) as { name?: unknown; message?: unknown };
+  return name === "TypeError" && message === "fetch failed";
+}
+
+const RETRYABLE_STATUS_CODES = new Set([408, 409, 429, 500, 502, 503, 504]);
+const RETRY_DELAYS_MS = [0, 500, 1000, 2000, 5000];
+
+/**
+ * POST that retries network errors and retryable statuses, throwing on a final
+ * error status. A single Idempotency-Key is sent with every attempt so the
+ * server can drop duplicates.
+ *
+ * @param retries - Number of retries after the first attempt.
+ */
+export async function idempotentPost(
+  input: string | URL,
+  init: Omit<RequestInit, "method"> = {},
+  retries = 3,
+): Promise<Response> {
+  const headers = new Headers(init.headers);
+  if (!headers.has("Idempotency-Key")) headers.set("Idempotency-Key", crypto.randomUUID());
+
+  for (let attempt = 0; ; attempt++) {
+    try {
+      return await fetchOrThrow(input, { ...init, method: "POST", headers });
+    } catch (e) {
+      const retryable =
+        isNetworkError(e) || (e instanceof HttpStatusError && RETRYABLE_STATUS_CODES.has(e.status));
+      if (attempt === retries || !retryable) throw e;
+    }
+    await sleep(RETRY_DELAYS_MS[Math.min(attempt, RETRY_DELAYS_MS.length - 1)]!);
+  }
+}
+
 /** A Disposable whose disposal does nothing. Useful as a conditional no-op. */
 export const nullDisposable: Disposable = { [Symbol.dispose]() {} };
 
+/**
+ * Run `listener` when `signal` aborts, or immediately if it already has.
+ * Dispose to unregister.
+ */
 export function onAbort(signal: AbortSignal, listener: () => void): Disposable {
-  signal.throwIfAborted();
+  if (signal.aborted) {
+    listener();
+    return nullDisposable;
+  }
   signal.addEventListener("abort", listener, { once: true });
 
   return {

package/src/version.ts

@@ -1 +1 @@
-export const SDK_VERSION = "0.43.0";
+export const SDK_VERSION = "0.44.0";