Markdown সংস্করণ

AI-translated from English; not yet reviewed by a fluent editor.

# শুধু পড়ার টুল কলসহ স্থানীয় Realtime ভয়েস এজেন্ট তৈরি করুন

> OpenAI Realtime ও দুটি কাল্পনিক শুধু-পড়ার টুল দিয়ে ব্রাউজারে সরাসরি কণ্ঠের কথোপকথন তৈরি করুন। সার্ভার, ব্রাউজার ও নিয়ন্ত্রকের সম্পূর্ণ কোড কল ID মেলানো, নিরাপদে চালিয়ে যাওয়া, বাধা দেওয়া ও মাইক্রোফোন ছাড়ার পদ্ধতি দেখায়।

By BIG CHANGE Editorial

Published: 2026-10-19T23:39:53.236Z
Updated: 2026-10-19T23:39:53.236Z
Canonical: https://bigchange.ai/blog/openai-realtime-voice-read-only-tool-calls-guide

![Conceptual charcoal illustration of a person speaking into a tabletop microphone while wearing headphones, with a compact computer and two separate unmarked modules nearby.](https://bigchange.ai/api/media/file/realtime-voice-tool-calls-hero-v1.png)
AI-generated conceptual illustration by BIG CHANGE; no actual OpenAI interface, API session, device test or heard answer is depicted.

মুখে উত্তর দিতে কয়েকটি খোঁজ দরকার হলে ব্রাউজারের কণ্ঠের কথোপকথন জটিল হয়। মডেল একটি সম্পূর্ণ উত্তরে একাধিক ফাংশন কল ফেরাতে পারে। প্রতিটি ফল তার মূল `call_id` দিয়ে ফেরত দিতে হবে, এবং সব ফল পাঠানোর পরেই নতুন উত্তর শুরু করতে হবে। এই নির্দেশিকা ডেভেলপারকে সম্পূর্ণ localhost উদাহরণ দেয়: সরাসরি মাইক্রোফোন ইনপুট, WebRTC প্রবাহিত প্লেব্যাক, দুটি কাল্পনিক শুধু-পড়ার টুল, বারবার কথার পালা ও বাধার সময় পরিষ্কার করা। এটি আমাদের [ব্রাউজারে কণ্ঠের প্রাথমিক নির্দেশিকা](https://bigchange.ai/blog/openai-realtime-browser-voice-webrtc-guide) সম্প্রসারণ করে; সেখানে বাইরের টুল ছাড়াই বলা উত্তর তৈরি হয়।

## বড় পরিবর্তন

- **কী বদলেছে:** OpenAI-এর [Realtime API](https://developers.openai.com/api/docs/guides/realtime-conversations) সরাসরি কণ্ঠের সেশনে ফাংশন কল ফেরাতে পারে। এই উদাহরণ `call_id` দিয়ে সম্পূর্ণ কলকে স্থানীয় ফলের সঙ্গে মেলায়, তারপর মডেলকে চালিয়ে যেতে বলে।
- **কেন গুরুত্বপূর্ণ:** ডেভেলপার একাধিক শুধু-পড়ার খোঁজের ওপর নির্ভরশীল বলা উত্তর পরীক্ষা করতে পারেন। মাইক্রোফোনের শব্দ ধরা ও বাজানো ব্রাউজারে এবং সাধারণ API কী স্থানীয় সার্ভারে থাকে।
- **যা লক্ষ করবেন:** স্থানীয় যাচাই কৃত্রিম ঘটনা দিয়ে ঘটনার ক্রম ও পরিষ্কার করা পরীক্ষা করে। আপনার নিজের সশুল্ক সেশনেই নিশ্চিত করতে হবে যে হিসাব, ব্রাউজার, যন্ত্র ও নেটওয়ার্ক থেকে শোনা যায় এমন সঠিক উত্তর এবং প্রত্যাশিত বিল হচ্ছে কি না।

উদাহরণ OpenAI-এর সাধারণ Realtime WebRTC প্রান্তবিন্দু `/v1/realtime/calls` ও `gpt-realtime-2.1` ব্যবহার করে। আলাদা GPT-Live সেশন প্রোটোকল ব্যবহার করে না। নিচের দুটি “গ্রন্থাগার” মান কাল্পনিক সফটওয়্যার পরীক্ষার তথ্য, কোনো আসল জায়গার বিবরণ নয়। BIG CHANGE ২০ অক্টোবর ২০২৬-এ চলতি [WebRTC](https://developers.openai.com/api/docs/guides/voice-webrtc), [কথোপকথন](https://developers.openai.com/api/docs/guides/realtime-conversations), [টুল](https://developers.openai.com/api/docs/guides/realtime-mcp) ও [ঘটনার](https://developers.openai.com/api/reference/resources/realtime/client-events) নথি যাচাই করেছে। আমরা স্থানীয় কৃত্রিম নিয়ন্ত্রক ও ব্রাউজার পরীক্ষা চালিয়েছি, কিন্তু সশুল্ক API সেশন খুলিনি বা আসল মাইক্রোফোন কিংবা শব্দ পরীক্ষা করিনি।

## ১. প্রবেশাধিকার যাচাই করে পাঁচটি ফাইল তৈরি করুন

Node.js 22.6 বা পরের সংস্করণ, মাইক্রোফোন ও স্পিকারসহ চলতি ব্রাউজার এবং `gpt-realtime-2.1` ব্যবহারের অধিকারসহ OpenAI API প্রকল্প দরকার। এর [মডেল পৃষ্ঠা](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) বলছে Free স্তর সমর্থিত নয়। আগে API বিলিং ও প্রকল্পের অনুরোধের হার ও খরচসীমা দেখুন; ChatGPT সাবস্ক্রিপশন API ব্যবহারের বিল দেয় না। আপনার স্বাভাবিক স্থানীয় গোপন তথ্য রাখার ব্যবস্থায় `OPENAI_API_KEY` রাখুন **সার্ভার প্রক্রিয়ার পরিবেশে** । এই ফাইল, ব্রাউজার কোড বা লিখিত কথার রেকর্ডে কী লিখবেন না। শুধু OpenAI-কে পাঠানোর অনুমতি আছে এমন কথা ব্যবহার করুন।

নতুন ডিরেক্টরি তৈরি করে নিচের পাঁচটি সম্পূর্ণ ব্লক তাদের ওপরে দেওয়া ফাইলনামে সংরক্ষণ করুন। `.mjs` এক্সটেনশন রাখুন এবং সব ফাইল একই ডিরেক্টরিতে রাখুন। সার্ভার শুনবে `127.0.0.1:3000` ঠিকানায়। এটি স্থানীয় পৃষ্ঠার SDP offer নিয়ে সার্ভারের কী দিয়ে OpenAI-কে পাঠায় ও SDP answer ফেরায়। ব্রাউজার সাধারণ API কী পায় না। স্থানীয় Host ও Origin যাচাই প্রদর্শনকে localhost-এ রাখতে সাহায্য করে; যৌথ সেবার ব্যবহারকারীদের পরিচয় প্রমাণ করে না।

**server.mjs**

```javascript
import express from "express";

const app = express();
// This demo accepts only the local page, including protection against DNS rebinding.
app.use((req, res, next) => {
  const hosts = ["localhost:3000", "127.0.0.1:3000"];
  if (!hosts.includes(req.get("host"))) return res.status(403).send("Local host required");
  if (req.method === "POST" && req.get("origin") !== `http://${req.get("host")}`) {
    return res.status(403).send("Same-origin local page required");
  }
  next();
});
app.use(express.text({ type: "application/sdp", limit: "64kb" }));

app.get("/", (_req, res) => res.sendFile("index.html", { root: process.cwd() }));
app.get("/controller.mjs", (_req, res) => res.sendFile("controller.mjs", { root: process.cwd() }));

app.post("/session", async (req, res) => {
  if (!process.env.OPENAI_API_KEY) return res.status(500).send("Server API key missing");
  if (typeof req.body !== "string" || !req.body.startsWith("v=")) {
    return res.status(400).send("Expected an SDP offer");
  }

  const form = new FormData();
  form.set("sdp", req.body);
  form.set("session", JSON.stringify({
    type: "realtime",
    model: "gpt-realtime-2.1",
    output_modalities: ["audio"],
    audio: { output: { voice: "marin" } },
    instructions: "Answer questions about the fictional demo library only using its read-only tools. State clearly that the data is synthetic software test data, not real venue information. For a lookup that may take noticeable time, give one short spoken progress preamble when useful, then call the tools. A preamble is never a result. Do not invent missing information. If a tool result is an error, say that lookup failed. Respond concisely in speech.",
    tools: [
      { type: "function", name: "get_demo_hours", description: "Read synthetic demo-library opening hours; no external account or network.", parameters: { type: "object", properties: {}, additionalProperties: false } },
      { type: "function", name: "get_demo_address", description: "Read synthetic demo-library address; no external account or network.", parameters: { type: "object", properties: {}, additionalProperties: false } }
    ],
    tool_choice: "auto"
  }));

  try {
    const upstream = await fetch("https://api.openai.com/v1/realtime/calls", {
      method: "POST",
      headers: { Authorization: `Bearer ${process.env.OPENAI_API_KEY}` },
      body: form,
      signal: AbortSignal.timeout(25000)
    });
    const answer = await upstream.text();
    if (!upstream.ok) {
      console.error("Realtime session rejected", upstream.status);
      return res.status(502).send(`OpenAI session request failed (${upstream.status})`);
    }
    res.type("application/sdp").send(answer);
  } catch (error) {
    console.error("Realtime session network failure", error.name);
    res.status(502).send("Could not reach the Realtime API");
  }
});

app.listen(3000, "127.0.0.1", () => console.log("Open http://localhost:3000"));
```

**index.html**

```html
<!doctype html>
<html lang="en">
<meta charset="utf-8">
<meta name="viewport" content="width=device-width,initial-scale=1">
<title>Local Realtime voice and read-only tool check</title>
<h1>Local voice and tool check</h1>
<p>The library data in this demo is synthetic software test data.</p>
<button id="start">Start voice</button>
<button id="stop" disabled>Stop and release microphone</button>
<p id="status" role="status">Idle</p>
<audio id="reply" autoplay controls></audio>
<pre id="events" aria-label="Event status"></pre>
<script type="module">
import { ToolController } from "/controller.mjs";

const start = document.querySelector("#start");
const stop = document.querySelector("#stop");
const status = document.querySelector("#status");
const events = document.querySelector("#events");
const reply = document.querySelector("#reply");
let current;

function note(line) {
  events.textContent = `${line}\n${events.textContent}`.slice(0, 3000);
}

// These values are synthetic test fixtures, never real business records.
async function runDemoTool(call, signal) {
  if (signal.aborted) throw Error("interrupted");
  let args;
  try { args = JSON.parse(call.arguments); } catch { return { ok: false, error: "Invalid arguments" }; }
  if (!args || Array.isArray(args) || typeof args !== "object" || Object.keys(args).length) {
    return { ok: false, error: "Expected an empty object" };
  }
  if (call.name === "get_demo_hours") return { ok: true, value: "Synthetic demo library hours: Monday-Friday 09:00-17:00." };
  if (call.name === "get_demo_address") return { ok: true, value: "Synthetic demo library address: 1 Example Lane. This is not a real venue." };
  return { ok: false, error: "Tool is not allowed" };
}

function closeSession(session = current, message = "Stopped") {
  if (!session || session.closed) return;
  session.closed = true;
  clearTimeout(session.setupTimer);
  clearTimeout(session.sessionTimer);
  session.controller?.close();
  session.abort.abort();
  session.mic?.getTracks().forEach(track => track.stop());
  if (session.pc) session.pc.onconnectionstatechange = null;
  session.dc?.close();
  session.pc?.close();
  reply.pause();
  if (current === session) {
    current = null;
    reply.srcObject = null;
    start.disabled = false;
    stop.disabled = true;
    status.textContent = message;
    note(message);
  }
}

start.onclick = async () => {
  const session = { abort: new AbortController(), closed: false };
  current = session;
  start.disabled = true;
  stop.disabled = false;
  status.textContent = "Requesting microphone";
  events.textContent = "";
  session.setupTimer = setTimeout(() => closeSession(session, "Setup timed out; microphone stopped"), 30000);
  try {
    const mic = await navigator.mediaDevices.getUserMedia({ audio: true });
    if (session.closed) { mic.getTracks().forEach(track => track.stop()); return; }
    session.mic = mic;
    const pc = session.pc = new RTCPeerConnection();
    pc.ontrack = event => {
      if (session.closed) return;
      reply.srcObject = event.streams[0];
      reply.play().catch(() => note("Playback blocked; press Play on the audio control"));
    };
    pc.onconnectionstatechange = () => {
      if (session.closed) return;
      note(`Peer: ${pc.connectionState}`);
      if (pc.connectionState === "connected") {
        clearTimeout(session.setupTimer);
        clearTimeout(session.sessionTimer);
        session.sessionTimer = setTimeout(() => closeSession(session, "Local session limit reached; microphone stopped"), 55 * 60000);
        status.textContent = "Connected; ask about the synthetic demo library";
      }
      if (["failed", "closed", "disconnected"].includes(pc.connectionState)) closeSession(session, "Connection ended; microphone stopped");
    };
    pc.addTrack(mic.getAudioTracks()[0], mic);
    const dc = session.dc = pc.createDataChannel("oai-events");
    const send = event => {
      if (session.closed || dc.readyState !== "open") throw Error("Event channel is not open");
      dc.send(JSON.stringify(event));
    };
    session.controller = new ToolController({
      send, runTool: runDemoTool,
      status: note,
      fatal: message => closeSession(session, `${message}; microphone stopped`)
    });
    dc.onmessage = message => {
      if (session.closed) return;
      let event;
      try { event = JSON.parse(message.data); } catch { closeSession(session, "Invalid event; microphone stopped"); return; }
      if (event.type === "session.created") note("Realtime session created");
      if (event.type === "output_audio_buffer.cleared") note("Server cleared unplayed speech after interruption");
      session.controller.handle(event).catch(() => closeSession(session, "Controller failed; microphone stopped"));
    };
    dc.onclose = () => { if (!session.closed) closeSession(session, "Event channel closed; microphone stopped"); };
    dc.onerror = () => closeSession(session, "Event channel failed; microphone stopped");
    const offer = await pc.createOffer();
    await pc.setLocalDescription(offer);
    if (session.closed) return;
    const response = await fetch("/session", {
      method: "POST", headers: { "Content-Type": "application/sdp" },
      body: offer.sdp, signal: session.abort.signal
    });
    if (!response.ok) throw Error(`Session request failed (${response.status})`);
    const answer = await response.text();
    if (session.closed) return;
    await pc.setRemoteDescription({ type: "answer", sdp: answer });
    if (!session.closed) status.textContent = "Signaling complete; waiting for connection";
  } catch (error) {
    if (!session.closed) closeSession(session, `Start failed: ${error.message}`);
  }
};
stop.onclick = () => closeSession();
window.addEventListener("pagehide", () => closeSession());
</script>
</html>
```

**controller.mjs**

```javascript
// The same controller runs in the browser and in the synthetic local checks.
export class ToolController {
  constructor({ send, runTool, status, fatal, setTimer = setTimeout, clearTimer = clearTimeout }) {
    Object.assign(this, { send, runTool, status, fatal, setTimer, clearTimer });
    this.epoch = 0;
    this.rounds = 0;
    this.counter = 0;
    this.responses = new Map();
    this.pending = null;
    this.closed = false;
  }

  abortPending() {
    if (!this.pending) return;
    this.pending.abort.abort();
    if (this.pending.timer) this.clearTimer(this.pending.timer);
    this.pending = null;
  }

  close() {
    this.closed = true;
    this.epoch++;
    this.abortPending();
    this.responses.clear();
  }

  fail(message) {
    if (this.closed) return;
    this.status(message);
    this.close();
    this.fatal(message);
  }

  interrupt() {
    if (this.closed) return;
    this.epoch++;
    this.rounds = 0;
    this.abortPending();
    this.status("Speech detected; interrupted result discarded");
  }

  async handle(event) {
    if (this.closed) return;
    if (event.type === "error") {
      this.fail(`Realtime error: ${event.error?.code || event.error?.message || "unknown"}`);
      return;
    }
    if (event.type === "input_audio_buffer.speech_started") { this.interrupt(); return; }
    if (event.type === "response.created") {
      if (event.response?.id) this.responses.set(event.response.id, this.epoch);
      return;
    }
    if (event.type === "conversation.item.done") {
      const p = this.pending;
      const id = event.item?.id;
      if (!p || p.epoch !== this.epoch || !p.acks.has(id)) return;
      p.acks.delete(id);
      if (p.acks.size === 0) {
        if (p.timer) this.clearTimer(p.timer);
        this.pending = null;
        if (!p.abort.signal.aborted && !this.closed && p.epoch === this.epoch) {
          this.status("All tool outputs acknowledged; resuming response");
          this.send({ type: "response.create" });
        }
      }
      return;
    }
    if (event.type !== "response.done") return;
    const response = event.response;
    const id = response?.id;
    const responseEpoch = this.responses.get(id);
    this.responses.delete(id);
    if (responseEpoch === undefined || responseEpoch !== this.epoch) return;
    this.status(`Response ${id}: ${response.status || "unknown"}`);
    if (response.status !== "completed") return; // Never execute partial/cancelled calls.
    const calls = (response.output || []).filter(item => item.type === "function_call");
    if (!calls.length) return;
    if (this.pending) { this.fail("Overlapping tool batches in one turn"); return; }
    if (calls.length > 8 || ++this.rounds > 3) { this.fail("Tool call or round bound reached"); return; }
    const ids = new Set();
    for (const call of calls) {
      if (call.status !== "completed" || !call.call_id || ids.has(call.call_id)) {
        this.fail("Incomplete or repeated function call ID"); return;
      }
      ids.add(call.call_id);
    }
    const p = { epoch: this.epoch, abort: new AbortController(), acks: new Set(), timer: null };
    this.pending = p;
    this.status(`Executing ${calls.length} read-only local call(s) from ${id}`);
    const outputs = await Promise.all(calls.map(async call => {
      try { return { call, result: await this.runTool(call, p.abort.signal) }; }
      catch { return { call, result: { ok: false, error: "Local lookup failed" } }; }
    }));
    if (this.closed || this.pending !== p || p.epoch !== this.epoch || p.abort.signal.aborted) return;
    try {
      for (const { call, result } of outputs) {
        const itemId = `tool_output_${++this.counter}`;
        p.acks.add(itemId);
        this.send({
          type: "conversation.item.create",
          event_id: `tool_event_${this.counter}`,
          item: { id: itemId, type: "function_call_output", call_id: call.call_id, output: JSON.stringify(result) }
        });
        this.status(`Sent result for ${call.call_id}`);
      }
      p.timer = this.setTimer(() => this.fail("Tool output acknowledgement timed out"), 8000);
    } catch { this.fail("Could not send tool outputs"); }
  }
}
```

**protocol-check.mjs**

```javascript
import assert from "node:assert/strict";
import { ToolController } from "./controller.mjs";

const deferred = () => { let resolve, reject; const promise = new Promise((a, b) => { resolve = a; reject = b; }); return { promise, resolve, reject }; };
const tick = () => new Promise(resolve => setImmediate(resolve));
const call = (id, name = "get_demo_hours") => ({ type: "function_call", status: "completed", call_id: id, name, arguments: "{}" });
const created = id => ({ type: "response.created", response: { id } });
const done = (id, status, output = []) => ({ type: "response.done", response: { id, status, output } });

function harness(runTool = async x => ({ ok: true, value: x.name })) {
  const sent = [], statuses = [], failures = [];
  const timers = new Map(); let nextTimer = 0;
  const controller = new ToolController({
    send: e => sent.push(e), runTool,
    status: s => statuses.push(s), fatal: e => failures.push(e),
    setTimer: callback => { const id = ++nextTimer; timers.set(id, callback); return id; },
    clearTimer: id => timers.delete(id)
  });
  return { controller, sent, statuses, failures, timers };
}

// Mixed audio/message output, two asynchronous calls resolved in reverse order.
{
  const a = deferred(), b = deferred();
  const h = harness(x => x.call_id === "call_A" ? a.promise : b.promise);
  await h.controller.handle(created("resp_1"));
  const work = h.controller.handle(done("resp_1", "completed", [
    { type: "message", status: "completed", content: [{ type: "output_audio", transcript: "Checking." }] },
    call("call_A"), call("call_B", "get_demo_address")
  ]));
  b.resolve({ ok: true, value: "address" }); await tick();
  assert.equal(h.sent.length, 0, "first finished lookup must not send or resume early");
  a.resolve({ ok: true, value: "hours" }); await work;
  assert.deepEqual(h.sent.map(x => x.item?.call_id), ["call_A", "call_B"]);
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 0);
  await h.controller.handle({ type: "conversation.item.done", item: { id: h.sent[1].item.id } });
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 0);
  await h.controller.handle({ type: "conversation.item.done", item: { id: h.sent[0].item.id } });
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 1, "one resume after both item acknowledgements");
}

// One local lookup error does not erase the other result.
{
  const h = harness(async x => { if (x.call_id === "bad") throw Error("synthetic failure"); return { ok: true, value: "fixture" }; });
  await h.controller.handle(created("resp_2"));
  await h.controller.handle(done("resp_2", "completed", [call("bad"), call("good")]));
  assert.equal(JSON.parse(h.sent[0].item.output).ok, false);
  assert.equal(JSON.parse(h.sent[1].item.output).ok, true);
  for (const e of h.sent.slice()) await h.controller.handle({ type: "conversation.item.done", item: { id: e.item.id } });
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 1);
}

// Partial/cancelled responses never dispatch a call.
for (const status of ["failed", "incomplete", "cancelled"]) {
  const h = harness();
  await h.controller.handle(created(`resp_${status}`));
  await h.controller.handle(done(`resp_${status}`, status, [call("ignored")]));
  assert.equal(h.sent.length, 0);
}

// Distinct rounds are bounded, and missing/duplicate IDs are rejected.
{
  const h = harness();
  for (let i = 1; i <= 3; i++) {
    await h.controller.handle(created(`round_${i}`));
    await h.controller.handle(done(`round_${i}`, "completed", [call(`call_${i}`)]));
    const last = h.sent.at(-1);
    await h.controller.handle({ type: "conversation.item.done", item: { id: last.item.id } });
  }
  await h.controller.handle(created("round_4"));
  await h.controller.handle(done("round_4", "completed", [call("too_many")]));
  assert.match(h.failures[0], /bound/);
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 3);
}
{
  const h = harness();
  await h.controller.handle(created("dup"));
  await h.controller.handle(done("dup", "completed", [call("same"), call("same")]));
  assert.match(h.failures[0], /repeated/);
}

// User speech or Stop invalidates in-flight lookups and ignores their late results.
for (const mode of ["speech", "stop"]) {
  const d = deferred(), h = harness(() => d.promise);
  await h.controller.handle(created(`resp_${mode}`));
  const work = h.controller.handle(done(`resp_${mode}`, "completed", [call("late")]));
  if (mode === "speech") await h.controller.handle({ type: "input_audio_buffer.speech_started" });
  else h.controller.close();
  d.resolve({ ok: true, value: "late fixture" }); await work;
  assert.equal(h.sent.length, 0);
}

// A late response completion or acknowledgement from the interrupted turn cannot resume it.
{
  const h = harness();
  await h.controller.handle(created("old"));
  await h.controller.handle({ type: "input_audio_buffer.speech_started" });
  await h.controller.handle(done("old", "completed", [call("late_call")]));
  assert.equal(h.sent.length, 0);
  await h.controller.handle(created("new"));
  await h.controller.handle(done("new", "completed", [call("fresh_call")]));
  const output = h.sent[0];
  await h.controller.handle({ type: "input_audio_buffer.speech_started" });
  await h.controller.handle({ type: "conversation.item.done", item: { id: output.item.id } });
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 0);
}

// Missing server acknowledgement closes instead of speculatively resuming.
{
  const h = harness();
  await h.controller.handle(created("no_ack"));
  await h.controller.handle(done("no_ack", "completed", [call("one")]));
  assert.equal(h.timers.size, 1);
  [...h.timers.values()][0]();
  assert.match(h.failures[0], /timed out/);
  assert.equal(h.sent.filter(x => x.type === "response.create").length, 0);
}

console.log("Synthetic controller checks passed: ordering, single resume, error isolation, bounds and interruption.");
```

**browser-check.mjs**

```javascript
import assert from "node:assert/strict";
import fs from "node:fs";
import vm from "node:vm";
import { ToolController } from "./controller.mjs";

const html = fs.readFileSync(new URL("./index.html", import.meta.url), "utf8");
const script = html.match(/<script type="module">([\s\S]*?)<\/script>/)?.[1]
  .replace('import { ToolController } from "/controller.mjs";', "");
assert.ok(script, "inline browser module found");

function fakePage(mediaPromise) {
  const nodes = Object.fromEntries(["#start", "#stop", "#status", "#events", "#reply"].map(k => [k, {
    disabled: k === "#stop", textContent: "", srcObject: null,
    pause() { this.paused = true; }, play() { return Promise.resolve(); }
  }]));
  let fetches = 0, peer;
  class FakePeer {
    constructor() { peer = this; this.connectionState = "new"; }
    addTrack() {}
    createDataChannel() { return this.dc = { readyState: "open", close() { this.closed = true; }, send() {} }; }
    async createOffer() { return { sdp: "v=0" }; }
    async setLocalDescription() {}
    async setRemoteDescription() {}
    close() { this.closed = true; }
  }
  vm.runInNewContext(script, {
    ToolController, document: { querySelector: k => nodes[k] },
    navigator: { mediaDevices: { getUserMedia: () => mediaPromise } },
    RTCPeerConnection: FakePeer,
    fetch: async () => { fetches++; return { ok: true, text: async () => "answer" }; },
    window: { addEventListener() {} },
    AbortController, setTimeout, clearTimeout, console
  });
  return { nodes, peer: () => peer, fetches: () => fetches };
}

// Stop while permission is pending; any late track is released without a session request.
{
  let allowMic;
  const page = fakePage(new Promise(resolve => { allowMic = resolve; }));
  const starting = page.nodes["#start"].onclick();
  page.nodes["#stop"].onclick();
  const track = { stopped: false, stop() { this.stopped = true; } };
  allowMic({ getTracks: () => [track], getAudioTracks: () => [track] });
  await starting;
  assert.equal(track.stopped, true);
  assert.equal(page.fetches(), 0);
  assert.equal(page.nodes["#start"].disabled, false);
}

// Stop after signaling: microphone, data channel, peer and playback all close.
{
  const track = { stopped: false, stop() { this.stopped = true; } };
  const page = fakePage(Promise.resolve({ getTracks: () => [track], getAudioTracks: () => [track] }));
  await page.nodes["#start"].onclick();
  page.nodes["#stop"].onclick();
  assert.equal(page.fetches(), 1);
  assert.equal(track.stopped, true);
  assert.equal(page.peer().closed, true);
  assert.equal(page.peer().dc.closed, true);
  assert.equal(page.nodes["#reply"].paused, true);
  assert.equal(page.nodes["#reply"].srcObject, null);
}

console.log("Synthetic browser lifecycle checks passed: late microphone and full Stop cleanup.");
```

সেই ডিরেক্টরিতে সার্ভারের একমাত্র নির্ভরতা ইনস্টল করে সার্ভার চালান:

```bash
npm init -y
npm install express
node server.mjs
```

খুলুন `http://localhost:3000`। পৃষ্ঠায় দেখা উচিত **Start voice**, **Stop and release microphone**, অডিও প্লেয়ার এবং ঘটনার অবস্থা। শুধু ব্রাউজার পৃষ্ঠা ও নিয়ন্ত্রক মডিউল পরিবেশিত হয়; দুটি পরীক্ষার ফাংশন ব্রাউজারে চলে, কোনো আসল জায়গা, ক্যালেন্ডার, CRM বা ব্যবসায়িক হিসাব ব্যবহার করে না।

## ২. শুরু করুন, শুনুন এবং ফল দেখুন

ক্লিক করুন **Start voice**, মাইক্রোফোনের অনুমতি দিয়ে অপেক্ষা করুন **Connected** দেখানো পর্যন্ত। কাল্পনিক নমুনা গ্রন্থাগারের সময় ও ঠিকানা জিজ্ঞেস করুন। ব্রাউজার WebRTC মিডিয়া ট্র্যাক দিয়ে মাইক্রোফোনের শব্দ পাঠায় এবং দূরের কথার ট্র্যাক আসামাত্র অডিও কন্ট্রোলে লাগায়। স্বয়ংক্রিয় বাজানো বন্ধ থাকলে দৃশ্যমান কন্ট্রোলে **Play** চাপুন। উপকারী হলে সার্ভারের নির্দেশ ছোট কথায় অগ্রগতি আগে জানাতে বলে। মডেল তা বাদ দিতে পারে; শুনতে পেলেও খোঁজ সফল হয়েছে বলে প্রমাণ হয় না।

ঘটনার প্যানেল কী, কাঁচা অডিও বা কথার লেখা না ছেপে উত্তরের অবস্থা, কল ID ও আউটপুটের স্বীকৃতি দেখায়। মডেল কোনো টুল না-ও নিতে পারে, একটি বা একাধিক নিতে পারে। যখন `response.done` তে `status: completed` থাকে, নিয়ন্ত্রক **সব** আউটপুট আইটেমে সম্পূর্ণ `function_call` আইটেম খোঁজে এবং প্রতিটি `call_id` আছে ও আলাদা কি না যাচাই করে। এটি অনুমোদিত খোঁজ, একাধিক একসঙ্গেও, চালায়, তারপর প্রতিটি মূল ID-র জন্য একটি `function_call_output` পাঠায়। ব্যর্থ খোঁজ ওই কলের ত্রুটির ফল হয়, অন্য ফলগুলি থাকে। নিয়ন্ত্রক প্রতিটি নির্দিষ্ট আউটপুট আইটেম ID-র জন্য `conversation.item.done` অপেক্ষা করে, তারপর মাত্র একটি `response.create` পাঠায়। সব স্বীকৃতির অপেক্ষা এই উদাহরণের সতর্ক স্থানীয় ক্রম, API-র শর্ত নয়। প্রতি উত্তরে সর্বোচ্চ আট কল ও বাধাহীন এক পালায় তিন টুল পর্ব আছে; এগুলি স্থানীয় সীমা।

খুঁজুন **Realtime session created**, সংযুক্ত পিয়ার, কল হলে তার ID, আউটপুটের স্বীকৃতি এবং সম্পূর্ণ পরবর্তী উত্তর। উত্তর শুনে বলা সময় ও ঠিকানা `index.html` এর কাল্পনিক স্ট্রিংয়ের সঙ্গে মেলান। উত্তর শেষের ঘটনা একাই শ্রাব্য প্লেব্যাক বা সঠিকতা নিশ্চিত করে না। এই পর্যবেক্ষণের জন্য নিজের বিলযোগ্য ব্রাউজার চালনা দরকার; BIG CHANGE তা করেনি।

## ৩. আবার পালা চালান, বাধা দিন এবং মাইক্রোফোন ছাড়ুন

নতুন করে শুরু না করে আরেকটি প্রশ্ন করুন। বাধা যাচাই করতে মডেল কথা বলার সময় বা খোঁজ অপেক্ষমাণ অবস্থায় বলুন। WebRTC ও কণ্ঠসক্রিয়তা শনাক্তকরণের ক্ষেত্রে OpenAI বাতিল করা ও এখনও না-বাজানো অডিও সার্ভার দিয়ে ছাঁটা নথিবদ্ধ করেছে। `input_audio_buffer.speech_started` এ স্থানীয় নিয়ন্ত্রক অপেক্ষমাণ খোঁজও অকার্যকর করে, যাতে দেরির ফল থামানো উত্তর আবার চালাতে না পারে। এই কোড WebSocket অডিও প্লেয়ারের দরকারি আলাদা প্লেব্যাক কার্সর ও ছাঁটার ঘটনা বাস্তবায়ন করে না।

ক্লিক করুন **Stop and release microphone** এবং নিশ্চিত করুন ব্রাউজারের মাইক্রোফোন সূচক নিভেছে। অনুমতি চাওয়ার সময়ও থামানো কাজ করে: দেরিতে অনুমতি এলে পাওয়া ট্র্যাক সঙ্গে সঙ্গে থামে। একই পরিষ্কার প্রক্রিয়া ট্র্যাক থামায়, চলতি সেশন অনুরোধ বাতিল করে, ডেটা চ্যানেল ও পিয়ার বন্ধ করে, প্লেব্যাক থামিয়ে বিচ্ছিন্ন করে, টুলের কাজ বাতিল করে এবং পৃষ্ঠা ছাড়া, সেটআপ বা স্থানীয় সেশনের সময় ফুরোনো কিংবা সংযোগ ব্যর্থতায় টাইমার মুছে দেয়। উদাহরণে সেটআপ ৩০ সেকেন্ড ও স্থানীয় সেশন ৫৫ মিনিট; OpenAI Realtime সর্বোচ্চ ৬০ মিনিট বলেছে।

## ৪. স্থানীয় যাচাই চালান এবং ব্যর্থতা সারান

একই ডিরেক্টরিতে চালান:

```bash
node --check server.mjs
node --check controller.mjs
node protocol-check.mjs
node browser-check.mjs
```

দুই স্ক্রিপ্ট কৃত্রিম ঘটনা ও ব্রাউজার অনুকরণ ব্যবহার করে। এগুলি মিশ্র বার্তা/ফাংশন উত্তর, উল্টো ক্রমে শেষ হওয়া দুই কল, একবার চালিয়ে যাওয়ার আগে সব আউটপুট ও স্বীকৃতি, কলের ত্রুটি আলাদা রাখা, শুধু সম্পূর্ণ কল চালানো, পর্বসীমা, কথা বলে বাধা, দেরির অনুমতি ছাড়া এবং Stop পরিষ্কার পরীক্ষা করে। API অনুরোধ করে না। পাস করা নেটওয়ার্ক সময়, আসল যন্ত্র, কথার মান বা উৎপাদন নির্ভরযোগ্যতা মাপে না।

যদি **Start** ব্যর্থ হয়, দৃশ্যমান অবস্থা ও স্থানীয় সার্ভারের পাওয়া বাইরের HTTP অবস্থা পড়ুন। অনুমতি, `localhost:3000`, সার্ভার পরিবেশের কী, মডেল প্রবেশ, বিলিং, সীমা ও নেটওয়ার্ক যাচাই করুন। 502 বাইরের প্রত্যাখ্যান, নেটওয়ার্ক ব্যর্থতা বা উদাহরণের ২৫ সেকেন্ড অনুরোধসীমা বোঝাতে পারে; OpenAI অনুরোধ পায়নি বলে প্রমাণ হয় না। সংযোগ হলেও শব্দ না থাকলে ইনপুট ও আউটপুট যন্ত্র দেখুন এবং **Play** চাপুন। ব্যর্থ, অসম্পূর্ণ বা বাতিল উত্তর আংশিক কল চালাতে পারে না। আউটপুট স্বীকৃতির সময় ফুরোলে নিয়ন্ত্রক অনিশ্চিত দ্বৈত চালিয়ে যাওয়া না পাঠিয়ে সেশন বন্ধ করে। শুরু বা নেটওয়ার্কের ফল অজানা হলে সেশন থামান, মাইক্রোফোন ছাড়া নিশ্চিত করুন এবং আবার চেষ্টার আগে প্রকল্পের ব্যবহার দেখুন; বাতিল অনুরোধেও খরচ হয়ে থাকতে পারে।

## খরচ ও সীমা

OpenAI-এর [মডেল পৃষ্ঠা](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) ও [মূল্যতালিকা](https://developers.openai.com/api/docs/pricing), ২০ অক্টোবর ২০২৬-এ যাচাইকৃত, ক্যাশবিহীন পাঠ ইনপুট/আউটপুটে প্রতি দশ লক্ষ টোকন ৪/২৪ মার্কিন ডলার ও অডিও ইনপুট/আউটপুটে ৩২/৬৪ ডলার দেখায়। আসল খরচ টোকন, অডিও ও পুনরাবৃত্ত কথার প্রসঙ্গে নির্ভর করে। আমরা বিল, বিলম্ব, সরাসরি টুলের আচরণ বা শুরুর প্রগতি বার্তা মাপিনি। মাইক্রোফোনের শব্দ OpenAI-কে যায়। স্থির পরীক্ষার ফাংশন আসল ব্যবসায়িক সংযোগ বা লেখার কাজের অনুমতি দেয় না। যৌথ ব্যবস্থায় নিজস্ব ব্যবহারকারী পরিচয়, সীমা, টুল অনুমোদন, নজরদারি ও পর্যালোচনা লাগবে।

### উৎস ও আরও পড়ুন

- [OpenAI WebRTC নির্দেশিকা](https://developers.openai.com/api/docs/guides/voice-webrtc): ব্রাউজার মিডিয়া ট্র্যাক, দূরের প্লেব্যাক, ডেটা চ্যানেল ও বিশ্বস্ত সার্ভারের SDP বিনিময়। এই নির্দিষ্ট ব্রাউজার বা হিসাব পরীক্ষা নয়।
- [Realtime কথোপকথন](https://developers.openai.com/api/docs/guides/realtime-conversations): সম্পূর্ণ উত্তরের সব আউটপুট, ফাংশন ফলের ক্রম, বাধা ও ৬০ মিনিটের সীমা। নির্দিষ্ট মডেল টুল ডাকবে এমন প্রতিশ্রুতি নেই।
- [Realtime টুল](https://developers.openai.com/api/docs/guides/realtime-mcp): অ্যাপের নিয়ন্ত্রণে ফাংশন কল এবং `function_call_output`। এই স্থানীয় পরীক্ষা তথ্যের সাফল্য প্রমাণ করে না।
- [ক্লায়েন্ট](https://developers.openai.com/api/reference/resources/realtime/client-events) ও [সার্ভার ঘটনা](https://developers.openai.com/api/reference/resources/realtime/server-events) নির্দেশক: আইটেম ID, স্বীকৃতি ও উত্তর ঘটনার গঠন। সব স্বীকৃতির অপেক্ষা উদাহরণের স্থানীয় সিদ্ধান্ত।
- [Realtime নির্দেশ লেখা](https://developers.openai.com/api/docs/guides/voice-prompting): শর্তসাপেক্ষ ছোট কথার ভূমিকার নির্দেশ; শ্রাব্য আউটপুটের নিশ্চয়তা নয়।
- [মডেল প্রবেশাধিকার](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) ও [API মূল্য](https://developers.openai.com/api/docs/pricing): চলতি প্রবেশস্তর ও টোকনদর। আসল বিল নিজের প্রকল্পের ব্যবহার থেকে দেখুন।

## Sources

- [OpenAI WebRTC নির্দেশিকা](https://developers.openai.com/api/docs/guides/voice-webrtc) — ব্রাউজার মাইক্রোফোন ও দূরের অডিও ট্র্যাক, oai-events ডেটা চ্যানেল এবং /v1/realtime/calls দিয়ে সাধারণ API কীসহ বিশ্বস্ত সার্ভার SDP বিনিময় নথিবদ্ধ করে। উদাহরণের আসল যন্ত্র বা নেটওয়ার্কের আচরণ প্রমাণ করে না।
- [OpenAI Realtime কথোপকথন](https://developers.openai.com/api/docs/guides/realtime-conversations) — response.done সম্পূর্ণ আউটপুট, ফাংশন ফলের পর চালানো, সার্ভার দিয়ে না-বাজা অডিও ছাঁটাসহ WebRTC VAD বাধা ও ৬০ মিনিটের সীমা নথিবদ্ধ করে। পাঠকের চালনায় টুল বা সঠিক কথার নিশ্চয়তা নয়।
- [টুলসহ OpenAI Realtime](https://developers.openai.com/api/docs/guides/realtime-mcp) — অ্যাপ ফাংশন টুল, মূল call_id-র function_call_output আইটেম এবং response.create দিয়ে চালানো নথিবদ্ধ করে। প্রতি আউটপুট স্বীকৃতির অপেক্ষা অতিরিক্ত স্থানীয় ক্রম।
- [OpenAI Realtime ক্লায়েন্ট ঘটনা](https://developers.openai.com/api/reference/resources/realtime/client-events) — উদাহরণের conversation.item.create, আইটেম ID, function_call_output ও response.create গঠন সংজ্ঞায়িত করে; নির্দেশক কোনো সংযোগ পরীক্ষা নয়।
- [OpenAI Realtime সার্ভার ঘটনা](https://developers.openai.com/api/reference/resources/realtime/server-events) — উদাহরণের সম্পূর্ণ উত্তর, চূড়ান্ত কথোপকথন আইটেমের স্বীকৃতি ও ত্রুটি ঘটনার গঠন দেয়। সব স্বীকৃতির অপেক্ষা স্থানীয় সিদ্ধান্ত, API শর্ত বা সংযোগ পরীক্ষা নয়।
- [OpenAI কণ্ঠসক্রিয়তা শনাক্তকরণ](https://developers.openai.com/api/docs/guides/realtime-vad) — স্থানীয় কাজ অকার্যকর করতে speech_started ও speech_stopped সংকেত নথিবদ্ধ করে; এখানে আসল বাধা পরীক্ষা হয়নি।
- [OpenAI Realtime নির্দেশ লেখা](https://developers.openai.com/api/docs/guides/voice-prompting) — শর্তসাপেক্ষ ছোট প্রগতি বার্তা চাওয়ার সমর্থন। সশুল্ক সেশনে কোনো বার্তা দেখা হয়নি।
- [OpenAI gpt-realtime-2.1 মডেল](https://developers.openai.com/api/docs/models/gpt-realtime-2.1) — মডেল ID, অসমর্থিত Free স্তর এবং দশ লক্ষ টোকনে ক্যাশবিহীন দর দেয়: পাঠ ইনপুট/আউটপুট ৪/২৪ মার্কিন ডলার, অডিও ৩২/৬৪। পাঠককে হিসাবের প্রবেশ ও বিলিং যাচাই করতে হবে।
- [OpenAI API মূল্য](https://developers.openai.com/api/docs/pricing) — gpt-realtime-2.1-এর প্রকাশিত পাঠ ও অডিও টোকনদর সমর্থন করে; এই গাইডের সেশনের স্থির খরচ দেয় না।
- [OpenAI API ও ChatGPT বিলিং](https://help.openai.com/en/articles/9039756-managing-billing-for-chatgpt-and-the-api-platform) — OpenAI বলে API ব্যবহার ChatGPT সাবস্ক্রিপশন থেকে আলাদাভাবে বিল হয়। এতে পাঠকের বর্তমান ব্যালান্স বা প্রকল্পসীমা প্রমাণ হয় না।