Bring your own brain: answer every turn from your own Claude or OpenAI model

Browser (your page)          Your server                          Zentiq
      |  POST /zentiq/session -->|  POST /v1/sessions/tokens          |
      |                          |  { personaId, autoRespond: false } |
      |<------- token -----------|<-----------------------------------|
      |  startSession(token) ------------------------------------->  | the avatar greets
      |                          |                                    |
      |<== learner.transcript.final { text, turnId } ================| the person finishes speaking
      |  POST /zentiq/turn ----->|                                    |
      |                          |  your model writes the reply       |
      |                          |  POST /v1/sessions/{id}/say        |
      |                          |  { text, turnId } ---------------->| the avatar speaks it

// npm install @zentiq/client  (version 0.2.0; npm 7 or later also installs the package it needs alongside it)
import { startSession } from "@zentiq/client";

const token = await fetch("/zentiq/session", { method: "POST" }).then((r) => r.json());
if (token.disclosure?.required) document.querySelector("#disclosure").textContent = token.disclosure.text;

const session = await startSession({ token: token.sessionToken, url: token.url, video: document.querySelector("#avatar") });

// The live events channel: forward each finished turn to your server.
session.room.on("dataReceived", (payload, _participant, _kind, topic) => {
  if (topic !== "events") return;
  let event;
  try {
    event = JSON.parse(new TextDecoder().decode(payload));
  } catch {
    return;
  }
  if (event.type !== "learner.transcript.final") return;
  fetch("/zentiq/turn", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ sessionId: token.sessionId, turnId: event.data.turnId, text: event.data.text }),
  });
});

window.addEventListener("pagehide", () => navigator.sendBeacon("/zentiq/end", JSON.stringify({ sessionId: token.sessionId })));

// npm install @anthropic-ai/sdk
import http from "node:http";
import Anthropic from "@anthropic-ai/sdk";

const ZENTIQ = "https://app.zentiqai.com/v1";
const SYSTEM =
  "You are Ava, a friendly finance tutor on a live video call. Reply in one to three short spoken sentences, " +
  "with no lists or formatting. Latency-sensitive; begin your visible answer immediately.";
const anthropic = new Anthropic();
const sessions = new Map(); // sessionId -> the conversation so far

async function zentiq(path, body = {}) {
  const res = await fetch(`${ZENTIQ}${path}`, {
    method: "POST",
    headers: { Authorization: `Bearer ${process.env.ZENTIQ_API_KEY}`, "Content-Type": "application/json" },
    body: JSON.stringify(body),
  });
  const json = await res.json().catch(() => ({}));
  if (!res.ok) throw new Error(json.error?.message ?? `Zentiq answered ${res.status}`);
  return json.data;
}

async function reply(history) {
  const response = await anthropic.beta.messages.create({
    model: "claude-opus-5",
    max_tokens: 2048,
    output_config: { effort: "low" }, // short spoken replies: answer fast
    betas: ["server-side-fallback-2026-07-01"],
    fallbacks: "default", // if the model declines, another answers in the same call
    system: SYSTEM,
    messages: history,
  });
  if (response.stop_reason === "refusal") return "Sorry, I can't help with that one. What else can I do for you?";
  return response.content
    .filter((block) => block.type === "text")
    .map((block) => block.text)
    .join("")
    .trim();
}

const readJson = (req) =>
  new Promise((resolve) => {
    let raw = "";
    req.on("data", (chunk) => (raw += chunk));
    req.on("end", () => {
      try {
        resolve(JSON.parse(raw || "{}"));
      } catch {
        resolve({});
      }
    });
  });

http
  .createServer(async (req, res) => {
    const send = (status, body) => {
      res.writeHead(status, { "Content-Type": "application/json" });
      res.end(JSON.stringify(body));
    };
    try {
      if (req.method === "POST" && req.url === "/zentiq/session") {
        const token = await zentiq("/sessions/tokens", { personaId: process.env.PERSONA_ID, autoRespond: false });
        sessions.set(token.sessionId, []);
        return send(200, token);
      }
      if (req.method === "POST" && req.url === "/zentiq/turn") {
        const { sessionId, turnId, text } = await readJson(req);
        const history = sessions.get(sessionId);
        if (!history || typeof text !== "string" || !text.trim()) return send(404, { error: "Unknown session." });
        history.push({ role: "user", content: text });
        const answer = (await reply(history)) || "Sorry, could you say that again?";
        history.push({ role: "assistant", content: answer });
        await zentiq(`/sessions/${encodeURIComponent(sessionId)}/say`, { text: answer.slice(0, 2000), turnId, eventId: `${turnId}:reply` });
        return send(200, { ok: true });
      }
      if (req.method === "POST" && req.url === "/zentiq/end") {
        const { sessionId } = await readJson(req);
        if (sessions.delete(sessionId)) await zentiq(`/sessions/${encodeURIComponent(sessionId)}/end`);
        return send(200, { ok: true });
      }
      send(404, { error: "Not found." });
    } catch (e) {
      send(500, { error: e instanceof Error ? e.message : "Something went wrong." });
    }
  })
  .listen(3000, () => console.log("http://localhost:3000"));

// npm install openai
import OpenAI from "openai";

const openai = new OpenAI();

async function reply(history) {
  const response = await openai.responses.create({
    model: process.env.OPENAI_MODEL ?? "gpt-6-astra",
    instructions: SYSTEM,
    input: history, // [{ role: "user" | "assistant", content: "…" }]
  });
  return response.output_text.trim();
}