lua-cli 3.15.3 → 3.16.2

package/dist/voice/test/index.js

@@ -0,0 +1,386 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/voice/test/run-voice.ts
+import { voice as voice2 } from "@livekit/agents";
+
+// src/voice/test/test-agent.ts
+import { llm, voice } from "@livekit/agents";
+function buildTestAgent(opts) {
+  const { voice: lv } = opts;
+  const sessionId = opts.sessionId ?? `test-${Date.now()}`;
+  const channel = opts.channel ?? "phone";
+  const userdata = {
+    ...opts.initialUserdata ?? {}
+  };
+  const enteredAt = Date.now();
+  const sessionRef = opts.sessionRef ?? {
+    current: null
+  };
+  const tools = buildToolContext(lv.tools, opts.mockTools, {
+    sessionRef,
+    handoffTargets: opts.handoffTargets,
+    llm: opts.llm,
+    onTransferToHuman: opts.onTransferToHuman
+  });
+  const instructions = lv.greeting ?? "";
+  let TestVoiceAgent = class TestVoiceAgent extends voice.Agent {
+    static {
+      __name(this, "TestVoiceAgent");
+    }
+    constructor() {
+      super({
+        instructions,
+        tools,
+        llm: opts.llm
+      });
+    }
+    // Override the SDK's `id` getter so handoff matchers can identify
+    // which LuaVoice this agent represents. LiveKit's RunResult
+    // agent_handoff event exposes the new agent instance — devs assert
+    // via name.
+    get id() {
+      return lv.name;
+    }
+    async onEnter() {
+      if (!lv.onEnter) return;
+      const ctx = buildHookContext({
+        session: this.session,
+        sessionId,
+        channel,
+        caller: opts.caller,
+        userdata,
+        enteredAt
+      });
+      await lv.onEnter(ctx);
+    }
+    async onUserTurnCompleted(chatCtx, newMessage) {
+      if (!lv.onUserTurnCompleted) return;
+      const turnCtx = {
+        items: chatCtx.items,
+        addMessage: /* @__PURE__ */ __name(({ role, content }) => {
+          chatCtx.addMessage({
+            role,
+            content
+          });
+        }, "addMessage")
+      };
+      const userText = extractTextContent(newMessage.content);
+      await lv.onUserTurnCompleted(turnCtx, {
+        content: userText
+      });
+    }
+    async onExit() {
+      if (!lv.onExit) return;
+      const ctx = buildHookContext({
+        session: this.session,
+        sessionId,
+        channel,
+        caller: opts.caller,
+        userdata,
+        enteredAt
+      });
+      await lv.onExit(ctx);
+    }
+  };
+  return new TestVoiceAgent();
+}
+__name(buildTestAgent, "buildTestAgent");
+function buildToolContext(tools, mockTools, opts) {
+  const ctx = {};
+  for (const t of tools) {
+    if (!t || !t.name || !t.execute) continue;
+    const mock = mockTools?.[t.name];
+    const execute = mock ?? t.execute;
+    ctx[t.name] = llm.tool({
+      description: t.description ?? "",
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      parameters: t.inputSchema ?? void 0,
+      execute: /* @__PURE__ */ __name(async (input, toolCtx) => {
+        return execute(input, buildToolCallCtx(toolCtx, opts));
+      }, "execute")
+    });
+  }
+  return ctx;
+}
+__name(buildToolContext, "buildToolContext");
+function buildToolCallCtx(livekitCtx, opts) {
+  return {
+    toolCallId: livekitCtx.toolCallId,
+    voice: {
+      say: /* @__PURE__ */ __name(async (text) => {
+        opts.sessionRef.current?.say(text);
+      }, "say"),
+      transferToHuman: /* @__PURE__ */ __name(async (msisdn, transferOpts) => {
+        if (transferOpts?.announce) opts.sessionRef.current?.say(transferOpts.announce);
+        if (opts.onTransferToHuman) await opts.onTransferToHuman(msisdn, transferOpts);
+      }, "transferToHuman"),
+      handoff: /* @__PURE__ */ __name((name) => {
+        const target = opts.handoffTargets?.[name];
+        if (!target) {
+          throw new Error(`Voice "${name}" not registered as handoff target. Pass it via runVoice({ handoffTargets: { ${name}: ${name}Voice } }).`);
+        }
+        const session = opts.sessionRef.current;
+        if (!session) {
+          throw new Error("handoff() called before session start.");
+        }
+        const targetAgent = buildTestAgent({
+          voice: target,
+          llm: opts.llm,
+          sessionRef: opts.sessionRef,
+          handoffTargets: opts.handoffTargets,
+          onTransferToHuman: opts.onTransferToHuman
+        });
+        session.updateAgent(targetAgent);
+      }, "handoff")
+    }
+  };
+}
+__name(buildToolCallCtx, "buildToolCallCtx");
+function buildHookContext(args) {
+  return {
+    sessionId: args.sessionId,
+    channel: {
+      kind: args.channel
+    },
+    caller: args.caller,
+    duration: Math.floor((Date.now() - args.enteredAt) / 1e3),
+    session: {
+      userdata: args.userdata,
+      history: args.session.chatCtx?.items ?? [],
+      say: /* @__PURE__ */ __name(async (text) => {
+        args.session.say(text);
+      }, "say"),
+      generateReply: /* @__PURE__ */ __name((replyOpts) => {
+        return args.session.generateReply(replyOpts ?? {});
+      }, "generateReply")
+    }
+  };
+}
+__name(buildHookContext, "buildHookContext");
+function extractTextContent(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => typeof part === "string" ? part : part.text ?? "").join("");
+}
+__name(extractTextContent, "extractTextContent");
+
+// src/voice/test/run-voice.ts
+var FakeLLM = voice2.testing.FakeLLM;
+async function runVoice(luaVoice, options = {}) {
+  const fakeLlm = options.llm instanceof Object && "chat" in options.llm ? options.llm : new FakeLLM(options.llm ?? []);
+  const initialUserdata = {
+    ...options.initialUserdata ?? {},
+    ...options.dispatchedContext ? {
+      dispatchedContext: options.dispatchedContext
+    } : {}
+  };
+  const sessionRef = {
+    current: null
+  };
+  const agent = buildTestAgent({
+    voice: luaVoice,
+    llm: fakeLlm,
+    caller: options.caller,
+    channel: options.channel,
+    sessionId: options.sessionId,
+    initialUserdata,
+    mockTools: options.mockTools,
+    handoffTargets: options.handoffTargets,
+    onTransferToHuman: options.onTransferToHuman,
+    sessionRef
+  });
+  const session = new voice2.AgentSession({
+    llm: fakeLlm
+  });
+  sessionRef.current = session;
+  await session.start(agent);
+  const testSession = {
+    session,
+    get history() {
+      return session.chatCtx?.items ?? [];
+    },
+    async run(userInput) {
+      const result = session.run({
+        userInput
+      });
+      await result.wait();
+      return result;
+    },
+    async runMany(inputs) {
+      const out = [];
+      for (const input of inputs) {
+        out.push(await testSession.run(input));
+      }
+      return out;
+    },
+    async close() {
+      if (luaVoice.onExit) {
+        await agent.onExit();
+      }
+      await session.close();
+    }
+  };
+  return testSession;
+}
+__name(runVoice, "runVoice");
+
+// src/voice/test/matchers.ts
+function expectContainsMessage(result, matcher) {
+  const messages = result.events.filter(isMessageEvent).filter((e) => e.item.role === "assistant");
+  const texts = messages.map((m) => contentToText(m.item.content));
+  const matched = texts.some((t) => predicateMatch(t, matcher));
+  if (!matched) {
+    throw new Error(`Expected assistant message matching ${describeMatcher(matcher)}; got:
+${texts.map((t) => `  - ${t}`).join("\n") || "  (no assistant messages)"}`);
+  }
+}
+__name(expectContainsMessage, "expectContainsMessage");
+function expectCalledTool(result, toolName, expectedArgs) {
+  const calls = result.events.filter(isFunctionCallEvent).filter((e) => e.item.name === toolName);
+  if (calls.length === 0) {
+    const namesSeen = result.events.filter(isFunctionCallEvent).map((e) => e.item.name).join(", ") || "(no tool calls)";
+    throw new Error(`Expected tool call to "${toolName}"; saw: ${namesSeen}`);
+  }
+  if (expectedArgs === void 0) return;
+  const matched = calls.some((c) => {
+    const parsed = parseToolArgs(c.item.arguments);
+    if (typeof expectedArgs === "function") return expectedArgs(parsed);
+    return shallowSubset(expectedArgs, parsed);
+  });
+  if (!matched) {
+    const seen = calls.map((c) => parseToolArgs(c.item.arguments));
+    throw new Error(`Expected tool "${toolName}" called with ${JSON.stringify(expectedArgs)}; saw:
+${seen.map((s) => `  - ${JSON.stringify(s)}`).join("\n")}`);
+  }
+}
+__name(expectCalledTool, "expectCalledTool");
+function expectContainsHandoff(result, voiceName) {
+  const handoffs = result.events.filter(isHandoffEvent);
+  if (handoffs.length === 0) {
+    throw new Error(`Expected handoff to "${voiceName}"; no handoff events emitted.`);
+  }
+  const matched = handoffs.some((h) => h.newAgent?.id === voiceName || h.item.agentName === voiceName);
+  if (!matched) {
+    const seen = handoffs.map((h) => h.newAgent?.id ?? "(unnamed)").join(", ");
+    throw new Error(`Expected handoff to "${voiceName}"; got handoffs to: ${seen}`);
+  }
+}
+__name(expectContainsHandoff, "expectContainsHandoff");
+function predicateMatch(text, matcher) {
+  if (typeof matcher === "string") return text.includes(matcher);
+  if (matcher instanceof RegExp) return matcher.test(text);
+  return matcher(text);
+}
+__name(predicateMatch, "predicateMatch");
+function describeMatcher(matcher) {
+  if (typeof matcher === "string") return `substring "${matcher}"`;
+  if (matcher instanceof RegExp) return `regex ${matcher.toString()}`;
+  return "custom predicate";
+}
+__name(describeMatcher, "describeMatcher");
+function contentToText(content) {
+  if (typeof content === "string") return content;
+  if (!Array.isArray(content)) return "";
+  return content.map((part) => typeof part === "string" ? part : part.text ?? "").join("");
+}
+__name(contentToText, "contentToText");
+function parseToolArgs(args) {
+  if (typeof args !== "string") return args;
+  try {
+    return JSON.parse(args);
+  } catch {
+    return args;
+  }
+}
+__name(parseToolArgs, "parseToolArgs");
+function shallowSubset(expected, actual) {
+  if (!actual || typeof actual !== "object") return false;
+  const a = actual;
+  for (const [k, v] of Object.entries(expected)) {
+    if (a[k] !== v) return false;
+  }
+  return true;
+}
+__name(shallowSubset, "shallowSubset");
+function isMessageEvent(e) {
+  return !!e && e.type === "message";
+}
+__name(isMessageEvent, "isMessageEvent");
+function isFunctionCallEvent(e) {
+  return !!e && e.type === "function_call";
+}
+__name(isFunctionCallEvent, "isFunctionCallEvent");
+function isHandoffEvent(e) {
+  return !!e && e.type === "agent_handoff";
+}
+__name(isHandoffEvent, "isHandoffEvent");
+
+// src/voice/test/judge.ts
+import { llm as llm2 } from "@livekit/agents";
+var DEFAULT_SYSTEM = [
+  "You are a strict evaluator. Given an agent response and a criterion,",
+  "decide whether the response satisfies the criterion. Reply with ONLY",
+  'the single word "yes" or "no" \u2014 no explanation, no punctuation.'
+].join(" ");
+async function judge(response, criterion, options) {
+  const system = options.systemInstruction ?? DEFAULT_SYSTEM;
+  const userParts = [
+    `Agent response: "${response.replace(/"/g, '\\"')}"`,
+    options.context ? `Context: ${options.context}` : null,
+    `Criterion: "${criterion.replace(/"/g, '\\"')}"`
+  ].filter(Boolean).join("\n");
+  const chatCtx = createChatContext(system, userParts);
+  const stream = options.llm.chat({
+    chatCtx
+  });
+  const text = await collectText(stream);
+  const verdict = text.trim().toLowerCase().split(/\s+/)[0];
+  return verdict === "yes" || verdict === "true" || verdict === "pass";
+}
+__name(judge, "judge");
+async function expectJudge(response, criterion, options) {
+  const ok = await judge(response, criterion, options);
+  if (!ok) {
+    throw new Error(`LLM judge rejected:
+  criterion: ${criterion}
+  response: ${response}`);
+  }
+}
+__name(expectJudge, "expectJudge");
+function createChatContext(system, user) {
+  const ctx = new llm2.ChatContext();
+  const add = ctx.addMessage.bind(ctx);
+  add({
+    role: "system",
+    content: system
+  });
+  add({
+    role: "user",
+    content: user
+  });
+  return ctx;
+}
+__name(createChatContext, "createChatContext");
+async function collectText(stream) {
+  let out = "";
+  for await (const chunk of stream) {
+    out += chunk.delta?.content ?? "";
+  }
+  return out;
+}
+__name(collectText, "collectText");
+
+// src/voice/test/index.ts
+import { llm as llm3, voice as voice3 } from "@livekit/agents";
+export {
+  expectCalledTool,
+  expectContainsHandoff,
+  expectContainsMessage,
+  expectJudge,
+  judge,
+  llm3 as llm,
+  runVoice,
+  voice3 as voice
+};
+//# sourceMappingURL=index.js.map

package/dist/voice/test/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/voice/test/run-voice.ts","../../../src/voice/test/test-agent.ts","../../../src/voice/test/matchers.ts","../../../src/voice/test/judge.ts","../../../src/voice/test/index.ts"],"sourcesContent":["/**\n * `runVoice` — bootstrap a LuaVoice into a LiveKit `voice.AgentSession`\n * test harness. Returns a TestSession the dev drives turn-by-turn.\n *\n * The harness is text-driven (no audio, no real STT/TTS/VAD) and runs\n * inside the dev's jest process. Production code paths (sandbox, bundle\n * decompression, lua-agents fetch) are bypassed — the dev's hooks are\n * imported directly from their source.\n *\n * Multi-turn semantics: the same AgentSession is reused across `run()`\n * calls so chat_ctx persists. Devs assert per-turn via `RunResult.expect`\n * or globally via `session.history` / `session.events`.\n */\n\nimport { llm, voice } from '@livekit/agents';\nimport type { LuaVoice } from '../../types/voice.js';\nimport { buildTestAgent } from './test-agent.js';\n\ntype FakeLLMResponse = voice.testing.FakeLLMResponse;\ntype RunResult = voice.testing.RunResult;\nconst FakeLLM = voice.testing.FakeLLM;\n\nexport interface RunVoiceOptions {\n  /**\n   * LLM mock script. Each entry is keyed by the user input text — when\n   * the agent's chat loop hits that input, the FakeLLM returns the\n   * paired content/toolCalls. Devs can pass a pre-built `llm.LLM`\n   * instance instead for full control (custom matching, multi-turn\n   * stateful responses, etc.).\n   */\n  llm?: FakeLLMResponse[] | llm.LLM;\n  /**\n   * Mock tool executions. Substitutes the dev's tool.execute for the\n   * named tool — return value flows into the LLM's next turn the same\n   * way a real execute would.\n   */\n  mockTools?: Record<string, (input: unknown, ctx?: unknown) => unknown>;\n  /** Caller info passed to onEnter / onExit hook ctx. */\n  caller?: { phoneNumber?: string; userId?: string; isAnonymous?: boolean };\n  channel?: 'phone' | 'meeting' | 'whatsapp' | 'webchat';\n  /** Pre-seeded session.userdata. Same as the worker's initial state when onEnter hasn't run yet. */\n  initialUserdata?: Record<string, unknown>;\n  /**\n   * Other LuaVoices the agent under test can hand off to. Pass each\n   * target voice keyed by name so `ctx.voice.handoff('billing-line')`\n   * resolves; assertion happens via `expectContainsHandoff(result, 'billing-line')`.\n   */\n  handoffTargets?: Record<string, import('../../types/voice.js').LuaVoice>;\n  /**\n   * Spy on `ctx.voice.transferToHuman(...)` calls from inside the\n   * voice's tools. Real SIP REFER / bridge dial never fires under\n   * the test harness — pass a jest.fn() (or any callback) to assert\n   * the dev's tool attempted a transfer.\n   */\n  onTransferToHuman?: import('./test-agent.js').TransferToHumanRecorder;\n  /**\n   * Seed `dispatchedContext` (what `Voice.call({ context })` would\n   * inject in production). Stored on session.userdata under the same\n   * key the worker uses, plus made available to the hook ctx.\n   */\n  dispatchedContext?: Record<string, unknown>;\n  sessionId?: string;\n}\n\nexport interface TestSession {\n  /**\n   * Drive a single user turn. Returns a `RunResult` (LiveKit's\n   * built-in assertion type) — chain `.expect.nextEvent()` /\n   * `.expect.containsFunctionCall()` / etc. on the result.\n   */\n  run(userInput: string): Promise<voice.testing.RunResult>;\n  /**\n   * Drive multiple turns sequentially, returning all results in order.\n   */\n  runMany(userInputs: string[]): Promise<voice.testing.RunResult[]>;\n  /** Direct access to the underlying LiveKit AgentSession. */\n  readonly session: voice.AgentSession;\n  /** The chat history accumulated across all turns. */\n  readonly history: ReadonlyArray<unknown>;\n  /** Call the LuaVoice's onExit hook (mirror end-of-session lifecycle). */\n  close(): Promise<void>;\n}\n\nexport async function runVoice(luaVoice: LuaVoice, options: RunVoiceOptions = {}): Promise<TestSession> {\n  const fakeLlm =\n    options.llm instanceof Object && 'chat' in (options.llm as object)\n      ? (options.llm as llm.LLM)\n      : new FakeLLM((options.llm as FakeLLMResponse[]) ?? []);\n\n  // Seed initialUserdata with dispatchedContext so dev hooks see what\n  // the production worker sees. The worker stamps it via\n  // `session.userdata.dispatchedContext` after seeding chat_ctx with a\n  // system message — we mirror only the userdata side here; tests that\n  // care about the system-message seed should assert on chat_ctx items.\n  const initialUserdata = {\n    ...(options.initialUserdata ?? {}),\n    ...(options.dispatchedContext ? { dispatchedContext: options.dispatchedContext } : {}),\n  };\n\n  const sessionRef: { current: voice.AgentSession | null } = { current: null };\n  const agent = buildTestAgent({\n    voice: luaVoice,\n    llm: fakeLlm,\n    caller: options.caller,\n    channel: options.channel,\n    sessionId: options.sessionId,\n    initialUserdata,\n    mockTools: options.mockTools,\n    handoffTargets: options.handoffTargets,\n    onTransferToHuman: options.onTransferToHuman,\n    sessionRef,\n  });\n\n  // No stt/tts/vad — test mode runs the LLM-only loop. The session's\n  // start() wires the agent without a room.\n  const session = new voice.AgentSession({\n    llm: fakeLlm,\n  } as ConstructorParameters<typeof voice.AgentSession>[0]);\n  sessionRef.current = session;\n\n  // start(agent) is what activates the session for `session.run()`. No\n  // room argument needed in test mode — `voice.AgentSession.run()` is\n  // explicitly designed to skip room connection.\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  await (session as unknown as { start: (a: voice.Agent) => Promise<void> }).start(agent);\n\n  const testSession: TestSession = {\n    session,\n    get history() {\n      return session.chatCtx?.items ?? [];\n    },\n    async run(userInput: string): Promise<voice.testing.RunResult> {\n      const result = session.run({ userInput });\n      await result.wait();\n      return result;\n    },\n    async runMany(inputs: string[]): Promise<voice.testing.RunResult[]> {\n      const out: voice.testing.RunResult[] = [];\n      for (const input of inputs) {\n        out.push(await testSession.run(input));\n      }\n      return out;\n    },\n    async close(): Promise<void> {\n      if (luaVoice.onExit) {\n        // `agent.onExit` already wraps this when the session shuts\n        // down naturally; tests use this hook to assert post-call\n        // behavior without spinning up the full close path.\n        await (agent as unknown as { onExit: () => Promise<void> }).onExit();\n      }\n      await session.close();\n    },\n  };\n\n  return testSession;\n}\n","/**\n * Build a `voice.Agent` from a `LuaVoice` for in-process testing.\n *\n * Distinct from the production `compiled-voice-agent` in lua-livekit:\n *   - No artifact loader, no bundle decompression — the dev's hooks are\n *     plain JS functions on the imported LuaVoice; we wire them directly.\n *   - No platform-API sandbox — tests run in the dev's own jest process,\n *     mock platform APIs via globals or by passing stubs.\n *   - No real STT/TTS/VAD — `voice.AgentSession` test mode skips audio\n *     entirely; only the LLM (Fake or dev-supplied) actually drives turns.\n */\n\nimport { llm, voice } from '@livekit/agents';\nimport type { LuaVoice, LuaVoiceHookContext, LuaVoiceTurnContext } from '../../types/voice.js';\nimport type { LuaTool } from '../../types/skill.js';\n\nexport interface BuildTestAgentOptions {\n  voice: LuaVoice;\n  /** Mocked LLM that scripts the agent's responses. */\n  llm: llm.LLM;\n  /** Caller info passed to onEnter / onExit hook ctx. */\n  caller?: { phoneNumber?: string; userId?: string; isAnonymous?: boolean };\n  channel?: 'phone' | 'meeting' | 'whatsapp' | 'webchat';\n  sessionId?: string;\n  /** Pre-seeded sessionview userdata (what onEnter would normally hydrate). */\n  initialUserdata?: Record<string, unknown>;\n  /**\n   * Map of tool name → mock execute. When set, the harness substitutes\n   * the dev's `tool.execute` with the mock. Tools without a mock keep\n   * their real execute (which may itself stub external calls).\n   */\n  mockTools?: Record<string, (input: unknown, ctx?: unknown) => unknown>;\n  /**\n   * Other LuaVoices reachable via `ctx.voice.handoff(name)`. The harness\n   * builds a stub Agent for the target on demand so RunResult emits an\n   * agent_handoff event the matcher can assert on.\n   */\n  handoffTargets?: Record<string, LuaVoice>;\n  /** Lazy session reference, populated by run-voice after start(). */\n  sessionRef?: { current: voice.AgentSession | null };\n  /**\n   * Spy on `ctx.voice.transferToHuman(...)` calls. Real REFER / bridge\n   * doesn't fire in the harness; this callback is the assertion hook\n   * for tests that exercise the dev's transfer logic. No-op when\n   * absent.\n   */\n  onTransferToHuman?: TransferToHumanRecorder;\n}\n\nexport function buildTestAgent(opts: BuildTestAgentOptions): voice.Agent {\n  const { voice: lv } = opts;\n  const sessionId = opts.sessionId ?? `test-${Date.now()}`;\n  const channel = opts.channel ?? 'phone';\n  const userdata: Record<string, unknown> = { ...(opts.initialUserdata ?? {}) };\n  const enteredAt = Date.now();\n  const sessionRef = opts.sessionRef ?? { current: null };\n\n  // Build the LiveKit ToolContext from the LuaVoice's tools.\n  const tools = buildToolContext(lv.tools, opts.mockTools, {\n    sessionRef,\n    handoffTargets: opts.handoffTargets,\n    llm: opts.llm,\n    onTransferToHuman: opts.onTransferToHuman,\n  });\n\n  // Persona becomes Agent.instructions. LuaVoice doesn't carry persona\n  // directly; the production worker reads it from the bound LuaAgent's\n  // persona via artifact-loader. For tests, default to greeting + a\n  // minimal stub — devs can override with mockLLM if they need richer\n  // persona-driven behavior in the LLM responses themselves.\n  const instructions = lv.greeting ?? '';\n\n  class TestVoiceAgent extends voice.Agent {\n    constructor() {\n      super({\n        instructions,\n        tools,\n        llm: opts.llm,\n        // No STT / TTS / VAD — test mode skips audio.\n      });\n    }\n    // Override the SDK's `id` getter so handoff matchers can identify\n    // which LuaVoice this agent represents. LiveKit's RunResult\n    // agent_handoff event exposes the new agent instance — devs assert\n    // via name.\n    override get id(): string {\n      return lv.name;\n    }\n\n    override async onEnter(): Promise<void> {\n      if (!lv.onEnter) return;\n      const ctx = buildHookContext({\n        session: this.session,\n        sessionId,\n        channel,\n        caller: opts.caller,\n        userdata,\n        enteredAt,\n      });\n      await lv.onEnter(ctx);\n    }\n\n    override async onUserTurnCompleted(chatCtx: llm.ChatContext, newMessage: llm.ChatMessage): Promise<void> {\n      if (!lv.onUserTurnCompleted) return;\n      const turnCtx: LuaVoiceTurnContext = {\n        items: chatCtx.items,\n        addMessage: ({ role, content }) => {\n          // Mirror lua-livekit's compiled-voice-agent: forward to the\n          // chatCtx so the LLM sees the injected RAG context on the next\n          // turn. Tests assert via `result.expect.containsMessage`.\n          (chatCtx as unknown as { addMessage: (m: { role: string; content: string }) => void }).addMessage({\n            role,\n            content,\n          });\n        },\n      };\n      const userText = extractTextContent(newMessage.content);\n      await lv.onUserTurnCompleted(turnCtx, { content: userText });\n    }\n\n    override async onExit(): Promise<void> {\n      if (!lv.onExit) return;\n      const ctx = buildHookContext({\n        session: this.session,\n        sessionId,\n        channel,\n        caller: opts.caller,\n        userdata,\n        enteredAt,\n      });\n      await lv.onExit(ctx);\n    }\n  }\n\n  return new TestVoiceAgent();\n}\n\n/**\n * Wrap each LuaTool / LuaVoiceTool in a LiveKit `llm.tool({})` so the\n * AgentSession can dispatch tool calls. The mockTools map overrides the\n * dev's `execute` when provided.\n */\n/**\n * Optional spy on `ctx.voice.transferToHuman(msisdn, opts)` calls\n * inside the test harness. Real SIP REFER / bridge dial doesn't fire\n * in tests — the harness has no SipClient — so this is the only way\n * to assert \"the dev's tool tried to transfer to a human\". Default is\n * a no-op log.\n */\nexport type TransferToHumanRecorder = (\n  msisdn: string,\n  opts?: { mode?: 'bridge' | 'refer'; announce?: string }\n) => Promise<void> | void;\n\ninterface BuildToolContextOptions {\n  sessionRef: { current: voice.AgentSession | null };\n  handoffTargets?: Record<string, LuaVoice>;\n  llm: llm.LLM;\n  /** Test-time hook for `ctx.voice.transferToHuman`. */\n  onTransferToHuman?: TransferToHumanRecorder;\n}\n\nfunction buildToolContext(\n  tools: ReadonlyArray<\n    | LuaTool<any>\n    | {\n        name: string;\n        description?: string;\n        inputSchema?: unknown;\n        execute?: (input: any, ctx?: any) => any;\n        voice?: { flags?: string[] };\n      }\n  >,\n  mockTools: Record<string, (input: unknown, ctx?: unknown) => unknown> | undefined,\n  opts: BuildToolContextOptions\n): llm.ToolContext {\n  const ctx: llm.ToolContext = {};\n  for (const t of tools) {\n    if (!t || !t.name || !t.execute) continue;\n    const mock = mockTools?.[t.name];\n    const execute = mock ?? t.execute;\n    ctx[t.name] = llm.tool({\n      description: t.description ?? '',\n      // eslint-disable-next-line @typescript-eslint/no-explicit-any\n      parameters: (t.inputSchema as any) ?? undefined,\n      execute: async (input: unknown, toolCtx: { toolCallId: string }) => {\n        return execute(input, buildToolCallCtx(toolCtx, opts));\n      },\n    });\n  }\n  return ctx;\n}\n\nfunction buildToolCallCtx(\n  livekitCtx: { toolCallId: string },\n  opts: BuildToolContextOptions\n): {\n  toolCallId: string;\n  voice: {\n    say: (text: string) => Promise<void>;\n    transferToHuman: (msisdn: string, opts?: { mode?: 'bridge' | 'refer'; announce?: string }) => Promise<void>;\n    handoff: (name: string) => void;\n  };\n} {\n  return {\n    toolCallId: livekitCtx.toolCallId,\n    voice: {\n      say: async (text: string) => {\n        opts.sessionRef.current?.say(text);\n      },\n      transferToHuman: async (msisdn: string, transferOpts?: { mode?: 'bridge' | 'refer'; announce?: string }) => {\n        // The harness can't actually transfer a SIP leg — no real\n        // SipClient, no real room. Delegate to the dev's recorder if\n        // they passed one (lets tests assert \"the agent attempted a\n        // transfer to +32...\"); otherwise no-op so the dev's tool\n        // doesn't crash mid-test.\n        if (transferOpts?.announce) opts.sessionRef.current?.say(transferOpts.announce);\n        if (opts.onTransferToHuman) await opts.onTransferToHuman(msisdn, transferOpts);\n      },\n      handoff: (name: string) => {\n        const target = opts.handoffTargets?.[name];\n        if (!target) {\n          throw new Error(\n            `Voice \"${name}\" not registered as handoff target. Pass it via runVoice({ handoffTargets: { ${name}: ${name}Voice } }).`\n          );\n        }\n        const session = opts.sessionRef.current;\n        if (!session) {\n          throw new Error('handoff() called before session start.');\n        }\n        const targetAgent = buildTestAgent({\n          voice: target,\n          llm: opts.llm,\n          sessionRef: opts.sessionRef,\n          handoffTargets: opts.handoffTargets,\n          onTransferToHuman: opts.onTransferToHuman,\n        });\n        session.updateAgent(targetAgent);\n      },\n    },\n  };\n}\n\ninterface BuildHookContextArgs {\n  session: voice.AgentSession;\n  sessionId: string;\n  channel: string;\n  caller?: { phoneNumber?: string; userId?: string; isAnonymous?: boolean };\n  userdata: Record<string, unknown>;\n  enteredAt: number;\n}\n\nfunction buildHookContext(args: BuildHookContextArgs): LuaVoiceHookContext {\n  return {\n    sessionId: args.sessionId,\n    channel: { kind: args.channel },\n    caller: args.caller,\n    duration: Math.floor((Date.now() - args.enteredAt) / 1000),\n    session: {\n      userdata: args.userdata,\n      history: args.session.chatCtx?.items ?? [],\n      say: async (text: string) => {\n        args.session.say(text);\n      },\n      generateReply: (replyOpts?: { instructions?: string }) => {\n        return args.session.generateReply(replyOpts ?? {});\n      },\n    },\n  };\n}\n\nfunction extractTextContent(content: llm.ChatMessage['content']): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  return content.map((part) => (typeof part === 'string' ? part : ((part as { text?: string }).text ?? ''))).join('');\n}\n","/**\n * Convenience wrappers around LiveKit's `RunAssert` API. The native\n * `result.expect.containsMessage(...)` etc. is already strong; these\n * exports give devs Jest-style helpers (`expectContainsHandoff(result,\n * 'billing-line')`) without needing to learn LiveKit's specific assert\n * chain.\n */\n\nimport type { voice } from '@livekit/agents';\n\ntype RunResult = voice.testing.RunResult;\n\n/**\n * Assert the run produced an assistant message matching the predicate.\n * Predicate can be a substring, a regex, or a custom function.\n */\nexport function expectContainsMessage(result: RunResult, matcher: string | RegExp | ((text: string) => boolean)): void {\n  const messages = (result.events as readonly unknown[])\n    .filter(isMessageEvent)\n    .filter((e) => e.item.role === 'assistant');\n  const texts = messages.map((m) => contentToText(m.item.content));\n  const matched = texts.some((t) => predicateMatch(t, matcher));\n  if (!matched) {\n    throw new Error(\n      `Expected assistant message matching ${describeMatcher(matcher)}; got:\\n${texts.map((t) => `  - ${t}`).join('\\n') || '  (no assistant messages)'}`\n    );\n  }\n}\n\n/**\n * Assert the run invoked a specific tool. Optional args matcher narrows\n * to a specific call shape.\n */\nexport function expectCalledTool(\n  result: RunResult,\n  toolName: string,\n  expectedArgs?: Record<string, unknown> | ((args: unknown) => boolean)\n): void {\n  const calls = (result.events as readonly unknown[])\n    .filter(isFunctionCallEvent)\n    .filter((e) => e.item.name === toolName);\n  if (calls.length === 0) {\n    const namesSeen =\n      (result.events as readonly unknown[])\n        .filter(isFunctionCallEvent)\n        .map((e) => e.item.name)\n        .join(', ') || '(no tool calls)';\n    throw new Error(`Expected tool call to \"${toolName}\"; saw: ${namesSeen}`);\n  }\n  if (expectedArgs === undefined) return;\n\n  const matched = calls.some((c) => {\n    const parsed = parseToolArgs(c.item.arguments);\n    if (typeof expectedArgs === 'function') return expectedArgs(parsed);\n    return shallowSubset(expectedArgs, parsed);\n  });\n  if (!matched) {\n    const seen = calls.map((c) => parseToolArgs(c.item.arguments));\n    throw new Error(\n      `Expected tool \"${toolName}\" called with ${JSON.stringify(expectedArgs)}; saw:\\n${seen.map((s) => `  - ${JSON.stringify(s)}`).join('\\n')}`\n    );\n  }\n}\n\n/**\n * Assert the run produced an agent handoff. By name (the LuaVoice's\n * `name` field), since the test harness doesn't have access to the\n * Agent constructor types LiveKit's `containsAgentHandoff` expects.\n */\nexport function expectContainsHandoff(result: RunResult, voiceName: string): void {\n  const handoffs = (result.events as readonly unknown[]).filter(isHandoffEvent);\n  if (handoffs.length === 0) {\n    throw new Error(`Expected handoff to \"${voiceName}\"; no handoff events emitted.`);\n  }\n  const matched = handoffs.some(\n    (h) => h.newAgent?.id === voiceName || (h.item as { agentName?: string }).agentName === voiceName\n  );\n  if (!matched) {\n    const seen = handoffs.map((h) => h.newAgent?.id ?? '(unnamed)').join(', ');\n    throw new Error(`Expected handoff to \"${voiceName}\"; got handoffs to: ${seen}`);\n  }\n}\n\n// --- internals ---\n\nfunction predicateMatch(text: string, matcher: string | RegExp | ((text: string) => boolean)): boolean {\n  if (typeof matcher === 'string') return text.includes(matcher);\n  if (matcher instanceof RegExp) return matcher.test(text);\n  return matcher(text);\n}\n\nfunction describeMatcher(matcher: string | RegExp | ((text: string) => boolean)): string {\n  if (typeof matcher === 'string') return `substring \"${matcher}\"`;\n  if (matcher instanceof RegExp) return `regex ${matcher.toString()}`;\n  return 'custom predicate';\n}\n\nfunction contentToText(content: unknown): string {\n  if (typeof content === 'string') return content;\n  if (!Array.isArray(content)) return '';\n  return content.map((part) => (typeof part === 'string' ? part : ((part as { text?: string }).text ?? ''))).join('');\n}\n\nfunction parseToolArgs(args: unknown): unknown {\n  if (typeof args !== 'string') return args;\n  try {\n    return JSON.parse(args);\n  } catch {\n    return args;\n  }\n}\n\nfunction shallowSubset(expected: Record<string, unknown>, actual: unknown): boolean {\n  if (!actual || typeof actual !== 'object') return false;\n  const a = actual as Record<string, unknown>;\n  for (const [k, v] of Object.entries(expected)) {\n    if (a[k] !== v) return false;\n  }\n  return true;\n}\n\ninterface MessageEvent {\n  type: 'message';\n  item: { role: string; content: unknown };\n}\ninterface FunctionCallEvent {\n  type: 'function_call';\n  item: { name: string; arguments: unknown };\n}\ninterface HandoffEvent {\n  type: 'agent_handoff';\n  item: { agentName?: string };\n  newAgent?: { id?: string };\n}\n\nfunction isMessageEvent(e: unknown): e is MessageEvent {\n  return !!e && (e as { type?: string }).type === 'message';\n}\n\nfunction isFunctionCallEvent(e: unknown): e is FunctionCallEvent {\n  return !!e && (e as { type?: string }).type === 'function_call';\n}\n\nfunction isHandoffEvent(e: unknown): e is HandoffEvent {\n  return !!e && (e as { type?: string }).type === 'agent_handoff';\n}\n","/**\n * LLM-as-judge: use an LLM to evaluate an agent response against a\n * natural-language criterion. Returns true when the judge agrees the\n * criterion holds.\n *\n * Use for soft assertions where regex/substring would be brittle —\n * \"the agent acknowledged the refund\" could be phrased a hundred ways.\n * For hard contracts (tool was called, handoff happened) prefer the\n * exact matchers in `matchers.ts`.\n *\n * Trade-offs (see audit M-4):\n *   - Non-deterministic: same input may flip between runs.\n *   - Costs tokens per assertion: a CI suite with 100 judge calls\n *     adds up.\n *   - Stronger judge (gpt-5, claude-opus) is more consistent than a\n *     cheap one.\n *\n * The dev passes their own LLM instance to keep judge cost + provider\n * choice explicit.\n */\n\nimport { llm } from '@livekit/agents';\n\nexport interface JudgeOptions {\n  /** LLM instance the judge prompt runs against. */\n  llm: llm.LLM;\n  /**\n   * Optional system instruction override. The default keeps the judge\n   * strict (\"answer yes or no, no explanation\"). Override when you need\n   * the judge to score on a scale or return structured output — though\n   * structured output is more brittle than yes/no.\n   */\n  systemInstruction?: string;\n  /**\n   * Optional context. When set, the judge sees additional facts\n   * before scoring the response. Useful for \"did the agent answer\n   * factually given these facts\": pass the facts as `context`.\n   */\n  context?: string;\n}\n\nconst DEFAULT_SYSTEM = [\n  'You are a strict evaluator. Given an agent response and a criterion,',\n  'decide whether the response satisfies the criterion. Reply with ONLY',\n  'the single word \"yes\" or \"no\" — no explanation, no punctuation.',\n].join(' ');\n\n/**\n * Returns true when the judge LLM concludes the response satisfies the\n * criterion. False on disagreement OR on any judge failure (network,\n * malformed response, timeout) — fail-closed so a flaky judge doesn't\n * mask a real assertion failure.\n */\nexport async function judge(response: string, criterion: string, options: JudgeOptions): Promise<boolean> {\n  const system = options.systemInstruction ?? DEFAULT_SYSTEM;\n  const userParts = [\n    `Agent response: \"${response.replace(/\"/g, '\\\\\"')}\"`,\n    options.context ? `Context: ${options.context}` : null,\n    `Criterion: \"${criterion.replace(/\"/g, '\\\\\"')}\"`,\n  ]\n    .filter(Boolean)\n    .join('\\n');\n\n  const chatCtx = createChatContext(system, userParts);\n  const stream = options.llm.chat({ chatCtx });\n  const text = await collectText(stream);\n  const verdict = text.trim().toLowerCase().split(/\\s+/)[0];\n  return verdict === 'yes' || verdict === 'true' || verdict === 'pass';\n}\n\n/**\n * Throwing variant for jest-style tests. Throws an Error with the\n * judge's verdict + the original criterion when the judge says no, so\n * the failure message in the test report is self-explanatory.\n */\nexport async function expectJudge(response: string, criterion: string, options: JudgeOptions): Promise<void> {\n  const ok = await judge(response, criterion, options);\n  if (!ok) {\n    throw new Error(`LLM judge rejected:\\n  criterion: ${criterion}\\n  response: ${response}`);\n  }\n}\n\n// --- internals ---\n\nfunction createChatContext(system: string, user: string): llm.ChatContext {\n  const ctx = new llm.ChatContext();\n  const add = (ctx as unknown as { addMessage: (m: { role: string; content: string }) => void }).addMessage.bind(ctx);\n  add({ role: 'system', content: system });\n  add({ role: 'user', content: user });\n  return ctx;\n}\n\nasync function collectText(stream: llm.LLMStream): Promise<string> {\n  let out = '';\n  for await (const chunk of stream as unknown as AsyncIterable<{ delta?: { content?: string } }>) {\n    out += chunk.delta?.content ?? '';\n  }\n  return out;\n}\n","/**\n * `lua-cli/voice/test` — public surface for `lua voice test` files.\n *\n * Devs import from `lua-cli/voice/test`:\n *\n * ```typescript\n * import { runVoice, expectContainsMessage, expectCalledTool, expectContainsHandoff, judge } from 'lua-cli/voice/test';\n * import support from './support.voice';\n *\n * it('looks up the order', async () => {\n *   const session = await runVoice(support, {\n *     llm: [\n *       { input: 'Where is order ABC?', toolCalls: [{ name: 'lookup_order', args: { id: 'ABC' } }] },\n *       { input: '', content: 'Order ABC was shipped Tuesday.' },\n *     ],\n *     mockTools: { lookup_order: ({ id }) => ({ id, status: 'shipped' }) },\n *   });\n *   const result = await session.run('Where is order ABC?');\n *   expectCalledTool(result, 'lookup_order', { id: 'ABC' });\n *   expectContainsMessage(result, /shipped/);\n * });\n * ```\n *\n * Re-exports are kept thin — LiveKit's `RunResult` and `FakeLLM` are\n * surfaced for devs who want native control beyond the helpers.\n */\n\nexport { runVoice, type TestSession, type RunVoiceOptions } from './run-voice.js';\nexport { expectContainsMessage, expectCalledTool, expectContainsHandoff } from './matchers.js';\nexport { judge, expectJudge, type JudgeOptions } from './judge.js';\n\n// Re-export LiveKit primitives so devs only depend on lua-cli.\n// `voice.testing` is a namespace inside the agents root export, not a\n// subpath; access via `voice.testing.X`.\nexport { llm, voice } from '@livekit/agents';\n"],"mappings":"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","names":["voice","llm","voice","buildTestAgent","opts","voice","lv","sessionId","Date","now","channel","userdata","initialUserdata","enteredAt","sessionRef","current","tools","buildToolContext","mockTools","handoffTargets","llm","onTransferToHuman","instructions","greeting","TestVoiceAgent","Agent","id","name","onEnter","ctx","buildHookContext","session","caller","onUserTurnCompleted","chatCtx","newMessage","turnCtx","items","addMessage","role","content","userText","extractTextContent","onExit","t","execute","mock","tool","description","parameters","inputSchema","undefined","input","toolCtx","buildToolCallCtx","livekitCtx","toolCallId","say","text","transferToHuman","msisdn","transferOpts","announce","handoff","target","Error","targetAgent","updateAgent","args","kind","duration","Math","floor","history","generateReply","replyOpts","Array","isArray","map","part","join","FakeLLM","voice","testing","runVoice","luaVoice","options","fakeLlm","llm","Object","initialUserdata","dispatchedContext","sessionRef","current","agent","buildTestAgent","caller","channel","sessionId","mockTools","handoffTargets","onTransferToHuman","session","AgentSession","start","testSession","history","chatCtx","items","run","userInput","result","wait","runMany","inputs","out","input","push","close","onExit","expectContainsMessage","result","matcher","messages","events","filter","isMessageEvent","e","item","role","texts","map","m","contentToText","content","matched","some","t","predicateMatch","Error","describeMatcher","join","expectCalledTool","toolName","expectedArgs","calls","isFunctionCallEvent","name","length","namesSeen","undefined","c","parsed","parseToolArgs","arguments","shallowSubset","seen","JSON","stringify","s","expectContainsHandoff","voiceName","handoffs","isHandoffEvent","h","newAgent","id","agentName","text","includes","RegExp","test","toString","Array","isArray","part","args","parse","expected","actual","a","k","v","Object","entries","type","llm","DEFAULT_SYSTEM","join","judge","response","criterion","options","system","systemInstruction","userParts","replace","context","filter","Boolean","chatCtx","createChatContext","stream","llm","chat","text","collectText","verdict","trim","toLowerCase","split","expectJudge","ok","Error","user","ctx","ChatContext","add","addMessage","bind","role","content","out","chunk","delta","llm","voice"]}

package/dist/voice-exports.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Sub-entrypoint for voice-related imports — re-exports the LiveKit
+ * plugin namespaces that LuaVoice's class-form `stt` / `tts` accept.
+ *
+ * Devs who write a code-defined LuaVoice with the plugin route can keep
+ * `lua-cli` as the only dependency they import:
+ *
+ * ```typescript
+ * import { LuaVoice } from 'lua-cli';
+ * import { deepgram, elevenlabs, inference } from 'lua-cli/voice';
+ *
+ * export default new LuaVoice({
+ *   llm: 'openai/gpt-5.2-chat-latest',                      // string descriptor → Inference
+ *   stt: new deepgram.STT({ model: 'nova-3' }),             // class form → direct plugin
+ *   tts: new elevenlabs.TTS({ voiceId: 'abc', model: 'eleven_v3' }),
+ * });
+ * ```
+ *
+ * Without this sub-entrypoint, devs would need to add
+ * `@livekit/agents-plugin-deepgram` etc. as direct dependencies in
+ * their own project. Routing through `lua-cli` keeps the dev-side
+ * `package.json` clean.
+ *
+ * Note: these are *type-only relevant* at compile time — the lua-cli
+ * compiler ASTs the dev's source and extracts `{ kind: 'plugin',
+ * provider, class, options }` for the wire shape. The actual
+ * `new deepgram.STT({...})` construction happens in the lua-livekit
+ * worker's dispatch path, not the dev's process. The re-exports here
+ * give devs full TypeScript autocomplete on plugin-specific options.
+ *
+ * `inference` is re-exported from `@livekit/agents` (the parent
+ * package) so devs can use the typed `new inference.LLM/STT/TTS({...})`
+ * form without adding `@livekit/agents` to their dev project.
+ */
+export * as deepgram from '@livekit/agents-plugin-deepgram';
+export * as elevenlabs from '@livekit/agents-plugin-elevenlabs';
+export * as openai from '@livekit/agents-plugin-openai';
+export * as google from '@livekit/agents-plugin-google';
+export * as xai from '@livekit/agents-plugin-xai';
+export { inference } from '@livekit/agents';

package/dist/voice-exports.js

@@ -0,0 +1,16 @@
+// src/voice-exports.ts
+import * as deepgram from "@livekit/agents-plugin-deepgram";
+import * as elevenlabs from "@livekit/agents-plugin-elevenlabs";
+import * as openai from "@livekit/agents-plugin-openai";
+import * as google from "@livekit/agents-plugin-google";
+import * as xai from "@livekit/agents-plugin-xai";
+import { inference } from "@livekit/agents";
+export {
+  deepgram,
+  elevenlabs,
+  google,
+  inference,
+  openai,
+  xai
+};
+//# sourceMappingURL=voice-exports.js.map

package/dist/voice-exports.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/voice-exports.ts"],"sourcesContent":["/**\n * Sub-entrypoint for voice-related imports — re-exports the LiveKit\n * plugin namespaces that LuaVoice's class-form `stt` / `tts` accept.\n *\n * Devs who write a code-defined LuaVoice with the plugin route can keep\n * `lua-cli` as the only dependency they import:\n *\n * ```typescript\n * import { LuaVoice } from 'lua-cli';\n * import { deepgram, elevenlabs, inference } from 'lua-cli/voice';\n *\n * export default new LuaVoice({\n *   llm: 'openai/gpt-5.2-chat-latest',                      // string descriptor → Inference\n *   stt: new deepgram.STT({ model: 'nova-3' }),             // class form → direct plugin\n *   tts: new elevenlabs.TTS({ voiceId: 'abc', model: 'eleven_v3' }),\n * });\n * ```\n *\n * Without this sub-entrypoint, devs would need to add\n * `@livekit/agents-plugin-deepgram` etc. as direct dependencies in\n * their own project. Routing through `lua-cli` keeps the dev-side\n * `package.json` clean.\n *\n * Note: these are *type-only relevant* at compile time — the lua-cli\n * compiler ASTs the dev's source and extracts `{ kind: 'plugin',\n * provider, class, options }` for the wire shape. The actual\n * `new deepgram.STT({...})` construction happens in the lua-livekit\n * worker's dispatch path, not the dev's process. The re-exports here\n * give devs full TypeScript autocomplete on plugin-specific options.\n *\n * `inference` is re-exported from `@livekit/agents` (the parent\n * package) so devs can use the typed `new inference.LLM/STT/TTS({...})`\n * form without adding `@livekit/agents` to their dev project.\n */\n\nexport * as deepgram from '@livekit/agents-plugin-deepgram';\nexport * as elevenlabs from '@livekit/agents-plugin-elevenlabs';\nexport * as openai from '@livekit/agents-plugin-openai';\nexport * as google from '@livekit/agents-plugin-google';\nexport * as xai from '@livekit/agents-plugin-xai';\nexport { inference } from '@livekit/agents';\n"],"mappings":";AAmCA,YAAYA,cAAc;AAC1B,YAAYC,gBAAgB;AAC5B,YAAYC,YAAY;AACxB,YAAYC,YAAY;AACxB,YAAYC,SAAS;AACrB,SAASC,iBAAiB;","names":["deepgram","elevenlabs","openai","google","xai","inference"]}

package/docs/README.md

@@ -1,6 +1,6 @@
-# Lua CLI - Complete API Documentation
+# lua-cli v3.16.2
 
-Welcome to the comprehensive API documentation for lua-cli v3.14.0. This guide covers every API, class, and function exported by the package.
+Welcome to the comprehensive API documentation for lua-cli v3.16.2. This guide covers every API, class, and function exported by the package.
 
 ## 📚 Documentation Index
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lua-cli",
-  "version": "3.15.3",
+  "version": "3.16.2",
   "description": "Build, test, and deploy AI agents with custom tools, webhooks, and scheduled jobs. Features LuaAgent unified configuration, streaming chat, and batch deployment.",
   "readmeFilename": "README.md",
   "main": "dist/api-exports.js",
@@ -10,18 +10,18 @@
     "lua-ai": "./dist/index.js"
   },
   "exports": {
-    ".": "./dist/api-exports.js"
-  },
-  "scripts": {
-    "clean": "rm -rf dist",
-    "build": "npm run clean && tsc && npm run build:vendor && chmod +x dist/index.js",
-    "build:vendor": "node scripts/build-vendor.mjs",
-    "prepack": "node scripts/resolve-workspace-deps.cjs",
-    "postpack": "git checkout package.json",
-    "prepublishOnly": "npm run build",
-    "test": "jest",
-    "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage"
+    ".": {
+      "types": "./dist/api-exports.d.ts",
+      "default": "./dist/api-exports.js"
+    },
+    "./voice": {
+      "types": "./dist/voice-exports.d.ts",
+      "default": "./dist/voice-exports.js"
+    },
+    "./voice/test": {
+      "types": "./dist/voice/test/index.d.ts",
+      "default": "./dist/voice/test/index.js"
+    }
   },
   "keywords": [
     "lua",
@@ -64,8 +64,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@lua/shared-source-sync": "0.0.1",
-    "@lua/shared-types": "0.0.1",
+    "@livekit/agents": "^1.4.2",
+    "@livekit/agents-plugin-deepgram": "^1.4.2",
+    "@livekit/agents-plugin-elevenlabs": "^1.4.2",
+    "@livekit/agents-plugin-google": "^1.4.2",
+    "@livekit/agents-plugin-openai": "^1.4.2",
+    "@livekit/agents-plugin-xai": "^1.4.2",
+    "@livekit/rtc-node": "^0.13.27",
     "@tailwindcss/postcss": "^4.1.14",
     "@tanstack/react-query": "^5.90.11",
     "@truestamp/canonify": "^2.1.0",
@@ -82,14 +87,13 @@
     "posthog-node": "^5.26.0",
     "ts-evaluator": "^2.0.0",
     "ts-morph": "^27.0.0",
+    "typescript": "^5.9.2",
+    "undici": "^6.21.0",
     "zod": "^3.25.76",
     "zod-to-json-schema": "^3.24.6"
   },
-  "bundledDependencies": [
-    "@lua/shared-source-sync",
-    "@lua/shared-types"
-  ],
   "devDependencies": {
+    "@microsoft/api-extractor": "^7.58.7",
     "@swc/core": "^1.15.0",
     "@swc/jest": "^0.2.39",
     "@types/diff": "^7.0.2",
@@ -104,6 +108,19 @@
     "nock": "^14.0.11",
     "stripe": "^19.2.0",
     "ts-node": "^10.9.2",
-    "typescript": "^5.9.2"
+    "tsup": "^8.5.1",
+    "@lua/shared-source-sync": "0.0.1",
+    "@lua/shared-types": "0.0.1",
+    "@lua/shared-sandbox": "0.0.1"
+  },
+  "scripts": {
+    "clean": "rm -rf dist temp",
+    "build": "npm run clean && tsup && npm run build:vendor && npm run build:dts && npm run build:dts-rollup && chmod +x dist/index.js",
+    "build:vendor": "node scripts/build-vendor.mjs",
+    "build:dts": "tsc -p tsconfig.build.json",
+    "build:dts-rollup": "node scripts/run-api-extractor.mjs",
+    "test": "jest",
+    "test:watch": "jest --watch",
+    "test:coverage": "jest --coverage"
   }
-}
+}