@inkibra/voice-sdk 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,673 +1,939 @@
-// src/client.ts
-function sessionStartMessage(options) {
-  return {
-    type: "session.start",
-    developer: options.developer
-  };
-}
-
-class LiveVoiceClient {
+// src/control.ts
+class ControlClient {
   endpoint;
   callbacks;
   socket;
-  microphone;
-  output;
-  preparation;
-  resolvePrepared;
-  rejectPrepared;
-  prepared = false;
   sessionToken;
+  snapshotValue;
+  waits = new Map;
+  executions = new Map;
+  requestCounter = 0;
+  prepared = false;
+  preparing;
   starting;
-  resolveStarted;
-  rejectStarted;
+  started = false;
+  terminal = false;
   constructor(endpoint, callbacks) {
     this.endpoint = endpoint;
     this.callbacks = callbacks;
   }
-  async prepare(token) {
-    if (this.prepared && this.sessionToken === token && this.socket?.readyState === WebSocket.OPEN)
-      return;
-    if (this.preparation && this.sessionToken === token)
-      return this.preparation;
-    if (this.socket)
-      this.stop();
-    this.sessionToken = token;
+  ratingUrl(sessionId) {
+    const url = new URL(this.endpoint);
+    url.protocol = url.protocol === "wss:" ? "https:" : url.protocol === "ws:" ? "http:" : url.protocol;
+    return `${url.origin}/v1/sessions/${encodeURIComponent(sessionId)}/rating`;
+  }
+  setCallbacks(callbacks) {
+    this.callbacks = callbacks;
+  }
+  get currentSnapshot() {
+    return this.snapshotValue;
+  }
+  retainedTaskIds() {
+    return [...this.executions.keys()];
+  }
+  async open(options) {
+    if (!options.token)
+      throw new Error("A Live Voice token is required.");
+    if (this.terminal)
+      throw new Error("This participant has been disposed or stopped.");
+    if (this.waits.has("open"))
+      throw new Error("A connection is already opening.");
+    this.closeSocket("replaced", false);
+    this.sessionToken = options.token;
     this.callbacks.onConnection("connecting");
-    const endpoint = this.endpoint.replace(/\/$/u, "");
-    const socket = new WebSocket(withSessionToken(`${endpoint}/${crypto.randomUUID()}`, token));
+    const url = new URL(`${this.endpoint.replace(/\/$/u, "")}/${encodeURIComponent(options.sessionId ?? crypto.randomUUID())}`);
+    url.searchParams.set("token", options.token);
+    const socket = new WebSocket(url);
     this.socket = socket;
-    socket.binaryType = "arraybuffer";
-    socket.addEventListener("message", (event) => this.onMessage(event.data));
+    const opening = this.exchange("open", 15000, () => {
+      const send = () => {
+        if (this.socket !== socket)
+          return;
+        this.send({
+          type: "session.open",
+          protocolVersion: 2,
+          mode: options.mode,
+          ...options.sessionId ? { sessionId: options.sessionId } : {},
+          ...options.participantId ? { participantId: options.participantId } : {},
+          tools: Object.entries(options.tools ?? {}).map(([name, tool]) => ({ name, description: tool.description, parameters: tool.parameters })),
+          ...options.developer === undefined ? {} : { developer: options.developer },
+          ...options.mediaMode ? { mediaMode: options.mediaMode } : {},
+          retainedTaskIds: options.retainedTaskIds ?? this.retainedTaskIds()
+        });
+      };
+      if (socket.readyState === WebSocket.OPEN)
+        send();
+      else
+        socket.addEventListener("open", send, { once: true });
+    });
+    socket.addEventListener("message", (event) => {
+      if (this.socket === socket)
+        this.onMessage(event.data);
+    });
     socket.addEventListener("close", (event) => {
-      if (this.socket !== socket)
-        return;
-      const wasPrepared = this.prepared;
-      if (!wasPrepared)
-        this.rejectPrepared?.(new Error("Session connection closed before preparation completed."));
-      this.microphone?.stop();
-      this.microphone = undefined;
-      this.output?.clear();
-      this.output = undefined;
-      this.socket = undefined;
-      this.prepared = false;
-      this.preparation = undefined;
-      this.resolvePrepared = undefined;
-      this.rejectPrepared = undefined;
-      this.sessionToken = undefined;
-      this.rejectStarted?.(new Error("Session connection closed before startup completed."));
-      this.clearStarting();
-      this.callbacks.onConnection("closed", event.reason || undefined);
+      if (this.socket === socket)
+        this.closeSocket(event.reason || "Connection lost", false);
     });
     socket.addEventListener("error", () => {
       if (this.socket !== socket)
         return;
-      const message = "Durable Object WebSocket failed.";
-      this.failPreparation(message);
-      this.rejectStarted?.(new Error(message));
-      this.clearStarting();
-      this.callbacks.onConnection("error", message);
+      this.callbacks.onConnection("error", "Live Voice WebSocket failed.");
+      this.closeSocket("Live Voice WebSocket failed.", false);
     });
-    this.preparation = new Promise((resolve, reject) => {
-      this.resolvePrepared = resolve;
-      this.rejectPrepared = reject;
-    });
-    await waitForOpen(socket);
-    socket.send(JSON.stringify({ type: "session.prepare", protocolVersion: 1 }));
-    return this.preparation;
-  }
-  async start(options) {
-    await this.prepare(options.token);
-    this.output = new OutputAudio((receipt) => {
-      if (this.socket?.readyState === WebSocket.OPEN)
-        this.socket.send(JSON.stringify({ type: "output.receipt", ...receipt }));
-    });
-    await this.output.resume();
-    this.starting = new Promise((resolve, reject) => {
-      this.resolveStarted = resolve;
-      this.rejectStarted = reject;
-    });
-    this.socket?.send(JSON.stringify(sessionStartMessage(options)));
-    await this.starting;
-    this.microphone = new Microphone((buffer) => {
-      if (this.socket?.readyState === WebSocket.OPEN)
-        this.socket.send(buffer);
-    }, (level) => {
-      this.output?.sidechain(level);
-      this.callbacks.onLevel(level);
+    try {
+      return await opening;
+    } catch (error) {
+      if (this.socket === socket)
+        this.closeSocket("Connection opening failed", false);
+      throw error;
+    }
+  }
+  async prepare() {
+    if (this.prepared)
+      return;
+    if (this.preparing)
+      return this.preparing;
+    this.preparing = this.exchange("prepare", 90000, () => this.send({ type: "session.prepare", protocolVersion: 2 })).then(() => {
+      this.prepared = true;
     });
-    await this.microphone.start();
-    this.callbacks.onConnection("live");
-  }
-  stop() {
-    this.microphone?.stop();
-    this.microphone = undefined;
-    this.output?.clear();
-    this.output = undefined;
-    if (this.socket?.readyState === WebSocket.OPEN)
-      this.socket.send(JSON.stringify({ type: "session.stop" }));
-    this.socket?.close(1000, "stopped");
+    try {
+      await this.preparing;
+    } finally {
+      this.preparing = undefined;
+    }
+  }
+  async start(options = {}) {
+    if (this.started)
+      return;
+    if (this.starting)
+      return this.starting;
+    const socket = this.socket;
+    this.starting = (async () => {
+      await this.prepare();
+      if (!socket || this.socket !== socket)
+        throw new Error("Connection changed during startup.");
+      await this.exchange("start", 90000, () => this.send({ type: "session.start", mediaMode: options.mediaMode }));
+      this.started = true;
+      this.callbacks.onConnection("live");
+    })();
+    try {
+      await this.starting;
+    } finally {
+      this.starting = undefined;
+    }
+  }
+  async stop() {
+    if (this.snapshotValue?.status === "stopped") {
+      this.closeSocket("stopped", true);
+      return;
+    }
+    try {
+      await this.exchange("stop", 5000, () => this.send({ type: "session.stop" }));
+    } finally {
+      this.closeSocket("stopped", true);
+    }
+  }
+  async detach() {
+    if (!this.socket)
+      return;
+    try {
+      await this.exchange("detach", 5000, () => this.send({ type: "participant.detach" }));
+    } finally {
+      this.closeSocket("detached", false);
+    }
+  }
+  closeSocket(reason = "closed", terminal = true) {
+    const socket = this.socket;
     this.socket = undefined;
     this.prepared = false;
-    this.preparation = undefined;
-    this.resolvePrepared = undefined;
-    this.rejectPrepared = undefined;
-    this.sessionToken = undefined;
-    this.rejectStarted?.(new Error("Session stopped before startup completed."));
-    this.clearStarting();
-    this.callbacks.onConnection("closed");
+    this.started = false;
+    this.terminal ||= terminal;
+    const error = new Error(reason);
+    for (const wait of this.waits.values())
+      wait.reject(error);
+    this.waits.clear();
+    if (terminal)
+      for (const execution of this.executions.values()) {
+        execution.controller.abort(error);
+        for (const wait of execution.pending.values())
+          wait.reject(error);
+        execution.pending.clear();
+      }
+    if (socket) {
+      if (this.snapshotValue?.participantId === "owner" && this.snapshotValue.status === "running") {
+        this.snapshotValue = { ...this.snapshotValue, status: "suspended", floor: { owner: "USER", assistantAudible: false } };
+      }
+      if (socket.readyState === WebSocket.OPEN || socket.readyState === WebSocket.CONNECTING)
+        socket.close(1000, reason.slice(0, 100));
+      this.callbacks.onConnection("closed", reason);
+    }
   }
   dispose() {
-    this.stop();
+    if (this.socket?.readyState === WebSocket.OPEN)
+      this.send({ type: this.snapshotValue?.participantId === "owner" ? "session.stop" : "participant.detach" });
+    this.closeSocket("disposed", true);
+  }
+  reconnect(options) {
+    return this.open({ ...options, token: options.token ?? this.sessionToken ?? "", mode: "reconnect", retainedTaskIds: this.retainedTaskIds() });
+  }
+  async requestTask(operation, taskId, resolution) {
+    const requestId = String(++this.requestCounter);
+    return await this.exchange(`task:${requestId}`, 15000, () => this.send({ type: "task.request", requestId, operation, ...taskId ? { taskId } : {}, ...resolution ? { resolution } : {} }));
   }
   playUiCue(cue) {
-    if (this.socket?.readyState === WebSocket.OPEN)
-      this.socket.send(JSON.stringify({ type: "cue.request", cue }));
+    this.send({ type: "cue.request", cue });
+  }
+  send(message) {
+    if (this.socket?.readyState !== WebSocket.OPEN)
+      throw new Error("Session is not connected.");
+    if (message instanceof Uint8Array) {
+      this.socket.send(message.buffer instanceof ArrayBuffer ? message : message.slice());
+    } else
+      this.socket.send(serialize(message));
+  }
+  async exchange(key, timeoutMs, send) {
+    if (this.waits.has(key))
+      throw new Error(`Operation already pending: ${key}`);
+    const wait = deferred();
+    this.waits.set(key, wait);
+    const timer = setTimeout(() => wait.reject(new Error(`Live Voice ${key} acknowledgement timed out.`)), timeoutMs);
+    try {
+      send();
+      return await wait.promise;
+    } finally {
+      clearTimeout(timer);
+      this.waits.delete(key);
+    }
   }
   onMessage(raw) {
     if (typeof raw !== "string")
       return;
     let message;
     try {
-      message = JSON.parse(raw);
+      const value = JSON.parse(raw);
+      if (!value || typeof value !== "object" || Array.isArray(value))
+        return;
+      message = value;
     } catch {
       return;
     }
     const type = String(message.type ?? "");
-    if (type === "session.prepared") {
-      this.prepared = true;
-      this.resolvePrepared?.();
-      this.resolvePrepared = undefined;
-      this.rejectPrepared = undefined;
+    if (type === "session.opened") {
+      const snapshot = message.snapshot;
+      if (!snapshot || typeof snapshot.sessionId !== "string" || typeof snapshot.connectionId !== "string" || typeof snapshot.participantId !== "string" || !Number.isSafeInteger(snapshot.sequence) || !Array.isArray(snapshot.tasks) || !snapshot.transcript || !snapshot.floor) {
+        this.waits.get("open")?.reject(new Error("Session opened without a valid snapshot."));
+        return;
+      }
+      this.snapshotValue = snapshot;
+      this.callbacks.onSnapshot?.(snapshot);
+      this.waits.get("open")?.resolve(snapshot);
+      for (const execution of this.executions.values())
+        for (const pending of execution.pending.values())
+          this.socket?.send(pending.serialized);
+      this.callbacks.onConnection("ready");
       return;
     }
-    if (type === "session.prepare_failed") {
-      this.failPreparation(String(message.message ?? "Session preparation failed."));
+    if (type === "session.open_failed" || type === "session.prepare_failed" || type === "session.start_failed") {
+      const key = type === "session.open_failed" ? "open" : type === "session.prepare_failed" ? "prepare" : "start";
+      this.waits.get(key)?.reject(new Error(String(message.message ?? type)));
+      return;
+    }
+    if (type === "session.prepared") {
+      this.waits.get("prepare")?.resolve();
       return;
     }
     if (type === "session.started") {
-      this.resolveStarted?.();
-      this.clearStarting();
+      if (this.snapshotValue)
+        this.snapshotValue = { ...this.snapshotValue, status: "running" };
+      this.waits.get("start")?.resolve();
       return;
     }
-    if (type === "public.event") {
-      this.callbacks.onPublicEvent({
-        name: String(message.name ?? "unknown"),
-        payload: asRecord(message.payload),
-        ...Number.isFinite(Number(message.atMs)) ? { atMs: Number(message.atMs) } : {}
-      });
+    if (type === "session.stopped") {
+      if (this.snapshotValue)
+        this.snapshotValue = { ...this.snapshotValue, status: "stopped", phase: undefined, floor: { owner: "USER", assistantAudible: false }, transcript: { turns: [] }, tasks: this.snapshotValue.tasks.map((task) => ({ taskId: task.taskId, participantId: task.participantId, status: task.status, createdAt: task.createdAt, updatedAt: task.updatedAt })) };
+      this.waits.get("stop")?.resolve();
+      if (this.snapshotValue?.participantId === "owner")
+        this.closeSocket("stopped", true);
+      else if (this.snapshotValue)
+        this.callbacks.onSnapshot?.(this.snapshotValue);
       return;
     }
-    if (type === "tool.call") {
-      this.handleToolCall(message);
+    if (type === "participant.detached") {
+      this.waits.get("detach")?.resolve();
       return;
     }
-    if (type === "session.limit") {
-      this.callbacks.onSessionLimit?.(String(message.reason ?? "SESSION_LIMIT"), Number.isFinite(Number(message.durationSeconds)) ? Number(message.durationSeconds) : undefined);
+    if (type === "public.event") {
+      if (!message.payload || typeof message.payload !== "object" || Array.isArray(message.payload))
+        return;
+      const event = { name: String(message.name), payload: message.payload, ...typeof message.sequence === "number" ? { sequence: message.sequence } : {}, ...typeof message.atMs === "number" ? { atMs: message.atMs } : {} };
+      if (event.sequence !== undefined && this.snapshotValue && event.sequence <= this.snapshotValue.sequence)
+        return;
+      if (this.snapshotValue) {
+        const snapshot = { ...this.snapshotValue, sequence: event.sequence ?? this.snapshotValue.sequence };
+        if (event.name === "task.update" && isTask(event.payload))
+          snapshot.tasks = [...snapshot.tasks.filter((task) => task.taskId !== event.payload.taskId), event.payload];
+        if (event.name === "transcript.canonical" && Array.isArray(event.payload.turns))
+          snapshot.transcript = { turns: event.payload.turns };
+        if (event.name === "floor" && (event.payload.owner === "USER" || event.payload.owner === "ASSISTANT") && typeof event.payload.assistantAudible === "boolean")
+          snapshot.floor = { owner: event.payload.owner, assistantAudible: event.payload.assistantAudible };
+        if (event.name === "phase" && typeof event.payload.phase === "string")
+          snapshot.phase = event.payload.phase;
+        if (event.name === "session.status" && ["created", "running", "suspended", "stopped"].includes(String(event.payload.status))) {
+          snapshot.status = event.payload.status;
+          if (snapshot.status === "suspended" || snapshot.status === "stopped")
+            snapshot.floor = { owner: "USER", assistantAudible: false };
+        }
+        this.snapshotValue = snapshot;
+      }
+      this.callbacks.onPublicEvent(event);
+      if (event.name === "task.update" && isTask(event.payload))
+        this.callbacks.onTaskUpdate?.(event.payload);
       return;
     }
-    if (type === "output.block") {
-      this.output?.blockForeground(String(message.generationId ?? ""));
+    if (type === "task.execute" && isTask(message.task)) {
+      this.execute(message.task);
       return;
     }
-    if (type === "output.audio" && typeof message.delta === "string") {
-      this.output?.enqueue({
-        encoded: message.delta,
-        lane: message.queue === "reaction" ? "REACTION" : "FOREGROUND",
-        generationId: String(message.generationId ?? ""),
-        mode: message.mode === "play" ? "play" : "buffer",
-        gain: clamp01(Number(message.gain ?? 1))
-      });
+    if (type === "task.cancel") {
+      this.executions.get(String(message.taskId))?.controller.abort();
       return;
     }
-    if (type === "output.release") {
-      this.output?.release(String(message.generationId ?? ""), clamp01(Number(message.gain ?? 1)));
+    if (type === "task.ack" || type === "task.error") {
+      const execution = this.executions.get(String(message.taskId));
+      const pending = execution?.pending.get(Number(message.sequence));
+      if (!execution || !pending)
+        return;
+      execution.pending.delete(Number(message.sequence));
+      if (type === "task.ack")
+        pending.resolve();
+      else {
+        execution.rejected = true;
+        pending.reject(new Error(String(message.message ?? "Task update rejected.")));
+      }
       return;
     }
-    if (type === "output.cancel") {
-      this.output?.cancel(String(message.generationId ?? ""));
+    if (type === "task.response") {
+      const pending = this.waits.get(`task:${String(message.requestId)}`);
+      if (message.error)
+        pending?.reject(new Error(String(message.error.message ?? "Task request failed.")));
+      else
+        pending?.resolve(message.result);
       return;
     }
-    if (type === "output.done") {
-      this.output?.done(message.queue === "reaction" ? "REACTION" : "FOREGROUND", String(message.generationId ?? ""));
+    if (type === "session.limit") {
+      this.callbacks.onSessionLimit?.(String(message.reason ?? "SESSION_LIMIT"), typeof message.durationSeconds === "number" ? message.durationSeconds : undefined);
       return;
     }
     this.callbacks.onUnknown?.(message);
   }
-  async handleToolCall(message) {
-    const callId = String(message.callId ?? "");
-    const name = String(message.name ?? "");
-    if (!callId || !name || this.socket?.readyState !== WebSocket.OPEN)
+  async execute(task) {
+    if (this.terminal || this.executions.has(task.taskId))
       return;
+    const entry = { controller: new AbortController, nextSequence: 1, rejected: false, pending: new Map };
+    this.executions.set(task.taskId, entry);
+    const publish = async (update) => {
+      if (this.terminal || entry.rejected)
+        throw new Error("Task update channel is closed.");
+      const sequence = entry.nextSequence;
+      const serialized = serialize({ type: "task.update", taskId: task.taskId, sequence, ...update });
+      entry.nextSequence++;
+      const wait = deferred();
+      entry.pending.set(sequence, { ...wait, serialized });
+      if (this.socket?.readyState === WebSocket.OPEN && !this.waits.has("open"))
+        this.socket.send(serialized);
+      await wait.promise;
+    };
+    const context = {
+      taskId: task.taskId,
+      sourceUserTurnId: task.sourceUserTurnId,
+      signal: entry.controller.signal,
+      progress: async (progress) => {
+        if (progress.fraction !== undefined && (!Number.isFinite(progress.fraction) || progress.fraction < 0 || progress.fraction > 1))
+          throw new Error("Task progress fraction must be between 0 and 1.");
+        await publish({ status: "running", progress });
+      },
+      partial: (value) => publish({ status: "running", partial: value })
+    };
     try {
-      if (!this.callbacks.onToolCall)
-        throw new Error(`No browser handler is registered for tool ${name}`);
-      const output = await this.callbacks.onToolCall({ callId, name, input: asRecord(message.input) });
-      this.socket?.send(JSON.stringify({ type: "tool.result", callId, ok: true, output: output ?? null }));
+      await publish({ status: "running" });
+      if (!this.callbacks.onTaskExecute)
+        throw new Error(`No handler is registered for task ${task.taskId}.`);
+      const output = await this.callbacks.onTaskExecute(task, context);
+      await publish({ status: "succeeded", output: output ?? null });
     } catch (error) {
-      this.socket?.send(JSON.stringify({
-        type: "tool.result",
-        callId,
-        ok: false,
-        error: error instanceof Error ? error.message : String(error)
-      }));
-    }
-  }
-  failPreparation(message) {
-    if (!this.prepared)
-      this.rejectPrepared?.(new Error(message));
-    this.preparation = undefined;
-    this.resolvePrepared = undefined;
-    this.rejectPrepared = undefined;
-  }
-  clearStarting() {
-    this.starting = undefined;
-    this.resolveStarted = undefined;
-    this.rejectStarted = undefined;
+      if (this.terminal)
+        return;
+      const message = error instanceof Error ? error.message : String(error);
+      if (entry.rejected) {
+        this.callbacks.onPublicEvent({ name: "error", payload: { code: "TASK_UPDATE_REJECTED", message } });
+        return;
+      }
+      const cancelled = entry.controller.signal.aborted && (error === entry.controller.signal.reason || error instanceof Error && error.name === "AbortError");
+      try {
+        await publish({ status: cancelled ? "cancelled" : "failed", error: message });
+      } catch (failure) {
+        if (!this.terminal)
+          this.callbacks.onPublicEvent({ name: "error", payload: { code: "TASK_UPDATE_FAILED", message: failure instanceof Error ? failure.message : String(failure) } });
+      }
+    }
   }
 }
-function withSessionToken(value, token) {
-  if (!token)
-    return value;
-  const url = new URL(value);
-  url.searchParams.set("token", token);
-  return url.toString();
+function isTask(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return false;
+  const task = value;
+  return typeof task.taskId === "string" && typeof task.participantId === "string" && typeof task.status === "string";
+}
+function serialize(value) {
+  return JSON.stringify(value, (_key, item) => {
+    if (typeof item === "function" || typeof item === "symbol" || typeof item === "bigint" || typeof item === "number" && !Number.isFinite(item))
+      throw new Error("Task data must be JSON serializable.");
+    return item;
+  });
+}
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((onResolve, onReject) => {
+    resolve = onResolve;
+    reject = onReject;
+  });
+  return { promise, resolve, reject };
 }
-var OPTICAL_SIDECHAIN = {
-  thresholdDb: -42,
-  ratio: 4,
-  maxReductionDb: 12,
-  attackSeconds: 0.12,
-  releaseSeconds: 0.36
-};
 
-class OutputAudio {
-  onReceipt;
-  context = new AudioContext({ sampleRate: 24000, latencyHint: "interactive" });
-  foregroundGain = this.context.createGain();
-  reactionGain = this.context.createGain();
-  outputBus = this.context.createGain();
-  nextStart = 0;
-  sources = new Map;
-  buffered = new Map;
-  released = new Set;
-  blockers = new Set;
-  started = new Set;
-  startedTimers = new Map;
-  completed = new Set;
-  doneGenerations = new Map;
-  playedSamples = new Map;
-  constructor(onReceipt) {
-    this.onReceipt = onReceipt;
-    this.foregroundGain.connect(this.outputBus);
-    this.reactionGain.connect(this.outputBus);
-    this.outputBus.connect(this.context.destination);
-  }
-  async resume() {
-    await this.context.resume();
-  }
-  sidechain(level) {
-    const gain = opticalSidechainGain(level);
-    const now = this.context.currentTime;
-    const current = this.foregroundGain.gain.value;
-    this.foregroundGain.gain.cancelAndHoldAtTime(now);
-    this.foregroundGain.gain.setTargetAtTime(gain, now, gain < current ? OPTICAL_SIDECHAIN.attackSeconds : OPTICAL_SIDECHAIN.releaseSeconds);
-  }
-  blockForeground(generationId) {
-    if (generationId)
-      this.blockers.add(generationId);
-  }
-  enqueue(chunk) {
-    if (!chunk.generationId)
-      return;
-    if (chunk.lane === "REACTION")
-      this.blockers.add(chunk.generationId);
-    const blocked = chunk.lane === "FOREGROUND" && this.blockers.size > 0;
-    if (blocked || chunk.mode === "buffer" && !this.released.has(chunk.generationId)) {
-      const queue = this.buffered.get(chunk.generationId) ?? [];
-      queue.push({ encoded: chunk.encoded, lane: chunk.lane, gain: chunk.gain });
-      this.buffered.set(chunk.generationId, queue);
-      return;
-    }
-    this.schedule(chunk.encoded, chunk.lane, chunk.generationId, chunk.gain);
-  }
-  release(generationId, gain = 1) {
-    if (!generationId)
-      return;
-    const chunks = this.buffered.get(generationId);
-    if (chunks?.[0]?.lane === "REACTION") {
-      for (const chunk of chunks)
-        chunk.gain = gain;
-    }
-    this.released.add(generationId);
-    const lane = this.buffered.get(generationId)?.[0]?.lane ?? this.doneGenerations.get(generationId);
-    if (lane === "REACTION" || !this.blockers.size)
-      this.flush(generationId);
-  }
-  done(lane, generationId) {
-    this.doneGenerations.set(generationId, lane);
-    this.finishIfComplete(generationId);
-  }
-  cancel(generationId) {
-    if (!generationId)
-      return;
-    const bufferedLane = this.buffered.get(generationId)?.[0]?.lane;
-    const sourceLane = [...this.sources.values()].find((value) => value.generationId === generationId)?.lane;
-    const lane = sourceLane ?? bufferedLane ?? this.doneGenerations.get(generationId) ?? "FOREGROUND";
-    this.buffered.delete(generationId);
-    this.released.delete(generationId);
-    this.blockers.delete(generationId);
-    this.doneGenerations.delete(generationId);
-    for (const [source, metadata] of this.sources) {
-      if (metadata.generationId !== generationId)
-        continue;
-      const elapsed = Math.max(0, this.context.currentTime - metadata.startAt);
-      const played = Math.min(metadata.samples, Math.floor(elapsed * 24000));
-      this.playedSamples.set(generationId, (this.playedSamples.get(generationId) ?? 0) + played);
-      source.onended = null;
-      this.sources.delete(source);
-      try {
-        source.stop();
-      } catch {}
-    }
-    this.recomputeNextStart();
-    const timer = this.startedTimers.get(generationId);
-    if (timer !== undefined)
-      window.clearTimeout(timer);
-    this.startedTimers.delete(generationId);
-    this.flushReleasedForeground();
-    this.onReceipt({ event: "cancelled", lane, generationId, playedSamples: this.playedSamples.get(generationId) ?? 0 });
-  }
-  clear() {
-    for (const source of this.sources.keys())
-      try {
-        source.stop();
-      } catch {}
-    for (const timer of this.startedTimers.values())
-      window.clearTimeout(timer);
-    this.sources.clear();
-    this.buffered.clear();
-    this.released.clear();
-    this.blockers.clear();
-    this.started.clear();
-    this.startedTimers.clear();
-    this.completed.clear();
-    this.doneGenerations.clear();
-    this.playedSamples.clear();
-    this.nextStart = 0;
-    this.context.close();
-  }
-  flush(generationId) {
-    const chunks = this.buffered.get(generationId);
-    if (!chunks)
-      return;
-    this.buffered.delete(generationId);
-    for (const chunk of chunks)
-      this.schedule(chunk.encoded, chunk.lane, generationId, chunk.gain);
-  }
-  flushReleasedForeground() {
-    if (this.blockers.size)
+// src/client.ts
+class LiveVoiceClient extends ControlClient {
+  mediaCallbacks;
+  media;
+  mediaStarting;
+  constructor(endpoint, mediaCallbacks) {
+    super(endpoint, mediaCallbacks);
+    this.mediaCallbacks = mediaCallbacks;
+  }
+  async start(options = {}) {
+    if (this.mediaStarting)
+      return this.mediaStarting;
+    if (this.media)
       return;
-    for (const generationId of this.released)
-      this.flush(generationId);
-  }
-  schedule(encoded, lane, generationId, gain) {
-    const binary = atob(encoded);
-    const bytes = Uint8Array.from(binary, (character) => character.charCodeAt(0));
-    const pcm = new Int16Array(bytes.buffer);
-    const audio = this.context.createBuffer(1, pcm.length, 24000);
-    const samples = audio.getChannelData(0);
-    for (let index = 0;index < pcm.length; index += 1)
-      samples[index] = pcm[index] / 32768;
-    const source = this.context.createBufferSource();
-    const chunkGain = this.context.createGain();
-    chunkGain.gain.value = lane === "REACTION" ? gain : 1;
-    source.buffer = audio;
-    source.connect(chunkGain).connect(lane === "REACTION" ? this.reactionGain : this.foregroundGain);
-    const startAt = Math.max(this.context.currentTime + 0.008, this.nextStart);
-    this.nextStart = startAt + audio.duration;
-    this.sources.set(source, { generationId, lane, samples: pcm.length, startAt });
-    source.onended = () => {
-      const metadata = this.sources.get(source);
-      this.sources.delete(source);
-      this.recomputeNextStart();
-      if (!metadata)
-        return;
-      this.playedSamples.set(generationId, (this.playedSamples.get(generationId) ?? 0) + metadata.samples);
-      this.finishIfComplete(generationId);
-    };
-    source.start(startAt);
-    if (!this.started.has(generationId)) {
-      this.started.add(generationId);
-      const timer = window.setTimeout(() => {
-        this.startedTimers.delete(generationId);
-        if ([...this.sources.values()].some((value) => value.generationId === generationId)) {
-          this.onReceipt({ event: "started", lane, generationId, playedSamples: 0 });
-        }
-      }, Math.max(0, (startAt - this.context.currentTime) * 1000));
-      this.startedTimers.set(generationId, timer);
+    const socket = this.socket;
+    this.mediaStarting = (async () => {
+      if (options.mediaMode === "browser") {
+        if (!socket || this.socket !== socket)
+          throw new Error("Connection changed during media startup.");
+        const preparation = this.prepare();
+        const media = new RealtimeMediaClient(this.endpoint, options.token ?? this.sessionToken, this.mediaCallbacks.onLevel, this.mediaCallbacks.onMediaStream, this.mediaCallbacks.onAudioElement, this.mediaCallbacks.onMediaClosed);
+        this.media = media;
+        await Promise.all([preparation, media.connect()]);
+        if (this.socket !== socket)
+          throw new Error("Connection changed during media startup.");
+      } else {
+        await this.prepare();
+      }
+      await super.start(options);
+    })();
+    try {
+      await this.mediaStarting;
+    } catch (error) {
+      this.closeMedia();
+      throw error;
+    } finally {
+      this.mediaStarting = undefined;
     }
   }
-  recomputeNextStart() {
-    this.nextStart = Math.max(this.context.currentTime, ...[...this.sources.values()].map((source) => source.startAt + source.samples / 24000));
+  closeSocket(reason = "closed", terminal = true) {
+    this.closeMedia();
+    super.closeSocket(reason, terminal);
   }
-  finishIfComplete(generationId) {
-    const lane = this.doneGenerations.get(generationId);
-    if (!lane || this.completed.has(generationId) || this.buffered.has(generationId))
-      return;
-    if ([...this.sources.values()].some((value) => value.generationId === generationId))
-      return;
-    this.completed.add(generationId);
-    if (lane === "REACTION") {
-      this.blockers.delete(generationId);
-      this.flushReleasedForeground();
-    }
-    this.onReceipt({ event: "completed", lane, generationId, playedSamples: this.playedSamples.get(generationId) ?? 0 });
+  closeMedia() {
+    const media = this.media;
+    this.media = undefined;
+    media?.close();
   }
 }
-function opticalSidechainGain(level) {
-  const safeLevel = Math.max(Number.EPSILON, level);
-  const inputDb = 20 * Math.log10(safeLevel);
-  if (inputDb <= OPTICAL_SIDECHAIN.thresholdDb)
-    return 1;
-  const compressedDb = Math.min(OPTICAL_SIDECHAIN.maxReductionDb, (inputDb - OPTICAL_SIDECHAIN.thresholdDb) * (1 - 1 / OPTICAL_SIDECHAIN.ratio));
-  return 10 ** (-compressedDb / 20);
+var MEDIA_REQUEST_TIMEOUT_MS = 1e4;
+var BRIDGE_REQUEST_TIMEOUT_MS = 24000;
+
+class MediaRequestError extends Error {
+  code;
+  status;
+  path;
+  constructor(message, code, status, path) {
+    super(message);
+    this.code = code;
+    this.status = status;
+    this.path = path;
+    this.name = "MediaRequestError";
+  }
 }
 
-class Microphone {
-  onFrame;
+class RealtimeMediaClient {
+  endpoint;
+  token;
   onLevel;
-  context;
+  onMediaStream;
+  onAudioElement;
+  onMediaClosed;
+  peer;
   stream;
-  node;
-  samples = [];
-  constructor(onFrame, onLevel) {
-    this.onFrame = onFrame;
+  audio;
+  levelTimer;
+  lifetime = new AbortController;
+  constructor(endpoint, token, onLevel, onMediaStream, onAudioElement, onMediaClosed) {
+    this.endpoint = endpoint;
+    this.token = token;
     this.onLevel = onLevel;
+    this.onMediaStream = onMediaStream;
+    this.onAudioElement = onAudioElement;
+    this.onMediaClosed = onMediaClosed;
+  }
+  async connect() {
+    if (!this.token)
+      throw new Error("A session token is required for WebRTC media");
+    this.lifetime.signal.throwIfAborted();
+    const microphone = deferred();
+    const abortMicrophone = () => microphone.reject(new Error("Media startup was cancelled."));
+    this.lifetime.signal.addEventListener("abort", abortMicrophone, { once: true });
+    navigator.mediaDevices.getUserMedia({
+      audio: {
+        echoCancellation: true,
+        noiseSuppression: true,
+        autoGainControl: true,
+        channelCount: 1
+      }
+    }).then((stream) => {
+      if (this.lifetime.signal.aborted)
+        stream.getTracks().forEach((track2) => track2.stop());
+      else
+        microphone.resolve(stream);
+    }, microphone.reject);
+    try {
+      this.stream = await microphone.promise;
+    } finally {
+      this.lifetime.signal.removeEventListener("abort", abortMicrophone);
+    }
+    const track = this.stream.getAudioTracks()[0];
+    if (!track)
+      throw new Error("No microphone track is available");
+    for (let attempt = 1;attempt <= 2; attempt += 1) {
+      try {
+        this.onMediaStream?.("microphone", this.stream);
+        await this.connectPeer(track);
+        return;
+      } catch (error) {
+        this.closePeer();
+        const code = error instanceof MediaRequestError ? error.code.toLowerCase() : "";
+        const retryable = error instanceof MediaRequestError && error.path.includes("/bridge") && (code === "empty_track_error" || code === "media_input_timeout" || code === "realtime_request_timeout" || code === "media_request_timeout");
+        if (attempt === 1 && retryable) {
+          await new Promise((resolve) => window.setTimeout(resolve, 250));
+          continue;
+        }
+        this.stream?.getTracks().forEach((mediaTrack) => mediaTrack.stop());
+        this.stream = undefined;
+        throw error;
+      }
+    }
   }
-  async start() {
-    this.stream = await navigator.mediaDevices.getUserMedia({ audio: { echoCancellation: true, noiseSuppression: true, autoGainControl: true, channelCount: 1 } });
-    this.context = new AudioContext({ sampleRate: 24000, latencyHint: "interactive" });
-    const sourceCode = `class LiveVoiceMic extends AudioWorkletProcessor { process(inputs) { const input=inputs[0]?.[0]; if(input) this.port.postMessage(input.slice()); return true; } } registerProcessor('live-voice-mic', LiveVoiceMic);`;
-    const moduleUrl = URL.createObjectURL(new Blob([sourceCode], { type: "text/javascript" }));
-    await this.context.audioWorklet.addModule(moduleUrl);
-    URL.revokeObjectURL(moduleUrl);
-    const source = this.context.createMediaStreamSource(this.stream);
-    this.node = new AudioWorkletNode(this.context, "live-voice-mic");
-    const silent = this.context.createGain();
-    silent.gain.value = 0;
-    source.connect(this.node).connect(silent).connect(this.context.destination);
-    this.node.port.onmessage = (event) => this.accept(event.data);
-    await this.context.resume();
-  }
-  stop() {
-    this.node?.disconnect();
+  async connectPeer(track) {
+    this.lifetime.signal.throwIfAborted();
+    const startedAt = performance.now();
+    const timing = {};
+    const iceStartedAt = performance.now();
+    const icePromise = this.request("/ice", "POST").then((value) => {
+      timing.ice = performance.now() - iceStartedAt;
+      return value;
+    });
+    const sessionStartedAt = performance.now();
+    const sessionPromise = this.request("/session", "POST").then((value) => {
+      timing.session = performance.now() - sessionStartedAt;
+      return value;
+    });
+    const [ice, session] = await Promise.all([icePromise, sessionPromise]);
+    if (!ice.iceServers?.length)
+      throw new Error("WebRTC ICE servers are unavailable");
+    if (!session.sessionId)
+      throw new Error("Cloudflare Realtime did not return a session");
+    const peer = new RTCPeerConnection({
+      iceServers: ice.iceServers,
+      bundlePolicy: "max-bundle"
+    });
+    this.peer = peer;
+    const transceiver = peer.addTransceiver(track, { direction: "sendonly" });
+    const sessionId = session.sessionId;
+    const offer = await peer.createOffer();
+    await peer.setLocalDescription(offer);
+    await waitForIceGathering(peer);
+    if (!peer.localDescription?.sdp || !transceiver.mid)
+      throw new Error("WebRTC microphone offer is incomplete");
+    const publishStartedAt = performance.now();
+    const published = await this.request(`/session/${encodeURIComponent(sessionId)}/publish`, "POST", {
+      sessionDescription: { type: "offer", sdp: peer.localDescription.sdp },
+      mid: transceiver.mid,
+      trackName: `microphone-${crypto.randomUUID()}`
+    });
+    timing.publish = performance.now() - publishStartedAt;
+    if (!published.sessionDescription)
+      throw new Error(published.errorDescription ?? "Cloudflare Realtime did not answer the microphone offer");
+    await peer.setRemoteDescription(published.sessionDescription);
+    const remoteTrack = deferred();
+    const abortTrack = () => remoteTrack.reject(new Error("Media startup was cancelled."));
+    this.lifetime.signal.addEventListener("abort", abortTrack, { once: true });
+    const remoteTrackTimeout = window.setTimeout(() => remoteTrack.reject(new Error("Assistant WebRTC track did not arrive")), 1e4);
+    peer.addEventListener("track", (event) => remoteTrack.resolve(event.track), { once: true });
+    let assistantTrack;
+    try {
+      const bridgeStartedAt = performance.now();
+      const bridged = await this.request(`/session/${encodeURIComponent(sessionId)}/bridge`, "POST", undefined, BRIDGE_REQUEST_TIMEOUT_MS);
+      timing.bridge = performance.now() - bridgeStartedAt;
+      let renegotiation = Promise.resolve();
+      if (bridged.requiresImmediateRenegotiation) {
+        if (!bridged.sessionDescription)
+          throw new Error("Assistant WebRTC offer is missing");
+        renegotiation = (async () => {
+          const renegotiateStartedAt = performance.now();
+          await peer.setRemoteDescription(bridged.sessionDescription);
+          const answer = await peer.createAnswer();
+          await peer.setLocalDescription(answer);
+          if (!peer.localDescription?.sdp)
+            throw new Error("Assistant WebRTC answer is incomplete");
+          await waitForIceGathering(peer);
+          timing.renegotiate = performance.now() - renegotiateStartedAt;
+          await this.request(`/session/${encodeURIComponent(sessionId)}/renegotiate`, "PUT", { sessionDescription: { type: "answer", sdp: peer.localDescription.sdp }, setupTimingMs: { ...timing, total: performance.now() - startedAt } });
+        })();
+      }
+      [assistantTrack] = await Promise.all([remoteTrack.promise, renegotiation]);
+    } finally {
+      window.clearTimeout(remoteTrackTimeout);
+      this.lifetime.signal.removeEventListener("abort", abortTrack);
+    }
+    this.lifetime.signal.throwIfAborted();
+    const audio = document.createElement("audio");
+    audio.autoplay = true;
+    audio.setAttribute("playsinline", "");
+    audio.style.display = "none";
+    audio.srcObject = new MediaStream([assistantTrack]);
+    document.body.appendChild(audio);
+    this.onMediaStream?.("assistant", new MediaStream([assistantTrack]));
+    this.onAudioElement?.(audio);
+    this.audio = audio;
+    await audio.play();
+    await waitForPeerConnection(peer);
+    this.lifetime.signal.throwIfAborted();
+    this.startLevelMeter(transceiver.sender);
+  }
+  close() {
+    this.lifetime.abort();
+    this.closePeer(true);
     this.stream?.getTracks().forEach((track) => track.stop());
-    this.context?.close();
-  }
-  accept(input) {
-    for (const value of input)
-      this.samples.push(value);
-    while (this.samples.length >= 480) {
-      const frame = this.samples.splice(0, 480);
-      const pcm = new Int16Array(480);
-      let energy = 0;
-      for (let index = 0;index < frame.length; index += 1) {
-        const value = Math.max(-1, Math.min(1, frame[index]));
-        energy += value * value;
-        pcm[index] = value < 0 ? value * 32768 : value * 32767;
+    this.stream = undefined;
+  }
+  closePeer(notify = false) {
+    window.clearInterval(this.levelTimer);
+    this.levelTimer = undefined;
+    this.audio?.pause();
+    this.audio?.remove();
+    this.audio = undefined;
+    this.peer?.close();
+    this.peer = undefined;
+    if (notify)
+      this.onMediaClosed?.();
+  }
+  startLevelMeter(sender) {
+    this.levelTimer = window.setInterval(() => {
+      sender.getStats().then((report) => {
+        let level = 0;
+        report.forEach((stat) => {
+          const candidate = Number(stat.audioLevel);
+          if (Number.isFinite(candidate))
+            level = Math.max(level, candidate);
+        });
+        this.onLevel(level);
+      }).catch(() => {});
+    }, 50);
+  }
+  async request(path, method, body, timeoutMs = MEDIA_REQUEST_TIMEOUT_MS) {
+    const endpoint = new URL(this.endpoint);
+    endpoint.protocol = endpoint.protocol === "wss:" ? "https:" : "http:";
+    endpoint.pathname = `/v1/media${path}`;
+    endpoint.search = "";
+    endpoint.searchParams.set("token", this.token ?? "");
+    let response;
+    try {
+      response = await fetch(endpoint, {
+        method,
+        headers: body === undefined ? undefined : { "content-type": "application/json" },
+        ...body === undefined ? {} : { body: JSON.stringify(body) },
+        signal: AbortSignal.any([this.lifetime.signal, AbortSignal.timeout(timeoutMs)])
+      });
+    } catch (error) {
+      if (error instanceof DOMException && (error.name === "TimeoutError" || error.name === "AbortError")) {
+        throw new MediaRequestError("WebRTC media request timed out", "MEDIA_REQUEST_TIMEOUT", 504, path);
       }
-      this.onLevel(Math.sqrt(energy / frame.length));
-      this.onFrame(pcm.buffer);
+      throw error;
     }
+    const payload = await response.json().catch(() => ({}));
+    if (!response.ok) {
+      throw new MediaRequestError(payload.error ?? `WebRTC media request failed (${response.status})`, payload.errorCode ?? `HTTP_${response.status}`, response.status, path);
+    }
+    return payload;
   }
 }
-function waitForOpen(socket) {
-  return new Promise((resolve, reject) => {
-    const timeout = window.setTimeout(() => reject(new Error("Durable Object connection timed out.")), 1e4);
-    socket.addEventListener("open", () => {
-      window.clearTimeout(timeout);
-      resolve();
-    }, { once: true });
-    socket.addEventListener("error", () => {
-      window.clearTimeout(timeout);
-      reject(new Error("Could not connect to the Durable Object."));
-    }, { once: true });
-  });
-}
-function clamp01(value) {
-  return Number.isFinite(value) ? Math.max(0, Math.min(1, value)) : 1;
+function waitForIceGathering(peer) {
+  const hasRoutableCandidate = () => / typ (?:srflx|relay) /u.test(peer.localDescription?.sdp ?? "");
+  if (hasRoutableCandidate())
+    return Promise.resolve();
+  const pending = deferred();
+  const timeout = window.setTimeout(() => finish(new Error("WebRTC routable ICE candidate gathering timed out")), 1e4);
+  const changed = () => {
+    if (hasRoutableCandidate())
+      finish();
+  };
+  const finish = (error) => {
+    window.clearTimeout(timeout);
+    peer.removeEventListener("icecandidate", changed);
+    peer.removeEventListener("icegatheringstatechange", changed);
+    if (error)
+      pending.reject(error);
+    else
+      pending.resolve();
+  };
+  peer.addEventListener("icecandidate", changed);
+  peer.addEventListener("icegatheringstatechange", changed);
+  return pending.promise;
 }
-function asRecord(value) {
-  return value && typeof value === "object" ? value : {};
+function waitForPeerConnection(peer) {
+  if (peer.connectionState === "connected")
+    return Promise.resolve();
+  const pending = deferred();
+  const timeout = window.setTimeout(() => finish(new Error("WebRTC media connection timed out")), 1e4);
+  const changed = () => {
+    if (peer.connectionState === "connected")
+      finish();
+    if (peer.connectionState === "failed" || peer.connectionState === "closed")
+      finish(new Error(`WebRTC media connection ${peer.connectionState}`));
+  };
+  const finish = (error) => {
+    window.clearTimeout(timeout);
+    peer.removeEventListener("connectionstatechange", changed);
+    if (error)
+      pending.reject(error);
+    else
+      pending.resolve();
+  };
+  peer.addEventListener("connectionstatechange", changed);
+  return pending.promise;
 }
 
-// src/public.ts
+// src/participant.ts
 var defaultEndpoint = "wss://inkibra-voice.inkibra.workers.dev/v1/live";
 
-class LiveVoiceSession {
+class LiveVoiceParticipant {
   client;
   tools;
+  developer;
+  connectedToken;
   listeners = new Map;
-  currentPhase;
-  constructor(client, tools) {
-    this.client = client;
-    this.tools = tools;
-  }
-  static async connect(options) {
-    if (!options.token)
-      throw new Error("A short-lived Live Voice session token is required.");
-    let session;
-    const client = new LiveVoiceClient(options.endpoint ?? defaultEndpoint, {
-      onConnection: (state, detail) => {
-        session?.emit("connection", { state, detail });
-        if (state === "error")
-          session?.emit("error", { code: "CONNECTION_ERROR", message: detail ?? "Live Voice connection failed." });
-      },
-      onPublicEvent: (event) => session?.acceptPublicEvent(event.name, event.payload, event.atMs),
-      onLevel: () => {},
-      onUnknown: (message) => session?.emit("unknown", { message }),
-      onSessionLimit: (reason, durationSeconds) => session?.emit("limit", { reason, durationSeconds }),
-      onToolCall: async (call) => session.executeTool(call)
-    });
-    session = new LiveVoiceSession(client, options.tools ?? {});
-    await client.start({
-      token: options.token,
-      developer: {
-        prompt: options.prompt ?? "",
-        conversation: options.conversation,
-        tools: Object.entries(options.tools ?? {}).map(([name, tool]) => ({
-          type: "function",
-          name,
-          description: tool.description,
-          parameters: tool.parameters
-        }))
+  lifetime = deferred();
+  closed = this.lifetime.promise;
+  constructor(options, client) {
+    this.client = client ?? new ControlClient(options.endpoint ?? defaultEndpoint, { onConnection: () => {}, onPublicEvent: () => {} });
+    this.tools = options.tools ?? {};
+    this.connectedToken = options.token;
+    this.developer = { prompt: options.prompt ?? "", ...options.conversation ? { conversation: options.conversation } : {} };
+    this.client.setCallbacks({
+      onConnection: (state, detail) => this.connectionChanged(state, detail),
+      onSnapshot: (snapshot) => this.emit("snapshot", snapshot),
+      onPublicEvent: (event) => this.acceptEvent(event),
+      onUnknown: (message) => this.unknownMessage(message),
+      onSessionLimit: (reason, durationSeconds) => this.emit("limit", { reason, durationSeconds }),
+      onTaskExecute: (task, context) => {
+        const tool = task.name ? this.tools[task.name] : undefined;
+        if (!tool || !task.input)
+          throw new Error(`No handler or invocation data for task ${task.taskId}.`);
+        return tool.execute(task.input, context);
       }
     });
-    return session;
   }
-  on(event, handler) {
-    const handlers = this.listeners.get(event) ?? new Set;
-    handlers.add(handler);
-    this.listeners.set(event, handlers);
-    return () => handlers.delete(handler);
+  get snapshot() {
+    const snapshot = this.client.currentSnapshot;
+    if (!snapshot)
+      throw new Error("Participant has not opened.");
+    return snapshot;
+  }
+  get sessionId() {
+    return this.snapshot.sessionId;
+  }
+  get participantId() {
+    return this.snapshot.participantId;
+  }
+  get connectionId() {
+    return this.snapshot.connectionId;
   }
   get phase() {
-    return this.currentPhase;
+    return this.snapshot.phase;
   }
-  stop() {
-    this.client.stop();
+  on(event, handler) {
+    let listeners = this.listeners.get(event);
+    if (!listeners) {
+      listeners = new Set;
+      this.listeners.set(event, listeners);
+    }
+    listeners.add(handler);
+    return () => {
+      listeners.delete(handler);
+    };
+  }
+  async rateSession(rating) {
+    const response = await fetch(this.client.ratingUrl(this.sessionId), {
+      method: "POST",
+      headers: { authorization: `Bearer ${this.connectedToken}`, "content-type": "application/json" },
+      body: JSON.stringify(rating)
+    });
+    const result = await response.json();
+    if (!response.ok)
+      throw new Error(typeof result.error === "string" ? result.error : `Unable to submit rating (${response.status}).`);
+    if (!result.rating || typeof result.rating !== "object" || !Array.isArray(result.storedFields))
+      throw new Error("Rating response was invalid.");
+    return result;
+  }
+  async reconnect(options = {}) {
+    if (options.token)
+      this.connectedToken = options.token;
+    return await this.client.reconnect({ token: this.connectedToken, sessionId: this.sessionId, participantId: this.participantId, tools: this.tools });
   }
   dispose() {
     this.client.dispose();
-    this.listeners.clear();
+    this.lifetime.resolve();
+  }
+  finish() {
+    this.lifetime.resolve();
+  }
+  connectionChanged(state, detail) {
+    this.emit("connection", { state, detail });
+    if (state === "closed" && this.client.currentSnapshot?.status === "stopped")
+      this.finish();
+  }
+  unknownMessage(message) {
+    this.emit("unknown", { message });
   }
   emit(event, value) {
-    for (const handler of this.listeners.get(event) ?? [])
-      handler(value);
+    for (const listener of this.listeners.get(event) ?? [])
+      listener(value);
+  }
+  taskApi() {
+    return {
+      list: () => this.client.requestTask("list"),
+      get: (taskId) => this.client.requestTask("get", taskId),
+      cancel: (taskId) => this.client.requestTask("cancel", taskId)
+    };
+  }
+  attachmentTaskApi() {
+    return { ...this.taskApi(), reconcile: (taskId, resolution) => this.client.requestTask("reconcile", taskId, resolution) };
   }
-  acceptPublicEvent(name, payload, atMs) {
+  acceptEvent(event) {
+    const { name, payload } = event;
+    if (name === "session.status") {
+      this.emit("snapshot", this.snapshot);
+      return;
+    }
+    if (name === "task.update" && typeof payload.taskId === "string") {
+      this.emit("task.update", payload);
+      return;
+    }
     if (name === "transcript.instantaneous" && typeof payload.text === "string") {
-      this.emit("transcript.instantaneous", { text: payload.text });
+      this.emit(name, { text: payload.text });
       return;
     }
     if (name === "transcript.canonical" && Array.isArray(payload.turns)) {
-      const turns = [];
-      for (const value of payload.turns) {
-        if (!value || typeof value !== "object" || Array.isArray(value))
-          continue;
-        const turn = value;
-        const role = turn.role;
-        if (typeof turn.id !== "string" || role !== "user" && role !== "assistant" || typeof turn.text !== "string")
-          continue;
-        turns.push({
-          id: turn.id,
-          role,
-          text: turn.text,
-          ...typeof turn.truncated === "boolean" ? { truncated: turn.truncated } : {}
-        });
-      }
-      this.emit("transcript.canonical", { turns });
+      this.emit(name, { turns: this.snapshot.transcript.turns });
       return;
     }
-    if (name === "floor" && (payload.owner === "USER" || payload.owner === "ASSISTANT") && typeof payload.assistantAudible === "boolean") {
-      this.emit("floor", { owner: payload.owner, assistantAudible: payload.assistantAudible });
+    if (name === "floor") {
+      this.emit(name, this.snapshot.floor);
       return;
     }
     if (name === "phase" && typeof payload.phase === "string") {
-      const event = {
-        phase: payload.phase,
-        source: payload.source === "floor" ? "floor" : "initial",
-        ...typeof payload.previousPhase === "string" ? { previousPhase: payload.previousPhase } : {}
-      };
-      this.currentPhase = event.phase;
-      this.emit("phase", event);
+      this.emit(name, { phase: payload.phase, source: payload.source === "floor" ? "floor" : "initial", ...typeof payload.previousPhase === "string" ? { previousPhase: payload.previousPhase } : {} });
       return;
     }
     if (name === "quick-reaction" && typeof payload.reaction === "string" && (payload.status === "prepared" || payload.status === "playing" || payload.status === "completed" || payload.status === "cancelled")) {
-      this.emit("quick-reaction", { reaction: payload.reaction, status: payload.status });
+      this.emit(name, { reaction: payload.reaction, status: payload.status });
       return;
     }
-    if (name === "assistant.energy" && Number.isFinite(Number(payload.current)) && Array.isArray(payload.predictions)) {
-      const predictions = [];
-      let valid = true;
-      for (const value of payload.predictions) {
-        if (!value || typeof value !== "object" || Array.isArray(value)) {
-          valid = false;
-          break;
-        }
-        const prediction = value;
-        const startMs = Number(prediction.startMs);
-        const endMs = Number(prediction.endMs);
-        const energy = Number(prediction.energy);
-        if (!Number.isFinite(startMs) || startMs < 0 || !Number.isFinite(endMs) || endMs <= startMs || !Number.isFinite(energy)) {
-          valid = false;
-          break;
-        }
-        predictions.push({ startMs, endMs, energy: Math.max(0, Math.min(1, energy)) });
-      }
-      if (valid) {
-        this.emit("assistant.energy", {
-          current: Math.max(0, Math.min(1, Number(payload.current))),
-          predictions
-        });
-        return;
-      }
-    }
     if (name === "error" && typeof payload.code === "string" && typeof payload.message === "string") {
-      this.emit("error", { code: payload.code, message: payload.message });
+      this.emit(name, { code: payload.code, message: payload.message });
+      return;
+    }
+    this.unknownMessage({ type: "public.event", ...event });
+  }
+}
+
+// src/public.ts
+class LiveVoiceOwner extends LiveVoiceParticipant {
+  tasks = this.taskApi();
+  started = false;
+  starting;
+  async start() {
+    if (this.started)
       return;
+    if (this.starting)
+      return this.starting;
+    this.starting = this.client.start({ mediaMode: "browser" });
+    try {
+      await this.starting;
+      this.started = true;
+    } finally {
+      this.starting = undefined;
     }
-    this.emit("unknown", { message: { type: "public.event", name, payload, ...atMs === undefined ? {} : { atMs } } });
   }
-  async executeTool(call) {
-    this.emit("tool.call", call);
-    const tool = this.tools[call.name];
-    if (!tool) {
-      const message = `No handler is registered for tool ${call.name}`;
-      this.emit("tool.result", { ...call, ok: false, error: message });
-      throw new Error(message);
+  async rate(rating) {
+    return this.rateSession(rating);
+  }
+  async stop() {
+    try {
+      await this.client.stop();
+    } finally {
+      this.started = false;
+      this.finish();
     }
+  }
+  async reconnect(options = {}) {
+    await super.reconnect(options);
+    if (this.started)
+      await this.client.start({ mediaMode: "browser" });
+    return this.snapshot;
+  }
+}
+
+class LiveVoiceAttachment extends LiveVoiceParticipant {
+  tasks = this.attachmentTaskApi();
+  async detach() {
     try {
-      const output = await tool.execute(call.input);
-      this.emit("tool.result", { ...call, ok: true, output });
-      return output;
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
-      this.emit("tool.result", { ...call, ok: false, error: message });
-      throw error;
+      await this.client.detach();
+    } finally {
+      this.finish();
     }
   }
 }
 
 class LiveVoice {
-  static connect(options) {
-    return LiveVoiceSession.connect(options);
+  static async create(options) {
+    const client = new LiveVoiceClient(options.endpoint ?? defaultEndpoint, { onConnection: () => {}, onPublicEvent: () => {}, onLevel: () => {} });
+    const owner = new LiveVoiceOwner(options, client);
+    await client.open({ token: options.token, mode: "create", participantId: "owner", mediaMode: "browser", tools: options.tools, developer: { prompt: options.prompt ?? "", ...options.conversation ? { conversation: options.conversation } : {} } });
+    return owner;
+  }
+  static async attach(options) {
+    const client = new ControlClient(options.endpoint ?? defaultEndpoint, { onConnection: () => {}, onPublicEvent: () => {} });
+    const attachment = new LiveVoiceAttachment(options, client);
+    await client.open({ token: options.token, mode: "attach", sessionId: options.sessionId, participantId: options.participantId, tools: options.tools });
+    return attachment;
   }
 }
 
 // src/index.ts
 var src_default = LiveVoice;
 export {
-  LiveVoiceSession,
+  LiveVoiceAttachment,
+  LiveVoiceOwner,
   src_default as default
 };