@juspay/neurolink 9.71.0 → 9.73.0

package/dist/lib/voice/livekit/config.js

@@ -25,6 +25,22 @@ function readEnv(name, fallback) {
     }
     return fallback;
 }
+function readOptionalEnv(name) {
+    const value = process.env[name];
+    return typeof value === "string" && value.trim().length > 0
+        ? value.trim()
+        : undefined;
+}
+function readNumberEnv(name, fallback) {
+    const raw = process.env[name];
+    if (typeof raw === "string" && raw.trim().length > 0) {
+        const parsed = Number(raw.trim());
+        if (Number.isFinite(parsed) && parsed > 0) {
+            return parsed;
+        }
+    }
+    return fallback;
+}
 /**
  * Resolve LiveKit server connection settings from the environment.
  *
@@ -51,6 +67,44 @@ export function resolveBrainDefaults() {
         model: readEnv("VOICE_LLM_MODEL", DEFAULT_LLM_MODEL),
     };
 }
+const DEFAULT_REALTIME_MODEL = "gemini-live-2.5-flash";
+const DEFAULT_REALTIME_LOCATION = "global";
+const DEFAULT_RESPONSE_MODALITY = "AUDIO";
+const DEFAULT_SYSTEM_PROMPT = "You are a concise voice assistant for a merchant dashboard. Keep replies short and spoken.";
+const DEFAULT_GREETING = "Briefly greet the merchant and ask how you can help with their store today.";
+const DEFAULT_LIGHTHOUSE_URL = "http://localhost:5173";
+const DEFAULT_MCP_PATH = "/ai/mcp/v2";
+/**
+ * Resolve the realtime (Gemini Live speech-to-speech) voice configuration from
+ * the environment.
+ *
+ * Every value has a safe default so a worker can run with no realtime-specific
+ * env at all. Vertex `project` is resolved from `VERTEX_PROJECT`, then the
+ * service-account project (`GOOGLE_AUTH_BREEZE_PROJECT_ID`), then
+ * `GOOGLE_CLOUD_PROJECT_ID`. The MCP URL is `VOICE_MCP_URL` if set, otherwise
+ * `${LIGHTHOUSE_URL}/ai/mcp/v2`.
+ */
+export function resolveRealtimeVoiceConfig() {
+    const lighthouseUrl = readEnv("LIGHTHOUSE_URL", DEFAULT_LIGHTHOUSE_URL);
+    const mcpUrl = readEnv("VOICE_MCP_URL", `${lighthouseUrl}${DEFAULT_MCP_PATH}`);
+    return {
+        project: readOptionalEnv("VERTEX_PROJECT") ??
+            readOptionalEnv("GOOGLE_AUTH_BREEZE_PROJECT_ID") ??
+            readOptionalEnv("GOOGLE_CLOUD_PROJECT_ID"),
+        location: readEnv("VERTEX_LOCATION", DEFAULT_REALTIME_LOCATION),
+        model: readEnv("VOICE_LIVE_MODEL", DEFAULT_REALTIME_MODEL),
+        voice: readOptionalEnv("VOICE_S2S_VOICE"),
+        responseModality: readEnv("VOICE_RESPONSE_MODALITY", DEFAULT_RESPONSE_MODALITY).toUpperCase(),
+        systemPrompt: readEnv("VOICE_SYSTEM_PROMPT", DEFAULT_SYSTEM_PROMPT),
+        greeting: readEnv("VOICE_GREETING", DEFAULT_GREETING),
+        toolsEnabled: readEnv("VOICE_S2S_TOOLS", "").toLowerCase() === "true",
+        mcpUrl,
+        emptyRoomGraceMs: readNumberEnv("VOICE_EMPTY_ROOM_GRACE_MS", 30_000),
+        joinDeadlineMs: readNumberEnv("VOICE_JOIN_DEADLINE_MS", 60_000),
+        hitlTimeoutMs: readNumberEnv("VOICE_HITL_TIMEOUT_MS", 45_000),
+        metricsIntervalMs: readNumberEnv("VOICE_METRICS_INTERVAL_MS", 10_000),
+    };
+}
 const EOU_TRUTHY = new Set(["1", "true", "english", "en", "on", "yes"]);
 /**
  * Resolve the semantic end-of-utterance (EOU) turn-detection settings.

package/dist/lib/voice/livekit/eventBridge.js

@@ -191,7 +191,7 @@ export async function attachEventBridge(params) {
         const json = JSON.stringify(envelope);
         const bytes = encoder.encode(json);
         const onError = (transport) => (error) => {
-            logger.warn("[LiveKitEventBridge] Failed to publish event", {
+            logger.warn("voice.bridge.publishFailed", {
                 transport,
                 type: event.type,
                 error: error instanceof Error ? error.message : String(error),
@@ -304,7 +304,7 @@ export async function attachEventBridge(params) {
             parsed = JSON.parse(decoder.decode(payload));
         }
         catch (error) {
-            logger.warn("[LiveKitEventBridge] Dropping malformed control message", {
+            logger.warn("voice.bridge.controlMalformed", {
                 error: error instanceof Error ? error.message : String(error),
             });
             return;
@@ -332,7 +332,7 @@ export async function attachEventBridge(params) {
     };
     room.on(RoomEvent.DataReceived, onData);
     publish({ type: "status", data: { state: "listening" } });
-    logger.info("[LiveKitEventBridge] Attached", {
+    logger.info("voice.bridge.attached", {
         eventsTopic,
         controlTopic,
         filtered: include !== undefined,
@@ -353,7 +353,7 @@ export async function attachEventBridge(params) {
             emitter.off(STREAM_END_EVENT, onStreamComplete);
             emitter.off(STREAM_ERROR_EVENT, onStreamError);
             room.off(RoomEvent.DataReceived, onData);
-            logger.info("[LiveKitEventBridge] Disposed");
+            logger.info("voice.bridge.disposed", {});
         },
     };
 }

package/dist/lib/voice/livekit/index.d.ts

@@ -8,8 +8,15 @@
  * See docs/features/livekit-voice-agent.md.
  */
 export { createVoiceBrain } from "./brain.js";
-export { resolveLiveKitServerConfig, resolveBrainDefaults } from "./config.js";
+export { resolveLiveKitServerConfig, resolveBrainDefaults, resolveRealtimeVoiceConfig, } from "./config.js";
 export { attachEventBridge } from "./eventBridge.js";
+export { attachRealtimeEventBridge } from "./realtimeEventBridge.js";
 export { mintJoinToken } from "./tokens.js";
+export { createVoiceRoom, dispatchVoiceAgent } from "./roomDispatch.js";
 export { defineVoiceAgent } from "./voiceAgent.js";
-export { startVoiceAgentWorker } from "./voiceAgentWorker.js";
+export { defineRealtimeVoiceAgent } from "./realtimeVoiceAgent.js";
+export { startVoiceAgentWorker, startRealtimeVoiceAgentWorker, installVoiceWorkerProcessGuards, } from "./voiceAgentWorker.js";
+export { ensureVertexAdc, clearGeminiApiKeyEnv } from "./vertexAuth.js";
+export { readCallContextFromRoom } from "./roomContext.js";
+export { sanitizeSchema, sanitizeToolParameters, findSchemaIssue, } from "./schemaSanitizer.js";
+export { buildRealtimeMcpTools, mcpResultToText } from "./realtimeMcpTools.js";

package/dist/lib/voice/livekit/index.js

@@ -8,9 +8,16 @@
  * See docs/features/livekit-voice-agent.md.
  */
 export { createVoiceBrain } from "./brain.js";
-export { resolveLiveKitServerConfig, resolveBrainDefaults } from "./config.js";
+export { resolveLiveKitServerConfig, resolveBrainDefaults, resolveRealtimeVoiceConfig, } from "./config.js";
 export { attachEventBridge } from "./eventBridge.js";
+export { attachRealtimeEventBridge } from "./realtimeEventBridge.js";
 export { mintJoinToken } from "./tokens.js";
+export { createVoiceRoom, dispatchVoiceAgent } from "./roomDispatch.js";
 export { defineVoiceAgent } from "./voiceAgent.js";
-export { startVoiceAgentWorker } from "./voiceAgentWorker.js";
+export { defineRealtimeVoiceAgent } from "./realtimeVoiceAgent.js";
+export { startVoiceAgentWorker, startRealtimeVoiceAgentWorker, installVoiceWorkerProcessGuards, } from "./voiceAgentWorker.js";
+export { ensureVertexAdc, clearGeminiApiKeyEnv } from "./vertexAuth.js";
+export { readCallContextFromRoom } from "./roomContext.js";
+export { sanitizeSchema, sanitizeToolParameters, findSchemaIssue, } from "./schemaSanitizer.js";
+export { buildRealtimeMcpTools, mcpResultToText } from "./realtimeMcpTools.js";
 //# sourceMappingURL=index.js.map

package/dist/lib/voice/livekit/realtimeEventBridge.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Realtime data-channel event bridge.
+ *
+ * The cascaded bridge (`eventBridge.ts`) is driven by NeuroLink's event emitter.
+ */
+import type { RealtimeEventBridgeHandle, RealtimeEventBridgeParams } from "../../types/index.js";
+/**
+ * Attach the realtime event bridge to a room.
+ *
+ * Returns `publishEvent` (worker → browser), `requestConfirmation` (HITL
+ * round-trip), and `dispose` (remove the control listener, decline anything
+ * still pending).
+ */
+export declare function attachRealtimeEventBridge(params: RealtimeEventBridgeParams): Promise<RealtimeEventBridgeHandle>;

package/dist/lib/voice/livekit/realtimeEventBridge.js

@@ -0,0 +1,161 @@
+/**
+ * Realtime data-channel event bridge.
+ *
+ * The cascaded bridge (`eventBridge.ts`) is driven by NeuroLink's event emitter.
+ */
+import { z } from "zod";
+import { logger } from "../../utils/logger.js";
+const DEFAULT_EVENTS_TOPIC = "ai-events";
+const DEFAULT_CONTROL_TOPIC = "ai-control";
+const DEFAULT_MAX_INLINE_BYTES = 12_000;
+const DEFAULT_HITL_TIMEOUT_MS = 45_000;
+const hitlControlMessageSchema = z.object({
+    action: z.enum(["hitl:accept", "hitl:reject"]),
+    confirmationId: z.string(),
+});
+/**
+ * Attach the realtime event bridge to a room.
+ *
+ * Returns `publishEvent` (worker → browser), `requestConfirmation` (HITL
+ * round-trip), and `dispose` (remove the control listener, decline anything
+ * still pending).
+ */
+export async function attachRealtimeEventBridge(params) {
+    const { room } = params;
+    const eventsTopic = params.eventsTopic ?? DEFAULT_EVENTS_TOPIC;
+    const controlTopic = params.controlTopic ?? DEFAULT_CONTROL_TOPIC;
+    const maxInlineBytes = params.maxInlineBytes ?? DEFAULT_MAX_INLINE_BYTES;
+    const hitlTimeoutMs = params.hitlTimeoutMs ?? DEFAULT_HITL_TIMEOUT_MS;
+    const { RoomEvent } = await import("@livekit/rtc-node");
+    const encoder = new TextEncoder();
+    const decoder = new TextDecoder();
+    let seq = 0;
+    let disposed = false;
+    const startedAt = Date.now();
+    const publishEvent = (type, data) => {
+        if (disposed) {
+            return;
+        }
+        const participant = room.localParticipant;
+        if (!participant) {
+            return;
+        }
+        try {
+            seq += 1;
+            const json = JSON.stringify({ seq, ts: Date.now(), type, data });
+            const bytes = encoder.encode(json);
+            const via = bytes.byteLength <= maxInlineBytes ? "data" : "stream";
+            logger.debug("realtime.bridge.publish", {
+                ms: Date.now() - startedAt,
+                seq,
+                type,
+                via,
+                bytes: bytes.byteLength,
+            });
+            if (via === "data") {
+                void participant.publishData(bytes, {
+                    reliable: true,
+                    topic: eventsTopic,
+                });
+            }
+            else {
+                void participant.sendText(json, { topic: eventsTopic });
+            }
+        }
+        catch {
+            /* non-fatal — the UI bridge is best-effort */
+        }
+    };
+    // HITL: WRITE-labeled tools pause for user confirmation. We publish a
+    // `hitl-prompt`, the UI replies on the control topic, and we resolve the
+    // pending request by confirmationId. A timeout is treated as a decline so a
+    // turn can never hang waiting on the user.
+    const pendingHitl = new Map();
+    let hitlSeq = 0;
+    const onData = (...args) => {
+        const payload = args[0];
+        const topic = args[3];
+        if (topic !== controlTopic || !(payload instanceof Uint8Array)) {
+            return;
+        }
+        let raw;
+        try {
+            raw = JSON.parse(decoder.decode(payload));
+        }
+        catch {
+            return;
+        }
+        const message = hitlControlMessageSchema.safeParse(raw);
+        if (!message.success) {
+            return;
+        }
+        const { action, confirmationId } = message.data;
+        const resolver = pendingHitl.get(confirmationId);
+        if (resolver) {
+            logger.debug("realtime.bridge.controlReceived", {
+                action,
+                confirmationId,
+            });
+            pendingHitl.delete(confirmationId);
+            resolver(action === "hitl:accept");
+        }
+        else {
+            logger.warn("realtime.bridge.controlUnmatched", {
+                action,
+                confirmationId,
+            });
+        }
+    };
+    room.on(RoomEvent.DataReceived, onData);
+    const requestConfirmation = (toolName, args) => {
+        if (disposed) {
+            logger.warn("realtime.bridge.hitlDisposed", { toolName });
+            return Promise.resolve(false);
+        }
+        hitlSeq += 1;
+        const confirmationId = `hitl_${seq}_${hitlSeq}`;
+        publishEvent("hitl-prompt", {
+            confirmationId,
+            toolName,
+            actionType: `Run ${toolName}`,
+            arguments: args ?? {},
+        });
+        logger.info("realtime.bridge.hitlPrompt", { toolName, confirmationId });
+        return new Promise((resolve) => {
+            const timer = setTimeout(() => {
+                pendingHitl.delete(confirmationId);
+                logger.warn("realtime.bridge.hitlTimeout", {
+                    toolName,
+                    confirmationId,
+                    timeoutMs: hitlTimeoutMs,
+                });
+                resolve(false);
+            }, hitlTimeoutMs);
+            pendingHitl.set(confirmationId, (approved) => {
+                clearTimeout(timer);
+                logger.info("realtime.bridge.hitlResolved", {
+                    toolName,
+                    confirmationId,
+                    approved,
+                });
+                resolve(approved);
+            });
+        });
+    };
+    return {
+        publishEvent,
+        requestConfirmation,
+        dispose() {
+            if (disposed) {
+                return;
+            }
+            disposed = true;
+            room.off(RoomEvent.DataReceived, onData);
+            for (const [, resolver] of pendingHitl) {
+                resolver(false);
+            }
+            pendingHitl.clear();
+        },
+    };
+}
+//# sourceMappingURL=realtimeEventBridge.js.map

package/dist/lib/voice/livekit/realtimeMcpTools.d.ts

@@ -0,0 +1,31 @@
+/**
+ * MCP tools → Gemini function tools bridge (realtime mode).
+ *
+ * In speech-to-speech mode Gemini owns the tool loop, so an external MCP
+ * server's tools are registered as LiveKit/Gemini function tools rather than
+ * NeuroLink tools. This connects to the MCP server as the calling user
+ * (`x-auth-token` + base64 `x-context`), sanitizes each tool's schema into the
+ * Gemini-safe subset, wires WRITE-labeled (destructive) tools through a HITL
+ * confirmation, and forwards tool start/result events to the browser bridge.
+ *
+ * `@livekit/agents` and `@modelcontextprotocol/sdk` are imported dynamically so
+ * the core package does not require them unless the realtime agent is used.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { llm as llmNs } from "@livekit/agents";
+import type { BuildRealtimeMcpToolsParams } from "../../types/index.js";
+/** Flatten an MCP tool result's text content into a single string for the model. */
+export declare function mcpResultToText(result: unknown): string;
+/**
+ * Connect to the MCP server as the calling user and bridge every tool into a
+ * LiveKit `ToolContext`. Returns the tool map + the client (close on shutdown).
+ * The server already scopes the tool list by `x-context`, so no client-side
+ * filtering is needed.
+ */
+export declare function buildRealtimeMcpTools(params: BuildRealtimeMcpToolsParams): Promise<{
+    tools: llmNs.ToolContext;
+    client: {
+        close: () => Promise<void>;
+    };
+}>;

package/dist/lib/voice/livekit/realtimeMcpTools.js

@@ -0,0 +1,194 @@
+/**
+ * MCP tools → Gemini function tools bridge (realtime mode).
+ *
+ * In speech-to-speech mode Gemini owns the tool loop, so an external MCP
+ * server's tools are registered as LiveKit/Gemini function tools rather than
+ * NeuroLink tools. This connects to the MCP server as the calling user
+ * (`x-auth-token` + base64 `x-context`), sanitizes each tool's schema into the
+ * Gemini-safe subset, wires WRITE-labeled (destructive) tools through a HITL
+ * confirmation, and forwards tool start/result events to the browser bridge.
+ *
+ * `@livekit/agents` and `@modelcontextprotocol/sdk` are imported dynamically so
+ * the core package does not require them unless the realtime agent is used.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import { z } from "zod";
+import { logger } from "../../utils/logger.js";
+import { findSchemaIssue, sanitizeToolParameters } from "./schemaSanitizer.js";
+/**
+ * The fields of an MCP tool result we render: text content parts and the error
+ * flag. The result crosses a network boundary from an external MCP server, so it
+ * is decoded with a schema (other content kinds — image, resource — are dropped).
+ */
+const toolResultSchema = z.object({
+    isError: z.boolean().optional(),
+    content: z
+        .array(z.object({ type: z.string().optional(), text: z.string().optional() }))
+        .optional(),
+});
+/** Flatten an MCP tool result's text content into a single string for the model. */
+export function mcpResultToText(result) {
+    const decoded = toolResultSchema.safeParse(result);
+    if (!decoded.success) {
+        return "Tool returned no content.";
+    }
+    const text = (decoded.data.content ?? [])
+        .map((part) => (part.type === "text" && part.text ? part.text : ""))
+        .filter(Boolean)
+        .join("\n")
+        .trim();
+    if (decoded.data.isError) {
+        return `Tool error: ${text || "unknown error"}`;
+    }
+    return text || "Tool returned no content.";
+}
+/**
+ * The function-result text returned to Gemini when the user rejects a HITL tool.
+ * Scope the rejection to THIS attempt — a "never retry" wording made the model
+ * refuse the tool permanently even when the user later asked for it again.
+ */
+function buildHitlDeclineMessage(toolName) {
+    return (`The user reviewed the request to run "${toolName}" and chose to reject it, ` +
+        `so it was NOT executed this time. Do not run it right now. Briefly let the user know ` +
+        `you didn't proceed because they declined, and ask if there's anything else. ` +
+        `If the user later asks for "${toolName}" again or says to go ahead, you may run it then — ` +
+        `this rejection applies only to this request, not to all future requests.`);
+}
+/**
+ * Register a tool handler under the name variants the model might call:
+ *   1. the Gemini-safe full name (hyphens → underscores; Gemini rewrites these
+ *      itself, so the rewritten form must be registered or the round-trip fails)
+ *   2. the bare short name (the model often drops the server prefix)
+ * First registration wins, so a unique full name is never shadowed by a generic
+ * short name. Returns the aliases actually registered.
+ */
+function registerToolAliases(toolContext, mcpToolName, handler) {
+    const safeFullName = mcpToolName.replace(/[^a-zA-Z0-9_]/g, "_");
+    const shortName = safeFullName.includes("_")
+        ? safeFullName.slice(safeFullName.lastIndexOf("_") + 1)
+        : safeFullName;
+    const candidates = [safeFullName, shortName].filter((name, index, all) => name.length > 0 && all.indexOf(name) === index);
+    const registered = [];
+    for (const alias of candidates) {
+        if (alias in toolContext) {
+            continue; // taken by another tool — don't clobber
+        }
+        toolContext[alias] = handler;
+        registered.push(alias);
+    }
+    return registered;
+}
+/**
+ * Connect to the MCP server as the calling user and bridge every tool into a
+ * LiveKit `ToolContext`. Returns the tool map + the client (close on shutdown).
+ * The server already scopes the tool list by `x-context`, so no client-side
+ * filtering is needed.
+ */
+export async function buildRealtimeMcpTools(params) {
+    const { mcpUrl, authToken, xContext, publishEvent, requestConfirmation } = params;
+    const { llm } = await import("@livekit/agents");
+    const { Client: McpClient } = await import("@modelcontextprotocol/sdk/client/index.js");
+    const { StreamableHTTPClientTransport } = await import("@modelcontextprotocol/sdk/client/streamableHttp.js");
+    const transport = new StreamableHTTPClientTransport(new URL(mcpUrl), {
+        requestInit: {
+            headers: { "x-auth-token": authToken, "x-context": xContext },
+        },
+    });
+    const client = new McpClient({ name: "neurolink-realtime-voice", version: "1.0.0" }, { capabilities: {} });
+    logger.info("realtime.mcp.connecting", {
+        mcpUrl,
+        hasAuthToken: authToken !== "",
+        hasContext: xContext !== "",
+    });
+    await client.connect(transport);
+    try {
+        const { tools: mcpTools } = await client.listTools();
+        logger.info("realtime.mcp.toolsListed", { count: mcpTools.length });
+        const toolContext = {};
+        const skipped = [];
+        for (const mcpTool of mcpTools) {
+            const parameters = sanitizeToolParameters(mcpTool.inputSchema);
+            const issue = findSchemaIssue(parameters);
+            if (issue) {
+                skipped.push(mcpTool.name);
+                logger.warn("realtime.mcp.toolSkipped", {
+                    tool: mcpTool.name,
+                    issue,
+                    rawInputSchema: JSON.stringify(mcpTool.inputSchema),
+                });
+                continue;
+            }
+            const requiresConfirmation = mcpTool.annotations?.destructiveHint === true;
+            const handler = llm.tool({
+                description: mcpTool.description ?? mcpTool.name,
+                parameters,
+                execute: async (args) => {
+                    if (requiresConfirmation) {
+                        const approved = await requestConfirmation(mcpTool.name, args ?? {});
+                        if (!approved) {
+                            logger.info("realtime.tool.hitlRejected", {
+                                tool: mcpTool.name,
+                            });
+                            return buildHitlDeclineMessage(mcpTool.name);
+                        }
+                        logger.info("realtime.tool.hitlApproved", { tool: mcpTool.name });
+                    }
+                    logger.info("realtime.tool.invoke", {
+                        tool: mcpTool.name,
+                        args: args ?? {},
+                    });
+                    publishEvent("tool-start", { name: mcpTool.name });
+                    const startedAt = Date.now();
+                    try {
+                        const result = await client.callTool({
+                            name: mcpTool.name,
+                            arguments: args ?? {},
+                        });
+                        const text = mcpResultToText(result);
+                        logger.info("realtime.tool.result", {
+                            tool: mcpTool.name,
+                            isError: result.isError === true,
+                            chars: text.length,
+                            ms: Date.now() - startedAt,
+                        });
+                        // Forward the RAW result so the client can extract a
+                        // chart/UIComponent and clear the in-progress indicator.
+                        publishEvent("tool-result", { name: mcpTool.name, result });
+                        return text;
+                    }
+                    catch (error) {
+                        logger.error("realtime.tool.error", {
+                            tool: mcpTool.name,
+                            ms: Date.now() - startedAt,
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                        publishEvent("tool-result", { name: mcpTool.name, result: null });
+                        return `Tool ${mcpTool.name} failed: ${String(error)}`;
+                    }
+                },
+            });
+            const aliases = registerToolAliases(toolContext, mcpTool.name, handler);
+            logger.info("realtime.mcp.toolRegistered", {
+                tool: mcpTool.name,
+                aliases,
+                hitl: requiresConfirmation,
+            });
+        }
+        logger.info("realtime.mcp.connected", {
+            registered: Object.keys(toolContext).length,
+            skipped: skipped.length,
+            skippedTools: skipped,
+        });
+        return { tools: toolContext, client };
+    }
+    catch (error) {
+        await client.close().catch((closeError) => {
+            logger.warn("realtime.mcp.closeFailed", {
+                error: closeError instanceof Error ? closeError.message : String(closeError),
+            });
+        });
+        throw error;
+    }
+}
+//# sourceMappingURL=realtimeMcpTools.js.map

package/dist/lib/voice/livekit/realtimeVoiceAgent.d.ts

@@ -0,0 +1,26 @@
+/**
+ * LiveKit Agents agent definition — realtime (Gemini Live speech-to-speech).
+ *
+ * `defineRealtimeVoiceAgent` returns the agent object placed as the default
+ * export of a worker entry file. Unlike the cascaded `defineVoiceAgent`
+ * (Silero VAD → STT → NeuroLink → TTS), here a single realtime model (Gemini
+ * Live on Vertex) does STT + reasoning + TTS + turn detection over one
+ *
+ * `@livekit/agents`, `@livekit/agents-plugin-google`, `@livekit/rtc-node`, and
+ * `@google/genai` are imported dynamically so the core package does not require
+ * them unless the realtime agent is used. Type-only imports are erased at build.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { JobContext } from "@livekit/agents";
+import type { RealtimeVoiceAgentConfig } from "../../types/index.js";
+/**
+ * Define a realtime (Gemini Live S2S) LiveKit voice agent.
+ *
+ * Place the result as the default export of the worker entry file and launch it
+ * with `startRealtimeVoiceAgentWorker`. With no `config` everything is resolved
+ * from the environment (see `resolveRealtimeVoiceConfig`).
+ */
+export declare function defineRealtimeVoiceAgent(config?: RealtimeVoiceAgentConfig): {
+    entry: (ctx: JobContext) => Promise<void>;
+};