@sayna-ai/node-sdk 0.0.5 → 0.0.7

package/README.md

@@ -52,6 +52,7 @@ Performs a health check on the Sayna server.
 **Returns**: `Promise<{ status: string }>` - Status object with "OK" when healthy.
 
 **Example**:
+
 ```typescript
 const health = await client.health();
 console.log(health.status); // "OK"
@@ -64,10 +65,14 @@ Retrieves the catalogue of text-to-speech voices grouped by provider.
 **Returns**: `Promise<Record<string, Voice[]>>` - Object where keys are provider names and values are arrays of voice descriptors.
 
 **Example**:
+
 ```typescript
 const voices = await client.getVoices();
 for (const [provider, voiceList] of Object.entries(voices)) {
-  console.log(`${provider}:`, voiceList.map(v => v.name));
+  console.log(
+    `${provider}:`,
+    voiceList.map((v) => v.name)
+  );
 }
 ```
 
@@ -75,14 +80,15 @@ for (const [provider, voiceList] of Object.entries(voices)) {
 
 Synthesizes text into audio using the REST API. This is a standalone method that doesn't require an active WebSocket connection.
 
-| parameter | type | purpose |
-| --- | --- | --- |
-| `text` | `string` | Text to synthesize (must be non-empty). |
-| `ttsConfig` | `TTSConfig` | Text-to-speech provider configuration. |
+| parameter   | type        | purpose                                 |
+| ----------- | ----------- | --------------------------------------- |
+| `text`      | `string`    | Text to synthesize (must be non-empty). |
+| `ttsConfig` | `TTSConfig` | Text-to-speech provider configuration.  |
 
 **Returns**: `Promise<ArrayBuffer>` - Raw audio data.
 
 **Example**:
+
 ```typescript
 const audioBuffer = await client.speakRest("Hello, world!", {
   provider: "elevenlabs",
@@ -93,7 +99,7 @@ const audioBuffer = await client.speakRest("Hello, world!", {
   sample_rate: 24000,
   connection_timeout: 30,
   request_timeout: 60,
-  pronunciations: []
+  pronunciations: [],
 });
 ```
 
@@ -101,15 +107,16 @@ const audioBuffer = await client.speakRest("Hello, world!", {
 
 Issues a LiveKit access token for a participant.
 
-| parameter | type | purpose |
-| --- | --- | --- |
-| `roomName` | `string` | LiveKit room to join or create. |
-| `participantName` | `string` | Display name for the participant. |
+| parameter             | type     | purpose                                |
+| --------------------- | -------- | -------------------------------------- |
+| `roomName`            | `string` | LiveKit room to join or create.        |
+| `participantName`     | `string` | Display name for the participant.      |
 | `participantIdentity` | `string` | Unique identifier for the participant. |
 
 **Returns**: `Promise<LiveKitTokenResponse>` - Object containing token, room name, participant identity, and LiveKit URL.
 
 **Example**:
+
 ```typescript
 const tokenInfo = await client.getLiveKitToken(
   "my-room",
@@ -120,6 +127,48 @@ console.log("Token:", tokenInfo.token);
 console.log("LiveKit URL:", tokenInfo.livekit_url);
 ```
 
+### `await client.getSipHooks()`
+
+Retrieves all configured SIP webhook hooks from the runtime cache.
+
+**Returns**: `Promise<SipHooksResponse>` - Object containing an array of configured hooks.
+
+**Example**:
+
+```typescript
+const response = await client.getSipHooks();
+for (const hook of response.hooks) {
+  console.log(`Host: ${hook.host}, URL: ${hook.url}`);
+}
+```
+
+### `await client.setSipHooks(hooks)`
+
+Sets or updates SIP webhook hooks in the runtime cache. Hooks with matching hosts will be replaced; new hosts will be added.
+
+| parameter | type        | purpose                                  |
+| --------- | ----------- | ---------------------------------------- |
+| `hooks`   | `SipHook[]` | Array of SIP hook configurations to set. |
+
+Each `SipHook` object contains:
+
+| field  | type     | description                              |
+| ------ | -------- | ---------------------------------------- |
+| `host` | `string` | SIP domain pattern (case-insensitive).   |
+| `url`  | `string` | HTTPS URL to forward webhook events to.  |
+
+**Returns**: `Promise<SipHooksResponse>` - Object containing the merged list of all configured hooks.
+
+**Example**:
+
+```typescript
+const response = await client.setSipHooks([
+  { host: "example.com", url: "https://webhook.example.com/events" },
+  { host: "another.com", url: "https://webhook.another.com/events" },
+]);
+console.log("Total hooks configured:", response.hooks.length);
+```
+
 ---
 
 ### WebSocket API Methods
@@ -128,13 +177,13 @@ These methods require an active WebSocket connection:
 
 ### `new SaynaClient(url, sttConfig, ttsConfig, livekitConfig?, withoutAudio?)`
 
-| parameter | type | purpose |
-| --- | --- | --- |
-| `url` | `string` | Sayna server URL (http://, https://, ws://, or wss://). |
-| `sttConfig` | `STTConfig` | Speech-to-text provider configuration. |
-| `ttsConfig` | `TTSConfig` | Text-to-speech provider configuration. |
-| `livekitConfig` | `LiveKitConfig` | Optional LiveKit room configuration. |
-| `withoutAudio` | `boolean` | Disable audio streaming (defaults to `false`). |
+| parameter       | type            | purpose                                                 |
+| --------------- | --------------- | ------------------------------------------------------- |
+| `url`           | `string`        | Sayna server URL (http://, https://, ws://, or wss://). |
+| `sttConfig`     | `STTConfig`     | Speech-to-text provider configuration.                  |
+| `ttsConfig`     | `TTSConfig`     | Text-to-speech provider configuration.                  |
+| `livekitConfig` | `LiveKitConfig` | Optional LiveKit room configuration.                    |
+| `withoutAudio`  | `boolean`       | Disable audio streaming (defaults to `false`).          |
 
 ### `await client.connect()`
 
@@ -168,11 +217,11 @@ Registers a callback for TTS playback completion events.
 
 Sends text to be synthesized as speech.
 
-| parameter | type | default | purpose |
-| --- | --- | --- | --- |
-| `text` | `string` | - | Text to synthesize. |
-| `flush` | `boolean` | `true` | Clear TTS queue before speaking. |
-| `allowInterruption` | `boolean` | `true` | Allow speech to be interrupted. |
+| parameter           | type      | default | purpose                          |
+| ------------------- | --------- | ------- | -------------------------------- |
+| `text`              | `string`  | -       | Text to synthesize.              |
+| `flush`             | `boolean` | `true`  | Clear TTS queue before speaking. |
+| `allowInterruption` | `boolean` | `true`  | Allow speech to be interrupted.  |
 
 ### `await client.onAudioInput(audioData)`
 
@@ -218,6 +267,133 @@ Identity assigned to the agent participant when LiveKit is enabled, if available
 
 Display name assigned to the agent participant when LiveKit is enabled, if available.
 
+---
+
+## Webhook Receiver
+
+The SDK includes a `WebhookReceiver` class for securely receiving and verifying cryptographically signed webhooks from Sayna's SIP service.
+
+### Security Features
+
+- **HMAC-SHA256 Signature Verification**: Ensures webhook authenticity
+- **Constant-Time Comparison**: Prevents timing attack vulnerabilities
+- **Replay Protection**: 5-minute timestamp window prevents replay attacks
+- **Strict Validation**: Comprehensive checks on all required fields
+
+### `new WebhookReceiver(secret?)`
+
+Creates a new webhook receiver instance.
+
+| parameter | type     | purpose                                                                      |
+| --------- | -------- | ---------------------------------------------------------------------------- |
+| `secret`  | `string` | HMAC signing secret (min 16 chars). Defaults to `SAYNA_WEBHOOK_SECRET` env. |
+
+**Example**:
+
+```typescript
+import { WebhookReceiver } from "@sayna/node-sdk";
+
+// Explicit secret
+const receiver = new WebhookReceiver("your-secret-key-min-16-chars");
+
+// Or use environment variable
+process.env.SAYNA_WEBHOOK_SECRET = "your-secret-key";
+const receiver = new WebhookReceiver();
+```
+
+### `receiver.receive(headers, body)`
+
+Verifies and parses an incoming SIP webhook.
+
+| parameter | type                                        | purpose                                      |
+| --------- | ------------------------------------------- | -------------------------------------------- |
+| `headers` | `Record<string, string \| string[] \| undefined>` | HTTP request headers (case-insensitive).     |
+| `body`    | `string`                                    | Raw request body as string (not parsed JSON). |
+
+**Returns**: `WebhookSIPOutput` - Parsed and validated webhook payload.
+
+**Throws**: `SaynaValidationError` if signature verification fails or payload is invalid.
+
+### Express Example
+
+```typescript
+import express from "express";
+import { WebhookReceiver } from "@sayna/node-sdk";
+
+const app = express();
+const receiver = new WebhookReceiver("your-secret-key-min-16-chars");
+
+app.post(
+  "/webhook",
+  express.json({
+    verify: (req, res, buf) => {
+      (req as any).rawBody = buf.toString("utf8");
+    },
+  }),
+  (req, res) => {
+    try {
+      const webhook = receiver.receive(req.headers, (req as any).rawBody);
+
+      console.log("Valid webhook received:");
+      console.log("  From:", webhook.from_phone_number);
+      console.log("  To:", webhook.to_phone_number);
+      console.log("  Room:", webhook.room.name);
+      console.log("  SIP Host:", webhook.sip_host);
+      console.log("  Participant:", webhook.participant.identity);
+
+      res.status(200).json({ received: true });
+    } catch (error) {
+      console.error("Webhook verification failed:", error.message);
+      res.status(401).json({ error: "Invalid signature" });
+    }
+  }
+);
+```
+
+### Fastify Example
+
+```typescript
+import Fastify from "fastify";
+import { WebhookReceiver } from "@sayna/node-sdk";
+
+const fastify = Fastify();
+const receiver = new WebhookReceiver();
+
+fastify.post(
+  "/webhook",
+  {
+    config: { rawBody: true },
+  },
+  async (request, reply) => {
+    try {
+      const webhook = receiver.receive(request.headers, request.rawBody);
+      return { received: true };
+    } catch (error) {
+      reply.code(401);
+      return { error: error.message };
+    }
+  }
+);
+```
+
+### WebhookSIPOutput Type
+
+The `receive` method returns a `WebhookSIPOutput` object with the following structure:
+
+| field               | type                    | description                                        |
+| ------------------- | ----------------------- | -------------------------------------------------- |
+| `participant`       | `WebhookSIPParticipant` | SIP participant information.                       |
+| `participant.identity` | `string`             | Unique identity assigned to the participant.       |
+| `participant.sid`   | `string`                | Participant session ID from LiveKit.               |
+| `participant.name`  | `string?`               | Display name (optional).                           |
+| `room`              | `WebhookSIPRoom`        | LiveKit room information.                          |
+| `room.name`         | `string`                | Name of the LiveKit room.                          |
+| `room.sid`          | `string`                | Room session ID from LiveKit.                      |
+| `from_phone_number` | `string`                | Caller's phone number (E.164 format).              |
+| `to_phone_number`   | `string`                | Called phone number (E.164 format).                |
+| `room_prefix`       | `string`                | Room name prefix configured in Sayna.              |
+| `sip_host`          | `string`                | SIP domain extracted from the To header.           |
+
 ## Development
 
 ```bash

package/dist/index.js

@@ -56,6 +56,7 @@ class SaynaClient {
   ttsConfig;
   livekitConfig;
   withoutAudio;
+  apiKey;
   websocket;
   isConnected = false;
   isReady = false;
@@ -71,7 +72,7 @@ class SaynaClient {
   ttsPlaybackCompleteCallback;
   readyPromiseResolve;
   readyPromiseReject;
-  constructor(url, sttConfig, ttsConfig, livekitConfig, withoutAudio = false) {
+  constructor(url, sttConfig, ttsConfig, livekitConfig, withoutAudio = false, apiKey) {
     if (!url || typeof url !== "string") {
       throw new SaynaValidationError("URL must be a non-empty string");
     }
@@ -88,6 +89,7 @@ class SaynaClient {
     this.ttsConfig = ttsConfig;
     this.livekitConfig = livekitConfig;
     this.withoutAudio = withoutAudio;
+    this.apiKey = apiKey ?? process.env.SAYNA_API_KEY;
   }
   async connect() {
     if (this.isConnected) {
@@ -98,7 +100,9 @@ class SaynaClient {
       this.readyPromiseResolve = resolve;
       this.readyPromiseReject = reject;
       try {
-        this.websocket = new WebSocket(wsUrl);
+        const headers = this.apiKey ? { Authorization: `Bearer ${this.apiKey}` } : undefined;
+        const WebSocketConstructor = WebSocket;
+        this.websocket = headers ? new WebSocketConstructor(wsUrl, undefined, { headers }) : new WebSocket(wsUrl);
         this.websocket.onopen = () => {
           this.isConnected = true;
           const configMessage = {
@@ -128,14 +132,18 @@ class SaynaClient {
                 await this.ttsCallback(buffer);
               }
             } else {
+              if (typeof event.data !== "string") {
+                throw new Error("Expected string data for JSON messages");
+              }
               const data = JSON.parse(event.data);
               await this.handleJsonMessage(data);
             }
           } catch (error) {
             if (this.errorCallback) {
+              const errorMessage = error instanceof Error ? error.message : String(error);
               await this.errorCallback({
                 type: "error",
-                message: `Failed to process message: ${error instanceof Error ? error.message : String(error)}`
+                message: `Failed to process message: ${errorMessage}`
               });
             }
           }
@@ -239,6 +247,10 @@ class SaynaClient {
     const headers = {
       ...options.headers
     };
+    const hasAuthHeader = Object.keys(headers).some((key) => key.toLowerCase() === "authorization");
+    if (this.apiKey && !hasAuthHeader) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
     if (options.method === "POST" && options.body && !headers["Content-Type"]) {
       headers["Content-Type"] = "application/json";
     }
@@ -248,10 +260,14 @@ class SaynaClient {
         headers
       });
       if (!response.ok) {
-        const errorData = await response.json().catch(() => ({
-          error: response.statusText
-        }));
-        throw new SaynaServerError(errorData?.error ?? `Request failed: ${response.status} ${response.statusText}`);
+        let errorMessage;
+        try {
+          const errorData = await response.json();
+          errorMessage = errorData && typeof errorData === "object" && "error" in errorData && typeof errorData.error === "string" ? errorData.error : `Request failed: ${response.status} ${response.statusText}`;
+        } catch {
+          errorMessage = `Request failed: ${response.status} ${response.statusText}`;
+        }
+        throw new SaynaServerError(errorMessage);
       }
       if (responseType === "arrayBuffer") {
         return await response.arrayBuffer();
@@ -265,7 +281,7 @@ class SaynaClient {
       throw new SaynaConnectionError(`Failed to fetch from ${endpoint}`, error);
     }
   }
-  async disconnect() {
+  disconnect() {
     if (this.websocket) {
       this.websocket.onopen = null;
       this.websocket.onmessage = null;
@@ -278,7 +294,7 @@ class SaynaClient {
     }
     this.cleanup();
   }
-  async onAudioInput(audioData) {
+  onAudioInput(audioData) {
     if (!this.isConnected || !this.websocket) {
       throw new SaynaNotConnectedError;
     }
@@ -315,7 +331,7 @@ class SaynaClient {
   registerOnTtsPlaybackComplete(callback) {
     this.ttsPlaybackCompleteCallback = callback;
   }
-  async speak(text, flush = true, allowInterruption = true) {
+  speak(text, flush = true, allowInterruption = true) {
     if (!this.isConnected || !this.websocket) {
       throw new SaynaNotConnectedError;
     }
@@ -337,7 +353,7 @@ class SaynaClient {
       throw new SaynaConnectionError("Failed to send speak command", error);
     }
   }
-  async clear() {
+  clear() {
     if (!this.isConnected || !this.websocket) {
       throw new SaynaNotConnectedError;
     }
@@ -353,10 +369,10 @@ class SaynaClient {
       throw new SaynaConnectionError("Failed to send clear command", error);
     }
   }
-  async ttsFlush(allowInterruption = true) {
-    await this.speak("", true, allowInterruption);
+  ttsFlush(allowInterruption = true) {
+    this.speak("", true, allowInterruption);
   }
-  async sendMessage(message, role, topic, debug) {
+  sendMessage(message, role, topic, debug) {
     if (!this.isConnected || !this.websocket) {
       throw new SaynaNotConnectedError;
     }
@@ -383,16 +399,16 @@ class SaynaClient {
     }
   }
   async health() {
-    return await this.fetchFromSayna("");
+    return this.fetchFromSayna("");
   }
   async getVoices() {
-    return await this.fetchFromSayna("voices");
+    return this.fetchFromSayna("voices");
   }
   async speakRest(text, ttsConfig) {
     if (!text || text.trim().length === 0) {
       throw new SaynaValidationError("Text cannot be empty");
     }
-    return await this.fetchFromSayna("speak", {
+    return this.fetchFromSayna("speak", {
       method: "POST",
       body: JSON.stringify({
         text,
@@ -410,7 +426,7 @@ class SaynaClient {
     if (!participantIdentity || participantIdentity.trim().length === 0) {
       throw new SaynaValidationError("participant_identity cannot be empty");
     }
-    return await this.fetchFromSayna("livekit/token", {
+    return this.fetchFromSayna("livekit/token", {
       method: "POST",
       body: JSON.stringify({
         room_name: roomName,
@@ -419,6 +435,29 @@ class SaynaClient {
       })
     });
   }
+  async getSipHooks() {
+    return this.fetchFromSayna("sip/hooks");
+  }
+  async setSipHooks(hooks) {
+    if (!Array.isArray(hooks)) {
+      throw new SaynaValidationError("hooks must be an array");
+    }
+    if (hooks.length === 0) {
+      throw new SaynaValidationError("hooks array cannot be empty");
+    }
+    for (const [i, hook] of hooks.entries()) {
+      if (!hook.host || typeof hook.host !== "string" || hook.host.trim().length === 0) {
+        throw new SaynaValidationError(`hooks[${i}].host must be a non-empty string`);
+      }
+      if (!hook.url || typeof hook.url !== "string" || hook.url.trim().length === 0) {
+        throw new SaynaValidationError(`hooks[${i}].url must be a non-empty string`);
+      }
+    }
+    return this.fetchFromSayna("sip/hooks", {
+      method: "POST",
+      body: JSON.stringify({ hooks })
+    });
+  }
   get ready() {
     return this.isReady;
   }
@@ -438,15 +477,139 @@ class SaynaClient {
     return this._saynaParticipantName;
   }
 }
+// src/webhook-receiver.ts
+import { createHmac, timingSafeEqual } from "crypto";
+var MIN_SECRET_LENGTH = 16;
+var TIMESTAMP_TOLERANCE_SECONDS = 300;
+
+class WebhookReceiver {
+  secret;
+  constructor(secret) {
+    const effectiveSecret = secret ?? process.env.SAYNA_WEBHOOK_SECRET;
+    if (!effectiveSecret) {
+      throw new SaynaValidationError("Webhook secret is required. Provide it as a constructor parameter or set SAYNA_WEBHOOK_SECRET environment variable.");
+    }
+    const trimmedSecret = effectiveSecret.trim();
+    if (trimmedSecret.length < MIN_SECRET_LENGTH) {
+      throw new SaynaValidationError(`Webhook secret must be at least ${MIN_SECRET_LENGTH} characters long. ` + `Received ${trimmedSecret.length} characters. ` + `Generate a secure secret with: openssl rand -hex 32`);
+    }
+    this.secret = trimmedSecret;
+  }
+  receive(headers, body) {
+    const normalizedHeaders = this.normalizeHeaders(headers);
+    const signature = this.getRequiredHeader(normalizedHeaders, "x-sayna-signature");
+    const timestamp = this.getRequiredHeader(normalizedHeaders, "x-sayna-timestamp");
+    const eventId = this.getRequiredHeader(normalizedHeaders, "x-sayna-event-id");
+    if (!signature.startsWith("v1=")) {
+      throw new SaynaValidationError("Invalid signature format. Expected 'v1=<hex>' but got: " + signature.substring(0, 10) + "...");
+    }
+    const signatureHex = signature.substring(3);
+    if (!/^[0-9a-f]{64}$/i.test(signatureHex)) {
+      throw new SaynaValidationError("Invalid signature: must be 64 hex characters (HMAC-SHA256)");
+    }
+    this.validateTimestamp(timestamp);
+    const canonical = `v1:${timestamp}:${eventId}:${body}`;
+    const hmac = createHmac("sha256", this.secret);
+    hmac.update(canonical, "utf8");
+    const expectedSignature = hmac.digest("hex");
+    if (!this.constantTimeEqual(signatureHex, expectedSignature)) {
+      throw new SaynaValidationError("Signature verification failed. The webhook may have been tampered with or the secret is incorrect.");
+    }
+    return this.parseAndValidatePayload(body);
+  }
+  normalizeHeaders(headers) {
+    const normalized = {};
+    for (const [key, value] of Object.entries(headers)) {
+      if (value !== undefined) {
+        const stringValue = Array.isArray(value) ? value[0] : value;
+        if (stringValue) {
+          normalized[key.toLowerCase()] = stringValue;
+        }
+      }
+    }
+    return normalized;
+  }
+  getRequiredHeader(headers, name) {
+    const value = headers[name.toLowerCase()];
+    if (!value) {
+      throw new SaynaValidationError(`Missing required header: ${name}`);
+    }
+    return value;
+  }
+  validateTimestamp(timestampStr) {
+    const timestamp = Number(timestampStr);
+    if (isNaN(timestamp)) {
+      throw new SaynaValidationError(`Invalid timestamp format: expected Unix seconds but got '${timestampStr}'`);
+    }
+    const now = Math.floor(Date.now() / 1000);
+    const diff = Math.abs(now - timestamp);
+    if (diff > TIMESTAMP_TOLERANCE_SECONDS) {
+      throw new SaynaValidationError(`Timestamp outside replay protection window. ` + `Difference: ${diff} seconds (max allowed: ${TIMESTAMP_TOLERANCE_SECONDS}). ` + `This webhook may be a replay attack or there may be significant clock skew.`);
+    }
+  }
+  constantTimeEqual(a, b) {
+    if (a.length !== b.length) {
+      return false;
+    }
+    const bufA = Buffer.from(a, "utf8");
+    const bufB = Buffer.from(b, "utf8");
+    return timingSafeEqual(bufA, bufB);
+  }
+  parseAndValidatePayload(body) {
+    let payload;
+    try {
+      payload = JSON.parse(body);
+    } catch (error) {
+      throw new SaynaValidationError(`Invalid JSON payload: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+      throw new SaynaValidationError("Webhook payload must be a JSON object");
+    }
+    const data = payload;
+    this.validateParticipant(data.participant);
+    this.validateRoom(data.room);
+    this.validateStringField(data, "from_phone_number", "from_phone_number");
+    this.validateStringField(data, "to_phone_number", "to_phone_number");
+    this.validateStringField(data, "room_prefix", "room_prefix");
+    this.validateStringField(data, "sip_host", "sip_host");
+    return data;
+  }
+  validateParticipant(participant) {
+    if (!participant || typeof participant !== "object" || Array.isArray(participant)) {
+      throw new SaynaValidationError("Webhook payload missing required field 'participant' (must be an object)");
+    }
+    const p = participant;
+    this.validateStringField(p, "identity", "participant.identity");
+    this.validateStringField(p, "sid", "participant.sid");
+    if (p.name !== undefined && typeof p.name !== "string") {
+      throw new SaynaValidationError("Field 'participant.name' must be a string if present");
+    }
+  }
+  validateRoom(room) {
+    if (!room || typeof room !== "object" || Array.isArray(room)) {
+      throw new SaynaValidationError("Webhook payload missing required field 'room' (must be an object)");
+    }
+    const r = room;
+    this.validateStringField(r, "name", "room.name");
+    this.validateStringField(r, "sid", "room.sid");
+  }
+  validateStringField(obj, field, displayName) {
+    const value = obj[field];
+    if (typeof value !== "string" || value.length === 0) {
+      throw new SaynaValidationError(`Webhook payload missing required field '${displayName}' (must be a non-empty string)`);
+    }
+  }
+}
 
 // src/index.ts
-async function saynaConnect(url, sttConfig, ttsConfig, livekitConfig, withoutAudio = false) {
-  const client = new SaynaClient(url, sttConfig, ttsConfig, livekitConfig, withoutAudio);
+async function saynaConnect(url, sttConfig, ttsConfig, livekitConfig, withoutAudio = false, apiKey) {
+  const client = new SaynaClient(url, sttConfig, ttsConfig, livekitConfig, withoutAudio, apiKey);
   await client.connect();
   return client;
 }
 export {
   saynaConnect,
+  WebhookReceiver,
   SaynaValidationError,
   SaynaServerError,
   SaynaNotReadyError,
@@ -456,4 +619,4 @@ export {
   SaynaClient
 };
 
-//# debugId=8028B4D3DBBE95F564756E2164756E21
+//# debugId=DBDEB289893BB9C064756E2164756E21