ElevenLabs Voice agent

import { chat } from "@trigger.dev/sdk/ai";
import { stepCountIs, streamText } from "ai";
import { HISTORY_TURNS, MAX_REPLY_TOKENS, SYSTEM_PROMPT } from "../lib/voice-config";
import { chatModel } from "../lib/model";

export const voiceChat = chat.agent({
  id: "voice-chat",
  // Keep the run warm between spoken turns so a quick follow-up doesn't cold-boot.
  idleTimeoutInSeconds: 120,

  // Keep only the last few turns so input tokens stay flat. Anthropic rejects a
  // conversation that doesn't start with a user message, so walk the window
  // forward to the first user message rather than slicing blindly.
  prepareMessages: ({ messages }) => {
    const maxMessages = HISTORY_TURNS * 2;
    if (messages.length <= maxMessages) return messages;
    const windowed = messages.slice(-maxMessages);
    const firstUser = windowed.findIndex((m) => m.role === "user");
    return firstUser > 0 ? windowed.slice(firstUser) : windowed;
  },

  run: async ({ messages, signal }) => {
    return streamText({
      // Spread first: wires up compaction, steering and telemetry.
      ...chat.toStreamTextOptions(),
      model: chatModel,
      system: SYSTEM_PROMPT,
      maxOutputTokens: MAX_REPLY_TOKENS,
      messages,
      abortSignal: signal,
      stopWhen: stepCountIs(1),
    });
  },
});

import { chat } from "@trigger.dev/sdk/chat-server";
import { streamText } from "ai";
import { MAX_REPLY_TOKENS, SYSTEM_PROMPT } from "./voice-config";
import { chatModel } from "./model";

// Runs turn 1 here while the agent run boots in parallel (~57% off first-turn
// time-to-first-token). Turns 2+ bypass this route and write straight to the session.
export const chatHandler = chat.headStart({
  agentId: "voice-chat",
  run: async ({ chat: helper }) =>
    streamText({
      // Spread pins stopWhen to stepCountIs(1) — don't override it, or this
      // handler runs steps the agent is supposed to own.
      ...helper.toStreamTextOptions(),
      model: chatModel,
      system: SYSTEM_PROMPT,
      maxOutputTokens: MAX_REPLY_TOKENS,
    }),
});

"use server";

import { auth } from "@trigger.dev/sdk";
import { chat } from "@trigger.dev/sdk/ai";
import { ElevenLabsClient } from "@elevenlabs/elevenlabs-js";

// Creates the session + triggers the first run. Idempotent per chatId.
export const startChatSession = chat.createStartSessionAction("voice-chat");

// The transport calls this to refresh the browser's session-scoped token.
export async function mintChatAccessToken(chatId: string) {
  return auth.createPublicToken({
    scopes: { read: { sessions: chatId }, write: { sessions: chatId } },
    expirationTime: "1h",
  });
}

// Single-use tokens for the browser's two ElevenLabs sockets; the API key stays here.
export async function mintScribeToken() {
  const { token } = await elevenlabs().tokens.singleUse.create("realtime_scribe");
  return token;
}
export async function mintTtsToken() {
  const { token } = await elevenlabs().tokens.singleUse.create("tts_websocket");
  return token;
}

"use client";

import { useChat } from "@ai-sdk/react";
import { useTriggerChatTransport } from "@trigger.dev/sdk/chat/react";
import type { voiceChat } from "@/trigger/chat";
import { mintChatAccessToken, startChatSession } from "@/app/actions";

const transport = useTriggerChatTransport<typeof voiceChat>({
  task: "voice-chat",
  accessToken: ({ chatId }) => mintChatAccessToken(chatId),
  startSession: ({ chatId, clientData }) => startChatSession({ chatId, clientData }),
  headStart: "/api/chat",
});

const { messages, sendMessage, status } = useChat({ transport });

TRIGGER_SECRET_KEY=tr_dev_xxxxxxxxxxxxxxxxxxxxxxxx
TRIGGER_PROJECT_REF=proj_xxxxxxxxxxxxxxxxxxxxxxxx
VOICE_ANTHROPIC_API_KEY=sk-ant-xxxxxxxxxxxxxxxxxxxx
ELEVENLABS_API_KEY=xxxxxxxxxxxxxxxxxxxxxxxx