@cohortapp/agent-sdk 2.3.0

package/scripts/huddle/launch-slack.sh

@@ -0,0 +1,232 @@
+#!/usr/bin/env bash
+set -euo pipefail
+
+# ---------------------------------------------------------------------------
+# Maestro Huddle — Slack Launcher with CDP
+#
+# Launches (or relaunches) the Slack desktop app with Chrome DevTools Protocol
+# enabled on port 9222. This allows Playwright/Puppeteer to connect and
+# control the Slack UI for huddle automation.
+#
+# Usage:
+#   ./launch-slack.sh             # Launch/relaunch Slack with CDP
+#   ./launch-slack.sh --check     # Check if CDP is available
+#   ./launch-slack.sh --kill      # Kill Slack entirely
+# ---------------------------------------------------------------------------
+
+CDP_PORT="${CDP_PORT:-9222}"
+CDP_URL="http://localhost:${CDP_PORT}"
+SLACK_APP="/Applications/Slack.app"
+SLACK_BINARY="${SLACK_APP}/Contents/MacOS/Slack"
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+LOG_FILE="${SCRIPT_DIR}/../../logs/huddle/launch-slack.log"
+PID_FILE="${SCRIPT_DIR}/../../state/huddle/slack-cdp.pid"
+
+mkdir -p "$(dirname "$LOG_FILE")" "$(dirname "$PID_FILE")"
+
+log() { echo "[$(date '+%H:%M:%S')] $*" | tee -a "$LOG_FILE"; }
+err() { echo "[$(date '+%H:%M:%S')] ERROR: $*" | tee -a "$LOG_FILE" >&2; }
+ok()  { echo "[$(date '+%H:%M:%S')] ✓ $*" | tee -a "$LOG_FILE"; }
+
+# ---------------------------------------------------------------------------
+# CDP connectivity check
+# ---------------------------------------------------------------------------
+
+check_cdp() {
+  local response
+  response=$(curl -s --connect-timeout 3 "${CDP_URL}/json/version" 2>/dev/null || echo "")
+
+  if [ -n "$response" ] && echo "$response" | python3 -c "import sys,json; json.load(sys.stdin)" 2>/dev/null; then
+    return 0
+  fi
+  return 1
+}
+
+list_cdp_targets() {
+  local targets
+  targets=$(curl -s --connect-timeout 3 "${CDP_URL}/json" 2>/dev/null || echo "[]")
+  echo "$targets"
+}
+
+# ---------------------------------------------------------------------------
+# Slack process management
+# ---------------------------------------------------------------------------
+
+is_slack_running() {
+  pgrep -x "Slack" &>/dev/null
+}
+
+get_slack_pid() {
+  pgrep -x "Slack" | head -1
+}
+
+kill_slack() {
+  if is_slack_running; then
+    log "Stopping Slack..."
+    osascript -e 'tell application "Slack" to quit' 2>/dev/null || true
+
+    # Wait up to 10 seconds for graceful shutdown
+    local i=0
+    while is_slack_running && [ $i -lt 10 ]; do
+      sleep 1
+      i=$((i + 1))
+    done
+
+    # Force kill if still running
+    if is_slack_running; then
+      log "Force killing Slack..."
+      pkill -9 -x "Slack" 2>/dev/null || true
+      sleep 2
+    fi
+
+    if ! is_slack_running; then
+      ok "Slack stopped"
+    else
+      err "Failed to stop Slack"
+      return 1
+    fi
+  else
+    log "Slack not running"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# Launch Slack with CDP
+# ---------------------------------------------------------------------------
+
+launch_slack_cdp() {
+  # Check if CDP is already available (Slack running with correct flag)
+  if check_cdp; then
+    ok "Slack already running with CDP on port ${CDP_PORT}"
+    show_status
+    return 0
+  fi
+
+  # If Slack is running but CDP isn't available, need to restart
+  if is_slack_running; then
+    log "Slack running but CDP not available — restarting with --remote-debugging-port=${CDP_PORT}"
+    kill_slack
+    sleep 2
+  fi
+
+  # Check port availability
+  if lsof -i ":${CDP_PORT}" &>/dev/null; then
+    err "Port ${CDP_PORT} is already in use by another process"
+    lsof -i ":${CDP_PORT}" | head -5 | while read -r line; do
+      log "  $line"
+    done
+    return 1
+  fi
+
+  # Launch Slack with CDP
+  log "Launching Slack with CDP on port ${CDP_PORT}..."
+  open -a "Slack" --args --remote-debugging-port="${CDP_PORT}"
+
+  # Wait for Slack to start and CDP to become available
+  local i=0
+  local max_wait=30
+  while [ $i -lt $max_wait ]; do
+    sleep 1
+    i=$((i + 1))
+
+    if check_cdp; then
+      ok "Slack launched with CDP — port ${CDP_PORT} ready"
+
+      # Save PID
+      local pid
+      pid=$(get_slack_pid)
+      echo "$pid" > "$PID_FILE"
+      log "Slack PID: ${pid}"
+
+      show_status
+      return 0
+    fi
+
+    # Progress indicator every 5 seconds
+    if [ $((i % 5)) -eq 0 ]; then
+      log "Waiting for CDP... (${i}/${max_wait}s)"
+    fi
+  done
+
+  err "Timed out waiting for CDP on port ${CDP_PORT} after ${max_wait}s"
+  err "Slack may have launched without the CDP flag"
+
+  # Check if Slack is at least running
+  if is_slack_running; then
+    log "Slack is running (PID: $(get_slack_pid)) but CDP is not responding"
+    log "Try: kill Slack manually, then rerun this script"
+  fi
+
+  return 1
+}
+
+# ---------------------------------------------------------------------------
+# Status
+# ---------------------------------------------------------------------------
+
+show_status() {
+  log ""
+  log "=== Slack CDP Status ==="
+
+  if ! is_slack_running; then
+    log "  Slack: NOT RUNNING"
+    return 1
+  fi
+
+  local pid
+  pid=$(get_slack_pid)
+  log "  Slack PID: ${pid}"
+
+  if check_cdp; then
+    log "  CDP: AVAILABLE at ${CDP_URL}"
+
+    # Count debuggable targets
+    local targets
+    targets=$(list_cdp_targets)
+    local count
+    count=$(echo "$targets" | python3 -c "import sys,json; print(len(json.load(sys.stdin)))" 2>/dev/null || echo "?")
+    log "  Targets: ${count} debuggable pages"
+
+    # Show version info
+    local version
+    version=$(curl -s "${CDP_URL}/json/version" 2>/dev/null | python3 -c "import sys,json; d=json.load(sys.stdin); print(f\"  Browser: {d.get('Browser','?')}\")" 2>/dev/null || true)
+    [ -n "$version" ] && log "$version"
+  else
+    log "  CDP: NOT AVAILABLE"
+    log "  Slack is running but was not launched with --remote-debugging-port"
+  fi
+
+  log ""
+}
+
+# ---------------------------------------------------------------------------
+# Main
+# ---------------------------------------------------------------------------
+
+main() {
+  log ""
+  log "=========================================="
+  log "  Maestro Huddle — Slack Launcher"
+  log "  $(date)"
+  log "=========================================="
+
+  case "${1:-launch}" in
+    --check|check)
+      show_status
+      ;;
+    --kill|kill)
+      kill_slack
+      rm -f "$PID_FILE"
+      ;;
+    --launch|launch|"")
+      launch_slack_cdp
+      ;;
+    *)
+      echo "Usage: $0 [--launch|--check|--kill]"
+      exit 1
+      ;;
+  esac
+}
+
+main "$@"

package/scripts/huddle/openai-realtime-bridge.mjs

@@ -0,0 +1,462 @@
+#!/usr/bin/env node
+/**
+ * Maestro Huddle — OpenAI Realtime Audio Bridge
+ *
+ * Drop-in replacement for the Deepgram + Claude + ElevenLabs pipeline in
+ * audio-bridge.mjs. Captures audio from BlackHole 2ch (Slack speaker tap),
+ * streams it to OpenAI Realtime (single speech-to-speech model), and plays
+ * the response back through BlackHole 16ch (Slack microphone). One model,
+ * one WebSocket, one lower-latency path — same brain that drives PSTN.
+ *
+ * Why a parallel module rather than modifying the existing bridge: the
+ * existing bridge is deeply coupled to Deepgram event semantics (interim /
+ * final transcripts, utterance boundaries) and to the discrete-turn
+ * conversation loop in huddle-server.mjs. The Realtime API replaces both
+ * with a duplex audio stream + native barge-in. Keeping them side-by-side
+ * lets operators switch with HUDDLE_BRAIN=openai-realtime.
+ *
+ * Event compatibility surface (same names as AudioBridge so huddle-server
+ * needs minimal changes):
+ *   - 'capture:started'  / 'capture:stopped'
+ *   - 'speech:start'     when the model starts replying
+ *   - 'speech:end'       when the model finishes a response
+ *   - 'transcript'       {text, role: 'user'|'assistant'} — full turn
+ *   - 'transcript:interim' {text} — partial transcript (user side only)
+ *   - 'tts:start'        when audio playback begins
+ *   - 'tts:end'          when audio playback ends
+ *   - 'tool:call'        {name, arguments} — tool was invoked
+ *   - 'error'            {component, message}
+ *
+ * Public methods (signature-compatible with AudioBridge):
+ *   start()                       — connect + start audio capture
+ *   stop()                        — flush + tear down
+ *   speak(text)                   — make the model say this text now
+ *                                   (translated to conversation.item.create +
+ *                                    response.create with explicit instructions)
+ *
+ * Env:
+ *   OPENAI_API_KEY                   — required
+ *   HUDDLE_CAPTURE_DEVICE            — default "BlackHole 2ch"
+ *   HUDDLE_PLAYBACK_DEVICE           — default "BlackHole 16ch"
+ *   HUDDLE_REALTIME_MODEL            — default "gpt-realtime-2"
+ *   HUDDLE_REALTIME_VOICE            — default "cedar"
+ *   AGENT_ROOT                       — where context-loader reads from
+ */
+
+import { EventEmitter } from "node:events";
+import { spawn, execFileSync } from "node:child_process";
+import { WebSocket } from "ws";
+
+const CAPTURE_DEVICE = process.env.HUDDLE_CAPTURE_DEVICE || "BlackHole 2ch";
+const PLAYBACK_DEVICE = process.env.HUDDLE_PLAYBACK_DEVICE || "BlackHole 16ch";
+
+// 24kHz PCM16 is OpenAI Realtime's recommended format. The huddle bridge
+// captures at 24kHz mono so no resampling is needed at the WS boundary.
+const SAMPLE_RATE = 24000;
+const BIT_DEPTH = 16;
+const CHANNELS = 1;
+
+const MODEL = process.env.HUDDLE_REALTIME_MODEL || "gpt-realtime-2";
+const VOICE = process.env.HUDDLE_REALTIME_VOICE || "cedar";
+
+// We chunk capture into ~40ms windows (1920 bytes at 24kHz mono 16-bit).
+// Smaller is more responsive; larger is fewer WS frames. 40ms is the sweet
+// spot — well under typical end-of-turn detection latency.
+const CAPTURE_CHUNK_BYTES = 1920;
+
+/**
+ * @param {object} options
+ * @param {string} [options.apiKey]            OpenAI API key (defaults to env)
+ * @param {string} [options.captureDevice]     BlackHole capture device
+ * @param {string} [options.playbackDevice]    BlackHole playback device
+ * @param {string} [options.agentRoot]         For context-loader (identity + RAG)
+ * @param {string} [options.voice]             Realtime voice (default cedar)
+ * @param {string} [options.peer]              Caller identifier (slack_id / phone / email)
+ * @param {string} [options.brief]             What the agent is supposed to accomplish
+ * @param {Array}  [options.tools]             OpenAI Realtime tool definitions
+ * @param {(call) => Promise<string>} [options.executeTool]
+ *                                             Tool execution handler (returns result text)
+ */
+export class OpenAIRealtimeHuddleBridge extends EventEmitter {
+  constructor(options = {}) {
+    super();
+    this.apiKey = options.apiKey || process.env.OPENAI_API_KEY || "";
+    if (!this.apiKey) throw new Error("OPENAI_API_KEY required for huddle realtime bridge");
+    this.captureDevice = options.captureDevice || CAPTURE_DEVICE;
+    this.playbackDevice = options.playbackDevice || PLAYBACK_DEVICE;
+    this.agentRoot = options.agentRoot || process.env.AGENT_ROOT || process.cwd();
+    this.voice = options.voice || VOICE;
+    this.peer = options.peer || null;
+    this.brief = options.brief || null;
+    this.tools = options.tools || [];
+    this.executeTool = options.executeTool || null;
+
+    // Audio pipeline state
+    this.captureProcess = null;
+    this.playbackProcess = null;
+    this.ws = null;
+    this.isCapturing = false;
+    this.responseInProgress = false;
+    this.currentTranscript = "";        // user side, accumulating
+    this.currentResponse = "";          // model side, accumulating
+    this.pendingFunctionCalls = new Map(); // call_id -> { name, args }
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Lifecycle
+  // ─────────────────────────────────────────────────────────────────────────
+
+  /**
+   * Probe macOS for the BlackHole capture + playback devices via
+   * SwitchAudioSource. Same signature as AudioBridge.checkDevices so the
+   * huddle-server doesn't care which brain is in use.
+   */
+  async checkDevices() {
+    const result = { capture: false, playback: false };
+    try {
+      const devices = execFileSync("SwitchAudioSource", ["-a"], { encoding: "utf8" });
+      result.capture = devices.includes(this.captureDevice);
+      result.playback = devices.includes(this.playbackDevice);
+    } catch { /* SwitchAudioSource not installed */ }
+    return result;
+  }
+
+  async start() {
+    if (this.isCapturing) return;
+
+    // Build the full instructions block via context-loader — same one the
+    // PSTN / outbound paths use. Identity + queues + decisions + team + RAG.
+    let instructions;
+    try {
+      const ctx = await import("../../lib/voice/context-loader.mjs");
+      instructions = await ctx.buildContextualInstructions({
+        agentRoot: this.agentRoot,
+        peer: this.peer,
+        callKind: "inbound",
+        brief: this.brief,
+      });
+    } catch (err) {
+      this.emit("error", { component: "context-loader", message: err.message });
+      instructions = `You are an AI executive operator. Reply briefly in voice mode.`;
+    }
+
+    await this._connectRealtime(instructions);
+    await this._startPlayback();
+    await this._startCapture();
+
+    this.isCapturing = true;
+    this.emit("capture:started");
+  }
+
+  async stop() {
+    this.isCapturing = false;
+
+    if (this.captureProcess) {
+      try { this.captureProcess.kill("SIGTERM"); } catch { /* */ }
+      this.captureProcess = null;
+    }
+    if (this.playbackProcess) {
+      try { this.playbackProcess.stdin?.end(); } catch { /* */ }
+      try { this.playbackProcess.kill("SIGTERM"); } catch { /* */ }
+      this.playbackProcess = null;
+    }
+    if (this.ws) {
+      try { this.ws.close(); } catch { /* */ }
+      this.ws = null;
+    }
+    this.emit("capture:stopped");
+  }
+
+  /**
+   * Force the model to say a specific line. Used by huddle-server.mjs for
+   * the initial greeting and the closing farewell. Translates to a
+   * conversation.item.create with a system-style message + response.create
+   * with explicit instructions — the model paraphrases but stays on-topic.
+   */
+  async speak(text) {
+    if (!text?.trim() || !this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+
+    this._sendWs({
+      type: "conversation.item.create",
+      item: {
+        type: "message",
+        role: "user",
+        content: [{
+          type: "input_text",
+          text: `[system instruction] On your next turn, say exactly: "${text}". After saying it, await the other party's response.`,
+        }],
+      },
+    });
+    this._sendWs({ type: "response.create" });
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Realtime WebSocket
+  // ─────────────────────────────────────────────────────────────────────────
+
+  async _connectRealtime(instructions) {
+    const url = `wss://api.openai.com/v1/realtime?model=${encodeURIComponent(MODEL)}`;
+    this.ws = new WebSocket(url, {
+      headers: { Authorization: `Bearer ${this.apiKey}` },
+    });
+
+    await new Promise((resolveOpen, rejectOpen) => {
+      this.ws.once("open", resolveOpen);
+      this.ws.once("error", rejectOpen);
+    });
+
+    // Push initial session config (GA schema: nested audio.input/output).
+    this._sendWs({
+      type: "session.update",
+      session: {
+        type: "realtime",
+        output_modalities: ["audio"],
+        instructions,
+        audio: {
+          input: {
+            format: { type: "audio/pcm", rate: SAMPLE_RATE },
+            turn_detection: {
+              type: "server_vad",
+              threshold: 0.55,
+              prefix_padding_ms: 300,
+              silence_duration_ms: 700,
+            },
+            transcription: { model: "whisper-1" },
+          },
+          output: {
+            format: { type: "audio/pcm", rate: SAMPLE_RATE },
+            voice: this.voice,
+          },
+        },
+        tools: this.tools,
+        tool_choice: this.tools.length ? "auto" : "none",
+      },
+    });
+
+    this.ws.on("message", (data) => this._onWsMessage(data));
+    this.ws.on("close", () => { this.responseInProgress = false; });
+    this.ws.on("error", (err) => {
+      this.emit("error", { component: "openai-realtime", message: err.message });
+    });
+  }
+
+  _sendWs(obj) {
+    if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+    try { this.ws.send(JSON.stringify(obj)); } catch { /* */ }
+  }
+
+  _onWsMessage(data) {
+    let evt;
+    try { evt = JSON.parse(data.toString()); }
+    catch { return; }
+
+    switch (evt.type) {
+      case "response.created":
+        this.responseInProgress = true;
+        this.currentResponse = "";
+        this.emit("speech:start");
+        break;
+
+      case "response.audio.delta":
+      case "response.output_audio.delta": {
+        const b64 = evt.delta || evt.audio || "";
+        if (b64 && this.playbackProcess?.stdin) {
+          const pcm = Buffer.from(b64, "base64");
+          try { this.playbackProcess.stdin.write(pcm); } catch { /* */ }
+        }
+        break;
+      }
+
+      case "response.audio_transcript.delta":
+      case "response.output_audio_transcript.delta":
+        if (evt.delta) this.currentResponse += evt.delta;
+        break;
+
+      case "response.audio_transcript.done":
+      case "response.output_audio_transcript.done":
+        if (this.currentResponse.trim()) {
+          this.emit("transcript", { role: "assistant", text: this.currentResponse.trim() });
+        }
+        break;
+
+      case "response.done":
+      case "response.completed":
+        this.responseInProgress = false;
+        this.emit("speech:end");
+        break;
+
+      case "conversation.item.input_audio_transcription.delta":
+        if (evt.delta) {
+          this.currentTranscript += evt.delta;
+          this.emit("transcript:interim", { text: this.currentTranscript });
+        }
+        break;
+
+      case "conversation.item.input_audio_transcription.completed":
+        if (evt.transcript) {
+          this.emit("transcript", { role: "user", text: evt.transcript });
+        }
+        this.currentTranscript = "";
+        break;
+
+      case "input_audio_buffer.speech_started":
+        // User started talking — request a cancel if the model is mid-reply.
+        // OpenAI's server_vad does the barge-in detection; this just stops
+        // the audio playback eagerly so the user's voice isn't trampled.
+        if (this.responseInProgress) {
+          this._sendWs({ type: "response.cancel" });
+        }
+        // Drain the playback buffer.
+        if (this.playbackProcess?.stdin) {
+          // sox stdin has no flush API; emit a tone of silence to unblock.
+          // The next response.audio.delta will pick up immediately.
+        }
+        break;
+
+      // Function calling (live tool use during huddle)
+      case "response.function_call_arguments.done": {
+        const callId = evt.call_id;
+        const name = evt.name;
+        const args = evt.arguments;
+        this.emit("tool:call", { name, arguments: args, call_id: callId });
+        this._handleFunctionCall(callId, name, args).catch((err) => {
+          this.emit("error", { component: "tool-call", message: err.message });
+        });
+        break;
+      }
+
+      case "error":
+        this.emit("error", {
+          component: "openai-realtime",
+          message: evt.error?.message || JSON.stringify(evt),
+        });
+        break;
+
+      default:
+        // many event types we don't need: response.created subtypes, audio
+        // buffer state etc. silent ignore.
+        break;
+    }
+  }
+
+  async _handleFunctionCall(callId, name, argsJson) {
+    if (!this.executeTool) {
+      // No executor wired — return a stub so the model doesn't hang.
+      this._sendFunctionResult(callId, JSON.stringify({
+        ok: false,
+        error: "no_tool_executor_wired_in_huddle_bridge",
+      }));
+      return;
+    }
+    let parsed = {};
+    try { parsed = JSON.parse(argsJson || "{}"); } catch { /* */ }
+    let result;
+    try {
+      result = await this.executeTool({ name, arguments: parsed, call_id: callId });
+    } catch (err) {
+      result = { ok: false, error: err.message };
+    }
+    this._sendFunctionResult(callId, typeof result === "string" ? result : JSON.stringify(result));
+  }
+
+  _sendFunctionResult(callId, output) {
+    this._sendWs({
+      type: "conversation.item.create",
+      item: {
+        type: "function_call_output",
+        call_id: callId,
+        output,
+      },
+    });
+    this._sendWs({ type: "response.create" });
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Audio capture (BlackHole 2ch → sox → WS append)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  async _startCapture() {
+    // sox -t coreaudio "BlackHole 2ch" -t raw -r 24000 -e signed-integer -b 16 -c 1 -
+    // streams raw little-endian PCM16 mono at 24kHz to stdout. We split the
+    // stream into ~40ms windows + base64-encode for OpenAI's
+    // input_audio_buffer.append messages.
+    this.captureProcess = spawn("sox", [
+      "-t", "coreaudio", this.captureDevice,
+      "-t", "raw",
+      "-r", String(SAMPLE_RATE),
+      "-e", "signed-integer",
+      "-b", String(BIT_DEPTH),
+      "-c", String(CHANNELS),
+      "-",
+    ], { stdio: ["ignore", "pipe", "pipe"] });
+
+    let leftover = Buffer.alloc(0);
+    this.captureProcess.stdout.on("data", (chunk) => {
+      if (!this.ws || this.ws.readyState !== WebSocket.OPEN) return;
+      // Concatenate with any trailing fractional-frame bytes from last tick
+      // and re-slice into clean CHUNK_BYTES windows.
+      const combined = leftover.length ? Buffer.concat([leftover, chunk]) : chunk;
+      const usable = Math.floor(combined.length / CAPTURE_CHUNK_BYTES) * CAPTURE_CHUNK_BYTES;
+      for (let off = 0; off < usable; off += CAPTURE_CHUNK_BYTES) {
+        const slice = combined.slice(off, off + CAPTURE_CHUNK_BYTES);
+        this._sendWs({
+          type: "input_audio_buffer.append",
+          audio: slice.toString("base64"),
+        });
+      }
+      leftover = combined.slice(usable);
+    });
+    this.captureProcess.stderr.on("data", (chunk) => {
+      const line = chunk.toString().trim();
+      if (line && !/^In:/.test(line)) {
+        // sox emits progress lines on stderr; ignore those.
+        this.emit("error", { component: "sox-capture", message: line });
+      }
+    });
+    this.captureProcess.on("exit", (code, signal) => {
+      if (this.isCapturing && code !== 0 && signal !== "SIGTERM") {
+        this.emit("error", {
+          component: "sox-capture",
+          message: `capture exited code=${code} signal=${signal}`,
+        });
+      }
+    });
+  }
+
+  // ─────────────────────────────────────────────────────────────────────────
+  // Audio playback (WS audio.delta → sox stdin → BlackHole 16ch)
+  // ─────────────────────────────────────────────────────────────────────────
+
+  async _startPlayback() {
+    // sox reads raw PCM16 from stdin and outputs it on the coreaudio
+    // playback device. The continuous-stdin pipe keeps the device live so
+    // each audio.delta plays immediately (no per-chunk device-open latency).
+    this.playbackProcess = spawn("sox", [
+      "-t", "raw",
+      "-r", String(SAMPLE_RATE),
+      "-e", "signed-integer",
+      "-b", String(BIT_DEPTH),
+      "-c", String(CHANNELS),
+      "-",
+      "-t", "coreaudio", this.playbackDevice,
+    ], { stdio: ["pipe", "ignore", "pipe"] });
+
+    this.playbackProcess.stderr.on("data", (chunk) => {
+      const line = chunk.toString().trim();
+      if (line && !/^In:/.test(line)) {
+        this.emit("error", { component: "sox-playback", message: line });
+      }
+    });
+    this.playbackProcess.on("exit", (code, signal) => {
+      if (this.isCapturing && code !== 0 && signal !== "SIGTERM") {
+        this.emit("error", {
+          component: "sox-playback",
+          message: `playback exited code=${code} signal=${signal}`,
+        });
+      }
+    });
+    this.emit("tts:start");
+  }
+}
+
+export default OpenAIRealtimeHuddleBridge;