@mastra/livekit 0.0.0-esbuild-bundle-worker-20260807173433

package/dist/worker-entry.js

@@ -0,0 +1,675 @@
+import { r as parseSessionMetadata, t as createWorkflowReplyGenerator } from "./workflow-generator-BtfClQcM.js";
+import { i as chatContextToMessages, r as createMastraVoiceAgent, t as createRemoteAgentReplyGenerator } from "./remote-C9K3UzKv.js";
+import { randomUUID } from "crypto";
+import { InferenceRunner, ServerOptions, cli, defineAgent, metrics, voice } from "@livekit/agents";
+import { RequestContext } from "@mastra/core/request-context";
+import { SpanType, getOrCreateSpan } from "@mastra/core/observability";
+import { fileURLToPath } from "url";
+//#region src/observability.ts
+function modelMeta(metadata) {
+	const out = {};
+	if (metadata?.modelProvider) out.modelProvider = metadata.modelProvider;
+	if (metadata?.modelName) out.modelName = metadata.modelName;
+	return out;
+}
+const ms = (n) => `${Math.round(n)}ms`;
+const secs = (n) => `${(n / 1e3).toFixed(1)}s`;
+/**
+* Maps a LiveKit pipeline metric to an event-span name and the latency/usage fields worth
+* recording. The name carries the headline number so it reads in the trace timeline without
+* opening the span. Metrics this release does not surface (interruption, EOT inference, avatar)
+* return `undefined` — they still feed the session usage roll-up via the ModelUsageCollector.
+*/
+function describeMetric(metric) {
+	switch (metric.type) {
+		case "eou_metrics": return {
+			name: `eou ${ms(metric.endOfUtteranceDelayMs)}`,
+			data: {
+				endOfUtteranceDelayMs: metric.endOfUtteranceDelayMs,
+				transcriptionDelayMs: metric.transcriptionDelayMs,
+				onUserTurnCompletedDelayMs: metric.onUserTurnCompletedDelayMs
+			}
+		};
+		case "stt_metrics": return {
+			name: `stt ${secs(metric.audioDurationMs)}`,
+			data: {
+				audioDurationMs: metric.audioDurationMs,
+				durationMs: metric.durationMs,
+				streamed: metric.streamed,
+				...modelMeta(metric.metadata)
+			}
+		};
+		case "llm_metrics": return {
+			name: `llm ttft ${ms(metric.ttftMs)}`,
+			data: {
+				ttftMs: metric.ttftMs,
+				durationMs: metric.durationMs,
+				tokensPerSecond: metric.tokensPerSecond,
+				promptTokens: metric.promptTokens,
+				completionTokens: metric.completionTokens,
+				totalTokens: metric.totalTokens,
+				cancelled: metric.cancelled,
+				...modelMeta(metric.metadata)
+			}
+		};
+		case "tts_metrics": return {
+			name: `tts ttfb ${ms(metric.ttfbMs)}`,
+			data: {
+				ttfbMs: metric.ttfbMs,
+				durationMs: metric.durationMs,
+				audioDurationMs: metric.audioDurationMs,
+				charactersCount: metric.charactersCount,
+				cancelled: metric.cancelled,
+				streamed: metric.streamed,
+				...modelMeta(metric.metadata)
+			}
+		};
+		case "vad_metrics": return {
+			name: "vad",
+			data: {
+				idleTimeMs: metric.idleTimeMs,
+				inferenceCount: metric.inferenceCount,
+				inferenceDurationTotalMs: metric.inferenceDurationTotalMs
+			}
+		};
+		case "realtime_model_metrics": return {
+			name: `realtime ttft ${ms(metric.ttftMs)}`,
+			data: {
+				ttftMs: metric.ttftMs,
+				durationMs: metric.durationMs,
+				tokensPerSecond: metric.tokensPerSecond,
+				promptTokens: metric.inputTokens,
+				completionTokens: metric.outputTokens,
+				totalTokens: metric.totalTokens,
+				...modelMeta(metric.metadata)
+			}
+		};
+		default: return;
+	}
+}
+/**
+* Opens a `voice call` trace for one LiveKit session and bridges LiveKit's voice-pipeline
+* metrics into Mastra observability.
+*
+* The returned root span groups everything about the call: each conversation turn's Mastra
+* agent run (nested via {@link VoiceCallObservability.tracingContext}) plus an event span for
+* every STT, TTS, end-of-utterance, VAD, and LLM-latency metric LiveKit emits. Metrics are
+* point-in-time, so they're recorded as event spans (no duration) with the value in the name.
+* The root closes on the session `close` event with a per-model usage roll-up (token, character,
+* and audio totals for the whole call) from a `ModelUsageCollector`.
+*
+* Returns `undefined` when the Mastra instance has no observability configured, so callers
+* can treat instrumentation as a no-op without branching on config.
+*/
+function startVoiceCallObservability(options) {
+	const span = getOrCreateSpan({
+		mastra: options.mastra,
+		type: SpanType.GENERIC,
+		name: "voice call",
+		requestContext: options.requestContext,
+		metadata: {
+			agentId: options.agentId,
+			roomName: options.roomName,
+			...options.metadata.threadId ? { threadId: options.metadata.threadId } : {},
+			...options.metadata.resourceId ? { resourceId: options.metadata.resourceId } : {}
+		}
+	});
+	if (!span) return void 0;
+	const usage = new metrics.ModelUsageCollector();
+	let finalized = false;
+	const finalize = (opts) => {
+		if (finalized) return;
+		finalized = true;
+		const summary = usage.flatten();
+		if (opts?.error) span.error({
+			error: opts.error instanceof Error ? opts.error : new Error(String(opts.error)),
+			metadata: { usage: summary }
+		});
+		else span.end({ output: { usage: summary } });
+	};
+	return {
+		span,
+		tracingContext: { currentSpan: span },
+		attach(session) {
+			session.on(voice.AgentSessionEventTypes.MetricsCollected, (event) => {
+				usage.collect(event.metrics);
+				const described = describeMetric(event.metrics);
+				if (!described) return;
+				span.createEventSpan({
+					type: SpanType.GENERIC,
+					name: described.name,
+					output: described.data
+				});
+			});
+			session.on(voice.AgentSessionEventTypes.Close, (event) => {
+				finalize({ error: event?.error ?? void 0 });
+			});
+		},
+		finalize
+	};
+}
+//#endregion
+//#region src/voice-thread.ts
+/**
+* Creates the call's memory thread up front when it doesn't exist yet, titled and tagged
+* so it reads as a voice call in Studio's thread list instead of an untitled thread that
+* only appears after the first exchange.
+*/
+async function ensureVoiceCallThread({ memory, threadId, resourceId, roomName }) {
+	if (await memory.getThreadById({ threadId })) return;
+	await memory.createThread({
+		threadId,
+		resourceId,
+		title: "Voice call",
+		metadata: {
+			source: "livekit",
+			roomName
+		}
+	});
+}
+/**
+* Persists the spoken greeting as an assistant message. The greeting is spoken via TTS
+* without going through the Mastra agent, so without this the saved thread would start
+* at the caller's first words instead of being a faithful call transcript.
+*/
+async function persistSpokenGreeting({ memory, threadId, resourceId, greeting }) {
+	if (!greeting.trim()) return;
+	const message = {
+		id: randomUUID(),
+		role: "assistant",
+		type: "text",
+		createdAt: /* @__PURE__ */ new Date(),
+		threadId,
+		resourceId,
+		content: {
+			format: 2,
+			parts: [{
+				type: "text",
+				text: greeting
+			}],
+			metadata: {
+				source: "voice",
+				kind: "greeting"
+			}
+		}
+	};
+	await memory.saveMessages({ messages: [message] });
+}
+//#endregion
+//#region src/worker-setup.ts
+/**
+* Coordination between worker definition and worker startup. LiveKit plugins register
+* their inference runners at module-import time, and the AgentServer only spawns the
+* inference process for runners registered before it starts — so plugin imports kicked
+* off by `createLiveKitWorker()` must complete before `runLiveKitWorker()` boots the
+* server.
+*/
+const pendingSetup = [];
+const requestedEouMethods = /* @__PURE__ */ new Set();
+function queueWorkerSetup(setup) {
+	pendingSetup.push(setup);
+}
+function workerSetupComplete() {
+	return Promise.allSettled(pendingSetup);
+}
+function requestEouMethod(method) {
+	requestedEouMethods.add(method);
+}
+function isEouMethodRequested(method) {
+	return requestedEouMethods.has(method);
+}
+//#endregion
+//#region src/worker.ts
+const EOU_METHODS = {
+	english: "lk_end_of_utterance_en",
+	multilingual: "lk_end_of_utterance_multilingual"
+};
+async function loadSileroVad() {
+	let silero;
+	try {
+		silero = await import("@livekit/agents-plugin-silero");
+	} catch (error) {
+		throw new Error("@mastra/livekit: voice activity detection requires '@livekit/agents-plugin-silero'. Install it, pass your own `vad` instance, or set `vad: false`.", { cause: error });
+	}
+	return silero.VAD.load();
+}
+async function loadTurnDetector(kind) {
+	let plugin;
+	try {
+		plugin = await import("@livekit/agents-plugin-livekit");
+	} catch (error) {
+		throw new Error(`@mastra/livekit: turnDetection '${kind}' requires '@livekit/agents-plugin-livekit'. Install it or use a built-in mode like 'vad' or 'stt'.`, { cause: error });
+	}
+	return kind === "english" ? new plugin.turnDetector.EnglishModel() : new plugin.turnDetector.MultilingualModel();
+}
+async function resolveMastraAgent(options, args) {
+	let ref = typeof options.agent === "function" ? await options.agent(args) : options.agent;
+	ref ??= args.metadata.agentId;
+	if (!ref) throw new Error("@mastra/livekit: no Mastra agent specified. Set `agent` on createLiveKitWorker or pass `agentId` in the dispatch metadata (e.g. via liveKitConnectionRoute).");
+	if (typeof ref !== "string") return ref;
+	try {
+		return options.mastra.getAgentById(ref);
+	} catch {
+		return options.mastra.getAgent(ref);
+	}
+}
+async function resolveWorkflow(options, args) {
+	const resolver = options.workflow;
+	const ref = typeof resolver === "function" ? await resolver(args) : resolver ?? "";
+	if (!ref) throw new Error("@mastra/livekit: no workflow specified. Set `workflow` on createLiveKitWorker.");
+	if (typeof ref !== "string") return { workflow: ref };
+	return { workflow: options.mastra.getWorkflowById(ref) };
+}
+function resolveMemory(options, mastraAgent, args, roomName) {
+	if (options.memory === false) return false;
+	if (typeof options.memory === "function") return options.memory({
+		...args,
+		roomName
+	});
+	if (mastraAgent && !mastraAgent.hasOwnMemory()) return false;
+	const thread = args.metadata.threadId ?? roomName;
+	return {
+		thread,
+		resource: args.metadata.resourceId ?? thread
+	};
+}
+async function resolveMemoryInstance(options, mastraAgent, args, requestContext) {
+	if (mastraAgent) return await mastraAgent.getMemory({ requestContext }) ?? null;
+	const resolver = options.memoryInstance;
+	if (!resolver) return null;
+	const instance = typeof resolver === "function" ? await resolver(args) : resolver;
+	if (!instance) return null;
+	instance.__registerMastra(options.mastra);
+	if (!instance.hasOwnStorage) {
+		const storage = options.mastra.getStorage();
+		if (storage) instance.setStorage(storage);
+	}
+	return instance;
+}
+function buildTurnHandling(options, turnDetection) {
+	return {
+		...turnDetection ? { turnDetection } : {},
+		preemptiveGeneration: { enabled: false },
+		...options.turnHandling
+	};
+}
+async function resolveInstructions(mastraAgent, requestContext) {
+	try {
+		const instructions = await mastraAgent.getInstructions({ requestContext });
+		return typeof instructions === "string" ? instructions : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* Resolves the effective greeting from the canonical `configuration.greeting` and the deprecated
+* top-level `greeting` / `persistGreeting` options. The legacy options are the base so existing
+* worker configs keep working unchanged; `configuration.greeting` overrides field-by-field. Exported
+* for unit testing.
+*/
+function resolveGreetingConfig(options) {
+	return {
+		text: options.greeting,
+		persist: options.persistGreeting,
+		...options.configuration?.greeting
+	};
+}
+/**
+* Resolves the greeting text for a call: returns a fixed string as-is, or invokes the resolver form
+* with the call context to produce a per-tenant greeting. Empty / whitespace-nothing results
+* normalize to `undefined` (no greeting). Exported for unit testing.
+*/
+async function resolveGreetingText(text, context) {
+	return (typeof text === "function" ? await text(context) : text) || void 0;
+}
+/**
+* Resolves a per-call session component (STT / TTS): invokes the `configuration` resolver with the
+* call context, falling back to the static top-level option when there is no resolver or it
+* resolves to `undefined`. Exported for unit testing.
+*/
+async function resolveSessionComponent(resolver, fallback, context) {
+	return (resolver ? await resolver(context) : void 0) ?? fallback;
+}
+/**
+* Speaks the session's opening greeting, honoring the interruption / playout options. Takes the
+* already-resolved greeting (see {@link resolveGreetingText}) and returns the LiveKit `SpeechHandle`,
+* or `undefined` when there is no greeting text. Extracted and exported so the greeting behavior is
+* unit-testable without a live room.
+*/
+async function speakGreeting(session, greeting) {
+	if (!greeting.text) return void 0;
+	const handle = session.say(greeting.text, greeting.allowInterruptions === void 0 ? void 0 : { allowInterruptions: greeting.allowInterruptions });
+	if (greeting.awaitPlayout) await handle.waitForPlayout().catch(() => {});
+	return handle;
+}
+/** Default tool name the worker watches for to end the call. Matches `createEndCallTool`'s default. */
+const DEFAULT_END_CALL_TOOL = "endCall";
+/** Default shutdown reason recorded when the agent ends the call. */
+const DEFAULT_END_CALL_REASON = "agent ended call";
+/** Default safety cap on waiting for the agent's closing words to finish before hanging up. */
+const DEFAULT_END_CALL_MAX_WAIT_MS = 3e4;
+/**
+* Default post-playout drain before the room is deleted. LiveKit's "playout completed" is
+* worker-local; the caller's client still holds network + jitter-buffer audio, so hanging up the
+* instant the state clears clips the tail of the goodbye.
+*/
+const DEFAULT_END_CALL_DRAIN_MS = 800;
+/** Agent states where the agent is still busy producing / playing a reply (not done speaking). */
+const AGENT_BUSY_STATES = /* @__PURE__ */ new Set(["thinking", "speaking"]);
+/**
+* Resolves once the agent is no longer producing or playing a reply — i.e. its state has left
+* `thinking`/`speaking` for `listening`/`idle`. Returns immediately when it's already idle. A
+* `maxWaitMs` safety cap guarantees it resolves even if the speaking state never clears. Used before
+* an agent-initiated hang-up so the closing words play out fully instead of being cut off by the
+* session close. Exported for unit testing.
+*/
+function waitForAgentDoneSpeaking(session, maxWaitMs = DEFAULT_END_CALL_MAX_WAIT_MS) {
+	if (!AGENT_BUSY_STATES.has(session.agentState)) return Promise.resolve();
+	return new Promise((resolve) => {
+		let timer;
+		const onChange = (ev) => {
+			if (AGENT_BUSY_STATES.has(ev.newState)) return;
+			cleanup();
+			resolve();
+		};
+		const cleanup = () => {
+			session.off(voice.AgentSessionEventTypes.AgentStateChanged, onChange);
+			if (timer) clearTimeout(timer);
+		};
+		session.on(voice.AgentSessionEventTypes.AgentStateChanged, onChange);
+		timer = setTimeout(() => {
+			cleanup();
+			resolve();
+		}, maxWaitMs);
+		timer.unref?.();
+	});
+}
+/**
+* Ends the call after the agent asked to (via its end-call tool): wait for the agent's closing words
+* to finish, speak an optional final `message`, hold a short drain (`drainMs`) so audio buffered at
+* the caller finishes playing, then disconnect. The teardown's session close
+* force-interrupts any playing speech, so the waits here MUST complete before we disconnect — that's
+* the whole point of the sequence. `ctx.deleteRoom()` hangs up the caller (SIP-safe); `ctx.shutdown()`
+* ends the job and runs the registered shutdown callbacks (`onCallEnd`), so end-of-call work happens
+* exactly as it does on a caller hang-up. Both run in a `finally` so a hiccup while waiting still ends
+* the call. Never rejects — every step is guarded and failures are logged, so callers can safely
+* fire-and-forget it (`void runEndCall(...)`) from hooks. Exported for unit testing.
+*/
+async function runEndCall(session, ctx, config, logger) {
+	try {
+		await waitForAgentDoneSpeaking(session, config.maxWaitMs ?? 3e4);
+		if (config.message) await session.say(config.message, { allowInterruptions: false }).waitForPlayout().catch(() => {});
+		const drainMs = config.drainMs ?? 800;
+		if (drainMs > 0) await new Promise((resolve) => setTimeout(resolve, drainMs));
+	} catch (error) {
+		logger.warn("@mastra/livekit: waiting for the agent to finish before ending the call failed", error);
+	} finally {
+		try {
+			await ctx.deleteRoom();
+		} catch (error) {
+			logger.warn("@mastra/livekit: deleteRoom while ending the call failed", error);
+		}
+		try {
+			ctx.shutdown(config.reason ?? "agent ended call");
+		} catch (error) {
+			logger.warn("@mastra/livekit: shutdown while ending the call failed", error);
+		}
+	}
+}
+/**
+* Builds the per-turn hook that detects the agent's end-call tool and kicks off the hang-up once, or
+* `undefined` when end-call isn't configured. The detector fires the teardown fire-and-forget (the
+* turn never waits on it) and de-dupes so a repeated tool call can't start two hang-ups.
+*/
+function buildEndCallDetector(config, getSession, ctx, logger) {
+	if (!config) return void 0;
+	const toolName = config.tool ?? "endCall";
+	let triggered = false;
+	return (turnCtx) => {
+		if (triggered) return;
+		if (!turnCtx.result.toolCalls.some((call) => call.toolName === toolName)) return;
+		const session = getSession();
+		if (!session) return;
+		triggered = true;
+		runEndCall(session, ctx, config, logger);
+	};
+}
+/** Runs the worker's own turn-complete detector alongside the user's `onTurnComplete`, if any. */
+function composeTurnComplete(user, detector) {
+	if (!detector) return user;
+	return (ctx) => {
+		detector(ctx);
+		return user?.(ctx);
+	};
+}
+/**
+* Builds a LiveKit agent worker definition that answers voice sessions with Mastra agents.
+*
+* Use as the default export of your worker entry file, then run it with the LiveKit
+* agents CLI:
+*
+* ```ts
+* // src/mastra/voice-worker.ts
+* import { fileURLToPath } from 'node:url';
+* import { createLiveKitWorker, runLiveKitWorker } from '@mastra/livekit/worker';
+* import { mastra } from './index';
+*
+* export default createLiveKitWorker({
+*   mastra,
+*   stt: 'deepgram/nova-3',
+*   tts: 'cartesia/sonic-3',
+*   turnDetection: 'multilingual',
+* });
+*
+* if (process.argv[1] === fileURLToPath(import.meta.url)) {
+*   runLiveKitWorker({ entry: import.meta.url, agentName: 'mastra-voice' });
+* }
+* ```
+*/
+function createLiveKitWorker(options) {
+	if (options.generate && (options.agent || options.workflow)) throw new Error("@mastra/livekit: set exactly one reply generator — `generate`, `agent`, or `workflow` — not a combination.");
+	if (options.agent && options.workflow) throw new Error("@mastra/livekit: set `agent` or `workflow`, not both — they are mutually exclusive reply generators.");
+	if (options.workflow && !options.workflowInput) throw new Error("@mastra/livekit: `workflowInput` is required when `workflow` is set. Map the turn into the workflow inputData, e.g. workflowInput: ({ chatCtx }) => ({ history: chatContextToMessages(chatCtx) }).");
+	if (options.generate && options.configuration?.endCall) throw new Error("@mastra/livekit: `configuration.endCall` has no effect with `generate` — the worker cannot observe tool calls from a custom reply generator. Detect the end-call tool inside your generator and call `runEndCall` directly instead.");
+	const wantsSileroVad = options.vad === void 0 || options.vad === "silero";
+	if (options.turnDetection === "multilingual" || options.turnDetection === "english") {
+		requestEouMethod(EOU_METHODS[options.turnDetection]);
+		queueWorkerSetup(import("@livekit/agents-plugin-livekit").then(() => {
+			for (const method of Object.values(EOU_METHODS)) if (!isEouMethodRequested(method)) delete InferenceRunner.registeredRunners[method];
+		}).catch(() => {}));
+	}
+	return defineAgent({
+		prewarm: async (proc) => {
+			if (wantsSileroVad) proc.userData.vad = await loadSileroVad();
+		},
+		entry: async (ctx) => {
+			const logger = options.mastra.getLogger();
+			const metadata = parseSessionMetadata(ctx.job.metadata);
+			const args = {
+				metadata,
+				ctx
+			};
+			const requestContext = metadata.requestContext ? new RequestContext(Object.entries(metadata.requestContext)) : void 0;
+			const endCallDetector = buildEndCallDetector(options.configuration?.endCall, () => session, ctx, logger);
+			const onTurnComplete = composeTurnComplete(options.onTurnComplete, endCallDetector);
+			let mastraAgent;
+			let replyGenerator;
+			let agentLabel;
+			if (options.generate) {
+				replyGenerator = options.generate;
+				agentLabel = "mastra-voice";
+			} else if (options.workflow) {
+				const { workflow } = await resolveWorkflow(options, args);
+				agentLabel = workflow.id;
+				const mapInput = options.workflowInput;
+				replyGenerator = createWorkflowReplyGenerator({
+					workflow,
+					workflowInput: (turnCtx) => mapInput({
+						...turnCtx,
+						metadata
+					}),
+					replyStep: options.replyStep,
+					resultText: options.resultText,
+					toolFeedback: options.toolFeedback,
+					onTurnComplete
+				});
+			} else {
+				mastraAgent = await resolveMastraAgent(options, args);
+				agentLabel = mastraAgent.id ?? mastraAgent.name;
+			}
+			await ctx.connect();
+			const roomName = ctx.room.name ?? "mastra-voice";
+			let vad;
+			if (options.vad && options.vad !== "silero") vad = options.vad;
+			else if (wantsSileroVad) vad = ctx.proc.userData.vad ?? await loadSileroVad();
+			let turnDetection;
+			if (options.turnDetection === "multilingual" || options.turnDetection === "english") turnDetection = await loadTurnDetector(options.turnDetection);
+			else turnDetection = options.turnDetection;
+			const memory = resolveMemory(options, mastraAgent, args, roomName);
+			const memoryInstance = memory ? await resolveMemoryInstance(options, mastraAgent, args, requestContext) : null;
+			if (memory && memoryInstance) try {
+				await ensureVoiceCallThread({
+					memory: memoryInstance,
+					threadId: memory.thread,
+					resourceId: memory.resource ?? memory.thread,
+					roomName
+				});
+			} catch (error) {
+				logger.warn("@mastra/livekit: failed to create the voice call thread", error);
+			}
+			const voiceObs = options.observability === false ? void 0 : startVoiceCallObservability({
+				mastra: options.mastra,
+				agentId: agentLabel,
+				roomName,
+				metadata,
+				requestContext
+			});
+			if (voiceObs) ctx.addShutdownCallback(async () => {
+				voiceObs.finalize();
+			});
+			if (options.onCallEnd) {
+				const onCallEnd = options.onCallEnd;
+				ctx.addShutdownCallback(async () => {
+					try {
+						await onCallEnd({
+							memory,
+							memoryInstance,
+							metadata,
+							requestContext,
+							configuration: options.configuration,
+							roomName,
+							ctx
+						});
+					} catch (error) {
+						logger.warn("@mastra/livekit: onCallEnd hook threw", error);
+					}
+				});
+			}
+			const greetingConfig = resolveGreetingConfig(options);
+			const greetingReminder = greetingConfig.repeatEvery && greetingConfig.repeatEvery > 0 ? {
+				everyMs: greetingConfig.repeatEvery,
+				text: greetingConfig.repeatText
+			} : void 0;
+			const agent = createMastraVoiceAgent({
+				...replyGenerator ? { generate: replyGenerator } : { agent: mastraAgent },
+				instructions: mastraAgent ? await resolveInstructions(mastraAgent, requestContext) : void 0,
+				memory,
+				requestContext,
+				toolFeedback: options.toolFeedback,
+				onTurnComplete,
+				greetingReminder,
+				streamOptions: voiceObs ? { tracingContext: voiceObs.tracingContext } : void 0
+			});
+			const callContext = {
+				metadata,
+				requestContext,
+				roomName,
+				ctx
+			};
+			const [stt, tts] = await Promise.all([resolveSessionComponent(options.configuration?.stt, options.stt, callContext), resolveSessionComponent(options.configuration?.tts, options.tts, callContext)]);
+			const session = new voice.AgentSession({
+				stt,
+				tts,
+				vad,
+				turnHandling: buildTurnHandling(options, turnDetection),
+				...options.sessionOptions
+			});
+			voiceObs?.attach(session);
+			try {
+				await session.start({
+					agent,
+					room: ctx.room,
+					inputOptions: options.inputOptions,
+					outputOptions: options.outputOptions
+				});
+				if (greetingConfig.text) {
+					const greetingText = await resolveGreetingText(greetingConfig.text, callContext);
+					if (greetingText) {
+						await speakGreeting(session, {
+							...greetingConfig,
+							text: greetingText
+						});
+						if (greetingConfig.persist !== false && memory && memoryInstance) try {
+							await persistSpokenGreeting({
+								memory: memoryInstance,
+								threadId: memory.thread,
+								resourceId: memory.resource ?? memory.thread,
+								greeting: greetingText
+							});
+						} catch (error) {
+							logger.warn("@mastra/livekit: failed to persist the greeting", error);
+						}
+					}
+				}
+				await options.onSessionStart?.({
+					session,
+					ctx,
+					agent,
+					metadata
+				});
+			} catch (error) {
+				voiceObs?.finalize({ error });
+				throw error;
+			}
+		}
+	});
+}
+//#endregion
+//#region src/run.ts
+function resolveWorkerEntryPath(entry) {
+	if (entry instanceof URL) return fileURLToPath(entry);
+	return entry.startsWith("file:") ? fileURLToPath(entry) : entry;
+}
+/**
+* Starts the LiveKit agent worker CLI (`dev` / `start` / `connect` subcommands) for a
+* worker entry file. Call it from the same file that default-exports
+* {@link createLiveKitWorker}, guarded so it only runs when executed directly:
+*
+* ```ts
+* import { fileURLToPath } from 'node:url';
+* import { createLiveKitWorker, runLiveKitWorker } from '@mastra/livekit/worker';
+* import { mastra } from './index';
+*
+* export default createLiveKitWorker({ mastra, agent: 'support' });
+*
+* if (process.argv[1] === fileURLToPath(import.meta.url)) {
+*   runLiveKitWorker({ entry: import.meta.url, agentName: 'mastra-voice' });
+* }
+* ```
+*
+* Using this helper (instead of `cli.runApp` from `@livekit/agents`) guarantees the worker
+* runtime and the bridge share one copy of the LiveKit SDK.
+*/
+function runLiveKitWorker(options) {
+	workerSetupComplete().then(() => {
+		cli.runApp(new ServerOptions({
+			agent: resolveWorkerEntryPath(options.entry),
+			agentName: options.agentName ?? "mastra-voice",
+			...options.serverOptions
+		}));
+	});
+}
+//#endregion
+export { DEFAULT_END_CALL_DRAIN_MS, DEFAULT_END_CALL_MAX_WAIT_MS, DEFAULT_END_CALL_REASON, DEFAULT_END_CALL_TOOL, chatContextToMessages, createLiveKitWorker, createRemoteAgentReplyGenerator, runEndCall, runLiveKitWorker, speakGreeting, waitForAgentDoneSpeaking };
+
+//# sourceMappingURL=worker-entry.js.map