@loop-voice-agent/web 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Loop Methods
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,143 @@
+# @loop-voice-agent/web
+
+Browser SDK for the Loop Voice Agent platform. Start a voice call from a
+**publishable key** and an **agent id** — the prompt, model and voice never
+reach the browser.
+
+> **Temporary package name.** This is published under `@loop-voice-agent/web`
+> while the product name is being decided. When it changes, a new package will
+> be published and consumers update their import line; the API will not change
+> as part of that rename.
+
+## Install
+
+```bash
+npm install @loop-voice-agent/web
+```
+
+ESM only. Modern bundlers (Vite, Next, Rollup, webpack 5) consume it directly.
+
+## Use
+
+```ts
+import { VoiceAgent } from "@loop-voice-agent/web";
+
+const client = new VoiceAgent(import.meta.env.VITE_VOICE_PUBLIC_KEY, {
+  baseUrl: "https://api.example.com",
+});
+
+client.on("call-start", () => setStatus("live"));
+client.on("call-end", ({ endedReason }) => setStatus(`ended: ${endedReason}`));
+client.on("message", (m) => {
+  if (m.type === "transcript" && m.transcriptType === "final") append(m.role, m.transcript);
+});
+client.on("error", ({ code, message }) => showError(code, message));
+
+await client.start(agentId, {
+  variables: { candidate_name: "Asha", role: "SDE" },
+  language: "hi",
+  channel: "audio",
+  metadata: { applicant_id: "A-123" },
+});
+
+// …later
+client.setMuted(true);
+client.stop();
+```
+
+Attach the agent's audio to play it:
+
+```ts
+audioEl.srcObject = client.getRemoteStream();
+```
+
+## Credentials
+
+Two key classes exist, and only one belongs in a browser:
+
+| Key     | Where it belongs | Authority                                       |
+| ------- | ---------------- | ----------------------------------------------- |
+| `vpk_…` | Browser bundle   | Start a call — and only from registered origins |
+| `vak_…` | Your server only | Create agents, place PSTN calls, read history   |
+
+A publishable key is safe to ship because its authority is capped and it only
+works from origins registered against it. **Register your app's origin** on the
+key, or every call fails with a 403 — that specific failure means the origin is
+missing, not that the key is wrong.
+
+## Events
+
+| Event          | Payload                     | When                                      |
+| -------------- | --------------------------- | ----------------------------------------- |
+| `call-start`   | —                           | Media is flowing                          |
+| `call-end`     | `{ endedReason, callId? }`  | The call ended, cleanly or otherwise      |
+| `speech-start` | —                           | The agent started speaking                |
+| `speech-end`   | —                           | The agent stopped speaking                |
+| `message`      | `TranscriptMessage \| …`    | A message from the server, usually a turn |
+| `error`        | `{ code, message, cause? }` | The call could not start                  |
+
+`error` and `call-end` are mutually exclusive for a single failure: a call that
+never started emits `error`, and one that started and then ended emits
+`call-end`. You never have to de-duplicate the two.
+
+Classify an ending with the exported helper rather than by matching strings
+yourself:
+
+```ts
+import { isAbnormalEndedReason } from "@loop-voice-agent/web";
+
+client.on("call-end", ({ endedReason }) => {
+  if (isAbnormalEndedReason(endedReason)) showRetry();
+  else showComplete();
+});
+```
+
+## Screen sharing
+
+Pass an **already-captured** stream — the SDK never calls `getDisplayMedia`
+itself, because browsers only grant it from a user gesture and capturing inside
+the SDK would raise a second picker mid-call:
+
+```ts
+const screenStream = await navigator.mediaDevices.getDisplayMedia({ video: true });
+await client.start(agentId, { screenStream });
+```
+
+Prefer passing it to `start()` when you have it up front: the track goes into the
+initial offer and skips a renegotiation round trip while the user waits. When the
+stream only arrives mid-call:
+
+```ts
+await client.startScreenShare(screenStream);
+```
+
+## Networking
+
+`start()` performs both hops for you:
+
+1. `POST {baseUrl}/v1/calls/web` with the publishable key → session bundle
+2. WebRTC offer → `POST {voiceWorkerUrl}/v1/calls/web/sessions` → SDP answer
+
+Behind symmetric NAT you need ICE servers; without them only host candidates are
+tried and the call fails with `pipeline-error-connection-failed`:
+
+```ts
+new VoiceAgent(key, {
+  baseUrl,
+  iceServers: [{ urls: "stun:stun.example.com:3478" }],
+});
+```
+
+## API
+
+- `new VoiceAgent(publicKey, options?)` — `baseUrl`, `iceServers`,
+  `connectTimeoutMs`, `fetch`, `getUserMedia`
+- `start(agentId, context?)` — `variables`, `language`, `channel`, `metadata`
+- `stop()` · `setMuted(bool)` · `isMuted()` · `destroy()`
+- `startScreenShare(stream)` · `isScreenSharing()`
+- `getStatus()` · `getCallId()` · `getLocalStream()` · `getRemoteStream()`
+- `on(event, handler)` · `once(...)` · `off(...)` — `on` returns an unsubscribe
+
+## License
+
+MIT

package/dist/client.d.ts

@@ -0,0 +1,143 @@
+import { type CallContext, type FetchLike } from "./controlPlane.js";
+import type { VoiceAgentErrorCode, VoiceAgentEventMap, VoiceAgentEventName } from "./events.js";
+/** Where the call is in its lifecycle. */
+export type CallStatus = "idle" | "connecting" | "active" | "ended" | "error";
+export interface VoiceAgentOptions {
+    /**
+     * Platform base URL — the Kong gateway. Defaults to same-origin, which is
+     * right when the app is served behind the same gateway and wrong otherwise,
+     * so most integrations pass this explicitly.
+     */
+    readonly baseUrl?: string;
+    /**
+     * ICE servers. Empty means host candidates only, which works on a LAN and
+     * fails behind symmetric NAT — a deployment serving real users over the
+     * internet needs at least a STUN server here, and realistically a TURN one.
+     */
+    readonly iceServers?: RTCIceServer[];
+    /**
+     * How long to wait for media after the server accepts the call, in ms.
+     *
+     * This exists because accepting a call is not connecting one. Without a
+     * bound, a user whose UDP is blocked sits on "Connecting…" indefinitely with
+     * nothing ever arriving to tell them otherwise.
+     */
+    readonly connectTimeoutMs?: number;
+    /** Injectable fetch, for tests and for consumers with an instrumented client. */
+    readonly fetch?: FetchLike;
+    /** Injectable media capture, for tests. Defaults to `navigator.mediaDevices`. */
+    readonly getUserMedia?: (constraints: MediaStreamConstraints) => Promise<MediaStream>;
+}
+/**
+ * A browser voice-agent client.
+ *
+ * ```ts
+ * const client = new VoiceAgent(publishableKey, { baseUrl });
+ * client.on("message", (m) => { if (m.type === "transcript") render(m); });
+ * await client.start(agentId, { variables: { candidate_name: "Asha" } });
+ * ```
+ *
+ * `start()` performs both hops — asking the platform for a session, then
+ * negotiating media with the assigned worker — so a caller supplies only a
+ * publishable key and an agent id, and never handles a session token or an SDP
+ * offer itself.
+ *
+ * One instance drives one call at a time. Calling `start()` twice without an
+ * intervening `stop()` is an error rather than a silent takeover, because the
+ * second call would otherwise orphan the first one's media with no event to
+ * say so.
+ */
+export declare class VoiceAgent {
+    private readonly publicKey;
+    private readonly emitter;
+    private readonly baseUrl;
+    private readonly iceServers;
+    private readonly connectTimeoutMs;
+    private readonly fetchImpl;
+    private readonly getUserMediaImpl;
+    private session;
+    private localStream;
+    private remoteStream;
+    private callId;
+    private status;
+    private muted;
+    private connectTimer;
+    /**
+     * Rejects the in-flight `start()`, if there is one.
+     *
+     * Without this, stopping a call mid-connect left `start()` pending forever:
+     * every asynchronous continuation correctly declined to act on a superseded
+     * attempt, and so nothing was left to settle the promise the caller was
+     * awaiting.
+     */
+    private pendingReject;
+    /**
+     * Monotonic attempt counter. Every asynchronous continuation checks it before
+     * acting, so a superseded attempt — one whose call was stopped, or replaced
+     * by a retry — can never emit an event or tear down the attempt that
+     * replaced it. Without this a slow first attempt's timeout fires into a
+     * healthy second call.
+     */
+    private attempt;
+    constructor(publicKey: string, options?: VoiceAgentOptions);
+    on<E extends VoiceAgentEventName>(event: E, handler: VoiceAgentEventMap[E]): () => void;
+    once<E extends VoiceAgentEventName>(event: E, handler: VoiceAgentEventMap[E]): () => void;
+    off<E extends VoiceAgentEventName>(event: E, handler: VoiceAgentEventMap[E]): void;
+    getStatus(): CallStatus;
+    getCallId(): string | undefined;
+    isMuted(): boolean;
+    /** The local microphone stream, for a level meter or a self-view. */
+    getLocalStream(): MediaStream | null;
+    /** The agent's stream — its audio, plus avatar video on a video call. */
+    getRemoteStream(): MediaStream | null;
+    /**
+     * Start a call with `agentId`.
+     *
+     * Resolves once media is flowing. Rejects if the call could not be started,
+     * having already emitted `error` — so a caller may either await this or bind
+     * `error`, and does not have to do both.
+     */
+    start(agentId: string, context?: CallContext): Promise<void>;
+    /** End the call. Idempotent, and safe to call before `start()`. */
+    stop(): void;
+    /**
+     * Attach a screen share to a call that is already running.
+     *
+     * Takes an ALREADY-CAPTURED stream rather than calling `getDisplayMedia`
+     * itself. The caller has to own the capture anyway — browsers only grant it
+     * from a user gesture — and capturing here would raise a second picker in the
+     * middle of a call the user is already on.
+     *
+     * Prefer passing `screenStream` to `start()` when the stream is available up
+     * front: it goes into the initial offer and avoids a renegotiation round trip
+     * while the user is waiting to be connected.
+     */
+    startScreenShare(stream: MediaStream): Promise<void>;
+    /** Whether a screen share is currently attached to the call. */
+    isScreenSharing(): boolean;
+    /** Mute or unmute the microphone. */
+    setMuted(muted: boolean): void;
+    /** Release everything and drop all handlers. The instance is done after this. */
+    destroy(): void;
+    private captureMicrophone;
+    private openMedia;
+    /**
+     * Settle a pending `start()` as cancelled. Emits nothing: the caller asked
+     * for this, so an `error` event would be an unexplained failure toast on a
+     * deliberate action.
+     */
+    private releasePending;
+    /** True when this attempt has been superseded by a stop() or a newer start(). */
+    private isSuperseded;
+    private clearConnectTimer;
+    private teardown;
+    private emitCallEnd;
+    /** Emit `error` and return the matching exception, so callers can `throw` it. */
+    private fail;
+}
+/** The error `start()` rejects with. The matching `error` event has already fired. */
+export declare class VoiceAgentError extends Error {
+    readonly code: VoiceAgentErrorCode;
+    readonly cause?: unknown;
+    constructor(code: VoiceAgentErrorCode, message: string, cause?: unknown);
+}

package/dist/client.js

@@ -0,0 +1,364 @@
+import { startWebCall, } from "./controlPlane.js";
+import { Emitter } from "./emitter.js";
+import { CLEAN_ENDED_REASONS, FAILED_ENDED_REASONS } from "./endedReason.js";
+import { decodeMessage } from "./messages.js";
+import { MediaSession } from "./session.js";
+const DEFAULT_CONNECT_TIMEOUT_MS = 15_000;
+const AUDIO_CONSTRAINTS = {
+    echoCancellation: true,
+    noiseSuppression: true,
+    autoGainControl: true,
+};
+const VIDEO_CONSTRAINTS = {
+    width: { ideal: 640 },
+    height: { ideal: 480 },
+    facingMode: "user",
+};
+/**
+ * A browser voice-agent client.
+ *
+ * ```ts
+ * const client = new VoiceAgent(publishableKey, { baseUrl });
+ * client.on("message", (m) => { if (m.type === "transcript") render(m); });
+ * await client.start(agentId, { variables: { candidate_name: "Asha" } });
+ * ```
+ *
+ * `start()` performs both hops — asking the platform for a session, then
+ * negotiating media with the assigned worker — so a caller supplies only a
+ * publishable key and an agent id, and never handles a session token or an SDP
+ * offer itself.
+ *
+ * One instance drives one call at a time. Calling `start()` twice without an
+ * intervening `stop()` is an error rather than a silent takeover, because the
+ * second call would otherwise orphan the first one's media with no event to
+ * say so.
+ */
+export class VoiceAgent {
+    publicKey;
+    emitter = new Emitter();
+    baseUrl;
+    iceServers;
+    connectTimeoutMs;
+    fetchImpl;
+    getUserMediaImpl;
+    session = null;
+    localStream = null;
+    remoteStream = null;
+    callId;
+    status = "idle";
+    muted = false;
+    connectTimer = null;
+    /**
+     * Rejects the in-flight `start()`, if there is one.
+     *
+     * Without this, stopping a call mid-connect left `start()` pending forever:
+     * every asynchronous continuation correctly declined to act on a superseded
+     * attempt, and so nothing was left to settle the promise the caller was
+     * awaiting.
+     */
+    pendingReject = null;
+    /**
+     * Monotonic attempt counter. Every asynchronous continuation checks it before
+     * acting, so a superseded attempt — one whose call was stopped, or replaced
+     * by a retry — can never emit an event or tear down the attempt that
+     * replaced it. Without this a slow first attempt's timeout fires into a
+     * healthy second call.
+     */
+    attempt = 0;
+    constructor(publicKey, options = {}) {
+        this.publicKey = publicKey;
+        this.baseUrl = options.baseUrl ?? "";
+        this.iceServers = options.iceServers ?? [];
+        this.connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+        this.fetchImpl = options.fetch ?? ((input, init) => globalThis.fetch(input, init));
+        this.getUserMediaImpl =
+            options.getUserMedia ?? ((c) => globalThis.navigator.mediaDevices.getUserMedia(c));
+    }
+    // ---------------------------------------------------------------- events --
+    on(event, handler) {
+        return this.emitter.on(event, handler);
+    }
+    once(event, handler) {
+        return this.emitter.once(event, handler);
+    }
+    off(event, handler) {
+        this.emitter.off(event, handler);
+    }
+    // ----------------------------------------------------------------- state --
+    getStatus() {
+        return this.status;
+    }
+    getCallId() {
+        return this.callId;
+    }
+    isMuted() {
+        return this.muted;
+    }
+    /** The local microphone stream, for a level meter or a self-view. */
+    getLocalStream() {
+        return this.localStream;
+    }
+    /** The agent's stream — its audio, plus avatar video on a video call. */
+    getRemoteStream() {
+        return this.remoteStream;
+    }
+    // ------------------------------------------------------------------ call --
+    /**
+     * Start a call with `agentId`.
+     *
+     * Resolves once media is flowing. Rejects if the call could not be started,
+     * having already emitted `error` — so a caller may either await this or bind
+     * `error`, and does not have to do both.
+     */
+    async start(agentId, context = {}) {
+        if (!this.publicKey) {
+            throw this.fail("missing-public-key", "No publishable key was supplied to VoiceAgent.");
+        }
+        if (!agentId) {
+            throw this.fail("missing-agent-id", "start() requires an agent id.");
+        }
+        if (this.status === "connecting" || this.status === "active") {
+            throw this.fail("already-started", "A call is already in progress — call stop() before starting another.");
+        }
+        const attempt = ++this.attempt;
+        this.status = "connecting";
+        this.callId = undefined;
+        this.muted = false;
+        const wantVideo = context.channel === "video";
+        const screenStream = context.screenStream;
+        try {
+            const session = await startWebCall(this.baseUrl, this.publicKey, agentId, context, this.fetchImpl);
+            if (this.isSuperseded(attempt))
+                throw cancelled();
+            this.callId = session.callId;
+            const stream = await this.captureMicrophone(wantVideo);
+            if (this.isSuperseded(attempt)) {
+                for (const track of stream.getTracks())
+                    track.stop();
+                throw cancelled();
+            }
+            this.localStream = stream;
+            await this.openMedia(attempt, session, stream, wantVideo, screenStream);
+        }
+        catch (err) {
+            // A cancellation is the caller's own stop() coming back to them; it is
+            // already fully handled and must not be reported as a failure.
+            if (err instanceof VoiceAgentError && err.code === "cancelled")
+                throw err;
+            if (this.isSuperseded(attempt))
+                throw cancelled();
+            this.teardown();
+            this.status = "error";
+            if (err instanceof VoiceAgentError)
+                throw err;
+            throw this.fail("media-plane-failed", describe(err), err);
+        }
+        finally {
+            this.pendingReject = null;
+        }
+    }
+    /** End the call. Idempotent, and safe to call before `start()`. */
+    stop() {
+        if (this.status !== "connecting" && this.status !== "active") {
+            this.teardown();
+            return;
+        }
+        const wasActive = this.status === "active";
+        this.attempt += 1; // supersede any in-flight attempt
+        this.releasePending();
+        this.teardown();
+        this.status = "ended";
+        // A call that never connected has no end to report — the caller either
+        // awaited a rejected start() or received `error`. Emitting `call-end` here
+        // too would make a single failure look like two events.
+        if (wasActive)
+            this.emitCallEnd(CLEAN_ENDED_REASONS.CUSTOMER_ENDED_CALL);
+    }
+    /**
+     * Attach a screen share to a call that is already running.
+     *
+     * Takes an ALREADY-CAPTURED stream rather than calling `getDisplayMedia`
+     * itself. The caller has to own the capture anyway — browsers only grant it
+     * from a user gesture — and capturing here would raise a second picker in the
+     * middle of a call the user is already on.
+     *
+     * Prefer passing `screenStream` to `start()` when the stream is available up
+     * front: it goes into the initial offer and avoids a renegotiation round trip
+     * while the user is waiting to be connected.
+     */
+    async startScreenShare(stream) {
+        if (this.status !== "active" || !this.session) {
+            throw this.fail("no-active-call", "startScreenShare() needs a live call — pass `screenStream` to start() instead.");
+        }
+        try {
+            await this.session.addScreenShare(stream);
+        }
+        catch (err) {
+            throw this.fail("screen-share-failed", describe(err), err);
+        }
+    }
+    /** Whether a screen share is currently attached to the call. */
+    isScreenSharing() {
+        return this.session?.hasScreenShare() ?? false;
+    }
+    /** Mute or unmute the microphone. */
+    setMuted(muted) {
+        this.muted = muted;
+        if (this.session && this.localStream)
+            this.session.setMuted(this.localStream, muted);
+    }
+    /** Release everything and drop all handlers. The instance is done after this. */
+    destroy() {
+        this.stop();
+        this.emitter.removeAll();
+    }
+    // -------------------------------------------------------------- internals --
+    async captureMicrophone(wantVideo) {
+        try {
+            return await this.getUserMediaImpl({
+                audio: AUDIO_CONSTRAINTS,
+                video: wantVideo ? VIDEO_CONSTRAINTS : false,
+            });
+        }
+        catch (err) {
+            throw this.fail("microphone-denied", "Microphone access was denied. Allow the microphone and try again.", err);
+        }
+    }
+    async openMedia(attempt, session, stream, wantVideo, screenStream) {
+        const connected = new Promise((resolve, reject) => {
+            const media = new MediaSession({ iceServers: this.iceServers, fetchImpl: this.fetchImpl }, {
+                onMessage: (raw) => {
+                    if (this.isSuperseded(attempt))
+                        return;
+                    const message = decodeMessage(raw);
+                    if (!message)
+                        return;
+                    // Speech frames are lifecycle, not content: they get their own
+                    // events rather than being handed to `message` handlers, which are
+                    // written to expect transcript turns.
+                    if (message.type === "speech-start")
+                        this.emitter.emit("speech-start");
+                    else if (message.type === "speech-end")
+                        this.emitter.emit("speech-end");
+                    else
+                        this.emitter.emit("message", message);
+                },
+                onTrack: (event) => {
+                    if (this.isSuperseded(attempt))
+                        return;
+                    const [remote] = event.streams;
+                    if (remote)
+                        this.remoteStream = remote;
+                },
+                onConnected: () => {
+                    if (this.isSuperseded(attempt) || this.status === "active")
+                        return;
+                    this.clearConnectTimer();
+                    this.status = "active";
+                    this.emitter.emit("call-start");
+                    resolve();
+                },
+                onFailed: (reason) => {
+                    if (this.isSuperseded(attempt))
+                        return;
+                    this.clearConnectTimer();
+                    const started = this.status === "active";
+                    this.teardown();
+                    this.status = started ? "ended" : "error";
+                    if (started) {
+                        this.emitCallEnd(FAILED_ENDED_REASONS.CONNECTION_FAILED);
+                    }
+                    else {
+                        reject(this.fail("connection-failed", `Could not establish a live audio path: ${reason}. A VPN or firewall blocking UDP is the usual cause.`));
+                    }
+                },
+                onDisconnected: () => {
+                    if (this.isSuperseded(attempt) || this.status !== "active")
+                        return;
+                    this.teardown();
+                    this.status = "ended";
+                    // The transport went away while the call was live. From here it is
+                    // indistinguishable from the agent hanging up, which is the far
+                    // more common cause, so it is reported as a clean end rather than
+                    // sending the user to a retry screen for a call that finished.
+                    this.emitCallEnd(CLEAN_ENDED_REASONS.ASSISTANT_ENDED_CALL);
+                },
+            });
+            this.session = media;
+            this.pendingReject = reject;
+            this.connectTimer = setTimeout(() => {
+                if (this.isSuperseded(attempt) || this.status === "active")
+                    return;
+                this.teardown();
+                this.status = "error";
+                reject(this.fail("connection-timeout", "Could not connect to the voice call. Please check your connection and try again."));
+            }, this.connectTimeoutMs);
+            media.connect(session, stream, wantVideo, screenStream).catch((err) => {
+                if (this.isSuperseded(attempt))
+                    return;
+                this.clearConnectTimer();
+                this.teardown();
+                this.status = "error";
+                reject(this.fail("media-plane-failed", describe(err), err));
+            });
+        });
+        await connected;
+    }
+    /**
+     * Settle a pending `start()` as cancelled. Emits nothing: the caller asked
+     * for this, so an `error` event would be an unexplained failure toast on a
+     * deliberate action.
+     */
+    releasePending() {
+        const reject = this.pendingReject;
+        this.pendingReject = null;
+        reject?.(cancelled());
+    }
+    /** True when this attempt has been superseded by a stop() or a newer start(). */
+    isSuperseded(attempt) {
+        return attempt !== this.attempt;
+    }
+    clearConnectTimer() {
+        if (this.connectTimer !== null) {
+            clearTimeout(this.connectTimer);
+            this.connectTimer = null;
+        }
+    }
+    teardown() {
+        this.clearConnectTimer();
+        this.session?.close();
+        this.session = null;
+        if (this.localStream) {
+            for (const track of this.localStream.getTracks())
+                track.stop();
+            this.localStream = null;
+        }
+        this.remoteStream = null;
+    }
+    emitCallEnd(endedReason) {
+        this.emitter.emit("call-end", {
+            endedReason,
+            ...(this.callId ? { callId: this.callId } : {}),
+        });
+    }
+    /** Emit `error` and return the matching exception, so callers can `throw` it. */
+    fail(code, message, cause) {
+        this.emitter.emit("error", { code, message, ...(cause === undefined ? {} : { cause }) });
+        return new VoiceAgentError(code, message, cause);
+    }
+}
+/** The error `start()` rejects with. The matching `error` event has already fired. */
+export class VoiceAgentError extends Error {
+    code;
+    cause;
+    constructor(code, message, cause) {
+        super(message);
+        this.name = "VoiceAgentError";
+        this.code = code;
+        this.cause = cause;
+    }
+}
+/** The rejection a cancelled `start()` produces. */
+const cancelled = () => new VoiceAgentError("cancelled", "The call was stopped before it connected.");
+const describe = (err) => err instanceof Error ? err.message : typeof err === "string" ? err : "Unknown error";
+//# sourceMappingURL=client.js.map