ElevenLabs Agents

import json
import time
import uuid

from fastapi import FastAPI, Header, HTTPException
from fastapi.responses import StreamingResponse
from pydantic import BaseModel

from docsassistant.core import ask      # the channel-agnostic core: async iterator of text tokens
from docsassistant.config import settings

app = FastAPI()


class Message(BaseModel):
    role: str
    content: str | list | None = None


class ChatRequest(BaseModel):
    model: str
    messages: list[Message]
    stream: bool = True
    user_id: str | None = None
    elevenlabs_extra_body: dict | None = None


def chunk(completion_id: str, model: str, delta: dict, finish: str | None = None) -> str:
    body = {
        "id": completion_id,
        "object": "chat.completion.chunk",
        "created": int(time.time()),
        "model": model,
        "choices": [{"index": 0, "delta": delta, "finish_reason": finish}],
    }
    return f"data: {json.dumps(body)}\n\n"


@app.post("/v1/chat/completions")
async def completions(request: ChatRequest, authorization: str = Header(default="")):
    if authorization != f"Bearer {settings.elevenlabs_llm_secret}":   # the secret stored in the agent's LLM settings
        raise HTTPException(status_code=401)

    turns = [(m.role, m.content) for m in request.messages
             if m.role in ("user", "assistant") and isinstance(m.content, str)]
    text = next((content for role, content in reversed(turns) if role == "user"), "")
    extra = request.elevenlabs_extra_body or {}
    user_id = extra.get("user_id", request.user_id or "anonymous")
    thread_id = extra.get("conversation_id")
    if thread_id is None:
        # No stable thread: a new one per turn would lose the conversation, so carry the platform's history instead.
        thread_id = f"elevenlabs-{uuid.uuid4()}"
        history = "\n".join(f"{role}: {content}" for role, content in turns[:-1][-10:])
        if history:
            text = f"Conversation so far:\n{history}\n\nCaller: {text}"
    completion_id = f"chatcmpl-{uuid.uuid4().hex}"

    async def events():
        yield chunk(completion_id, request.model, {"role": "assistant"})
        async for token in ask(thread_id, user_id, text):
            yield chunk(completion_id, request.model, {"content": token})
        yield chunk(completion_id, request.model, {}, finish="stop")
        yield "data: [DONE]\n\n"

    return StreamingResponse(events(), media_type="text/event-stream")

import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.UUID;
import java.util.stream.Collectors;

import org.springframework.ai.chat.client.ChatClient;
import org.springframework.ai.chat.memory.ChatMemory;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.server.ResponseStatusException;
import reactor.core.publisher.Flux;

@RestController
class CustomLlmController {

    private final ChatClient docsAssistant;
    private final String secret;

    CustomLlmController(ChatClient docsAssistant, @Value("${elevenlabs.llm-secret}") String secret) {
        this.docsAssistant = docsAssistant;
        this.secret = secret;
    }

    record Message(String role, Object content) { }

    record ChatRequest(String model, List<Message> messages, Map<String, Object> elevenlabs_extra_body) { }

    // Each Map element is written as one "data: {json}" event; the String is written as "data: [DONE]".
    @PostMapping(value = "/v1/chat/completions", produces = MediaType.TEXT_EVENT_STREAM_VALUE)
    Flux<Object> completions(@RequestBody ChatRequest request,
                             @RequestHeader(value = "Authorization", defaultValue = "") String auth) {
        if (!("Bearer " + this.secret).equals(auth)) {
            throw new ResponseStatusException(HttpStatus.UNAUTHORIZED);
        }
        List<Message> turns = request.messages().stream()
                .filter(m -> ("user".equals(m.role()) || "assistant".equals(m.role())) && m.content() instanceof String)
                .toList();
        String text = turns.reversed().stream()
                .filter(m -> "user".equals(m.role()))
                .map(m -> (String) m.content()).findFirst().orElse("");
        Map<String, Object> extra = request.elevenlabs_extra_body() == null
                ? Map.of() : request.elevenlabs_extra_body();
        Object conversationId = extra.get("conversation_id");
        String thread;
        if (conversationId != null) {
            thread = conversationId.toString();
        } else {
            // No stable thread: a new one per turn would lose the conversation, so carry the platform's history instead.
            thread = "elevenlabs-" + UUID.randomUUID();
            List<Message> earlier = turns.subList(Math.max(0, turns.size() - 11), Math.max(0, turns.size() - 1));
            if (!earlier.isEmpty()) {
                String history = earlier.stream().map(m -> m.role() + ": " + m.content())
                        .collect(Collectors.joining("\n"));
                text = "Conversation so far:\n" + history + "\n\nCaller: " + text;
            }
        }
        String id = "chatcmpl-" + UUID.randomUUID().toString().replace("-", "");

        Flux<String> tokens = this.docsAssistant.prompt()
                .user(text)
                .advisors(a -> a.param(ChatMemory.CONVERSATION_ID, thread))
                .stream().content();
        return Flux.concat(
                Flux.just(chunk(id, request.model(), Map.of("role", "assistant"), null)),
                tokens.map(t -> chunk(id, request.model(), Map.of("content", t), null)),
                Flux.just(chunk(id, request.model(), Map.of(), "stop"), "[DONE]"));
    }

    private static Map<String, Object> chunk(String id, String model, Map<String, Object> delta, String finish) {
        Map<String, Object> choice = new HashMap<>();
        choice.put("index", 0);
        choice.put("delta", delta);
        choice.put("finish_reason", finish);
        return Map.of("id", id, "object", "chat.completion.chunk",
                "created", System.currentTimeMillis() / 1000, "model", model, "choices", List.of(choice));
    }
}

import httpx
from fastapi import Depends, FastAPI

from docsassistant.security import current_user, User
from docsassistant.config import settings

app = FastAPI()


@app.get("/api/elevenlabs/token")
async def conversation_token(user: User = Depends(current_user)) -> dict:
    async with httpx.AsyncClient(timeout=10) as http:
        response = await http.get(
            "https://api.elevenlabs.io/v1/convai/conversation/token",
            params={"agent_id": settings.elevenlabs_agent_id},
            headers={"xi-api-key": settings.elevenlabs_api_key},
        )
    response.raise_for_status()
    return response.json()      # {"token": "..."}

import { ConversationProvider, useConversationControls, useConversationStatus } from "@elevenlabs/react";

function Button() {
  const { startSession, endSession } = useConversationControls();
  const { status } = useConversationStatus();

  async function start() {
    await navigator.mediaDevices.getUserMedia({ audio: true });      // ask for the microphone from a user gesture
    const response = await fetch("/api/elevenlabs/token", { credentials: "include" });
    const { token } = await response.json();
    await startSession({ conversationToken: token });
  }

  return status === "connected"
    ? <button onClick={() => endSession()}>End call</button>
    : <button onClick={start}>Ask DocsAssistant</button>;
}

export function VoiceWidget() {
  return (
    <ConversationProvider>
      <Button />
    </ConversationProvider>
  );
}