@elizaos/plugin-streaming 2.0.0-beta.1

package/dist/services/tts-stream-bridge.d.ts

@@ -0,0 +1,103 @@
+import { Writable } from 'node:stream';
+
+/**
+ * TTS Stream Bridge — generates TTS audio server-side and pipes PCM data
+ * into FFmpeg's audio track for RTMP streaming.
+ *
+ * Uses pipe:3 (a 4th stdio fd) as the audio input to FFmpeg. Writes PCM
+ * silence when idle and decoded TTS audio when speaking. This avoids FIFO
+ * complexity and works cross-platform.
+ *
+ * @module services/tts-stream-bridge
+ */
+
+type TtsProvider = "elevenlabs" | "openai" | "edge" | (string & {});
+type TtsConfig = {
+    enabled?: boolean;
+    provider?: TtsProvider;
+    elevenlabs?: {
+        apiKey?: string;
+        voiceId?: string;
+        modelId?: string;
+        voiceSettings?: Record<string, unknown>;
+    };
+    openai?: {
+        apiKey?: string;
+        model?: string;
+        voice?: string;
+    };
+    edge?: {
+        voice?: string;
+    };
+};
+/** Resolved TTS configuration for a speak() call. */
+interface ResolvedTtsConfig {
+    provider: TtsProvider;
+    elevenlabs?: {
+        apiKey: string;
+        voiceId: string;
+        modelId: string;
+        voiceSettings?: Record<string, unknown>;
+    };
+    openai?: {
+        apiKey: string;
+        model: string;
+        voice: string;
+    };
+    edge?: {
+        voice: string;
+    };
+}
+/** Public interface for the TTS stream bridge. */
+interface ITtsStreamBridge {
+    attach(stream: Writable): void;
+    detach(): void;
+    isAttached(): boolean;
+    isSpeaking(): boolean;
+    speak(text: string, config: ResolvedTtsConfig): Promise<boolean>;
+}
+declare class TtsStreamBridge implements ITtsStreamBridge {
+    private writeStream;
+    private tickTimer;
+    private pcmQueue;
+    private _speaking;
+    private silenceChunk;
+    constructor();
+    /** Attach the bridge to an FFmpeg stdio pipe (pipe:3). */
+    attach(stream: Writable): void;
+    /** Detach from FFmpeg — stops tick loop and clears queue. */
+    detach(): void;
+    /** Whether the bridge is currently attached to an FFmpeg process. */
+    isAttached(): boolean;
+    /** Whether TTS audio is currently being played. */
+    isSpeaking(): boolean;
+    /**
+     * Generate TTS for the given text and queue PCM audio for playback.
+     * Non-blocking — queues audio and returns immediately after generation.
+     */
+    speak(text: string, config: ResolvedTtsConfig): Promise<boolean>;
+    /** Called every CHUNK_MS — writes next PCM chunk (TTS or silence) to FFmpeg. */
+    private tick;
+    private generateTts;
+    private generateElevenlabs;
+    private generateOpenai;
+    private generateEdge;
+    /** Decode MP3 audio to raw s16le PCM using an FFmpeg subprocess. */
+    private decodeMp3ToPcm;
+}
+/**
+ * Resolve TTS configuration from eliza config, finding the best available
+ * provider with valid API keys.
+ */
+declare function resolveTtsConfig(ttsConfig: TtsConfig | undefined): ResolvedTtsConfig | null;
+/**
+ * Get a summary of available TTS providers and their status.
+ */
+declare function getTtsProviderStatus(ttsConfig: TtsConfig | undefined): {
+    configuredProvider: string | null;
+    hasApiKey: boolean;
+    resolvedProvider: string | null;
+};
+declare const ttsStreamBridge: TtsStreamBridge;
+
+export { type ITtsStreamBridge, type ResolvedTtsConfig, type TtsConfig, type TtsProvider, getTtsProviderStatus, resolveTtsConfig, ttsStreamBridge };

package/dist/services/tts-stream-bridge.js

@@ -0,0 +1,327 @@
+import { spawn } from "node:child_process";
+import { logger, sanitizeSpeechText } from "@elizaos/core";
+const TAG = "[TtsStreamBridge]";
+const SAMPLE_RATE = 24e3;
+const CHANNELS = 1;
+const BYTES_PER_SAMPLE = 2;
+const CHUNK_MS = 50;
+const CHUNK_BYTES = SAMPLE_RATE * BYTES_PER_SAMPLE * CHANNELS * CHUNK_MS / 1e3;
+const ELEVENLABS_TIMEOUT_MS = 2e4;
+const OPENAI_TIMEOUT_MS = 2e4;
+class TtsStreamBridge {
+  writeStream = null;
+  tickTimer = null;
+  pcmQueue = [];
+  _speaking = false;
+  silenceChunk;
+  constructor() {
+    this.silenceChunk = Buffer.alloc(CHUNK_BYTES, 0);
+  }
+  /** Attach the bridge to an FFmpeg stdio pipe (pipe:3). */
+  attach(stream) {
+    this.detach();
+    this.writeStream = stream;
+    stream.on("error", (err) => {
+      logger.warn(`${TAG} Write stream error: ${err.message}`);
+    });
+    this.tickTimer = setInterval(() => this.tick(), CHUNK_MS);
+    logger.info(`${TAG} Attached to FFmpeg audio pipe`);
+  }
+  /** Detach from FFmpeg — stops tick loop and clears queue. */
+  detach() {
+    if (this.tickTimer) {
+      clearInterval(this.tickTimer);
+      this.tickTimer = null;
+    }
+    this.writeStream = null;
+    this.pcmQueue = [];
+    this._speaking = false;
+  }
+  /** Whether the bridge is currently attached to an FFmpeg process. */
+  isAttached() {
+    return this.writeStream !== null;
+  }
+  /** Whether TTS audio is currently being played. */
+  isSpeaking() {
+    return this._speaking;
+  }
+  /**
+   * Generate TTS for the given text and queue PCM audio for playback.
+   * Non-blocking — queues audio and returns immediately after generation.
+   */
+  async speak(text, config) {
+    if (!this.writeStream) {
+      logger.warn(`${TAG} Cannot speak \u2014 not attached to FFmpeg`);
+      return false;
+    }
+    const speakableText = sanitizeSpeechText(text);
+    if (!speakableText) return false;
+    try {
+      logger.info(
+        `${TAG} Generating TTS (${config.provider}, ${speakableText.length} chars)`
+      );
+      const mp3 = await this.generateTts(speakableText, config);
+      if (!mp3 || mp3.length === 0) {
+        logger.warn(`${TAG} TTS returned empty audio`);
+        return false;
+      }
+      const pcm = await this.decodeMp3ToPcm(mp3);
+      if (!pcm || pcm.length === 0) {
+        logger.warn(`${TAG} PCM decode returned empty buffer`);
+        return false;
+      }
+      const chunks = [];
+      for (let i = 0; i < pcm.length; i += CHUNK_BYTES) {
+        const end = Math.min(i + CHUNK_BYTES, pcm.length);
+        const chunk = Buffer.alloc(CHUNK_BYTES, 0);
+        pcm.copy(chunk, 0, i, end);
+        chunks.push(chunk);
+      }
+      this.pcmQueue.push(...chunks);
+      this._speaking = true;
+      logger.info(
+        `${TAG} Queued ${chunks.length} PCM chunks (${(pcm.length / SAMPLE_RATE / BYTES_PER_SAMPLE).toFixed(1)}s)`
+      );
+      return true;
+    } catch (err) {
+      logger.error(`${TAG} TTS generation failed: ${String(err)}`);
+      return false;
+    }
+  }
+  /** Called every CHUNK_MS — writes next PCM chunk (TTS or silence) to FFmpeg. */
+  tick() {
+    if (!this.writeStream) return;
+    let chunk;
+    if (this.pcmQueue.length > 0) {
+      chunk = this.pcmQueue.shift();
+      if (this.pcmQueue.length === 0) {
+        this._speaking = false;
+        logger.info(`${TAG} Finished speaking`);
+      }
+    } else {
+      chunk = this.silenceChunk;
+    }
+    try {
+      this.writeStream.write(chunk);
+    } catch {
+    }
+  }
+  // ── TTS generation ─────────────────────────────────────────────────────
+  async generateTts(text, config) {
+    switch (config.provider) {
+      case "elevenlabs":
+        return this.generateElevenlabs(text, config);
+      case "openai":
+        return this.generateOpenai(text, config);
+      case "edge":
+        return this.generateEdge(text, config);
+      default:
+        throw new Error(`Unknown TTS provider: ${config.provider}`);
+    }
+  }
+  async generateElevenlabs(text, config) {
+    const el = config.elevenlabs;
+    if (!el?.apiKey) throw new Error("ElevenLabs API key not available");
+    const voiceId = el.voiceId || "EXAVITQu4vr4xnSDxMaL";
+    const modelId = el.modelId || "eleven_flash_v2_5";
+    const url = `https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream?output_format=mp3_22050_32`;
+    const payload = {
+      text,
+      model_id: modelId
+    };
+    if (el.voiceSettings && Object.keys(el.voiceSettings).length > 0) {
+      payload.voice_settings = el.voiceSettings;
+    }
+    const resp = await fetchWithTimeout(
+      url,
+      {
+        method: "POST",
+        headers: {
+          "xi-api-key": el.apiKey,
+          "Content-Type": "application/json",
+          Accept: "audio/mpeg"
+        },
+        body: JSON.stringify(payload)
+      },
+      ELEVENLABS_TIMEOUT_MS
+    );
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`ElevenLabs ${resp.status}: ${body.slice(0, 200)}`);
+    }
+    return Buffer.from(await resp.arrayBuffer());
+  }
+  async generateOpenai(text, config) {
+    const oai = config.openai;
+    if (!oai?.apiKey) throw new Error("OpenAI API key not available");
+    const model = oai.model || "tts-1";
+    const voice = oai.voice || "alloy";
+    const resp = await fetchWithTimeout(
+      "https://api.openai.com/v1/audio/speech",
+      {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${oai.apiKey}`,
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          model,
+          input: text,
+          voice,
+          response_format: "mp3"
+        })
+      },
+      OPENAI_TIMEOUT_MS
+    );
+    if (!resp.ok) {
+      const body = await resp.text().catch(() => "");
+      throw new Error(`OpenAI TTS ${resp.status}: ${body.slice(0, 200)}`);
+    }
+    return Buffer.from(await resp.arrayBuffer());
+  }
+  async generateEdge(text, config) {
+    try {
+      const edgeTtsModule = "node-edge-tts";
+      const { MsEdgeTTS } = await import(edgeTtsModule);
+      const tts = new MsEdgeTTS();
+      const voice = config.edge?.voice || "en-US-AriaNeural";
+      await tts.setMetadata(voice, "audio-24khz-48kbitrate-mono-mp3");
+      const readable = tts.toStream(text);
+      return new Promise((resolve, reject) => {
+        const chunks = [];
+        readable.on("data", (chunk) => chunks.push(chunk));
+        readable.on("end", () => resolve(Buffer.concat(chunks)));
+        readable.on("error", reject);
+      });
+    } catch (err) {
+      throw new Error(
+        `Edge TTS failed (node-edge-tts may not be installed): ${String(err)}`
+      );
+    }
+  }
+  // ── MP3 → PCM decode ──────────────────────────────────────────────────
+  /** Decode MP3 audio to raw s16le PCM using an FFmpeg subprocess. */
+  decodeMp3ToPcm(mp3) {
+    return new Promise((resolve, reject) => {
+      const proc = spawn(
+        "ffmpeg",
+        [
+          "-i",
+          "pipe:0",
+          "-f",
+          "s16le",
+          "-ar",
+          String(SAMPLE_RATE),
+          "-ac",
+          String(CHANNELS),
+          "pipe:1"
+        ],
+        { stdio: ["pipe", "pipe", "ignore"] }
+      );
+      const chunks = [];
+      proc.stdout?.on("data", (chunk) => chunks.push(chunk));
+      proc.on("close", (code) => {
+        if (code === 0) {
+          resolve(Buffer.concat(chunks));
+        } else {
+          reject(new Error(`FFmpeg decode exited with code ${code}`));
+        }
+      });
+      proc.on("error", reject);
+      proc.stdin?.write(mp3);
+      proc.stdin?.end();
+    });
+  }
+}
+function fetchWithTimeout(url, init, timeoutMs) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  return fetch(url, { ...init, signal: controller.signal }).finally(
+    () => clearTimeout(timer)
+  );
+}
+function isRedactedSecret(val) {
+  return /^\*+$/.test(val) || val === "REDACTED" || val === "[REDACTED]";
+}
+function resolveTtsConfig(ttsConfig) {
+  if (!ttsConfig) return null;
+  const preferredProvider = ttsConfig.provider || "elevenlabs";
+  const providers = [preferredProvider];
+  if (!providers.includes("elevenlabs")) providers.push("elevenlabs");
+  if (!providers.includes("openai")) providers.push("openai");
+  if (!providers.includes("edge")) providers.push("edge");
+  for (const provider of providers) {
+    switch (provider) {
+      case "elevenlabs": {
+        const el = ttsConfig.elevenlabs;
+        const apiKey = resolveKey(el?.apiKey, "ELEVENLABS_API_KEY");
+        if (apiKey) {
+          return {
+            provider: "elevenlabs",
+            elevenlabs: {
+              apiKey,
+              voiceId: el?.voiceId || "EXAVITQu4vr4xnSDxMaL",
+              modelId: el?.modelId || "eleven_flash_v2_5",
+              voiceSettings: el?.voiceSettings ? { ...el.voiceSettings } : void 0
+            }
+          };
+        }
+        break;
+      }
+      case "openai": {
+        const oai = ttsConfig.openai;
+        const apiKey = resolveKey(oai?.apiKey, "OPENAI_API_KEY");
+        if (apiKey) {
+          return {
+            provider: "openai",
+            openai: {
+              apiKey,
+              model: oai?.model || "tts-1",
+              voice: oai?.voice || "alloy"
+            }
+          };
+        }
+        break;
+      }
+      case "edge": {
+        return {
+          provider: "edge",
+          edge: {
+            voice: ttsConfig.edge?.voice || "en-US-AriaNeural"
+          }
+        };
+      }
+    }
+  }
+  return null;
+}
+function resolveKey(configKey, envVar) {
+  const ck = configKey?.trim();
+  if (ck && !isRedactedSecret(ck)) return ck;
+  const ev = process.env[envVar]?.trim();
+  if (ev && !isRedactedSecret(ev)) return ev;
+  const explicitCloudTts = process.env.ELIZAOS_CLOUD_USE_TTS === "true";
+  const legacyCloudTts = process.env.ELIZAOS_CLOUD_USE_TTS === void 0 && process.env.ELIZAOS_CLOUD_ENABLED === "true" && process.env.ELIZA_CLOUD_TTS_DISABLED !== "true";
+  if (explicitCloudTts || legacyCloudTts) {
+    const cloudKey = process.env.ELIZAOS_CLOUD_API_KEY?.trim();
+    if (cloudKey && !isRedactedSecret(cloudKey)) {
+      return cloudKey;
+    }
+  }
+  return null;
+}
+function getTtsProviderStatus(ttsConfig) {
+  const resolved = resolveTtsConfig(ttsConfig);
+  return {
+    configuredProvider: ttsConfig?.provider || null,
+    hasApiKey: resolved ? resolved.provider !== "edge" : false,
+    resolvedProvider: resolved?.provider || null
+  };
+}
+const ttsStreamBridge = new TtsStreamBridge();
+export {
+  getTtsProviderStatus,
+  resolveTtsConfig,
+  ttsStreamBridge
+};
+//# sourceMappingURL=tts-stream-bridge.js.map

package/dist/services/tts-stream-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/services/tts-stream-bridge.ts"],"sourcesContent":["/**\n * TTS Stream Bridge — generates TTS audio server-side and pipes PCM data\n * into FFmpeg's audio track for RTMP streaming.\n *\n * Uses pipe:3 (a 4th stdio fd) as the audio input to FFmpeg. Writes PCM\n * silence when idle and decoded TTS audio when speaking. This avoids FIFO\n * complexity and works cross-platform.\n *\n * @module services/tts-stream-bridge\n */\n\nimport { spawn } from \"node:child_process\";\nimport type { Writable } from \"node:stream\";\nimport { logger, sanitizeSpeechText } from \"@elizaos/core\";\n\nexport type TtsProvider = \"elevenlabs\" | \"openai\" | \"edge\" | (string & {});\n\nexport type TtsConfig = {\n  enabled?: boolean;\n  provider?: TtsProvider;\n  elevenlabs?: {\n    apiKey?: string;\n    voiceId?: string;\n    modelId?: string;\n    voiceSettings?: Record<string, unknown>;\n  };\n  openai?: {\n    apiKey?: string;\n    model?: string;\n    voice?: string;\n  };\n  edge?: {\n    voice?: string;\n  };\n};\n\nconst TAG = \"[TtsStreamBridge]\";\n\n// PCM format: signed 16-bit little-endian, 24 kHz, mono\nconst SAMPLE_RATE = 24000;\nconst CHANNELS = 1;\nconst BYTES_PER_SAMPLE = 2;\nconst CHUNK_MS = 50;\n/** Bytes per tick: 24000 * 2 * 1 * 50/1000 = 2400 */\nconst CHUNK_BYTES =\n  (SAMPLE_RATE * BYTES_PER_SAMPLE * CHANNELS * CHUNK_MS) / 1000;\n\nconst ELEVENLABS_TIMEOUT_MS = 20_000;\nconst OPENAI_TIMEOUT_MS = 20_000;\n\n/** Resolved TTS configuration for a speak() call. */\nexport interface ResolvedTtsConfig {\n  provider: TtsProvider;\n  elevenlabs?: {\n    apiKey: string;\n    voiceId: string;\n    modelId: string;\n    voiceSettings?: Record<string, unknown>;\n  };\n  openai?: {\n    apiKey: string;\n    model: string;\n    voice: string;\n  };\n  edge?: {\n    voice: string;\n  };\n}\n\n/** Public interface for the TTS stream bridge. */\nexport interface ITtsStreamBridge {\n  attach(stream: Writable): void;\n  detach(): void;\n  isAttached(): boolean;\n  isSpeaking(): boolean;\n  speak(text: string, config: ResolvedTtsConfig): Promise<boolean>;\n}\n\nclass TtsStreamBridge implements ITtsStreamBridge {\n  private writeStream: Writable | null = null;\n  private tickTimer: ReturnType<typeof setInterval> | null = null;\n  private pcmQueue: Buffer[] = [];\n  private _speaking = false;\n  private silenceChunk: Buffer;\n\n  constructor() {\n    // Pre-allocate a silence chunk (all zeros = silence in s16le)\n    this.silenceChunk = Buffer.alloc(CHUNK_BYTES, 0);\n  }\n\n  /** Attach the bridge to an FFmpeg stdio pipe (pipe:3). */\n  attach(stream: Writable): void {\n    this.detach();\n    this.writeStream = stream;\n    stream.on(\"error\", (err) => {\n      logger.warn(`${TAG} Write stream error: ${err.message}`);\n    });\n    // Start the tick loop — writes PCM chunks every CHUNK_MS\n    this.tickTimer = setInterval(() => this.tick(), CHUNK_MS);\n    logger.info(`${TAG} Attached to FFmpeg audio pipe`);\n  }\n\n  /** Detach from FFmpeg — stops tick loop and clears queue. */\n  detach(): void {\n    if (this.tickTimer) {\n      clearInterval(this.tickTimer);\n      this.tickTimer = null;\n    }\n    this.writeStream = null;\n    this.pcmQueue = [];\n    this._speaking = false;\n  }\n\n  /** Whether the bridge is currently attached to an FFmpeg process. */\n  isAttached(): boolean {\n    return this.writeStream !== null;\n  }\n\n  /** Whether TTS audio is currently being played. */\n  isSpeaking(): boolean {\n    return this._speaking;\n  }\n\n  /**\n   * Generate TTS for the given text and queue PCM audio for playback.\n   * Non-blocking — queues audio and returns immediately after generation.\n   */\n  async speak(text: string, config: ResolvedTtsConfig): Promise<boolean> {\n    if (!this.writeStream) {\n      logger.warn(`${TAG} Cannot speak — not attached to FFmpeg`);\n      return false;\n    }\n\n    const speakableText = sanitizeSpeechText(text);\n    if (!speakableText) return false;\n\n    try {\n      logger.info(\n        `${TAG} Generating TTS (${config.provider}, ${speakableText.length} chars)`,\n      );\n      const mp3 = await this.generateTts(speakableText, config);\n      if (!mp3 || mp3.length === 0) {\n        logger.warn(`${TAG} TTS returned empty audio`);\n        return false;\n      }\n\n      const pcm = await this.decodeMp3ToPcm(mp3);\n      if (!pcm || pcm.length === 0) {\n        logger.warn(`${TAG} PCM decode returned empty buffer`);\n        return false;\n      }\n\n      // Split PCM into CHUNK_BYTES-sized buffers for smooth playback\n      const chunks: Buffer[] = [];\n      for (let i = 0; i < pcm.length; i += CHUNK_BYTES) {\n        const end = Math.min(i + CHUNK_BYTES, pcm.length);\n        const chunk = Buffer.alloc(CHUNK_BYTES, 0);\n        pcm.copy(chunk, 0, i, end);\n        chunks.push(chunk);\n      }\n\n      this.pcmQueue.push(...chunks);\n      this._speaking = true;\n      logger.info(\n        `${TAG} Queued ${chunks.length} PCM chunks (${(pcm.length / SAMPLE_RATE / BYTES_PER_SAMPLE).toFixed(1)}s)`,\n      );\n      return true;\n    } catch (err) {\n      logger.error(`${TAG} TTS generation failed: ${String(err)}`);\n      return false;\n    }\n  }\n\n  /** Called every CHUNK_MS — writes next PCM chunk (TTS or silence) to FFmpeg. */\n  private tick(): void {\n    if (!this.writeStream) return;\n\n    let chunk: Buffer;\n    if (this.pcmQueue.length > 0) {\n      chunk = this.pcmQueue.shift() as Buffer;\n      if (this.pcmQueue.length === 0) {\n        this._speaking = false;\n        logger.info(`${TAG} Finished speaking`);\n      }\n    } else {\n      chunk = this.silenceChunk;\n    }\n\n    try {\n      this.writeStream.write(chunk);\n    } catch {\n      // Stream may have been closed — detach will handle cleanup\n    }\n  }\n\n  // ── TTS generation ─────────────────────────────────────────────────────\n\n  private async generateTts(\n    text: string,\n    config: ResolvedTtsConfig,\n  ): Promise<Buffer> {\n    switch (config.provider) {\n      case \"elevenlabs\":\n        return this.generateElevenlabs(text, config);\n      case \"openai\":\n        return this.generateOpenai(text, config);\n      case \"edge\":\n        return this.generateEdge(text, config);\n      default:\n        throw new Error(`Unknown TTS provider: ${config.provider}`);\n    }\n  }\n\n  private async generateElevenlabs(\n    text: string,\n    config: ResolvedTtsConfig,\n  ): Promise<Buffer> {\n    const el = config.elevenlabs;\n    if (!el?.apiKey) throw new Error(\"ElevenLabs API key not available\");\n\n    const voiceId = el.voiceId || \"EXAVITQu4vr4xnSDxMaL\";\n    const modelId = el.modelId || \"eleven_flash_v2_5\";\n    const url = `https://api.elevenlabs.io/v1/text-to-speech/${encodeURIComponent(voiceId)}/stream?output_format=mp3_22050_32`;\n\n    const payload: Record<string, unknown> = {\n      text,\n      model_id: modelId,\n    };\n    if (el.voiceSettings && Object.keys(el.voiceSettings).length > 0) {\n      payload.voice_settings = el.voiceSettings;\n    }\n\n    const resp = await fetchWithTimeout(\n      url,\n      {\n        method: \"POST\",\n        headers: {\n          \"xi-api-key\": el.apiKey,\n          \"Content-Type\": \"application/json\",\n          Accept: \"audio/mpeg\",\n        },\n        body: JSON.stringify(payload),\n      },\n      ELEVENLABS_TIMEOUT_MS,\n    );\n\n    if (!resp.ok) {\n      const body = await resp.text().catch(() => \"\");\n      throw new Error(`ElevenLabs ${resp.status}: ${body.slice(0, 200)}`);\n    }\n\n    return Buffer.from(await resp.arrayBuffer());\n  }\n\n  private async generateOpenai(\n    text: string,\n    config: ResolvedTtsConfig,\n  ): Promise<Buffer> {\n    const oai = config.openai;\n    if (!oai?.apiKey) throw new Error(\"OpenAI API key not available\");\n\n    const model = oai.model || \"tts-1\";\n    const voice = oai.voice || \"alloy\";\n\n    const resp = await fetchWithTimeout(\n      \"https://api.openai.com/v1/audio/speech\",\n      {\n        method: \"POST\",\n        headers: {\n          Authorization: `Bearer ${oai.apiKey}`,\n          \"Content-Type\": \"application/json\",\n        },\n        body: JSON.stringify({\n          model,\n          input: text,\n          voice,\n          response_format: \"mp3\",\n        }),\n      },\n      OPENAI_TIMEOUT_MS,\n    );\n\n    if (!resp.ok) {\n      const body = await resp.text().catch(() => \"\");\n      throw new Error(`OpenAI TTS ${resp.status}: ${body.slice(0, 200)}`);\n    }\n\n    return Buffer.from(await resp.arrayBuffer());\n  }\n\n  private async generateEdge(\n    text: string,\n    config: ResolvedTtsConfig,\n  ): Promise<Buffer> {\n    // Edge TTS requires node-edge-tts package — optional dependency\n    try {\n      // Use a variable so Vite's static analysis doesn't try to resolve this optional dep\n      const edgeTtsModule = \"node-edge-tts\";\n      const { MsEdgeTTS } = await import(edgeTtsModule);\n      const tts = new MsEdgeTTS();\n      const voice = config.edge?.voice || \"en-US-AriaNeural\";\n      await tts.setMetadata(voice, \"audio-24khz-48kbitrate-mono-mp3\");\n      const readable = tts.toStream(text);\n\n      return new Promise<Buffer>((resolve, reject) => {\n        const chunks: Buffer[] = [];\n        readable.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n        readable.on(\"end\", () => resolve(Buffer.concat(chunks)));\n        readable.on(\"error\", reject);\n      });\n    } catch (err) {\n      throw new Error(\n        `Edge TTS failed (node-edge-tts may not be installed): ${String(err)}`,\n      );\n    }\n  }\n\n  // ── MP3 → PCM decode ──────────────────────────────────────────────────\n\n  /** Decode MP3 audio to raw s16le PCM using an FFmpeg subprocess. */\n  private decodeMp3ToPcm(mp3: Buffer): Promise<Buffer> {\n    return new Promise<Buffer>((resolve, reject) => {\n      const proc = spawn(\n        \"ffmpeg\",\n        [\n          \"-i\",\n          \"pipe:0\",\n          \"-f\",\n          \"s16le\",\n          \"-ar\",\n          String(SAMPLE_RATE),\n          \"-ac\",\n          String(CHANNELS),\n          \"pipe:1\",\n        ],\n        { stdio: [\"pipe\", \"pipe\", \"ignore\"] },\n      );\n\n      const chunks: Buffer[] = [];\n      proc.stdout?.on(\"data\", (chunk: Buffer) => chunks.push(chunk));\n      proc.on(\"close\", (code) => {\n        if (code === 0) {\n          resolve(Buffer.concat(chunks));\n        } else {\n          reject(new Error(`FFmpeg decode exited with code ${code}`));\n        }\n      });\n      proc.on(\"error\", reject);\n      proc.stdin?.write(mp3);\n      proc.stdin?.end();\n    });\n  }\n}\n\n// ── Helper ────────────────────────────────────────────────────────────────\n\nfunction fetchWithTimeout(\n  url: string,\n  init: RequestInit,\n  timeoutMs: number,\n): Promise<Response> {\n  const controller = new AbortController();\n  const timer = setTimeout(() => controller.abort(), timeoutMs);\n  return fetch(url, { ...init, signal: controller.signal }).finally(() =>\n    clearTimeout(timer),\n  );\n}\n\n// ── Config resolution ─────────────────────────────────────────────────────\n\n/** Helper to check if a string looks like a redacted secret placeholder. */\nfunction isRedactedSecret(val: string): boolean {\n  return /^\\*+$/.test(val) || val === \"REDACTED\" || val === \"[REDACTED]\";\n}\n\n/**\n * Resolve TTS configuration from eliza config, finding the best available\n * provider with valid API keys.\n */\nexport function resolveTtsConfig(\n  ttsConfig: TtsConfig | undefined,\n): ResolvedTtsConfig | null {\n  if (!ttsConfig) return null;\n\n  const preferredProvider = ttsConfig.provider || \"elevenlabs\";\n\n  // Try providers in preference order: configured → elevenlabs → openai → edge\n  const providers: TtsProvider[] = [preferredProvider];\n  if (!providers.includes(\"elevenlabs\")) providers.push(\"elevenlabs\");\n  if (!providers.includes(\"openai\")) providers.push(\"openai\");\n  if (!providers.includes(\"edge\")) providers.push(\"edge\");\n\n  for (const provider of providers) {\n    switch (provider) {\n      case \"elevenlabs\": {\n        const el = ttsConfig.elevenlabs;\n        const apiKey = resolveKey(el?.apiKey, \"ELEVENLABS_API_KEY\");\n        if (apiKey) {\n          return {\n            provider: \"elevenlabs\",\n            elevenlabs: {\n              apiKey,\n              voiceId: el?.voiceId || \"EXAVITQu4vr4xnSDxMaL\",\n              modelId: el?.modelId || \"eleven_flash_v2_5\",\n              voiceSettings: el?.voiceSettings\n                ? { ...el.voiceSettings }\n                : undefined,\n            },\n          };\n        }\n        break;\n      }\n      case \"openai\": {\n        const oai = ttsConfig.openai;\n        const apiKey = resolveKey(oai?.apiKey, \"OPENAI_API_KEY\");\n        if (apiKey) {\n          return {\n            provider: \"openai\",\n            openai: {\n              apiKey,\n              model: oai?.model || \"tts-1\",\n              voice: oai?.voice || \"alloy\",\n            },\n          };\n        }\n        break;\n      }\n      case \"edge\": {\n        // Edge TTS always works (no API key needed)\n        return {\n          provider: \"edge\",\n          edge: {\n            voice: ttsConfig.edge?.voice || \"en-US-AriaNeural\",\n          },\n        };\n      }\n    }\n  }\n\n  return null;\n}\n\nfunction resolveKey(\n  configKey: string | undefined,\n  envVar: string,\n): string | null {\n  const ck = configKey?.trim();\n  if (ck && !isRedactedSecret(ck)) return ck;\n  const ev = process.env[envVar]?.trim();\n  if (ev && !isRedactedSecret(ev)) return ev;\n\n  const explicitCloudTts = process.env.ELIZAOS_CLOUD_USE_TTS === \"true\";\n  const legacyCloudTts =\n    process.env.ELIZAOS_CLOUD_USE_TTS === undefined &&\n    process.env.ELIZAOS_CLOUD_ENABLED === \"true\" &&\n    process.env.ELIZA_CLOUD_TTS_DISABLED !== \"true\";\n  if (explicitCloudTts || legacyCloudTts) {\n    const cloudKey = process.env.ELIZAOS_CLOUD_API_KEY?.trim();\n    if (cloudKey && !isRedactedSecret(cloudKey)) {\n      return cloudKey;\n    }\n  }\n\n  return null;\n}\n\n/**\n * Get a summary of available TTS providers and their status.\n */\nexport function getTtsProviderStatus(ttsConfig: TtsConfig | undefined): {\n  configuredProvider: string | null;\n  hasApiKey: boolean;\n  resolvedProvider: string | null;\n} {\n  const resolved = resolveTtsConfig(ttsConfig);\n  return {\n    configuredProvider: ttsConfig?.provider || null,\n    hasApiKey: resolved ? resolved.provider !== \"edge\" : false,\n    resolvedProvider: resolved?.provider || null,\n  };\n}\n\n// Module singleton\nexport const ttsStreamBridge = new TtsStreamBridge();\n"],"mappings":"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","names":[]}

package/package.json

@@ -0,0 +1,106 @@
+{
+  "name": "@elizaos/plugin-streaming",
+  "description": "Unified RTMP streaming for elizaOS (Twitch, YouTube, X, pump.fun, custom and named ingest URLs)",
+  "version": "2.0.0-beta.1",
+  "type": "module",
+  "main": "dist/index.js",
+  "module": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "packageType": "plugin",
+  "platform": "node",
+  "license": "MIT",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@elizaos/cloud-routing": "2.0.0-beta.1",
+    "@elizaos/core": "2.0.0-beta.1",
+    "@elizaos/plugin-browser": "2.0.0-beta.1"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.22.0",
+    "@typescript-eslint/parser": "^8.22.0",
+    "eslint": "^10.0.0",
+    "prettier": "^3.8.3",
+    "tsup": "^8.5.1",
+    "typescript": "^6.0.3",
+    "vitest": "^4.0.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "test": "vitest run",
+    "lint": "bunx @biomejs/biome check --write --unsafe src",
+    "lint:check": "bunx @biomejs/biome check src",
+    "typecheck": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo tsconfig.tsbuildinfo",
+    "format": "bunx @biomejs/biome format --write .",
+    "format:check": "bunx @biomejs/biome format ."
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/elizaos-plugins/plugin-streaming.git"
+  },
+  "keywords": [
+    "elizaos",
+    "elizaos-plugin",
+    "streaming",
+    "rtmp"
+  ],
+  "agentConfig": {
+    "pluginType": "elizaos:plugin:1.0.0",
+    "pluginParameters": {
+      "TWITCH_STREAM_KEY": {
+        "type": "string",
+        "description": "Twitch RTMP stream key",
+        "required": false
+      },
+      "YOUTUBE_STREAM_KEY": {
+        "type": "string",
+        "description": "YouTube Live stream key",
+        "required": false
+      },
+      "YOUTUBE_RTMP_URL": {
+        "type": "string",
+        "description": "Optional YouTube RTMP ingest URL override",
+        "required": false
+      },
+      "X_STREAM_KEY": {
+        "type": "string",
+        "required": false
+      },
+      "X_RTMP_URL": {
+        "type": "string",
+        "required": false
+      },
+      "PUMPFUN_STREAM_KEY": {
+        "type": "string",
+        "required": false
+      },
+      "PUMPFUN_RTMP_URL": {
+        "type": "string",
+        "required": false
+      },
+      "CUSTOM_RTMP_URL": {
+        "type": "string",
+        "required": false
+      },
+      "CUSTOM_RTMP_KEY": {
+        "type": "string",
+        "required": false
+      }
+    }
+  }
+}