Set up a custom LLM WebSocket server for your Retell agent

import express, { Request } from "express";
import expressWs from "express-ws";
import { RawData, WebSocket } from "ws";

const app = expressWs(express()).app;
const PORT = 3000;

app.ws("/llm-websocket/:call_id", (ws: WebSocket, req: Request) => {
  const callId = req.params.call_id;
  console.log("LLM WebSocket open for call:", callId);

  ws.on("error", (err) => console.error("LLM WebSocket error:", err));
  ws.on("close", () => console.log("LLM WebSocket closed for call:", callId));

  ws.on("message", (data: RawData, isBinary: boolean) => {
    if (isBinary) {
      ws.close(1007, "Expected a text frame.");
      return;
    }
    console.log(JSON.parse(data.toString()));
  });
});

app.listen(PORT, () => console.log(`Listening on ${PORT}`));

import json
from fastapi import FastAPI, WebSocket, WebSocketDisconnect

app = FastAPI()

@app.websocket("/llm-websocket/{call_id}")
async def llm_websocket(websocket: WebSocket, call_id: str):
    await websocket.accept()
    print(f"LLM WebSocket open for call: {call_id}")

    try:
        while True:
            print(json.loads(await websocket.receive_text()))
    except WebSocketDisconnect:
        print(f"LLM WebSocket closed for call: {call_id}")

const BEGIN_MESSAGE = "How may I help you?";

ws.send(
  JSON.stringify({
    response_type: "config",
    config: {
      auto_reconnect: true,
      call_details: true,
    },
  }),
);

ws.send(
  JSON.stringify({
    response_type: "response",
    response_id: 0,
    content: BEGIN_MESSAGE,
    content_complete: true,
  }),
);

BEGIN_MESSAGE = "How may I help you?"

await websocket.send_json(
    {
        "response_type": "config",
        "config": {
            "auto_reconnect": True,
            "call_details": True,
        },
    }
)

await websocket.send_json(
    {
        "response_type": "response",
        "response_id": 0,
        "content": BEGIN_MESSAGE,
        "content_complete": True,
    }
)

ws.on("message", (data: RawData, isBinary: boolean) => {
  if (isBinary) {
    ws.close(1007, "Expected a text frame.");
    return;
  }
  const request = JSON.parse(data.toString());

  switch (request.interaction_type) {
    case "ping_pong":
      ws.send(
        JSON.stringify({
          response_type: "ping_pong",
          timestamp: request.timestamp,
        }),
      );
      break;

    case "response_required":
    case "reminder_required":
      ws.send(
        JSON.stringify({
          response_type: "response",
          response_id: request.response_id,
          content: "I am sorry, can you say that again?",
          content_complete: true,
        }),
      );
      break;

    case "call_details":
      console.log("Call details:", request.call);
      break;

    case "update_only":
      // Live transcript and turn taking. Nothing to answer.
      break;
  }
});

while True:
    request = json.loads(await websocket.receive_text())
    interaction_type = request["interaction_type"]

    if interaction_type == "ping_pong":
        await websocket.send_json(
            {
                "response_type": "ping_pong",
                "timestamp": request["timestamp"],
            }
        )

    elif interaction_type in ("response_required", "reminder_required"):
        await websocket.send_json(
            {
                "response_type": "response",
                "response_id": request["response_id"],
                "content": "I am sorry, can you say that again?",
                "content_complete": True,
            }
        )

    elif interaction_type == "call_details":
        print("Call details:", request["call"])

    # update_only carries the live transcript. Nothing to answer.