@mastra/livekit 0.3.0 → 0.3.1-alpha.0

package/dist/worker-entry.js

@@ -1,586 +1,675 @@
-import { parseSessionMetadata, createWorkflowReplyGenerator, DEFAULT_LIVEKIT_AGENT_NAME } from './chunk-2E3MTAOA.js';
-import { createMastraVoiceAgent } from './chunk-4O7IN74Y.js';
-export { chatContextToMessages, createRemoteAgentReplyGenerator } from './chunk-4O7IN74Y.js';
-import { voice, InferenceRunner, defineAgent, cli, ServerOptions, metrics } from '@livekit/agents';
-import { RequestContext } from '@mastra/core/request-context';
-import { getOrCreateSpan, SpanType } from '@mastra/core/observability';
-import { randomUUID } from 'crypto';
-import { fileURLToPath } from 'url';
-
+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 out = {};
+	if (metadata?.modelProvider) out.modelProvider = metadata.modelProvider;
+	if (metadata?.modelName) out.modelName = metadata.modelName;
+	return out;
 }
-var ms = (n) => `${Math.round(n)}ms`;
-var secs = (n) => `${(n / 1e3).toFixed(1)}s`;
+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 void 0;
-  }
+	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
-  };
+	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
+	};
 }
-async function ensureVoiceCallThread({
-  memory,
-  threadId,
-  resourceId,
-  roomName
-}) {
-  const existing = await memory.getThreadById({ threadId });
-  if (existing) return;
-  await memory.createThread({
-    threadId,
-    resourceId,
-    title: "Voice call",
-    metadata: { source: "livekit", roomName }
-  });
+//#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
+		}
+	});
 }
-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] });
+/**
+* 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] });
 }
-
-// src/worker-setup.ts
-var pendingSetup = [];
-var requestedEouMethods = /* @__PURE__ */ new Set();
+//#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);
+	pendingSetup.push(setup);
 }
 function workerSetupComplete() {
-  return Promise.allSettled(pendingSetup);
+	return Promise.allSettled(pendingSetup);
 }
 function requestEouMethod(method) {
-  requestedEouMethods.add(method);
+	requestedEouMethods.add(method);
 }
 function isEouMethodRequested(method) {
-  return requestedEouMethods.has(method);
+	return requestedEouMethods.has(method);
 }
-
-// src/worker.ts
-var EOU_METHODS = {
-  english: "lk_end_of_utterance_en",
-  multilingual: "lk_end_of_utterance_multilingual"
+//#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();
+	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();
+	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);
-  }
+	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) };
+	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 };
+	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;
+	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 } : {},
-    // Preemptive generation re-runs the Mastra agent on interim transcripts (up to 3
-    // times per turn), and every run persists the user message to the memory thread —
-    // duplicating and even saving partial transcripts. Off by default; opt back in via
-    // `turnHandling.preemptiveGeneration` if the latency win matters more than exact
-    // thread history.
-    preemptiveGeneration: { enabled: false },
-    ...options.turnHandling
-  };
+	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 void 0;
-  }
+	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
-  };
+	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) {
-  const resolved = typeof text === "function" ? await text(context) : text;
-  return resolved || void 0;
+	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) {
-  const resolved = resolver ? await resolver(context) : void 0;
-  return resolved ?? fallback;
+	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;
+	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;
 }
-var DEFAULT_END_CALL_TOOL = "endCall";
-var DEFAULT_END_CALL_REASON = "agent ended call";
-var DEFAULT_END_CALL_MAX_WAIT_MS = 3e4;
-var DEFAULT_END_CALL_DRAIN_MS = 800;
-var AGENT_BUSY_STATES = /* @__PURE__ */ new Set(["thinking", "speaking"]);
+/** 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?.();
-  });
+	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 ?? DEFAULT_END_CALL_MAX_WAIT_MS);
-    if (config.message) {
-      await session.say(config.message, { allowInterruptions: false }).waitForPlayout().catch(() => {
-      });
-    }
-    const drainMs = config.drainMs ?? DEFAULT_END_CALL_DRAIN_MS;
-    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 ?? DEFAULT_END_CALL_REASON);
-    } catch (error) {
-      logger.warn("@mastra/livekit: shutdown while ending the call failed", error);
-    }
-  }
+	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 ?? DEFAULT_END_CALL_TOOL;
-  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;
-    void runEndCall(session, ctx, config, 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) => {
-    void detector(ctx);
-    return user?.(ctx);
-  };
+	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 \u2014 `generate`, `agent`, or `workflow` \u2014 not a combination."
-    );
-  }
-  if (options.agent && options.workflow) {
-    throw new Error(
-      "@mastra/livekit: set `agent` or `workflow`, not both \u2014 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` \u2014 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;
-      }
-    }
-  });
+	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;
+	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) {
-  void workerSetupComplete().then(() => {
-    cli.runApp(
-      new ServerOptions({
-        agent: resolveWorkerEntryPath(options.entry),
-        agentName: options.agentName ?? DEFAULT_LIVEKIT_AGENT_NAME,
-        ...options.serverOptions
-      })
-    );
-  });
+	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 };
 
-export { DEFAULT_END_CALL_DRAIN_MS, DEFAULT_END_CALL_MAX_WAIT_MS, DEFAULT_END_CALL_REASON, DEFAULT_END_CALL_TOOL, createLiveKitWorker, runEndCall, runLiveKitWorker, speakGreeting, waitForAgentDoneSpeaking };
-//# sourceMappingURL=worker-entry.js.map
 //# sourceMappingURL=worker-entry.js.map