@acpfx/tts-deepgram 0.2.2 → 0.2.4

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2024-2026 acpfx contributors
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,43 @@
+# @acpfx/tts-deepgram
+
+Text-to-speech via Deepgram streaming API. Converts agent text deltas into audio chunks in real time.
+
+## Usage
+
+This package is a pipeline node for [@acpfx/cli](../orchestrator/README.md). See the CLI package for installation and usage.
+
+Requires a `DEEPGRAM_API_KEY` environment variable.
+
+## Manifest
+
+- **Consumes:** `agent.delta`, `agent.complete`, `agent.tool_start`, `control.interrupt`
+- **Emits:** `audio.chunk`, `lifecycle.ready`, `lifecycle.done`, `control.error`
+
+## Settings
+
+| Name | Type | Default | Description |
+|------|------|---------|-------------|
+| `voice` | string | `aura-2-apollo-en` | Deepgram voice model name |
+| `sampleRate` | number | `16000` | Audio sample rate in Hz |
+| `apiKey` | string | | Overrides `DEEPGRAM_API_KEY` env var |
+
+## Pipeline Example
+
+```yaml
+nodes:
+  tts:
+    use: "@acpfx/tts-deepgram"
+    settings: { voice: aura-2-aries-en }
+    outputs: [player]
+env:
+  DEEPGRAM_API_KEY: ${DEEPGRAM_API_KEY}
+```
+
+## External Links
+
+- [Deepgram](https://deepgram.com) -- Speech AI platform
+- [Deepgram Developer Docs](https://developers.deepgram.com) -- API reference and guides
+
+## License
+
+ISC

package/dist/index.js

@@ -0,0 +1,347 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { createInterface } from "node:readline";
+
+// ../core/src/config.ts
+import { parse as parseYaml } from "yaml";
+
+// ../core/src/manifest.ts
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { z as z2 } from "zod";
+
+// ../core/src/acpfx-flags.ts
+import { z } from "zod";
+var SetupCheckResponseSchema = z.object({
+  needed: z.boolean(),
+  description: z.string().optional()
+});
+var SetupProgressSchema = z.discriminatedUnion("type", [
+  z.object({
+    type: z.literal("progress"),
+    message: z.string(),
+    pct: z.number().optional()
+  }),
+  z.object({ type: z.literal("complete"), message: z.string() }),
+  z.object({ type: z.literal("error"), message: z.string() })
+]);
+var UnsupportedFlagResponseSchema = z.object({
+  unsupported: z.boolean(),
+  flag: z.string()
+});
+
+// ../core/src/manifest.ts
+var ArgumentTypeSchema = z2.enum(["string", "number", "boolean"]);
+var ManifestArgumentSchema = z2.object({
+  type: ArgumentTypeSchema,
+  default: z2.unknown().optional(),
+  description: z2.string().optional(),
+  required: z2.boolean().optional(),
+  enum: z2.array(z2.unknown()).optional()
+});
+var ManifestEnvFieldSchema = z2.object({
+  required: z2.boolean().optional(),
+  description: z2.string().optional()
+});
+var NodeManifestSchema = z2.object({
+  name: z2.string(),
+  description: z2.string().optional(),
+  consumes: z2.array(z2.string()),
+  emits: z2.array(z2.string()),
+  arguments: z2.record(z2.string(), ManifestArgumentSchema).optional(),
+  additional_arguments: z2.boolean().optional(),
+  env: z2.record(z2.string(), ManifestEnvFieldSchema).optional()
+});
+function handleAcpfxFlags(manifestPath) {
+  const acpfxFlag = process.argv.find((a) => a.startsWith("--acpfx-"));
+  const legacyManifest = process.argv.includes("--manifest");
+  if (!acpfxFlag && !legacyManifest) return;
+  const flag = acpfxFlag ?? "--acpfx-manifest";
+  switch (flag) {
+    case "--acpfx-manifest":
+      printManifest(manifestPath);
+      break;
+    case "--acpfx-setup-check":
+      process.stdout.write(JSON.stringify({ needed: false }) + "\n");
+      process.exit(0);
+      break;
+    default:
+      process.stdout.write(
+        JSON.stringify({ unsupported: true, flag }) + "\n"
+      );
+      process.exit(0);
+  }
+}
+function handleManifestFlag(manifestPath) {
+  handleAcpfxFlags(manifestPath);
+}
+function printManifest(manifestPath) {
+  if (!manifestPath) {
+    const script = process.argv[1];
+    const scriptDir = dirname(script);
+    const scriptBase = script.replace(/\.[^.]+$/, "");
+    const colocated = `${scriptBase}.manifest.json`;
+    try {
+      readFileSync(colocated);
+      manifestPath = colocated;
+    } catch {
+      manifestPath = join(scriptDir, "manifest.json");
+    }
+  }
+  try {
+    const content = readFileSync(manifestPath, "utf8");
+    process.stdout.write(content.trim() + "\n");
+    process.exit(0);
+  } catch (err) {
+    process.stderr.write(`Failed to read manifest: ${err}
+`);
+    process.exit(1);
+  }
+}
+
+// ../node-sdk/src/index.ts
+var NODE_NAME = process.env.ACPFX_NODE_NAME ?? "unknown";
+function emit(event) {
+  process.stdout.write(JSON.stringify(event) + "\n");
+}
+function log(level, message) {
+  emit({ type: "log", level, component: NODE_NAME, message });
+}
+log.info = (message) => log("info", message);
+log.warn = (message) => log("warn", message);
+log.error = (message) => log("error", message);
+log.debug = (message) => log("debug", message);
+
+// src/index.ts
+handleManifestFlag();
+var WS_URL = "wss://api.deepgram.com/v1/speak";
+var DEFAULT_VOICE = "aura-2-apollo-en";
+var TRACK_ID = "tts";
+var settings = JSON.parse(process.env.ACPFX_SETTINGS || "{}");
+var API_KEY = settings.apiKey ?? process.env.DEEPGRAM_API_KEY ?? "";
+var VOICE = settings.voice ?? DEFAULT_VOICE;
+var SAMPLE_RATE = settings.sampleRate ?? 16e3;
+var CHANNELS = 1;
+var BYTES_PER_SAMPLE = 2;
+var CHUNK_DURATION_MS = 100;
+var CHUNK_SIZE = Math.floor(
+  SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE * CHUNK_DURATION_MS / 1e3
+);
+if (!API_KEY) {
+  log.error("No API key. Set DEEPGRAM_API_KEY or settings.apiKey");
+  process.exit(1);
+}
+var ws = null;
+var connected = false;
+var interrupted = false;
+var pcmBuffer = Buffer.alloc(0);
+var currentRequestId = null;
+async function openWebSocket() {
+  if (ws && connected) return;
+  const url = `${WS_URL}?model=${encodeURIComponent(VOICE)}&encoding=linear16&sample_rate=${SAMPLE_RATE}`;
+  ws = new WebSocket(url, ["token", API_KEY]);
+  await new Promise((resolve, reject) => {
+    ws.addEventListener(
+      "open",
+      () => {
+        connected = true;
+        log.info("Connected to Deepgram TTS");
+        resolve();
+      },
+      { once: true }
+    );
+    ws.addEventListener(
+      "error",
+      () => reject(new Error("TTS WebSocket connection failed")),
+      { once: true }
+    );
+  });
+  ws.addEventListener("message", (event) => {
+    if (interrupted) return;
+    const data = event.data;
+    if (typeof data === "object" && data !== null && typeof data.arrayBuffer === "function") {
+      data.arrayBuffer().then((ab) => {
+        if (interrupted) return;
+        handleAudioData(Buffer.from(ab));
+      });
+      return;
+    }
+    if (data instanceof ArrayBuffer || Buffer.isBuffer(data)) {
+      handleAudioData(Buffer.from(data));
+      return;
+    }
+    if (typeof data === "string") {
+      try {
+        const msg = JSON.parse(data);
+        if (msg.type === "Flushed") {
+          if (pcmBuffer.length > 0) {
+            emitAudioChunk(pcmBuffer);
+            pcmBuffer = Buffer.alloc(0);
+          }
+        } else if (msg.type === "Warning") {
+          log.warn(`Deepgram warning: ${msg.description ?? msg.code ?? "unknown"}`);
+        }
+      } catch {
+      }
+    }
+  });
+  function handleAudioData(rawPcm) {
+    pcmBuffer = Buffer.concat([pcmBuffer, rawPcm]);
+    while (pcmBuffer.length >= CHUNK_SIZE) {
+      const chunk = pcmBuffer.subarray(0, CHUNK_SIZE);
+      pcmBuffer = pcmBuffer.subarray(CHUNK_SIZE);
+      emitAudioChunk(chunk);
+    }
+  }
+  ws.addEventListener("error", (event) => {
+    log.error(`WebSocket error: ${event.message ?? "unknown"}`);
+    emit({
+      type: "control.error",
+      component: "tts-deepgram",
+      message: "TTS WebSocket error",
+      fatal: false
+    });
+  });
+  ws.addEventListener("close", (event) => {
+    log.info(`WebSocket closed (code=${event.code})`);
+    connected = false;
+  });
+}
+function emitAudioChunk(pcm) {
+  const durationMs = Math.round(
+    pcm.length / (SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE) * 1e3
+  );
+  emit({
+    type: "audio.chunk",
+    trackId: TRACK_ID,
+    format: "pcm_s16le",
+    sampleRate: SAMPLE_RATE,
+    channels: CHANNELS,
+    data: Buffer.from(pcm).toString("base64"),
+    durationMs
+  });
+}
+var inUrl = false;
+var inCodeBlock = false;
+function stripMarkdown(text) {
+  if (text.includes("```")) {
+    inCodeBlock = !inCodeBlock;
+    return "";
+  }
+  if (inCodeBlock) return "";
+  let result = "";
+  for (let i = 0; i < text.length; i++) {
+    const ch = text[i];
+    if (inUrl) {
+      if (ch === ")") inUrl = false;
+      continue;
+    }
+    if (ch === "]" && i + 1 < text.length && text[i + 1] === "(") {
+      inUrl = true;
+      i++;
+      continue;
+    }
+    if (ch === "[" || ch === "]") continue;
+    if (ch === "*" || ch === "~" || ch === "`") continue;
+    if (ch === "#" && (i === 0 || text[i - 1] === "\n")) continue;
+    result += ch;
+  }
+  return result;
+}
+function sendText(text) {
+  if (!ws || !connected) {
+    log.warn(`sendText dropped (connected=${connected}): "${text.slice(0, 30)}"`);
+    return;
+  }
+  const clean = stripMarkdown(text);
+  if (!clean) return;
+  ws.send(JSON.stringify({ type: "Speak", text: clean }));
+}
+function flushStream() {
+  if (!ws || !connected) return;
+  log.debug("Sending Flush");
+  ws.send(JSON.stringify({ type: "Flush" }));
+}
+function clearStream() {
+  if (!ws || !connected) return;
+  log.debug("Sending Clear");
+  ws.send(JSON.stringify({ type: "Clear" }));
+}
+function closeWebSocket() {
+  connected = false;
+  pcmBuffer = Buffer.alloc(0);
+  if (ws) {
+    try {
+      ws.send(JSON.stringify({ type: "Close" }));
+      ws.close();
+    } catch {
+    }
+    ws = null;
+  }
+}
+async function main() {
+  await openWebSocket();
+  emit({ type: "lifecycle.ready", component: "tts-deepgram" });
+  const rl = createInterface({ input: process.stdin });
+  const eventQueue = [];
+  let processing = false;
+  async function processQueue() {
+    if (processing) return;
+    processing = true;
+    while (eventQueue.length > 0) {
+      const line = eventQueue.shift();
+      try {
+        const event = JSON.parse(line);
+        await handleEvent(event);
+      } catch {
+      }
+    }
+    processing = false;
+  }
+  async function handleEvent(event) {
+    if (event.type === "agent.delta") {
+      if (event.delta) {
+        if (interrupted || !connected) {
+          log.info(`Reconnecting (interrupted=${interrupted}, connected=${connected})`);
+          interrupted = false;
+          closeWebSocket();
+          await openWebSocket();
+        }
+        currentRequestId = event.requestId;
+        sendText(event.delta);
+      }
+    } else if (event.type === "agent.tool_start" && !interrupted) {
+      if (connected) {
+        log.info("Tool started \u2014 flushing TTS segment");
+        flushStream();
+      }
+    } else if (event.type === "agent.complete" && !interrupted) {
+      flushStream();
+      currentRequestId = null;
+    } else if (event.type === "control.interrupt") {
+      interrupted = true;
+      clearStream();
+      closeWebSocket();
+      currentRequestId = null;
+    }
+  }
+  rl.on("line", (line) => {
+    if (!line.trim()) return;
+    eventQueue.push(line);
+    processQueue();
+  });
+  rl.on("close", () => {
+    closeWebSocket();
+    emit({ type: "lifecycle.done", component: "tts-deepgram" });
+    process.exit(0);
+  });
+  process.on("SIGTERM", () => {
+    closeWebSocket();
+    process.exit(0);
+  });
+}
+main().catch((err) => {
+  log.error(`Fatal: ${err.message}`);
+  process.exit(1);
+});

package/dist/manifest.json

@@ -0,0 +1 @@
+{"name":"tts-deepgram","description":"Text-to-speech via Deepgram streaming API","consumes":["agent.delta","agent.complete","agent.tool_start","control.interrupt"],"emits":["audio.chunk","lifecycle.ready","lifecycle.done","control.error"],"arguments":{"voice":{"type":"string","default":"aura-2-apollo-en","description":"Deepgram voice model name"},"sampleRate":{"type":"number","default":16000,"description":"Audio sample rate in Hz"},"apiKey":{"type":"string","description":"Deepgram API key (overrides DEEPGRAM_API_KEY env var)"}},"env":{"DEEPGRAM_API_KEY":{"required":true,"description":"Deepgram API key for TTS"}}}

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@acpfx/tts-deepgram",
-  "version": "0.2.2",
+  "version": "0.2.4",
   "type": "module",
   "bin": {
     "acpfx-tts-deepgram": "./dist/index.js"
   },
   "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "manifest.yaml"
+  ],
   "dependencies": {
     "@acpfx/core": "0.4.0",
     "@acpfx/node-sdk": "0.3.0"
   },
   "scripts": {
-    "build": "esbuild src/index.ts --bundle --platform=node --format=esm --outfile=dist/index.js --packages=external"
+    "build": "esbuild src/index.ts --bundle --banner:js=\"#!/usr/bin/env node\" --platform=node --format=esm --outfile=dist/index.js --packages=external && node ../../scripts/copy-manifest.js"
   }
 }

package/CHANGELOG.md

@@ -1,38 +0,0 @@
-# @acpfx/tts-deepgram
-
-## 0.2.2
-
-### Patch Changes
-
-- Updated dependencies [0e6838e]
-  - @acpfx/core@0.4.0
-  - @acpfx/node-sdk@0.3.0
-
-## 0.2.1
-
-### Patch Changes
-
-- Updated dependencies [79c6694]
-- Updated dependencies [a0320a1]
-  - @acpfx/core@0.3.0
-  - @acpfx/node-sdk@0.2.1
-
-## 0.2.0
-
-### Minor Changes
-
-- d757640: Initial release: type-safe contracts, Rust orchestrator, manifest-driven event filtering
-
-  - Rust schema crate as canonical event type source of truth with codegen to TypeScript + Zod
-  - Node manifests (manifest.yaml) declaring consumes/emits contracts
-  - Orchestrator event filtering: nodes only receive declared events
-  - Rust orchestrator with ratatui TUI (--ui flag)
-  - node-sdk with structured logging helpers
-  - CI/CD with GitHub Actions and changesets
-  - Platform-specific npm packages for Rust binaries (esbuild-style distribution)
-
-### Patch Changes
-
-- Updated dependencies [d757640]
-  - @acpfx/core@0.2.0
-  - @acpfx/node-sdk@0.2.0

package/src/index.ts

@@ -1,316 +0,0 @@
-/**
- * tts-deepgram node — Deepgram Aura streaming TTS via WebSocket.
- *
- * Reads agent.delta events, streams text tokens to Deepgram WebSocket,
- * emits audio.chunk events as audio arrives.
- *
- * True streaming: sends each delta token as it arrives via {"type":"Speak","text":"..."}.
- * Explicit segment control:
- *   - Flush on agent.tool_start (finalize current segment)
- *   - Clear on control.interrupt (discard buffered text)
- *
- * Settings (via ACPFX_SETTINGS):
- *   voice?: string      — Deepgram voice model (default: aura-2-apollo-en)
- *   apiKey?: string      — API key (falls back to DEEPGRAM_API_KEY env)
- *   sampleRate?: number  — output sample rate (default: 16000)
- */
-
-import { createInterface } from "node:readline";
-import { emit, log, handleManifestFlag } from "@acpfx/node-sdk";
-
-handleManifestFlag();
-
-const WS_URL = "wss://api.deepgram.com/v1/speak";
-const DEFAULT_VOICE = "aura-2-apollo-en";
-const TRACK_ID = "tts";
-
-type Settings = {
-  voice?: string;
-  apiKey?: string;
-  sampleRate?: number;
-};
-
-const settings: Settings = JSON.parse(process.env.ACPFX_SETTINGS || "{}");
-const API_KEY = settings.apiKey ?? process.env.DEEPGRAM_API_KEY ?? "";
-const VOICE = settings.voice ?? DEFAULT_VOICE;
-const SAMPLE_RATE = settings.sampleRate ?? 16000;
-const CHANNELS = 1;
-const BYTES_PER_SAMPLE = 2;
-const CHUNK_DURATION_MS = 100;
-const CHUNK_SIZE = Math.floor(
-  (SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE * CHUNK_DURATION_MS) / 1000,
-);
-
-if (!API_KEY) {
-  log.error("No API key. Set DEEPGRAM_API_KEY or settings.apiKey");
-  process.exit(1);
-}
-
-let ws: WebSocket | null = null;
-let connected = false;
-let interrupted = false;
-let pcmBuffer = Buffer.alloc(0);
-let currentRequestId: string | null = null;
-
-
-async function openWebSocket(): Promise<void> {
-  if (ws && connected) return;
-
-  const url =
-    `${WS_URL}?model=${encodeURIComponent(VOICE)}` +
-    `&encoding=linear16` +
-    `&sample_rate=${SAMPLE_RATE}`;
-
-  ws = new WebSocket(url, ["token", API_KEY]);
-
-  await new Promise<void>((resolve, reject) => {
-    ws!.addEventListener(
-      "open",
-      () => {
-        connected = true;
-        log.info("Connected to Deepgram TTS");
-        resolve();
-      },
-      { once: true },
-    );
-    ws!.addEventListener(
-      "error",
-      () => reject(new Error("TTS WebSocket connection failed")),
-      { once: true },
-    );
-  });
-
-  ws.addEventListener("message", (event: MessageEvent) => {
-    if (interrupted) return;
-
-    const data = event.data;
-
-    // Handle Blob (browser-style WebSocket returns Blobs for binary)
-    if (typeof data === "object" && data !== null && typeof (data as any).arrayBuffer === "function") {
-      (data as Blob).arrayBuffer().then((ab) => {
-        if (interrupted) return;
-        handleAudioData(Buffer.from(ab));
-      });
-      return;
-    }
-
-    // Handle ArrayBuffer / Buffer
-    if (data instanceof ArrayBuffer || Buffer.isBuffer(data)) {
-      handleAudioData(Buffer.from(data as ArrayBuffer));
-      return;
-    }
-
-    // Text frame — metadata/control message
-    if (typeof data === "string") {
-      try {
-        const msg = JSON.parse(data);
-        if (msg.type === "Flushed") {
-          if (pcmBuffer.length > 0) {
-            emitAudioChunk(pcmBuffer);
-            pcmBuffer = Buffer.alloc(0);
-          }
-        } else if (msg.type === "Warning") {
-          log.warn(`Deepgram warning: ${msg.description ?? msg.code ?? "unknown"}`);
-        }
-      } catch {
-        // ignore
-      }
-    }
-  });
-
-  function handleAudioData(rawPcm: Buffer): void {
-    pcmBuffer = Buffer.concat([pcmBuffer, rawPcm]);
-    while (pcmBuffer.length >= CHUNK_SIZE) {
-      const chunk = pcmBuffer.subarray(0, CHUNK_SIZE);
-      pcmBuffer = pcmBuffer.subarray(CHUNK_SIZE);
-      emitAudioChunk(chunk);
-    }
-  }
-
-  ws.addEventListener("error", (event: Event) => {
-    log.error(`WebSocket error: ${(event as ErrorEvent).message ?? "unknown"}`);
-    emit({
-      type: "control.error",
-      component: "tts-deepgram",
-      message: "TTS WebSocket error",
-      fatal: false,
-    });
-  });
-
-  ws.addEventListener("close", (event: CloseEvent) => {
-    log.info(`WebSocket closed (code=${event.code})`);
-    connected = false;
-  });
-}
-
-function emitAudioChunk(pcm: Buffer): void {
-  const durationMs = Math.round(
-    (pcm.length / (SAMPLE_RATE * CHANNELS * BYTES_PER_SAMPLE)) * 1000,
-  );
-  emit({
-    type: "audio.chunk",
-    trackId: TRACK_ID,
-    format: "pcm_s16le",
-    sampleRate: SAMPLE_RATE,
-    channels: CHANNELS,
-    data: Buffer.from(pcm).toString("base64"),
-    durationMs,
-  });
-}
-
-/**
- * Strip markdown characters from streaming tokens.
- * Since tokens arrive fragmented (e.g., "**" then "bold" then "**"),
- * we can't use pattern-based regex. Instead, just remove markdown
- * syntax characters and track URL state to skip link targets.
- */
-let inUrl = false;
-let inCodeBlock = false;
-
-function stripMarkdown(text: string): string {
-  // Track code block state across tokens
-  if (text.includes("```")) {
-    inCodeBlock = !inCodeBlock;
-    return "";
-  }
-  if (inCodeBlock) return "";
-
-  // Track markdown link URL: after "](" skip until ")"
-  let result = "";
-  for (let i = 0; i < text.length; i++) {
-    const ch = text[i];
-    if (inUrl) {
-      if (ch === ")") inUrl = false;
-      continue; // skip URL characters
-    }
-    if (ch === "]" && i + 1 < text.length && text[i + 1] === "(") {
-      inUrl = true;
-      i++; // skip the "("
-      continue;
-    }
-    if (ch === "[" || ch === "]") continue; // link brackets
-    if (ch === "*" || ch === "~" || ch === "`") continue;
-    if (ch === "#" && (i === 0 || text[i - 1] === "\n")) continue;
-    result += ch;
-  }
-  return result;
-}
-
-function sendText(text: string): void {
-  if (!ws || !connected) {
-    log.warn(`sendText dropped (connected=${connected}): "${text.slice(0, 30)}"`);
-    return;
-  }
-  const clean = stripMarkdown(text);
-  if (!clean) return;
-  ws.send(JSON.stringify({ type: "Speak", text: clean }));
-}
-
-function flushStream(): void {
-  if (!ws || !connected) return;
-  log.debug("Sending Flush");
-  ws.send(JSON.stringify({ type: "Flush" }));
-}
-
-function clearStream(): void {
-  if (!ws || !connected) return;
-  log.debug("Sending Clear");
-  ws.send(JSON.stringify({ type: "Clear" }));
-}
-
-function closeWebSocket(): void {
-  connected = false;
-  pcmBuffer = Buffer.alloc(0);
-  if (ws) {
-    try {
-      ws.send(JSON.stringify({ type: "Close" }));
-      ws.close();
-    } catch {
-      // ignore
-    }
-    ws = null;
-  }
-}
-
-// --- Main ---
-
-async function main(): Promise<void> {
-  await openWebSocket();
-
-  emit({ type: "lifecycle.ready", component: "tts-deepgram" });
-
-  const rl = createInterface({ input: process.stdin });
-
-  const eventQueue: string[] = [];
-  let processing = false;
-
-  async function processQueue(): Promise<void> {
-    if (processing) return;
-    processing = true;
-
-    while (eventQueue.length > 0) {
-      const line = eventQueue.shift()!;
-      try {
-        const event = JSON.parse(line);
-        await handleEvent(event);
-      } catch {
-        // ignore
-      }
-    }
-
-    processing = false;
-  }
-
-  async function handleEvent(event: Record<string, unknown>): Promise<void> {
-    if (event.type === "agent.delta") {
-      if (event.delta) {
-        if (interrupted || !connected) {
-          log.info(`Reconnecting (interrupted=${interrupted}, connected=${connected})`);
-          interrupted = false;
-          closeWebSocket();
-          await openWebSocket();
-        }
-        currentRequestId = event.requestId as string;
-        sendText(event.delta as string);
-      }
-    } else if (event.type === "agent.tool_start" && !interrupted) {
-      // Tool call started — flush current segment
-      if (connected) {
-        log.info("Tool started — flushing TTS segment");
-        flushStream();
-      }
-    } else if (event.type === "agent.complete" && !interrupted) {
-      // Agent done — flush remaining text
-      flushStream();
-      currentRequestId = null;
-    } else if (event.type === "control.interrupt") {
-      interrupted = true;
-      // Clear discards buffered text immediately
-      clearStream();
-      closeWebSocket();
-      currentRequestId = null;
-    }
-  }
-
-  rl.on("line", (line) => {
-    if (!line.trim()) return;
-    eventQueue.push(line);
-    processQueue();
-  });
-
-  rl.on("close", () => {
-    closeWebSocket();
-    emit({ type: "lifecycle.done", component: "tts-deepgram" });
-    process.exit(0);
-  });
-
-  process.on("SIGTERM", () => {
-    closeWebSocket();
-    process.exit(0);
-  });
-}
-
-main().catch((err) => {
-  log.error(`Fatal: ${err.message}`);
-  process.exit(1);
-});