@juspay/neurolink 9.69.3 → 9.70.1

package/dist/voice/livekit/voiceAgent.js

@@ -0,0 +1,414 @@
+/**
+ * LiveKit Agents agent definition.
+ *
+ * `defineVoiceAgent` returns the agent object placed as the default export of a
+ * worker entry file. The framework runs it as a Job (one per call, in its own
+ * process): it connects to the room, builds the NeuroLink brain via the
+ * supplied factory, wires Silero VAD + STT/TTS plugins, and overrides `llmNode`
+ * so every turn is generated by `neurolink.stream()`.
+ *
+ * `@livekit/agents` and the plugins are optional dependencies, imported
+ * dynamically so the core package does not require them unless the LiveKit
+ * voice agent is used. Type-only imports are erased at build time and add no
+ * runtime dependency.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import { ReadableStream } from "node:stream/web";
+import { logger } from "../../utils/logger.js";
+import { createVoiceBrain } from "./brain.js";
+import { resolveBrainDefaults, resolveEouTurnDetection } from "./config.js";
+import { attachEventBridge } from "./eventBridge.js";
+const DEFAULT_CONVERSATION_PREFIX = "voice";
+// Turn-end timing defaults (approach A: silence tuning). Longer silence +
+// endpointing floor so natural mid-sentence pauses ("...and so, [pause] um")
+// don't end the turn early and split one utterance into two. Overridable via
+// config (vad.minSilenceDuration / turn.minEndpointingDelay).
+const DEFAULT_MIN_SILENCE_DURATION = 1.0; // seconds (Silero VAD)
+const DEFAULT_MIN_ENDPOINTING_DELAY = 1000; // ms (framework endpointing floor)
+/**
+ * Find the most recent user utterance in a chat context.
+ * Uses the `type === "message"` discriminant — no type assertions.
+ */
+function latestUserText(chatCtx) {
+    const items = chatCtx.items;
+    for (let i = items.length - 1; i >= 0; i -= 1) {
+        const item = items[i];
+        if (item.type === "message" && item.role === "user") {
+            return item.textContent;
+        }
+    }
+    return undefined;
+}
+/**
+ * Build a text stream for a single turn from the brain, abortable on cancel.
+ * When the framework cancels the stream (barge-in), the brain's turn is aborted.
+ */
+function brainTurnStream(brain, transcript, conversationId, onAbortedBeforeOutput) {
+    const controller = new AbortController();
+    const generator = brain.streamReply({
+        transcript,
+        conversationId,
+        signal: controller.signal,
+    });
+    const iterator = generator[Symbol.asyncIterator]();
+    let producedOutput = false;
+    return new ReadableStream({
+        async pull(streamController) {
+            const next = await iterator.next();
+            if (next.done === true) {
+                streamController.close();
+                return;
+            }
+            producedOutput = true;
+            streamController.enqueue(next.value);
+        },
+        cancel() {
+            controller.abort();
+            if (!producedOutput) {
+                onAbortedBeforeOutput?.();
+            }
+        },
+    });
+}
+/**
+ * Construct the English semantic EOU turn detector, or `undefined` if disabled.
+ *
+ * Layered on top of VAD: VAD detects acoustic silence, then this model decides
+ * whether the user's turn is semantically complete, so natural mid-sentence
+ * pauses don't split one utterance. Opt-in via `LIVEKIT_EOU_TURN_DETECTION`.
+ * The runner is registered in the worker process (see `voiceAgentWorker.ts`);
+ * here we only construct the model handle, which dispatches inference to the
+ * shared executor via the running job context.
+ */
+async function loadEouTurnDetector() {
+    const { enabled, unlikelyThreshold } = resolveEouTurnDetection();
+    if (!enabled) {
+        return undefined;
+    }
+    const { turnDetector } = await import("@livekit/agents-plugin-livekit");
+    return new turnDetector.EnglishModel(unlikelyThreshold);
+}
+/**
+ * Construct the Silero VAD instance for the session.
+ *
+ * Stricter-than-default thresholds so background noise isn't treated as speech
+ * (a higher activation threshold and a minimum speech duration reject short,
+ * quiet noise bursts).
+ */
+async function loadVad(config) {
+    const silero = await import("@livekit/agents-plugin-silero");
+    return silero.VAD.load({
+        activationThreshold: config?.activationThreshold ?? 0.6,
+        minSpeechDuration: config?.minSpeechDuration ?? 0.2,
+        minSilenceDuration: config?.minSilenceDuration ?? DEFAULT_MIN_SILENCE_DURATION,
+    });
+}
+/**
+ * Construct the STT plugin instance from configuration.
+ *
+ * Only defined options are passed — passing `undefined` would override the
+ * plugin's own defaults (e.g. its default model) with `undefined` and break it.
+ */
+async function buildStt(config) {
+    if (config.provider === "soniox") {
+        const soniox = await import("@livekit/agents-plugin-soniox");
+        const opts = {};
+        if (config.model !== undefined) {
+            opts.model = config.model;
+        }
+        if (config.language !== undefined) {
+            // Soft hint only: Soniox biases toward this language but can still
+            // auto-detect another (e.g. the user switching to Telugu mid-call).
+            // Do NOT set `languageHintsStrict` — forcing the hinted language makes
+            // the realtime STT stall/error on other-language audio and the session
+            // never recovers (no further transcripts, so no audio at all).
+            opts.languageHints = [config.language];
+        }
+        if (config.maxEndpointDelayMs !== undefined) {
+            opts.maxEndpointDelayMs = config.maxEndpointDelayMs;
+        }
+        return new soniox.STT(opts);
+    }
+    if (config.provider === "deepgram") {
+        const deepgram = await import("@livekit/agents-plugin-deepgram");
+        const opts = {};
+        if (config.language !== undefined) {
+            opts.language = config.language;
+        }
+        return new deepgram.STT(opts);
+    }
+    throw new Error(`Unsupported LiveKit STT provider "${config.provider}" (supported: soniox, deepgram)`);
+}
+/**
+ * Construct the TTS plugin instance from configuration.
+ *
+ * Only defined options are passed — passing `undefined` would override the
+ * plugin's own defaults (default voice/model) with `undefined` and break it.
+ */
+async function buildTts(config) {
+    if (config.provider === "cartesia") {
+        const cartesia = await import("@livekit/agents-plugin-cartesia");
+        const opts = {};
+        if (config.voice !== undefined) {
+            opts.voice = config.voice;
+        }
+        if (config.model !== undefined) {
+            opts.model = config.model;
+        }
+        return new cartesia.TTS(opts);
+    }
+    if (config.provider === "elevenlabs") {
+        const elevenlabs = await import("@livekit/agents-plugin-elevenlabs");
+        const opts = {};
+        if (config.voice !== undefined) {
+            opts.voiceId = config.voice;
+        }
+        if (config.model !== undefined) {
+            opts.modelID = config.model;
+        }
+        return new elevenlabs.TTS(opts);
+    }
+    throw new Error(`Unsupported LiveKit TTS provider "${config.provider}" (supported: cartesia, elevenlabs)`);
+}
+/**
+ * Define a LiveKit voice agent backed by NeuroLink.
+ *
+ * Place the result as the default export of the worker entry file:
+ *
+ * ```ts
+ * export default defineVoiceAgent({
+ *   createNeuroLink: async () => buildConfiguredNeuroLink(),
+ *   stt: { provider: "deepgram" },
+ *   tts: { provider: "elevenlabs" },
+ * });
+ * ```
+ */
+export function defineVoiceAgent(config) {
+    const defaults = resolveBrainDefaults();
+    const provider = config.provider ?? defaults.provider;
+    const model = config.model ?? defaults.model;
+    const conversationPrefix = config.conversationIdPrefix ?? DEFAULT_CONVERSATION_PREFIX;
+    async function entry(ctx) {
+        const entryStartedAt = Date.now();
+        await ctx.connect();
+        logger.debug(`[LiveKitVoiceAgent] Joined room "${ctx.room.name}" in ${Date.now() - entryStartedAt}ms`);
+        // When the user actually stopped speaking (VAD), used to measure how long
+        // the agent waited after speech before committing the turn to the LLM.
+        let userStoppedSpeakingAt;
+        const neurolink = await config.createNeuroLink();
+        const brain = createVoiceBrain({
+            neurolink,
+            provider,
+            model,
+            systemPrompt: config.systemPrompt,
+            temperature: config.temperature,
+            maxTokens: config.maxTokens,
+            userId: config.userId,
+        });
+        const conversationId = `${conversationPrefix}-${ctx.room.name ?? ctx.job.id}`;
+        const { voice, llm } = await import("@livekit/agents");
+        const [vad, stt, tts, eouTurnDetector] = await Promise.all([
+            loadVad(config.vad),
+            buildStt(config.stt),
+            buildTts(config.tts),
+            loadEouTurnDetector(),
+        ]);
+        const transcriptEventsEnabled = config.events?.enabled === true &&
+            typeof neurolink.getEventEmitter === "function";
+        const transcriptEmitter = transcriptEventsEnabled
+            ? neurolink.getEventEmitter?.()
+            : undefined;
+        let userTranscriptBuffer = "";
+        let pendingPrefix = "";
+        function emitUserTranscriptSegment(segmentText, isFinal) {
+            if (transcriptEmitter === undefined) {
+                return;
+            }
+            const trimmed = segmentText.trim();
+            if (isFinal) {
+                userTranscriptBuffer =
+                    userTranscriptBuffer.length > 0
+                        ? `${userTranscriptBuffer} ${trimmed}`
+                        : trimmed;
+                transcriptEmitter.emit("voice:user-transcript", {
+                    text: userTranscriptBuffer,
+                    final: false,
+                });
+                return;
+            }
+            const live = userTranscriptBuffer.length > 0
+                ? `${userTranscriptBuffer} ${trimmed}`
+                : trimmed;
+            transcriptEmitter.emit("voice:user-transcript", {
+                text: live,
+                final: false,
+            });
+        }
+        /**
+         * Lock the user bubble at turn-end and reset the buffer for the next turn.
+         * `replacesPrevious` tells the client this committed turn absorbed a prior
+         * interrupted turn, so it should remove the orphaned previous user bubble.
+         */
+        function commitUserTranscript(finalText, replacesPrevious = false) {
+            if (transcriptEmitter !== undefined) {
+                transcriptEmitter.emit("voice:user-transcript", {
+                    text: finalText,
+                    final: true,
+                    replacesPrevious,
+                });
+            }
+            userTranscriptBuffer = "";
+        }
+        class NeuroLinkVoiceAgent extends voice.Agent {
+            async llmNode(chatCtx, _toolCtx, _modelSettings) {
+                const transcript = latestUserText(chatCtx);
+                if (transcript === undefined || transcript.trim().length === 0) {
+                    userTranscriptBuffer = "";
+                    return null;
+                }
+                const hadPrefix = pendingPrefix.length > 0;
+                const promptText = hadPrefix
+                    ? `${pendingPrefix} ${transcript}`
+                    : transcript;
+                pendingPrefix = "";
+                commitUserTranscript(promptText, hadPrefix);
+                if (userStoppedSpeakingAt !== undefined) {
+                    logger.debug(`[LiveKitVoiceAgent] Endpointing waited ${Date.now() - userStoppedSpeakingAt}ms before sending turn to LLM`);
+                }
+                return brainTurnStream(brain, promptText, conversationId, () => {
+                    // Interrupted before producing any reply → carry this turn's text
+                    // forward; the next turn merges it (prompt + UI).
+                    pendingPrefix = promptText;
+                });
+            }
+        }
+        class PlaceholderLLM extends llm.LLM {
+            label() {
+                return "neurolink-placeholder";
+            }
+            chat() {
+                throw new Error("PlaceholderLLM.chat must not be called — llmNode overrides generation");
+            }
+        }
+        const turnHandling = {
+            interruption: {
+                minWords: config.interruption?.minWords ?? 2,
+                minDuration: config.interruption?.minDuration ?? 600,
+            },
+        };
+        if (eouTurnDetector !== undefined) {
+            turnHandling.turnDetection = eouTurnDetector;
+            logger.info("[LiveKitVoiceAgent] Semantic end-of-utterance turn detection enabled (English)");
+        }
+        else if (config.turn?.mode) {
+            turnHandling.turnDetection = config.turn.mode;
+        }
+        const endpointing = {};
+        endpointing.minDelay =
+            config.turn?.minEndpointingDelay ?? DEFAULT_MIN_ENDPOINTING_DELAY;
+        if (config.turn?.maxEndpointingDelay !== undefined) {
+            endpointing.maxDelay = config.turn.maxEndpointingDelay;
+        }
+        if (Object.keys(endpointing).length > 0) {
+            turnHandling.endpointing = endpointing;
+        }
+        const session = new voice.AgentSession({
+            vad,
+            stt,
+            tts,
+            llm: new PlaceholderLLM(),
+            turnHandling,
+            // Do NOT speculatively call the LLM on preflight transcripts before the
+            // turn ends — with NeuroLink as the brain each call is a real LLM request,
+            // and it makes the agent feel like it responds while you're still talking.
+            preemptiveGeneration: false,
+        });
+        const agent = new NeuroLinkVoiceAgent({
+            instructions: config.systemPrompt ?? "",
+        });
+        // Inactivity watchdog: shut the per-call Job down after a stretch with no
+        // user or agent activity (mirrors Clairvoyance). On timeout `ctx.shutdown`
+        // runs the shutdown callbacks (disposing the bridge) and the Job process
+        // exits — freeing its RAM and the EOU model — while the browser observes a
+        // room disconnect. Reset on every interaction below. Configure via
+        // VOICE_INACTIVITY_TIMEOUT_MS (default 10 min); <= 0 disables the watchdog.
+        const inactivityTimeoutMs = Number(process.env.VOICE_INACTIVITY_TIMEOUT_MS ?? 600_000);
+        const inactivityEnabled = Number.isFinite(inactivityTimeoutMs) && inactivityTimeoutMs > 0;
+        let inactivityTimer;
+        let inactivityFired = false;
+        function clearInactivityTimer() {
+            if (inactivityTimer !== undefined) {
+                clearTimeout(inactivityTimer);
+                inactivityTimer = undefined;
+            }
+        }
+        function noteActivity() {
+            if (!inactivityEnabled || inactivityFired) {
+                return;
+            }
+            clearInactivityTimer();
+            inactivityTimer = setTimeout(() => {
+                inactivityFired = true;
+                logger.info(`[LiveKitVoiceAgent] Inactivity timeout (${Math.round(inactivityTimeoutMs / 1000)}s) reached — shutting down job for room "${ctx.room.name}"`);
+                ctx.shutdown("inactivity timeout");
+            }, inactivityTimeoutMs);
+            // The watchdog must not, by itself, keep the event loop alive.
+            inactivityTimer.unref?.();
+        }
+        ctx.addShutdownCallback(async () => {
+            clearInactivityTimer();
+        });
+        // Track when the user actually stops speaking (VAD) so endpointing latency
+        // can be measured, and reset the inactivity watchdog on user activity.
+        session.on(voice.AgentSessionEventTypes.UserStateChanged, (ev) => {
+            noteActivity();
+            if (ev.oldState === "speaking" && ev.newState !== "speaking") {
+                userStoppedSpeakingAt = Date.now();
+            }
+        });
+        // Reset the inactivity watchdog on any agent speech/processing and on every
+        // committed conversation item (user turn or agent reply), so the timeout
+        // only fires during a genuine lull in the conversation.
+        session.on(voice.AgentSessionEventTypes.AgentStateChanged, () => {
+            noteActivity();
+        });
+        session.on(voice.AgentSessionEventTypes.ConversationItemAdded, () => {
+            noteActivity();
+        });
+        // Forward user STT transcripts to the data-channel bridge as a single
+        // live-updating bubble. `UserInputTranscribed` fires `isFinal: true` per
+        // finalized SEGMENT (several per turn), so we never forward those as the
+        // turn-final; `emitUserTranscriptSegment` accumulates them into the per-turn
+        // buffer and emits `final: false`. The lone `final: true` is sent from
+        // `llmNode` at the real turn boundary.
+        if (transcriptEventsEnabled) {
+            session.on(voice.AgentSessionEventTypes.UserInputTranscribed, (ev) => {
+                emitUserTranscriptSegment(ev.transcript, ev.isFinal);
+            });
+        }
+        logger.info("[LiveKitVoiceAgent] Session starting", {
+            room: ctx.room.name,
+            provider,
+            model,
+        });
+        await session.start({ agent, room: ctx.room });
+        // Start the inactivity countdown now that the session is live; every
+        // interaction handler above re-arms it.
+        noteActivity();
+        // Data-channel event bridge: forward NeuroLink events (text, tool calls,
+        // results, HITL prompts, status) to the browser, and accept HITL responses
+        // back. Only when enabled and the instance exposes its event emitter.
+        if (config.events?.enabled === true && neurolink.getEventEmitter) {
+            const bridge = await attachEventBridge({
+                room: ctx.room,
+                emitter: neurolink.getEventEmitter(),
+                options: config.events,
+            });
+            ctx.addShutdownCallback(async () => {
+                bridge.dispose();
+            });
+        }
+    }
+    return { entry };
+}

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

@@ -0,0 +1,27 @@
+/**
+ * LiveKit Agents worker launcher.
+ *
+ * Registers a worker with the LiveKit server (Cloud or self-hosted) for the
+ * given agent entry file. LiveKit dispatches one Job per room, each running in
+ * its own process, which provides worker-per-call isolation and horizontal
+ * scaling. Connection settings are resolved from the environment.
+ *
+ * `@livekit/agents` is an optional dependency, imported dynamically.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import type { LiveKitWorkerLaunchOptions } from "../../types/index.js";
+/**
+ * Launch the LiveKit voice agent worker.
+ *
+ * Call from a small runner script; `agentFile` must point to the file whose
+ * default export is the result of `defineVoiceAgent`.
+ *
+ * ```ts
+ * await startVoiceAgentWorker({
+ *   agentFile: new URL("./voice-agent-entry.js", import.meta.url).pathname,
+ *   agentName: "neurolink-voice",
+ * });
+ * ```
+ */
+export declare function startVoiceAgentWorker(options: LiveKitWorkerLaunchOptions): Promise<void>;

package/dist/voice/livekit/voiceAgentWorker.js

@@ -0,0 +1,57 @@
+/**
+ * LiveKit Agents worker launcher.
+ *
+ * Registers a worker with the LiveKit server (Cloud or self-hosted) for the
+ * given agent entry file. LiveKit dispatches one Job per room, each running in
+ * its own process, which provides worker-per-call isolation and horizontal
+ * scaling. Connection settings are resolved from the environment.
+ *
+ * `@livekit/agents` is an optional dependency, imported dynamically.
+ *
+ * See docs/features/livekit-voice-agent.md.
+ */
+import { resolveEouTurnDetection, resolveLiveKitServerConfig, } from "./config.js";
+const DEFAULT_AGENT_NAME = "neurolink-voice";
+const EOU_METHOD_MULTILINGUAL = "lk_end_of_utterance_multilingual";
+/**
+ * Register the English EOU inference runner in the worker process.
+ *
+ * Must run before `cli.runApp`: the worker only spawns the shared inference
+ * executor when `InferenceRunner.registeredRunners` is non-empty at startup,
+ * and passes that registry to the executor process. Importing the plugin
+ * registers both English and multilingual runners, so we delete multilingual to
+ * keep only the English model loaded.
+ */
+async function registerEouTurnDetectorRunner() {
+    const { InferenceRunner } = await import("@livekit/agents");
+    // Importing the plugin's turn-detector module triggers registerRunner().
+    await import("@livekit/agents-plugin-livekit");
+    delete InferenceRunner.registeredRunners[EOU_METHOD_MULTILINGUAL];
+}
+/**
+ * Launch the LiveKit voice agent worker.
+ *
+ * Call from a small runner script; `agentFile` must point to the file whose
+ * default export is the result of `defineVoiceAgent`.
+ *
+ * ```ts
+ * await startVoiceAgentWorker({
+ *   agentFile: new URL("./voice-agent-entry.js", import.meta.url).pathname,
+ *   agentName: "neurolink-voice",
+ * });
+ * ```
+ */
+export async function startVoiceAgentWorker(options) {
+    const server = resolveLiveKitServerConfig();
+    const { cli, WorkerOptions } = await import("@livekit/agents");
+    if (resolveEouTurnDetection().enabled) {
+        await registerEouTurnDetectorRunner();
+    }
+    cli.runApp(new WorkerOptions({
+        agent: options.agentFile,
+        agentName: options.agentName ?? DEFAULT_AGENT_NAME,
+        wsURL: server.url,
+        apiKey: server.apiKey,
+        apiSecret: server.apiSecret,
+    }));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@juspay/neurolink",
-  "version": "9.69.3",
+  "version": "9.70.1",
   "packageManager": "pnpm@10.15.1",
   "description": "Universal AI Development Platform with working MCP integration, multi-provider support, voice (TTS/STT/realtime), and professional CLI. 58+ external MCP servers discoverable, multimodal file processing, RAG pipelines. Build, test, and deploy AI applications with 21+ providers: OpenAI, Anthropic, Google AI Studio, Google Vertex, AWS Bedrock, Azure OpenAI, Mistral, LiteLLM, SageMaker, Hugging Face, Ollama, OpenAI-compatible, OpenRouter, DeepSeek, NVIDIA NIM, LM Studio, llama.cpp, plus voice (OpenAI TTS, ElevenLabs, Deepgram, Azure Speech).",
   "author": {
@@ -108,6 +108,8 @@
     "test:dynamic": "npx tsx test/continuous-test-suite-dynamic.ts",
     "test:proxy": "npx tsx test/continuous-test-suite-proxy.ts",
     "test:bugfixes": "npx tsx test/continuous-test-suite-bugfixes.ts",
+    "test:json": "npx tsx test/continuous-test-suite-json.ts",
+    "test:json-e2e": "npx tsx test/continuous-test-suite-json-e2e.ts",
     "test:workflow": "npx tsx test/continuous-test-suite-workflow.ts",
     "test:hitl": "npx tsx test/continuous-test-suite-hitl.ts",
     "test:tasks": "npx tsx test/continuous-test-suite-tasks.ts",
@@ -294,6 +296,11 @@
       "types": "./dist/adapters/*.d.ts",
       "import": "./dist/adapters/*.js",
       "default": "./dist/adapters/*.js"
+    },
+    "./livekit": {
+      "types": "./dist/voice/livekit/index.d.ts",
+      "import": "./dist/voice/livekit/index.js",
+      "default": "./dist/voice/livekit/index.js"
     }
   },
   "dependencies": {
@@ -332,10 +339,11 @@
     "dotenv": "^17.3.1",
     "eventsource-parser": "^3.0.8",
     "google-auth-library": "^10.6.1",
-    "hono": "^4.12.3",
+    "hono": "^4.12.21",
     "inquirer": "^13.3.0",
     "jose": "^6.1.3",
     "json-schema-to-zod": "^2.7.0",
+    "jsonrepair": "^3.14.0",
     "nanoid": "^5.1.5",
     "open": "^11.0.0",
     "ora": "^9.3.0",
@@ -343,7 +351,7 @@
     "redis": "^5.11.0",
     "tar-stream": "^3.1.8",
     "undici": ">=7.22.0",
-    "ws": "^8.19.0",
+    "ws": "^8.20.1",
     "yargs": "^18.0.0",
     "zod": "^4.3.6",
     "zod-to-json-schema": "^3.25.1"
@@ -370,10 +378,18 @@
     "@aws-sdk/client-sagemaker": "^3.1000.0",
     "@fastify/cors": "^11.2.0",
     "@fastify/rate-limit": "^10.3.0",
-    "@hono/node-server": "^1.19.9",
+    "@hono/node-server": "^1.19.13",
     "@koa/cors": "^5.0.0",
     "@koa/router": "^15.3.1",
     "@langfuse/otel": "^5.0.1",
+    "@livekit/agents": "^1.4.5",
+    "@livekit/agents-plugin-cartesia": "^1.4.5",
+    "@livekit/agents-plugin-deepgram": "^1.4.5",
+    "@livekit/agents-plugin-elevenlabs": "^1.4.5",
+    "@livekit/agents-plugin-livekit": "^1.4.5",
+    "@livekit/agents-plugin-silero": "^1.4.5",
+    "@livekit/agents-plugin-soniox": "^1.4.5",
+    "@livekit/rtc-node": "^0.13.29",
     "@picovoice/cobra-node": "^3.0.2",
     "bullmq": "^5.52.2",
     "cors": "^2.8.5",
@@ -385,6 +401,7 @@
     "fluent-ffmpeg": "^2.1.3",
     "koa": "^3.1.1",
     "koa-bodyparser": "^4.4.1",
+    "livekit-server-sdk": "^2.15.4",
     "mammoth": "^1.11.0",
     "mediabunny": "^1.40.1",
     "music-metadata": "^11.11.2",
@@ -449,7 +466,7 @@
     "react-dom": "^19.2.4",
     "semantic-release": "^25.0.3",
     "shell-quote": "^1.8.3",
-    "svelte": "^5.53.6",
+    "svelte": "^5.55.7",
     "svelte-check": "^4.4.4",
     "ts-morph": "^24.0.0",
     "tslib": "^2.8.1",
@@ -457,7 +474,7 @@
     "typedoc": "^0.28.17",
     "typedoc-plugin-markdown": "^4.10.0",
     "typescript": "^5.9.3",
-    "vite": "^8.0.1",
+    "vite": "^8.0.5",
     "vitest": "^4.1.0",
     "why-is-node-running": "^3.2.2"
   },