@mastra/livekit 0.2.0 → 0.3.0

package/dist/worker-entry.js

@@ -1,201 +1,12 @@
 import { parseSessionMetadata, createWorkflowReplyGenerator, DEFAULT_LIVEKIT_AGENT_NAME } from './chunk-2E3MTAOA.js';
-import { InferenceRunner, defineAgent, voice, cli, ServerOptions, metrics, llm } from '@livekit/agents';
+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 { ReadableStream } from 'stream/web';
 import { getOrCreateSpan, SpanType } from '@mastra/core/observability';
 import { randomUUID } from 'crypto';
 import { fileURLToPath } from 'url';
 
-// src/messages.ts
-function textOfMessage(message) {
-  const parts = [];
-  for (const part of message.content) {
-    if (typeof part === "string") {
-      parts.push(part);
-    } else if (part.type === "instructions") {
-      parts.push(part.value);
-    } else if (part.type === "audio_content" && part.transcript) {
-      parts.push(part.transcript);
-    }
-  }
-  return parts.join("\n").trim();
-}
-function toVoiceTurnMessage(item) {
-  if (item.type !== "message") return void 0;
-  const content = textOfMessage(item);
-  if (!content) return void 0;
-  if (item.role === "user") return { role: "user", content };
-  if (item.role === "assistant") return { role: "assistant", content };
-  return { role: "system", content };
-}
-function extractNewTurnMessages(chatCtx) {
-  const items = chatCtx.items;
-  let lastAssistantIdx = -1;
-  for (let i = items.length - 1; i >= 0; i--) {
-    const item = items[i];
-    if (item?.type === "message" && item.role === "assistant") {
-      lastAssistantIdx = i;
-      break;
-    }
-  }
-  const messages = [];
-  for (const item of items.slice(lastAssistantIdx + 1)) {
-    const message = toVoiceTurnMessage(item);
-    if (message) messages.push(message);
-  }
-  return messages;
-}
-function chatContextToMessages(chatCtx) {
-  const withoutInstructions = chatCtx.copy({ excludeInstructions: true, excludeFunctionCall: true });
-  const messages = [];
-  for (const item of withoutInstructions.items) {
-    const message = toVoiceTurnMessage(item);
-    if (message) messages.push(message);
-  }
-  return messages;
-}
-
-// src/bridge.ts
-var DEFAULT_INSTRUCTIONS = "You are a helpful voice assistant powered by a Mastra agent.";
-function createAgentReplyGenerator(options) {
-  const { agent, streamOptions, toolFeedback, onTurnComplete } = options;
-  return (ctx) => {
-    if (ctx.messages.length === 0) return null;
-    const abortController = new AbortController();
-    const mergedOptions = {
-      ...streamOptions,
-      abortSignal: abortController.signal
-    };
-    if (ctx.memory) mergedOptions.memory = ctx.memory;
-    if (ctx.requestContext) mergedOptions.requestContext = ctx.requestContext;
-    let cancelled = false;
-    let replyText = "";
-    const toolCalls = [];
-    const emitTurnComplete = (interrupted) => {
-      if (!onTurnComplete) return;
-      const completeCtx = { ...ctx, result: { text: replyText, toolCalls, interrupted } };
-      Promise.resolve().then(() => onTurnComplete(completeCtx)).catch((error) => {
-        console.warn("@mastra/livekit: onTurnComplete hook threw", error);
-      });
-    };
-    return new ReadableStream({
-      start: async (controller) => {
-        try {
-          const result = await agent.stream(ctx.messages, mergedOptions);
-          for await (const chunk of result.fullStream) {
-            if (cancelled) break;
-            if (chunk.type === "text-delta") {
-              if (chunk.payload.text) {
-                replyText += chunk.payload.text;
-                controller.enqueue(chunk.payload.text);
-              }
-            } else if (chunk.type === "tool-call") {
-              const toolCall = {
-                toolCallId: chunk.payload.toolCallId,
-                toolName: chunk.payload.toolName,
-                args: chunk.payload.args
-              };
-              toolCalls.push(toolCall);
-              if (toolFeedback) {
-                const filler = toolFeedback(toolCall);
-                if (filler) controller.enqueue(filler.endsWith(" ") ? filler : `${filler} `);
-              }
-            } else if (chunk.type === "error") {
-              const error = chunk.payload.error;
-              throw error instanceof Error ? error : new Error(String(error));
-            }
-          }
-          if (!cancelled) controller.close();
-          emitTurnComplete(cancelled);
-        } catch (error) {
-          if (cancelled || abortController.signal.aborted) {
-            emitTurnComplete(true);
-            return;
-          }
-          controller.error(error);
-        }
-      },
-      cancel: () => {
-        cancelled = true;
-        abortController.abort();
-      }
-    });
-  };
-}
-function toRequestContext(value) {
-  if (!value) return void 0;
-  if (value instanceof RequestContext) return value;
-  return new RequestContext(Object.entries(value));
-}
-var MastraPlaceholderLLM = class extends llm.LLM {
-  label() {
-    return "mastra.MastraVoiceAgent";
-  }
-  get model() {
-    return "mastra-agent";
-  }
-  get provider() {
-    return "mastra";
-  }
-  chat() {
-    throw new Error(
-      "@mastra/livekit: reply generation runs through the Mastra agent via llmNode; the placeholder LLM cannot be used for inference."
-    );
-  }
-};
-var MastraVoiceAgent = class extends voice.Agent {
-  mastraAgent;
-  memory;
-  requestContext;
-  streamOptions;
-  replyGenerator;
-  constructor(options) {
-    if (options.agent && options.generate) {
-      throw new Error(
-        "@mastra/livekit: MastraVoiceAgent requires `agent` or `generate`, not both \u2014 they are mutually exclusive reply sources."
-      );
-    }
-    super({
-      id: options.id,
-      instructions: options.instructions ?? DEFAULT_INSTRUCTIONS,
-      stt: options.stt,
-      vad: options.vad,
-      llm: new MastraPlaceholderLLM(),
-      tts: options.tts,
-      turnHandling: options.turnHandling
-    });
-    this.memory = options.memory ?? false;
-    this.requestContext = toRequestContext(options.requestContext);
-    this.streamOptions = options.streamOptions;
-    if (options.generate) {
-      this.replyGenerator = options.generate;
-    } else if (options.agent) {
-      this.mastraAgent = options.agent;
-      this.replyGenerator = createAgentReplyGenerator({
-        agent: options.agent,
-        streamOptions: options.streamOptions,
-        toolFeedback: options.toolFeedback,
-        onTurnComplete: options.onTurnComplete
-      });
-    } else {
-      throw new Error("@mastra/livekit: MastraVoiceAgent requires `agent` or `generate`.");
-    }
-  }
-  async llmNode(chatCtx, _toolCtx, _modelSettings) {
-    const messages = this.memory === false ? chatContextToMessages(chatCtx) : extractNewTurnMessages(chatCtx);
-    if (messages.length === 0) return null;
-    return this.replyGenerator({
-      messages,
-      chatCtx,
-      memory: this.memory,
-      requestContext: this.requestContext,
-      tracingContext: this.streamOptions?.tracingContext
-    });
-  }
-};
-function createMastraVoiceAgent(options) {
-  return new MastraVoiceAgent(options);
-}
 function modelMeta(metadata) {
   const out = {};
   if (metadata?.modelProvider) out.modelProvider = metadata.modelProvider;
@@ -471,6 +282,103 @@ async function resolveInstructions(mastraAgent, requestContext) {
     return void 0;
   }
 }
+function resolveGreetingConfig(options) {
+  return {
+    text: options.greeting,
+    persist: options.persistGreeting,
+    ...options.configuration?.greeting
+  };
+}
+async function resolveGreetingText(text, context) {
+  const resolved = typeof text === "function" ? await text(context) : text;
+  return resolved || void 0;
+}
+async function resolveSessionComponent(resolver, fallback, context) {
+  const resolved = resolver ? await resolver(context) : void 0;
+  return resolved ?? fallback;
+}
+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;
+}
+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"]);
+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?.();
+  });
+}
+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);
+    }
+  }
+}
+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);
+  };
+}
+function composeTurnComplete(user, detector) {
+  if (!detector) return user;
+  return (ctx) => {
+    void detector(ctx);
+    return user?.(ctx);
+  };
+}
 function createLiveKitWorker(options) {
   if (options.generate && (options.agent || options.workflow)) {
     throw new Error(
@@ -487,6 +395,11 @@ function createLiveKitWorker(options) {
       "@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]);
@@ -512,6 +425,8 @@ function createLiveKitWorker(options) {
       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;
@@ -528,7 +443,7 @@ function createLiveKitWorker(options) {
           replyStep: options.replyStep,
           resultText: options.resultText,
           toolFeedback: options.toolFeedback,
-          onTurnComplete: options.onTurnComplete
+          onTurnComplete
         });
       } else {
         mastraAgent = await resolveMastraAgent(options, args);
@@ -578,24 +493,40 @@ function createLiveKitWorker(options) {
         const onCallEnd = options.onCallEnd;
         ctx.addShutdownCallback(async () => {
           try {
-            await onCallEnd({ memory, memoryInstance, metadata, requestContext, roomName, ctx });
+            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: options.onTurnComplete,
+        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: options.stt,
-        tts: options.tts,
+        stt,
+        tts,
         vad,
         turnHandling: buildTurnHandling(options, turnDetection),
         ...options.sessionOptions
@@ -608,18 +539,21 @@ function createLiveKitWorker(options) {
           inputOptions: options.inputOptions,
           outputOptions: options.outputOptions
         });
-        if (options.greeting) {
-          session.say(options.greeting);
-          if (options.persistGreeting !== false && memory && memoryInstance) {
-            try {
-              await persistSpokenGreeting({
-                memory: memoryInstance,
-                threadId: memory.thread,
-                resourceId: memory.resource ?? memory.thread,
-                greeting: options.greeting
-              });
-            } catch (error) {
-              logger.warn("@mastra/livekit: failed to persist the greeting", error);
+        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);
+              }
             }
           }
         }
@@ -647,6 +581,6 @@ function runLiveKitWorker(options) {
   });
 }
 
-export { chatContextToMessages, createLiveKitWorker, runLiveKitWorker };
+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