@juspay/neurolink 9.69.3 → 9.70.0

package/dist/types/livekit.d.ts

@@ -0,0 +1,369 @@
+/**
+ * Types for the LiveKit voice agent integration.
+ *
+ * The integration uses LiveKit (WebRTC transport, VAD, turn detection,
+ * interruption, worker-per-call scaling) as the real-time loop, and NeuroLink
+ * as the brain (LLM, tools, memory). These types describe the brain seam, the
+ * worker configuration, and the join-token request — all transport-agnostic
+ * except where a LiveKit-specific concept is named explicitly.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { NeuroLinkEvents, TypedEventEmitter } from "./common.js";
+import type { StreamOptions, StreamResult } from "./stream.js";
+/**
+ * Minimal structural shape of the NeuroLink instance the brain depends on.
+ *
+ * Declared structurally (rather than importing the `NeuroLink` class) so the
+ * brain layer stays decoupled from SDK construction and can be unit-tested with
+ * a lightweight stub. The real `NeuroLink` instance satisfies this shape.
+ *
+ * `getEventEmitter` is optional so lightweight stubs remain valid; the real
+ * `NeuroLink` instance provides it, and the data-channel event bridge uses it
+ * to forward tool/text/HITL events to the browser.
+ */
+export type LiveKitNeuroLinkStreamer = {
+    stream: (options: StreamOptions) => Promise<StreamResult>;
+    getEventEmitter?: () => TypedEventEmitter<NeuroLinkEvents>;
+};
+/**
+ * Configuration for the transport-agnostic voice brain.
+ *
+ * The brain owns the conversation: it calls `neurolink.stream()` with a stable
+ * `conversationId` so NeuroLink's memory layer is the source of truth, and it
+ * leaves tool-calling to the NeuroLink instance.
+ */
+export type LiveKitBrainConfig = {
+    /** Configured NeuroLink instance (memory + tools registered on it). */
+    neurolink: LiveKitNeuroLinkStreamer;
+    /** LLM provider name passed to `stream()` (e.g. "bedrock"). */
+    provider?: string;
+    /** LLM model name passed to `stream()` (e.g. "claude-sonnet-4-6"). */
+    model?: string;
+    /** System prompt applied to every turn. */
+    systemPrompt?: string;
+    /** Sampling temperature for spoken-style responses. */
+    temperature?: number;
+    /** Upper bound on tokens per turn. */
+    maxTokens?: number;
+    /** Optional user identifier recorded alongside memory. */
+    userId?: string;
+};
+/** A single user turn handed to the brain. */
+export type LiveKitBrainTurn = {
+    /** Final transcript of the user's utterance. */
+    transcript: string;
+    /** Stable conversation id keying NeuroLink memory for this session. */
+    conversationId: string;
+    /** Cancellation signal; aborting stops the in-flight LLM and tool calls. */
+    signal?: AbortSignal;
+};
+/**
+ * The brain's public surface: stream the assistant reply as text deltas.
+ * The transport layer converts these deltas into audio (TTS).
+ */
+export type LiveKitVoiceBrain = {
+    streamReply: (turn: LiveKitBrainTurn) => AsyncGenerator<string, void, unknown>;
+};
+/** Speech-to-text plugin selection for the LiveKit worker. */
+export type LiveKitSttConfig = {
+    provider: string;
+    model?: string;
+    language?: string;
+    /**
+     * Soniox only: maximum delay (ms) between speech cessation and the STT
+     * endpoint. Raise it so Soniox does not finalize on short pauses — that lets
+     * VAD silence (not the STT endpoint) decide when the turn ends.
+     */
+    maxEndpointDelayMs?: number;
+};
+/** Text-to-speech plugin selection for the LiveKit worker. */
+export type LiveKitTtsConfig = {
+    provider: string;
+    voice?: string;
+    model?: string;
+};
+/**
+ * Silero VAD tuning. Stricter values reject background noise (higher threshold,
+ * longer minimum speech). Durations are in seconds.
+ */
+export type LiveKitVadConfig = {
+    /** Probability cutoff for "this is speech" (default 0.6). Higher = stricter. */
+    activationThreshold?: number;
+    /** Minimum speech length before a turn starts, seconds (default 0.2). */
+    minSpeechDuration?: number;
+    /** Silence before a turn ends, seconds (default 0.6) — tolerates pauses. */
+    minSilenceDuration?: number;
+};
+/**
+ * Turn-detection (end-of-utterance) tuning.
+ *
+ * `mode` selects what decides the user's turn is over:
+ * - `"vad"`  — Silero VAD silence (see `LiveKitVadConfig.minSilenceDuration`).
+ *   Tolerates natural mid-sentence pauses; the turn only ends after a full
+ *   silence window. This mirrors Clairvoyance's behavior.
+ * - `"stt"`  — the STT provider's own endpoint detection (e.g. Soniox). Often
+ *   much faster/aggressive — short pauses can prematurely split one utterance
+ *   into several turns.
+ * - `"realtime_llm"` / `"manual"` — advanced/manual strategies.
+ *
+ * `minEndpointingDelay` / `maxEndpointingDelay` are the framework's endpointing
+ * window in milliseconds (in VAD mode the effective end delay is
+ * `max(VAD silence, minEndpointingDelay)`).
+ */
+export type LiveKitTurnConfig = {
+    mode?: "stt" | "vad" | "realtime_llm" | "manual";
+    minEndpointingDelay?: number;
+    maxEndpointingDelay?: number;
+};
+/**
+ * Interruption (barge-in) tuning. Requiring real words / a minimum duration
+ * stops background noise from cutting off the assistant.
+ */
+export type LiveKitInterruptionConfig = {
+    /** Minimum recognized words to count as an interruption (default 2). */
+    minWords?: number;
+    /** Minimum audio duration to count as an interruption, ms (default 600). */
+    minDuration?: number;
+};
+/**
+ * Options for `defineVoiceAgent` — the agent definition placed as the default
+ * export of the worker entry file.
+ *
+ * LiveKit runs each call as a Job in its own child process and re-imports the
+ * entry file there, so the NeuroLink instance cannot be passed as a live object
+ * from a parent. Instead, `createNeuroLink` is invoked **inside each job
+ * process** to build the brain (and register its tools) for that call.
+ */
+export type LiveKitVoiceAgentConfig = {
+    /**
+     * Factory that builds the NeuroLink instance for a job process.
+     * Called once per call, inside the job's own process.
+     */
+    createNeuroLink: () => LiveKitNeuroLinkStreamer | Promise<LiveKitNeuroLinkStreamer>;
+    /** Realtime speech-to-text selection. */
+    stt: LiveKitSttConfig;
+    /** Realtime text-to-speech selection. */
+    tts: LiveKitTtsConfig;
+    /** LLM provider/model overrides (default to env-resolved values). */
+    provider?: string;
+    model?: string;
+    systemPrompt?: string;
+    temperature?: number;
+    maxTokens?: number;
+    /** Prefix used when deriving a per-room conversation id (default "voice"). */
+    conversationIdPrefix?: string;
+    /** Optional user id recorded alongside memory. */
+    userId?: string;
+    /** Silero VAD tuning (stricter = ignores background noise). */
+    vad?: LiveKitVadConfig;
+    /** Turn-detection tuning (VAD vs STT endpointing, delays). */
+    turn?: LiveKitTurnConfig;
+    /** Interruption tuning (require words/duration so noise can't barge in). */
+    interruption?: LiveKitInterruptionConfig;
+    /**
+     * Data-channel event bridge: forward NeuroLink events (text, tool calls,
+     * tool results, HITL prompts, status) to the browser over the LiveKit data
+     * channel, and accept control messages (HITL responses) back. Disabled
+     * unless `enabled` is `true`.
+     */
+    events?: LiveKitEventBridgeConfig;
+};
+/** Options for `startVoiceAgentWorker` — launches the LiveKit Agents worker. */
+export type LiveKitWorkerLaunchOptions = {
+    /**
+     * Absolute path to the entry file whose default export is the result of
+     * `defineVoiceAgent`. LiveKit re-imports this file in each job process.
+     */
+    agentFile: string;
+    /** Name the worker registers under for dispatch (default "neurolink-voice"). */
+    agentName?: string;
+};
+/** Resolved LiveKit server connection settings. */
+export type LiveKitServerConfig = {
+    /** LiveKit server URL (ws/wss). */
+    url: string;
+    /** API key for token signing and worker registration. */
+    apiKey: string;
+    /** API secret for token signing and worker registration. */
+    apiSecret: string;
+};
+/** LLM defaults resolved from the environment for the brain. */
+export type LiveKitBrainDefaults = {
+    provider: string;
+    model: string;
+};
+/** Arguments for minting a browser join token. */
+export type LiveKitTokenRequest = {
+    /** Participant identity (e.g. the authenticated user id). */
+    identity: string;
+    /** Room name to join (auto-created on first join). */
+    room: string;
+    /** LiveKit API key. */
+    apiKey: string;
+    /** LiveKit API secret. */
+    apiSecret: string;
+    /** Token lifetime in seconds (default 600; clamped to a 3600 max). */
+    ttlSeconds?: number;
+};
+/** Discriminant tags for outbound voice events. */
+export type LiveKitVoiceEventType = "user-text" | "text" | "tool-start" | "tool-result" | "status" | "hitl-prompt" | "done";
+/**
+ * A user STT transcript for display. Interim partials stream with
+ * `final: false`; the end-of-utterance result has `final: true`. The client
+ * updates one live bubble and commits it on `final`.
+ *
+ * `replacesPrevious` is set on the committed (`final: true`) text of a turn that
+ * absorbed a previous turn the user interrupted before it produced any reply
+ * (strict barge-in club). The client removes the orphaned previous user bubble
+ * so the merged utterance shows as one bubble.
+ */
+export type LiveKitVoiceUserTextEvent = {
+    type: "user-text";
+    data: {
+        text: string;
+        final: boolean;
+        replacesPrevious?: boolean;
+    };
+};
+/** A streamed chunk of the assistant's spoken/written reply. */
+export type LiveKitVoiceTextEvent = {
+    type: "text";
+    data: {
+        delta: string;
+    };
+};
+/** A tool invocation has started (best-effort status; may not always fire). */
+export type LiveKitVoiceToolStartEvent = {
+    type: "tool-start";
+    data: {
+        id?: string;
+        name: string;
+        input?: unknown;
+    };
+};
+/**
+ * A tool invocation has finished. `result` carries the tool's structured
+ * output (for example, a chart payload) for the client to render.
+ */
+export type LiveKitVoiceToolResultEvent = {
+    type: "tool-result";
+    data: {
+        id?: string;
+        name: string;
+        result?: unknown;
+        success?: boolean;
+        error?: string;
+    };
+};
+/** Coarse agent state, useful for UI indicators (e.g. "thinking…"). */
+export type LiveKitVoiceStatusEvent = {
+    type: "status";
+    data: {
+        state: "thinking" | "speaking" | "listening" | "error";
+        detail?: string;
+    };
+};
+/** A human-in-the-loop confirmation the user must approve or reject. */
+export type LiveKitVoiceHitlPromptEvent = {
+    type: "hitl-prompt";
+    data: {
+        confirmationId: string;
+        toolName: string;
+        actionType?: string;
+        arguments?: unknown;
+        timeoutMs?: number;
+        allowModification?: boolean;
+    };
+};
+/** The current turn has finished. */
+export type LiveKitVoiceDoneEvent = {
+    type: "done";
+    data: {
+        reason?: string;
+    };
+};
+/** Discriminated union of all outbound voice events (before enveloping). */
+export type LiveKitVoiceEvent = LiveKitVoiceUserTextEvent | LiveKitVoiceTextEvent | LiveKitVoiceToolStartEvent | LiveKitVoiceToolResultEvent | LiveKitVoiceStatusEvent | LiveKitVoiceHitlPromptEvent | LiveKitVoiceDoneEvent;
+/**
+ * Wire format published to the browser: a `LiveKitVoiceEvent` plus a monotonic
+ * sequence number and a timestamp so the client can order and de-duplicate.
+ */
+export type LiveKitVoiceEventEnvelope = LiveKitVoiceEvent & {
+    seq: number;
+    ts: number;
+};
+/** Control messages sent from the browser back to the agent. */
+export type LiveKitVoiceControlMessage = {
+    action: "hitl:accept";
+    confirmationId: string;
+    modifiedArguments?: unknown;
+} | {
+    action: "hitl:reject";
+    confirmationId: string;
+    reason?: string;
+};
+/**
+ * Configuration for the data-channel event bridge, set on
+ * `LiveKitVoiceAgentConfig.events`.
+ */
+export type LiveKitEventBridgeConfig = {
+    /** Master switch — the bridge is inert unless this is `true`. */
+    enabled?: boolean;
+    /** Data-channel topic for outbound events (default "ai-events"). */
+    eventsTopic?: string;
+    /** Data-channel topic for inbound control messages (default "ai-control"). */
+    controlTopic?: string;
+    /** If set, only these event types are forwarded (default: all). */
+    include?: LiveKitVoiceEventType[];
+    /**
+     * Payloads encoded larger than this many bytes are sent via the chunked text
+     * stream API instead of a single reliable data packet (default 12000).
+     */
+    maxInlineBytes?: number;
+};
+/**
+ * Minimal structural view of the LiveKit room the bridge needs: a local
+ * participant to publish on, and event (un)subscription. Declared structurally
+ * so `src/lib/types` carries no dependency on `@livekit/rtc-node`; the real
+ * `Room` from a job context satisfies this shape.
+ */
+export type LiveKitBridgeRoom = {
+    localParticipant?: {
+        publishData(data: Uint8Array, options: {
+            reliable?: boolean;
+            topic?: string;
+        }): Promise<void>;
+        sendText(text: string, options?: {
+            topic?: string;
+        }): Promise<unknown>;
+    };
+    on(event: string, listener: (...args: unknown[]) => void): unknown;
+    off(event: string, listener: (...args: unknown[]) => void): unknown;
+};
+/**
+ * Normalized tool fields extracted from a `tool:start` / `tool:end` emitter
+ * payload, used internally by the event bridge.
+ */
+export type LiveKitToolEventFields = {
+    name: string;
+    id?: string;
+    input?: unknown;
+    result?: unknown;
+    success?: boolean;
+    error?: string;
+};
+/** Inputs to `attachEventBridge`. */
+export type LiveKitEventBridgeParams = {
+    /** The LiveKit room for this call (from the job context). */
+    room: LiveKitBridgeRoom;
+    /** NeuroLink's event emitter (`neurolink.getEventEmitter()`). */
+    emitter: TypedEventEmitter<NeuroLinkEvents>;
+    /** Bridge options (topics, filtering, chunking threshold). */
+    options?: LiveKitEventBridgeConfig;
+};
+/** Handle returned by `attachEventBridge` for teardown. */
+export type LiveKitEventBridgeHandle = {
+    /** Remove all listeners and stop publishing. Idempotent. */
+    dispose: () => void;
+};

package/dist/types/livekit.js

@@ -0,0 +1,12 @@
+/**
+ * Types for the LiveKit voice agent integration.
+ *
+ * The integration uses LiveKit (WebRTC transport, VAD, turn detection,
+ * interruption, worker-per-call scaling) as the real-time loop, and NeuroLink
+ * as the brain (LLM, tools, memory). These types describe the brain seam, the
+ * worker configuration, and the join-token request — all transport-agnostic
+ * except where a LiveKit-specific concept is named explicitly.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+export {};

package/dist/voice/livekit/brain.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Transport-agnostic voice brain.
+ *
+ * Given a user transcript and a stable conversation id, it streams the
+ * assistant's reply as text deltas by calling `neurolink.stream()`. NeuroLink
+ * owns history (via the conversation id and its memory layer) and tools (the
+ * tool-calling loop runs inside `stream()`); this module never touches a
+ * transport. The LiveKit worker (or any other transport) consumes the text
+ * deltas and converts them to audio.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { LiveKitBrainConfig, LiveKitVoiceBrain } from "../../types/index.js";
+/**
+ * Create a voice brain bound to a configured NeuroLink instance.
+ *
+ * The returned `streamReply` is an async generator of text deltas for a single
+ * turn. Aborting `turn.signal` stops the in-flight LLM and tool calls and ends
+ * the generator promptly (barge-in support).
+ */
+export declare function createVoiceBrain(config: LiveKitBrainConfig): LiveKitVoiceBrain;

package/dist/voice/livekit/brain.js

@@ -0,0 +1,74 @@
+/**
+ * Transport-agnostic voice brain.
+ *
+ * Given a user transcript and a stable conversation id, it streams the
+ * assistant's reply as text deltas by calling `neurolink.stream()`. NeuroLink
+ * owns history (via the conversation id and its memory layer) and tools (the
+ * tool-calling loop runs inside `stream()`); this module never touches a
+ * transport. The LiveKit worker (or any other transport) consumes the text
+ * deltas and converts them to audio.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import { logger } from "../../utils/logger.js";
+/**
+ * Extract spoken text from a stream chunk without type assertions.
+ *
+ * `StreamResult.stream` yields a union: text chunks (`{ content: string }`),
+ * a no-output sentinel, and audio/image events. Only text chunks carry a
+ * string `content`; everything else yields `undefined` and is skipped.
+ */
+function extractTextDelta(chunk) {
+    if (typeof chunk === "object" && chunk !== null && "content" in chunk) {
+        const value = chunk.content;
+        if (typeof value === "string" && value.length > 0) {
+            return value;
+        }
+    }
+    return undefined;
+}
+/**
+ * Create a voice brain bound to a configured NeuroLink instance.
+ *
+ * The returned `streamReply` is an async generator of text deltas for a single
+ * turn. Aborting `turn.signal` stops the in-flight LLM and tool calls and ends
+ * the generator promptly (barge-in support).
+ */
+export function createVoiceBrain(config) {
+    const { neurolink, provider, model, systemPrompt, temperature, maxTokens, userId, } = config;
+    async function* streamReply(turn) {
+        const { transcript, conversationId, signal } = turn;
+        if (signal?.aborted) {
+            return;
+        }
+        const context = {
+            sessionId: conversationId,
+            conversationId,
+        };
+        if (userId !== undefined) {
+            context.userId = userId;
+        }
+        const result = await neurolink.stream({
+            input: { text: transcript },
+            provider,
+            model,
+            systemPrompt,
+            temperature,
+            maxTokens,
+            context,
+            abortSignal: signal,
+            disableTools: false,
+        });
+        for await (const chunk of result.stream) {
+            if (signal?.aborted) {
+                logger.debug("[LiveKitBrain] Turn aborted mid-stream; stopping");
+                return;
+            }
+            const delta = extractTextDelta(chunk);
+            if (delta !== undefined) {
+                yield delta;
+            }
+        }
+    }
+    return { streamReply };
+}

package/dist/voice/livekit/config.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Environment resolution for the LiveKit voice agent.
+ *
+ * Reads LiveKit connection settings and LLM defaults from `process.env` with
+ * descriptive errors for missing required values. No type assertions: presence
+ * is verified with explicit string checks.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { LiveKitServerConfig, LiveKitBrainDefaults } from "../../types/index.js";
+/**
+ * Resolve LiveKit server connection settings from the environment.
+ *
+ * Requires `LIVEKIT_URL`, `LIVEKIT_API_KEY`, and `LIVEKIT_API_SECRET`. Works
+ * identically for LiveKit Cloud, a self-hosted server, or `livekit-server --dev`
+ * — only the values differ.
+ */
+export declare function resolveLiveKitServerConfig(): LiveKitServerConfig;
+/**
+ * Resolve the LLM provider/model defaults for the brain.
+ *
+ * Defaults to Bedrock / Claude; overridable via `VOICE_LLM_PROVIDER` and
+ * `VOICE_LLM_MODEL`.
+ */
+export declare function resolveBrainDefaults(): LiveKitBrainDefaults;
+/**
+ * Resolve the semantic end-of-utterance (EOU) turn-detection settings.
+ *
+ * Opt-in via `LIVEKIT_EOU_TURN_DETECTION` (`1`/`true`/`english`/`en`/`on`/`yes`).
+ * When enabled, the English `@livekit/agents-plugin-livekit` EOU model decides
+ * whether the user's turn is truly over, layered on top of VAD silence — so
+ * natural mid-sentence pauses don't split one utterance. English-only; the
+ * model adds ~200MB RAM per worker and ~10ms per turn-end.
+ *
+ * `LIVEKIT_EOU_UNLIKELY_THRESHOLD` optionally overrides the model's confidence
+ * threshold (lower = end the turn more eagerly).
+ */
+export declare function resolveEouTurnDetection(): {
+    enabled: boolean;
+    unlikelyThreshold: number | undefined;
+};

package/dist/voice/livekit/config.js

@@ -0,0 +1,79 @@
+/**
+ * Environment resolution for the LiveKit voice agent.
+ *
+ * Reads LiveKit connection settings and LLM defaults from `process.env` with
+ * descriptive errors for missing required values. No type assertions: presence
+ * is verified with explicit string checks.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+const DEFAULT_LLM_PROVIDER = "bedrock";
+const DEFAULT_LLM_MODEL = "claude-sonnet-4-6";
+/** Read a required environment variable or throw a descriptive error. */
+function requireEnv(name) {
+    const value = process.env[name];
+    if (typeof value !== "string" || value.trim().length === 0) {
+        throw new Error(`${name} is not set in environment (required for the LiveKit voice agent)`);
+    }
+    return value.trim();
+}
+/** Read an optional environment variable, falling back to a default. */
+function readEnv(name, fallback) {
+    const value = process.env[name];
+    if (typeof value === "string" && value.trim().length > 0) {
+        return value.trim();
+    }
+    return fallback;
+}
+/**
+ * Resolve LiveKit server connection settings from the environment.
+ *
+ * Requires `LIVEKIT_URL`, `LIVEKIT_API_KEY`, and `LIVEKIT_API_SECRET`. Works
+ * identically for LiveKit Cloud, a self-hosted server, or `livekit-server --dev`
+ * — only the values differ.
+ */
+export function resolveLiveKitServerConfig() {
+    return {
+        url: requireEnv("LIVEKIT_URL"),
+        apiKey: requireEnv("LIVEKIT_API_KEY"),
+        apiSecret: requireEnv("LIVEKIT_API_SECRET"),
+    };
+}
+/**
+ * Resolve the LLM provider/model defaults for the brain.
+ *
+ * Defaults to Bedrock / Claude; overridable via `VOICE_LLM_PROVIDER` and
+ * `VOICE_LLM_MODEL`.
+ */
+export function resolveBrainDefaults() {
+    return {
+        provider: readEnv("VOICE_LLM_PROVIDER", DEFAULT_LLM_PROVIDER),
+        model: readEnv("VOICE_LLM_MODEL", DEFAULT_LLM_MODEL),
+    };
+}
+const EOU_TRUTHY = new Set(["1", "true", "english", "en", "on", "yes"]);
+/**
+ * Resolve the semantic end-of-utterance (EOU) turn-detection settings.
+ *
+ * Opt-in via `LIVEKIT_EOU_TURN_DETECTION` (`1`/`true`/`english`/`en`/`on`/`yes`).
+ * When enabled, the English `@livekit/agents-plugin-livekit` EOU model decides
+ * whether the user's turn is truly over, layered on top of VAD silence — so
+ * natural mid-sentence pauses don't split one utterance. English-only; the
+ * model adds ~200MB RAM per worker and ~10ms per turn-end.
+ *
+ * `LIVEKIT_EOU_UNLIKELY_THRESHOLD` optionally overrides the model's confidence
+ * threshold (lower = end the turn more eagerly).
+ */
+export function resolveEouTurnDetection() {
+    const raw = process.env.LIVEKIT_EOU_TURN_DETECTION;
+    const enabled = typeof raw === "string" && EOU_TRUTHY.has(raw.trim().toLowerCase());
+    const thresholdRaw = process.env.LIVEKIT_EOU_UNLIKELY_THRESHOLD;
+    let unlikelyThreshold;
+    if (typeof thresholdRaw === "string" && thresholdRaw.trim().length > 0) {
+        const parsed = Number(thresholdRaw.trim());
+        if (Number.isFinite(parsed)) {
+            unlikelyThreshold = parsed;
+        }
+    }
+    return { enabled, unlikelyThreshold };
+}

package/dist/voice/livekit/eventBridge.d.ts

@@ -0,0 +1,27 @@
+/**
+ * Data-channel event bridge.
+ *
+ * Connects NeuroLink's event emitter to the LiveKit room's data channel: it
+ * forwards NeuroLink events (text deltas, tool start/result, HITL prompts,
+ * stream lifecycle) to the browser as small versioned envelopes, and accepts
+ * control messages (HITL responses) back, re-emitting them onto the emitter so
+ * NeuroLink's HITL manager resolves.
+ *
+ * This is the WebRTC counterpart of the chat-mode SSE controller: same event
+ * source, different transport. The browser renders the envelopes (transcript,
+ * tool status, charts, confirmation prompts).
+ *
+ * `@livekit/rtc-node` is an optional dependency, imported dynamically only for
+ * the `RoomEvent` enum value. All payloads arrive typed as `unknown` and are
+ * narrowed with runtime guards — no type assertions.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { LiveKitEventBridgeHandle, LiveKitEventBridgeParams } from "../../types/index.js";
+/**
+ * Attach the data-channel event bridge to a room.
+ *
+ * Returns a handle whose `dispose()` removes every listener and stops
+ * publishing; it is safe to call more than once.
+ */
+export declare function attachEventBridge(params: LiveKitEventBridgeParams): Promise<LiveKitEventBridgeHandle>;