@dtelecom/agents-js 0.1.0

package/dist/index.js

@@ -0,0 +1,1750 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/utils/logger.ts
+function detectLevel() {
+  const debug = typeof process !== "undefined" && process.env?.DEBUG;
+  if (debug && (debug === "*" || debug.includes("@dtelecom/agents"))) {
+    return "debug";
+  }
+  return "info";
+}
+function setLogLevel(level) {
+  globalLevel = level;
+}
+function getLogLevel() {
+  return globalLevel;
+}
+function timestamp() {
+  const d = /* @__PURE__ */ new Date();
+  const h = String(d.getHours()).padStart(2, "0");
+  const m = String(d.getMinutes()).padStart(2, "0");
+  const s = String(d.getSeconds()).padStart(2, "0");
+  const ms = String(d.getMilliseconds()).padStart(3, "0");
+  return `${h}:${m}:${s}.${ms}`;
+}
+function createLogger(tag) {
+  const prefix = `[@dtelecom/agents:${tag}]`;
+  return {
+    debug(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.debug) console.debug(timestamp(), prefix, ...args);
+    },
+    info(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.info) console.info(timestamp(), prefix, ...args);
+    },
+    warn(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.warn) console.warn(timestamp(), prefix, ...args);
+    },
+    error(...args) {
+      if (LEVELS[globalLevel] <= LEVELS.error) console.error(timestamp(), prefix, ...args);
+    }
+  };
+}
+var LEVELS, globalLevel;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    LEVELS = {
+      debug: 0,
+      info: 1,
+      warn: 2,
+      error: 3,
+      silent: 4
+    };
+    globalLevel = detectLevel();
+  }
+});
+
+// src/memory/memory-store.ts
+var import_better_sqlite3, sqliteVec, log8, MemoryStore;
+var init_memory_store = __esm({
+  "src/memory/memory-store.ts"() {
+    "use strict";
+    import_better_sqlite3 = __toESM(require("better-sqlite3"));
+    sqliteVec = __toESM(require("sqlite-vec"));
+    init_logger();
+    log8 = createLogger("MemoryStore");
+    MemoryStore = class {
+      db;
+      constructor(dbPath) {
+        this.db = new import_better_sqlite3.default(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("synchronous = NORMAL");
+        sqliteVec.load(this.db);
+        this.createTables();
+        log8.info(`Memory store opened: ${dbPath}`);
+      }
+      createTables() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS turns (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        room TEXT NOT NULL,
+        session_id TEXT NOT NULL,
+        speaker TEXT NOT NULL,
+        text TEXT NOT NULL,
+        is_agent BOOLEAN DEFAULT 0,
+        created_at INTEGER NOT NULL
+      );
+
+      CREATE TABLE IF NOT EXISTS sessions (
+        id TEXT PRIMARY KEY,
+        room TEXT NOT NULL,
+        started_at INTEGER NOT NULL,
+        ended_at INTEGER,
+        participants TEXT,
+        summary TEXT,
+        turn_count INTEGER DEFAULT 0
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_turns_room_session ON turns(room, session_id);
+      CREATE INDEX IF NOT EXISTS idx_turns_room_time ON turns(room, created_at);
+      CREATE INDEX IF NOT EXISTS idx_sessions_room ON sessions(room);
+    `);
+        const hasVecTable = this.db.prepare(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name=?"
+        );
+        if (!hasVecTable.get("turn_vectors")) {
+          this.db.exec(`
+        CREATE VIRTUAL TABLE turn_vectors USING vec0(
+          turn_id INTEGER PRIMARY KEY,
+          embedding FLOAT[384] distance_metric=cosine
+        );
+      `);
+        }
+        if (!hasVecTable.get("session_vectors")) {
+          this.db.exec(`
+        CREATE VIRTUAL TABLE session_vectors USING vec0(
+          session_id TEXT PRIMARY KEY,
+          embedding FLOAT[384] distance_metric=cosine
+        );
+      `);
+        }
+      }
+      /** Insert a turn and its embedding vector. */
+      insertTurn(room, sessionId, speaker, text, isAgent, embedding) {
+        const stmt = this.db.prepare(`
+      INSERT INTO turns (room, session_id, speaker, text, is_agent, created_at)
+      VALUES (?, ?, ?, ?, ?, ?)
+    `);
+        const info = stmt.run(room, sessionId, speaker, text, isAgent ? 1 : 0, Date.now());
+        const turnId = info.lastInsertRowid;
+        this.db.prepare(
+          "INSERT INTO turn_vectors (turn_id, embedding) VALUES (?, ?)"
+        ).run(BigInt(turnId), Buffer.from(embedding.buffer));
+        return Number(turnId);
+      }
+      /** Create a new session record. */
+      insertSession(id, room) {
+        this.db.prepare(`
+      INSERT INTO sessions (id, room, started_at)
+      VALUES (?, ?, ?)
+    `).run(id, room, Date.now());
+      }
+      /** Update a session with summary and end time. */
+      updateSessionSummary(sessionId, summary, turnCount, participants, embedding) {
+        this.db.prepare(`
+      UPDATE sessions
+      SET summary = ?, ended_at = ?, turn_count = ?, participants = ?
+      WHERE id = ?
+    `).run(summary, Date.now(), turnCount, JSON.stringify(participants), sessionId);
+        this.db.prepare(
+          "INSERT INTO session_vectors (session_id, embedding) VALUES (?, ?)"
+        ).run(sessionId, Buffer.from(embedding.buffer));
+      }
+      /** End a session without summary (e.g., too few turns). */
+      endSession(sessionId, turnCount, participants) {
+        this.db.prepare(`
+      UPDATE sessions
+      SET ended_at = ?, turn_count = ?, participants = ?
+      WHERE id = ?
+    `).run(Date.now(), turnCount, JSON.stringify(participants), sessionId);
+      }
+      /** KNN search turns by embedding similarity. */
+      searchTurns(room, queryEmbedding, limit) {
+        const rows = this.db.prepare(`
+      SELECT t.speaker, t.text, t.created_at, t.session_id, tv.distance
+      FROM turn_vectors tv
+      JOIN turns t ON t.id = tv.turn_id
+      WHERE t.room = ?
+        AND tv.embedding MATCH ?
+        AND k = ?
+      ORDER BY tv.distance
+    `).all(room, Buffer.from(queryEmbedding.buffer), limit * 2);
+        return rows.slice(0, limit).map((r) => ({
+          speaker: r.speaker,
+          text: r.text,
+          created_at: r.created_at,
+          session_id: r.session_id,
+          distance: r.distance
+        }));
+      }
+      /** KNN search session summaries by embedding similarity. */
+      searchSessions(room, queryEmbedding, limit) {
+        const rows = this.db.prepare(`
+      SELECT s.id as session_id, s.summary, s.started_at, sv.distance
+      FROM session_vectors sv
+      JOIN sessions s ON s.id = sv.session_id
+      WHERE s.room = ?
+        AND sv.embedding MATCH ?
+        AND k = ?
+      ORDER BY sv.distance
+    `).all(room, Buffer.from(queryEmbedding.buffer), limit * 2);
+        return rows.filter((r) => r.summary).slice(0, limit);
+      }
+      /** Get the last N turns from a specific session. */
+      getRecentTurns(room, sessionId, limit) {
+        return this.db.prepare(`
+      SELECT * FROM turns
+      WHERE room = ? AND session_id = ?
+      ORDER BY created_at DESC
+      LIMIT ?
+    `).all(room, sessionId, limit);
+      }
+      /** Get all turns for a session (for summarization). */
+      getSessionTurns(sessionId) {
+        return this.db.prepare(`
+      SELECT * FROM turns
+      WHERE session_id = ?
+      ORDER BY created_at ASC
+    `).all(sessionId);
+      }
+      /** Get total turn count for a session. */
+      getSessionTurnCount(sessionId) {
+        const row = this.db.prepare(
+          "SELECT COUNT(*) as count FROM turns WHERE session_id = ?"
+        ).get(sessionId);
+        return row.count;
+      }
+      /** Close the database. */
+      close() {
+        this.db.close();
+        log8.info("Memory store closed");
+      }
+    };
+  }
+});
+
+// src/memory/embedder.ts
+var log9, MODEL_NAME, EMBEDDING_DIM, Embedder;
+var init_embedder = __esm({
+  "src/memory/embedder.ts"() {
+    "use strict";
+    init_logger();
+    log9 = createLogger("Embedder");
+    MODEL_NAME = "Xenova/all-MiniLM-L6-v2";
+    EMBEDDING_DIM = 384;
+    Embedder = class {
+      pipeline = null;
+      initPromise = null;
+      get dimensions() {
+        return EMBEDDING_DIM;
+      }
+      /** Load the embedding model. Call once at startup. */
+      async init() {
+        if (this.pipeline) return;
+        if (this.initPromise) return this.initPromise;
+        this.initPromise = this.loadModel();
+        return this.initPromise;
+      }
+      async loadModel() {
+        const start = performance.now();
+        log9.info(`Loading embedding model "${MODEL_NAME}"...`);
+        const { pipeline } = await import("@huggingface/transformers");
+        this.pipeline = await pipeline("feature-extraction", MODEL_NAME);
+        log9.info(`Embedding model loaded in ${(performance.now() - start).toFixed(0)}ms`);
+      }
+      /** Embed a single text. Returns Float32Array of length 384. */
+      async embed(text) {
+        await this.init();
+        const result = await this.pipeline(text, {
+          pooling: "mean",
+          normalize: true
+        });
+        return new Float32Array(result.data);
+      }
+      /** Cosine similarity between two normalized vectors. Returns value in [-1, 1]. */
+      static cosineSimilarity(a, b) {
+        let dot = 0;
+        for (let i = 0; i < a.length; i++) {
+          dot += a[i] * b[i];
+        }
+        return dot;
+      }
+      /** Embed multiple texts in one call (more efficient than calling embed() in a loop). */
+      async embedBatch(texts) {
+        if (texts.length === 0) return [];
+        await this.init();
+        const results = [];
+        for (const text of texts) {
+          const result = await this.pipeline(text, {
+            pooling: "mean",
+            normalize: true
+          });
+          results.push(new Float32Array(result.data));
+        }
+        return results;
+      }
+    };
+  }
+});
+
+// src/memory/room-memory.ts
+var room_memory_exports = {};
+__export(room_memory_exports, {
+  RoomMemory: () => RoomMemory
+});
+var import_crypto, log10, RoomMemory;
+var init_room_memory = __esm({
+  "src/memory/room-memory.ts"() {
+    "use strict";
+    import_crypto = require("crypto");
+    init_memory_store();
+    init_embedder();
+    init_logger();
+    log10 = createLogger("RoomMemory");
+    RoomMemory = class {
+      store;
+      embedder;
+      room;
+      sessionId = null;
+      participants = /* @__PURE__ */ new Set();
+      pendingTurns = [];
+      flushTimer = null;
+      flushIntervalMs;
+      flushing = false;
+      constructor(config) {
+        this.store = new MemoryStore(config.dbPath);
+        this.embedder = new Embedder();
+        this.room = config.room;
+        this.flushIntervalMs = config.flushIntervalMs ?? 5e3;
+      }
+      /** Get the embedder instance (for reuse in other components). */
+      getEmbedder() {
+        return this.embedder;
+      }
+      /** Initialize embedder (loads model). Call once at startup. */
+      async init() {
+        await this.embedder.init();
+      }
+      /** Start a new session for this room. */
+      startSession() {
+        this.sessionId = (0, import_crypto.randomUUID)();
+        this.participants.clear();
+        this.store.insertSession(this.sessionId, this.room);
+        this.flushTimer = setInterval(() => {
+          this.flushPending().catch((err) => {
+            log10.error("Error flushing pending turns:", err);
+          });
+        }, this.flushIntervalMs);
+        log10.info(`Session started: ${this.sessionId}`);
+        return this.sessionId;
+      }
+      /** Track a participant joining. */
+      addParticipant(identity) {
+        this.participants.add(identity);
+      }
+      /**
+       * Store a turn to memory. Non-blocking — queues for batch embedding.
+       * Call this for EVERY final transcription, even if agent doesn't respond.
+       */
+      storeTurn(speaker, text, isAgent) {
+        if (!this.sessionId) {
+          log10.warn("storeTurn called without active session");
+          return;
+        }
+        this.pendingTurns.push({ speaker, text, isAgent });
+        if (this.pendingTurns.length >= 5) {
+          this.flushPending().catch((err) => {
+            log10.error("Error flushing pending turns:", err);
+          });
+        }
+      }
+      /** Flush pending turns: embed and insert into database. */
+      async flushPending() {
+        if (this.flushing || this.pendingTurns.length === 0 || !this.sessionId) return;
+        this.flushing = true;
+        const batch = this.pendingTurns.splice(0);
+        const texts = batch.map((t) => `[${t.speaker}]: ${t.text}`);
+        try {
+          const embeddings = await this.embedder.embedBatch(texts);
+          for (let i = 0; i < batch.length; i++) {
+            const turn = batch[i];
+            this.store.insertTurn(
+              this.room,
+              this.sessionId,
+              turn.speaker,
+              turn.text,
+              turn.isAgent,
+              embeddings[i]
+            );
+          }
+          log10.debug(`Flushed ${batch.length} turns to memory`);
+        } catch (err) {
+          log10.error("Error embedding/storing turns:", err);
+          this.pendingTurns.unshift(...batch);
+        } finally {
+          this.flushing = false;
+        }
+      }
+      /**
+       * Search memory for context relevant to a query.
+       * Returns formatted string ready to inject into LLM system prompt.
+       */
+      async searchRelevant(query, turnLimit = 5, sessionLimit = 2) {
+        const queryEmbedding = await this.embedder.embed(query);
+        const turns = this.store.searchTurns(this.room, queryEmbedding, turnLimit);
+        const sessions = this.store.searchSessions(this.room, queryEmbedding, sessionLimit);
+        if (turns.length === 0 && sessions.length === 0) {
+          return "";
+        }
+        const parts = [];
+        if (sessions.length > 0) {
+          parts.push("Past session summaries:");
+          for (const s of sessions) {
+            const date = new Date(s.started_at).toLocaleDateString();
+            parts.push(`  [${date}]: ${s.summary}`);
+          }
+        }
+        if (turns.length > 0) {
+          parts.push("Relevant past turns:");
+          for (const t of turns) {
+            const date = new Date(t.created_at).toLocaleDateString();
+            const time = new Date(t.created_at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" });
+            parts.push(`  [${date} ${time}, ${t.speaker}]: ${t.text}`);
+          }
+        }
+        return parts.join("\n");
+      }
+      /**
+       * End the current session. Generates an LLM summary and stores it.
+       */
+      async endSession(llm) {
+        if (!this.sessionId) return;
+        await this.flushPending();
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+        }
+        const turnCount = this.store.getSessionTurnCount(this.sessionId);
+        const participantList = Array.from(this.participants);
+        if (turnCount < 3) {
+          this.store.endSession(this.sessionId, turnCount, participantList);
+          log10.info(`Session ended (${turnCount} turns, no summary)`);
+          this.sessionId = null;
+          return;
+        }
+        try {
+          const turns = this.store.getSessionTurns(this.sessionId);
+          const transcript = turns.map((t) => `[${t.speaker}]: ${t.text}`).join("\n");
+          const messages = [
+            {
+              role: "system",
+              content: "Summarize this tutoring session concisely. Include: topics covered, phrases practiced, mistakes the student made, what they struggled with, and what they did well. Be factual and brief."
+            },
+            { role: "user", content: transcript }
+          ];
+          let summary = "";
+          for await (const chunk of llm.chat(messages)) {
+            if (chunk.type === "token" && chunk.token) {
+              summary += chunk.token;
+            }
+          }
+          if (summary.trim()) {
+            const embedding = await this.embedder.embed(summary.trim());
+            this.store.updateSessionSummary(
+              this.sessionId,
+              summary.trim(),
+              turnCount,
+              participantList,
+              embedding
+            );
+            log10.info(`Session ended with summary (${turnCount} turns, ${participantList.length} participants)`);
+          } else {
+            this.store.endSession(this.sessionId, turnCount, participantList);
+            log10.info(`Session ended (${turnCount} turns, summary was empty)`);
+          }
+        } catch (err) {
+          log10.error("Error generating session summary:", err);
+          this.store.endSession(this.sessionId, turnCount, participantList);
+        }
+        this.sessionId = null;
+      }
+      /** Close the memory store. Flush pending turns first. */
+      async close() {
+        if (this.flushTimer) {
+          clearInterval(this.flushTimer);
+          this.flushTimer = null;
+        }
+        await this.flushPending();
+        this.store.close();
+      }
+    };
+  }
+});
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AudioInput: () => AudioInput,
+  AudioOutput: () => AudioOutput,
+  BargeIn: () => BargeIn,
+  BaseSTTStream: () => BaseSTTStream,
+  ContextManager: () => ContextManager,
+  Embedder: () => Embedder,
+  MemoryStore: () => MemoryStore,
+  Pipeline: () => Pipeline,
+  RoomConnection: () => RoomConnection,
+  RoomMemory: () => RoomMemory,
+  SentenceSplitter: () => SentenceSplitter,
+  TurnDetector: () => TurnDetector,
+  VoiceAgent: () => VoiceAgent,
+  createLogger: () => createLogger,
+  getLogLevel: () => getLogLevel,
+  setLogLevel: () => setLogLevel
+});
+module.exports = __toCommonJS(src_exports);
+
+// src/core/voice-agent.ts
+var import_events2 = require("events");
+
+// src/room/room-connection.ts
+var import_server_sdk_node = require("@dtelecom/server-sdk-node");
+init_logger();
+var log = createLogger("RoomConnection");
+var RoomConnection = class {
+  room;
+  audioSource = null;
+  localTrack = null;
+  _connected = false;
+  constructor() {
+    this.room = new import_server_sdk_node.Room();
+  }
+  get connected() {
+    return this._connected;
+  }
+  /**
+   * Connect to a dTelecom room.
+   *
+   * 1. Create an Ed25519 JWT via AccessToken
+   * 2. Discover nearest SFU via getWsUrl()
+   * 3. Connect Room via WebRTC
+   * 4. Publish an audio track for the agent to speak through
+   */
+  async connect(options) {
+    const { room: roomName, apiKey, apiSecret, identity = "agent", name } = options;
+    log.info(`Connecting to room "${roomName}" as "${identity}"...`);
+    const { AccessToken } = await import("@dtelecom/server-sdk-js");
+    const token = new AccessToken(apiKey, apiSecret, {
+      identity,
+      name: name ?? identity
+    });
+    token.addGrant({
+      roomJoin: true,
+      room: roomName,
+      canPublish: true,
+      canSubscribe: true,
+      canPublishData: true
+    });
+    const wsUrl = await token.getWsUrl();
+    const jwt = token.toJwt();
+    log.info(`SFU URL: ${wsUrl}`);
+    await this.room.connect(wsUrl, jwt, { autoSubscribe: true });
+    this._connected = true;
+    log.info("Connected successfully");
+  }
+  /**
+   * Publish an audio track so the agent can speak.
+   * Returns the AudioSource to feed PCM16 audio into.
+   */
+  async publishAudioTrack() {
+    if (this.audioSource) return this.audioSource;
+    this.audioSource = new import_server_sdk_node.AudioSource(48e3, 1);
+    this.localTrack = import_server_sdk_node.LocalAudioTrack.createAudioTrack("agent-voice", this.audioSource);
+    await this.room.localParticipant.publishTrack(this.localTrack, {
+      name: "agent-voice",
+      source: import_server_sdk_node.TrackSource.MICROPHONE
+    });
+    log.info("Audio track published");
+    return this.audioSource;
+  }
+  /** Disconnect from the room and clean up resources. */
+  async disconnect() {
+    if (!this._connected) return;
+    if (this.localTrack) {
+      await this.room.localParticipant.unpublishTrack(this.localTrack);
+      this.localTrack = null;
+    }
+    if (this.audioSource) {
+      this.audioSource.destroy();
+      this.audioSource = null;
+    }
+    await this.room.disconnect();
+    this._connected = false;
+    log.info("Disconnected from room");
+  }
+};
+
+// src/room/audio-input.ts
+init_logger();
+var log2 = createLogger("AudioInput");
+var AudioInput = class {
+  participantIdentity;
+  stream;
+  _closed = false;
+  frameCount = 0;
+  constructor(track, participantIdentity) {
+    this.participantIdentity = participantIdentity;
+    this.stream = track.createStream(16e3, 1);
+    log2.info(`AudioInput created for "${participantIdentity}" (trackSid=${track.sid})`);
+  }
+  get closed() {
+    return this._closed;
+  }
+  /**
+   * Async iterate over PCM16 buffers from this participant.
+   * Each yielded Buffer is 16kHz mono PCM16 LE.
+   */
+  async *frames() {
+    for await (const frame of this.stream) {
+      if (this._closed) break;
+      this.frameCount++;
+      if (this.frameCount === 1 || this.frameCount % 500 === 0) {
+        log2.info(`[${this.participantIdentity}] frame #${this.frameCount}`);
+      }
+      yield frame.toBuffer();
+    }
+    log2.info(`[${this.participantIdentity}] frame iterator ended (total: ${this.frameCount})`);
+  }
+  /** Async iterate over AudioFrame objects. */
+  async *audioFrames() {
+    for await (const frame of this.stream) {
+      if (this._closed) break;
+      yield frame;
+    }
+  }
+  close() {
+    if (this._closed) return;
+    this._closed = true;
+    this.stream.close();
+    log2.debug(`AudioInput closed for participant "${this.participantIdentity}"`);
+  }
+};
+
+// src/room/audio-output.ts
+var import_server_sdk_node2 = require("@dtelecom/server-sdk-node");
+var import_fs = require("fs");
+var import_path = require("path");
+init_logger();
+var log3 = createLogger("AudioOutput");
+var SAMPLE_RATE = 16e3;
+var CHANNELS = 1;
+var FRAME_DURATION_MS = 20;
+var SAMPLES_PER_FRAME = SAMPLE_RATE * FRAME_DURATION_MS / 1e3;
+var SILENCE = new Int16Array(SAMPLES_PER_FRAME);
+var AudioOutput = class {
+  source;
+  _playing = false;
+  _responding = false;
+  _stopped = false;
+  silenceInterval = null;
+  /** When set, raw PCM from TTS is saved to this directory as WAV files for debugging. */
+  dumpDir = null;
+  dumpCounter = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  get playing() {
+    return this._playing;
+  }
+  /**
+   * Mark the start of a multi-sentence response.
+   * Suppresses silence injection between sentences so partial frames
+   * in AudioSource's buffer don't get corrupted by interleaved silence.
+   */
+  beginResponse() {
+    this._responding = true;
+  }
+  /** Mark the end of a response — re-enable silence keepalive. */
+  endResponse() {
+    this._responding = false;
+  }
+  /**
+   * Start sparse silence keepalive to prevent the SFU from dropping the track.
+   * With Opus DTX enabled, the encoder handles silence natively — we only need
+   * an occasional packet to keep the SSRC alive.
+   */
+  startSilence() {
+    if (this.silenceInterval) return;
+    log3.debug("Starting silence keepalive (sparse, 3s interval)");
+    this.silenceInterval = setInterval(() => {
+      if (!this._playing && !this._responding && !this._stopped) {
+        const f = new import_server_sdk_node2.AudioFrame(SILENCE, SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME);
+        this.source.captureFrame(f).catch(() => {
+        });
+      }
+    }, 3e3);
+  }
+  /**
+   * Write a PCM16 buffer to the audio output.
+   * The buffer is split into 20ms frames and fed to AudioSource.
+   */
+  async writeBuffer(pcm16) {
+    this._playing = true;
+    try {
+      await this.writeFrames(pcm16);
+    } finally {
+      this._playing = false;
+    }
+  }
+  /**
+   * Write a stream of PCM16 buffers (from TTS) to the audio output.
+   * Supports cancellation via AbortSignal.
+   */
+  async writeStream(stream, signal) {
+    this._playing = true;
+    const streamStart = performance.now();
+    let chunkCount = 0;
+    let totalBytes = 0;
+    log3.debug("writeStream: started");
+    const rawChunks = this.dumpDir ? [] : null;
+    try {
+      for await (const chunk of stream) {
+        if (signal?.aborted) {
+          log3.debug(`writeStream: cancelled after ${chunkCount} chunks, ${(performance.now() - streamStart).toFixed(0)}ms`);
+          break;
+        }
+        chunkCount++;
+        totalBytes += chunk.byteLength;
+        rawChunks?.push(Buffer.from(chunk));
+        await this.writeFrames(chunk);
+      }
+    } finally {
+      this._playing = false;
+      const elapsed = performance.now() - streamStart;
+      const audioDurationMs = totalBytes / 2 / SAMPLE_RATE * 1e3;
+      log3.info(
+        `writeStream: done \u2014 ${chunkCount} chunks, ${totalBytes} bytes, audio=${audioDurationMs.toFixed(0)}ms, wall=${elapsed.toFixed(0)}ms`
+      );
+      if (rawChunks && rawChunks.length > 0 && this.dumpDir) {
+        try {
+          if (!(0, import_fs.existsSync)(this.dumpDir)) (0, import_fs.mkdirSync)(this.dumpDir, { recursive: true });
+          const filePath = (0, import_path.join)(this.dumpDir, `tts-raw-${++this.dumpCounter}.wav`);
+          writeWav(filePath, rawChunks, SAMPLE_RATE);
+          log3.info(`writeStream: saved raw TTS to ${filePath}`);
+        } catch (err) {
+          log3.warn("writeStream: failed to save WAV dump:", err);
+        }
+      }
+    }
+  }
+  /**
+   * Split a PCM16 buffer into 20ms frames and write them at real-time pace.
+   * Partial frames at the end are sent directly — AudioSource handles
+   * accumulation in its internal buffer.
+   */
+  async writeFrames(pcm16) {
+    const aligned = Buffer.alloc(pcm16.byteLength);
+    pcm16.copy(aligned);
+    const samples = new Int16Array(
+      aligned.buffer,
+      aligned.byteOffset,
+      aligned.byteLength / 2
+    );
+    let offset = 0;
+    while (offset < samples.length) {
+      const end = Math.min(offset + SAMPLES_PER_FRAME, samples.length);
+      const frameSamples = samples.subarray(offset, end);
+      const frame = new import_server_sdk_node2.AudioFrame(
+        frameSamples,
+        SAMPLE_RATE,
+        CHANNELS,
+        frameSamples.length
+      );
+      await this.source.captureFrame(frame);
+      if (frameSamples.length === SAMPLES_PER_FRAME) {
+        await sleep(FRAME_DURATION_MS);
+      }
+      offset = end;
+    }
+  }
+  /**
+   * Write silence frames for the given duration.
+   * Used to pad the end of a response so the last Opus frame is fully flushed
+   * and the audio doesn't cut off abruptly.
+   */
+  async writeSilence(durationMs) {
+    const frameCount = Math.ceil(durationMs / FRAME_DURATION_MS);
+    for (let i = 0; i < frameCount; i++) {
+      const frame = new import_server_sdk_node2.AudioFrame(SILENCE, SAMPLE_RATE, CHANNELS, SAMPLES_PER_FRAME);
+      await this.source.captureFrame(frame);
+      await sleep(FRAME_DURATION_MS);
+    }
+  }
+  /** Flush any buffered audio in AudioSource */
+  flush() {
+    this.source.flush();
+    this._playing = false;
+  }
+  /** Stop the silence keepalive */
+  stop() {
+    this._stopped = true;
+    if (this.silenceInterval) {
+      clearInterval(this.silenceInterval);
+      this.silenceInterval = null;
+    }
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function writeWav(filePath, pcmChunks, sampleRate) {
+  const dataSize = pcmChunks.reduce((sum, b) => sum + b.byteLength, 0);
+  const header = Buffer.alloc(44);
+  header.write("RIFF", 0);
+  header.writeUInt32LE(36 + dataSize, 4);
+  header.write("WAVE", 8);
+  header.write("fmt ", 12);
+  header.writeUInt32LE(16, 16);
+  header.writeUInt16LE(1, 20);
+  header.writeUInt16LE(1, 22);
+  header.writeUInt32LE(sampleRate, 24);
+  header.writeUInt32LE(sampleRate * 2, 28);
+  header.writeUInt16LE(2, 32);
+  header.writeUInt16LE(16, 34);
+  header.write("data", 36);
+  header.writeUInt32LE(dataSize, 40);
+  (0, import_fs.writeFileSync)(filePath, header);
+  for (const chunk of pcmChunks) {
+    (0, import_fs.appendFileSync)(filePath, chunk);
+  }
+}
+
+// src/core/pipeline.ts
+var import_events = require("events");
+
+// src/core/context-manager.ts
+init_logger();
+var log4 = createLogger("ContextManager");
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+var ContextManager = class {
+  instructions;
+  maxContextTokens;
+  recentTurnsToKeep;
+  turns = [];
+  summary = null;
+  constructor(options) {
+    this.instructions = options.instructions;
+    this.maxContextTokens = options.maxContextTokens ?? 5e3;
+    this.recentTurnsToKeep = options.recentTurnsToKeep ?? 4;
+  }
+  /** Add a user's speech turn to the conversation */
+  addUserTurn(speaker, text) {
+    this.turns.push({
+      speaker,
+      text,
+      isAgent: false,
+      timestamp: Date.now()
+    });
+  }
+  /** Add the agent's response to the conversation */
+  addAgentTurn(text) {
+    this.turns.push({
+      speaker: "assistant",
+      text,
+      isAgent: true,
+      timestamp: Date.now()
+    });
+  }
+  /**
+   * Build the messages array for the LLM call.
+   *
+   * Structure:
+   * [system prompt]
+   * [memory context, if provided]
+   * [conversation summary, if any]
+   * [recent verbatim turns]
+   *
+   * @param memoryContext - Optional relevant context injected by the application
+   */
+  buildMessages(memoryContext) {
+    const messages = [];
+    messages.push({ role: "system", content: this.instructions });
+    if (memoryContext) {
+      messages.push({
+        role: "system",
+        content: `Relevant context from past conversations:
+${memoryContext}`
+      });
+    }
+    if (this.summary) {
+      messages.push({
+        role: "system",
+        content: `Conversation summary so far:
+${this.summary}`
+      });
+    }
+    const turnsToInclude = this.summary ? this.turns.slice(-this.recentTurnsToKeep) : this.turns;
+    for (const turn of turnsToInclude) {
+      if (turn.isAgent) {
+        messages.push({ role: "assistant", content: turn.text });
+      } else {
+        messages.push({
+          role: "user",
+          content: `[${turn.speaker}]: ${turn.text}`
+        });
+      }
+    }
+    return messages;
+  }
+  /** Check if summarization should be triggered */
+  shouldSummarize() {
+    const totalTokens = this.turns.reduce(
+      (acc, t) => acc + estimateTokens(t.text) + 10,
+      estimateTokens(this.instructions)
+    );
+    return totalTokens > this.maxContextTokens;
+  }
+  /**
+   * Summarize older turns using the LLM.
+   * Keeps the most recent turns verbatim.
+   */
+  async summarize(llm) {
+    if (this.turns.length <= this.recentTurnsToKeep) return;
+    const olderTurns = this.turns.slice(0, -this.recentTurnsToKeep);
+    const transcript = olderTurns.map((t) => `[${t.speaker}]: ${t.text}`).join("\n");
+    const summaryPrompt = [
+      {
+        role: "system",
+        content: "Summarize this conversation concisely, preserving key facts, decisions, and action items."
+      },
+      { role: "user", content: transcript }
+    ];
+    let summaryText = "";
+    for await (const chunk of llm.chat(summaryPrompt)) {
+      if (chunk.type === "token" && chunk.token) {
+        summaryText += chunk.token;
+      }
+    }
+    this.summary = this.summary ? `${this.summary}
+
+${summaryText}` : summaryText;
+    this.turns = this.turns.slice(-this.recentTurnsToKeep);
+    log4.info(`Summarized ${olderTurns.length} turns, ${this.turns.length} recent turns kept`);
+  }
+  /** Get the full transcript */
+  getFullTranscript() {
+    return this.turns.map((t) => `[${t.speaker}]: ${t.text}`).join("\n");
+  }
+  /** Reset the context */
+  reset() {
+    this.turns = [];
+    this.summary = null;
+  }
+};
+
+// src/core/sentence-splitter.ts
+var MIN_CHUNK = 20;
+var MAX_CHUNK = 150;
+var SentenceSplitter = class {
+  buffer = "";
+  /** Add a token and get back any speakable chunks */
+  push(token) {
+    this.buffer += token;
+    return this.extractChunks();
+  }
+  /** Flush any remaining text as a final chunk */
+  flush() {
+    const text = this.buffer.trim();
+    this.buffer = "";
+    return text.length > 0 ? text : null;
+  }
+  /** Reset the splitter */
+  reset() {
+    this.buffer = "";
+  }
+  extractChunks() {
+    const chunks = [];
+    while (true) {
+      const sentenceMatch = this.buffer.match(/[^.!?]*[.!?]\s*/);
+      if (sentenceMatch && sentenceMatch.index !== void 0) {
+        const end = sentenceMatch.index + sentenceMatch[0].length;
+        const chunk = this.buffer.slice(0, end).trim();
+        if (chunk.length >= MIN_CHUNK) {
+          chunks.push(chunk);
+          this.buffer = this.buffer.slice(end);
+          continue;
+        }
+      }
+      if (this.buffer.length >= MAX_CHUNK) {
+        const clauseMatch = this.buffer.match(/[,;:\u2014]\s*/);
+        if (clauseMatch && clauseMatch.index !== void 0 && clauseMatch.index >= MIN_CHUNK) {
+          const end = clauseMatch.index + clauseMatch[0].length;
+          const chunk = this.buffer.slice(0, end).trim();
+          chunks.push(chunk);
+          this.buffer = this.buffer.slice(end);
+          continue;
+        }
+        const spaceIdx = this.buffer.lastIndexOf(" ", MAX_CHUNK);
+        if (spaceIdx >= MIN_CHUNK) {
+          const chunk = this.buffer.slice(0, spaceIdx).trim();
+          chunks.push(chunk);
+          this.buffer = this.buffer.slice(spaceIdx);
+          continue;
+        }
+      }
+      break;
+    }
+    return chunks;
+  }
+};
+
+// src/core/turn-detector.ts
+init_logger();
+var log5 = createLogger("TurnDetector");
+var TurnDetector = class {
+  silenceTimeoutMs;
+  silenceTimer = null;
+  _onTurnEnd = null;
+  lastFinalText = "";
+  constructor(options = {}) {
+    this.silenceTimeoutMs = options.silenceTimeoutMs ?? 800;
+  }
+  /** Set the callback for when a turn ends */
+  set onTurnEnd(cb) {
+    this._onTurnEnd = cb;
+  }
+  /**
+   * Feed a transcription result.
+   * Returns true if this result represents a completed turn.
+   */
+  handleTranscription(text, isFinal) {
+    this.clearTimer();
+    if (isFinal && text.trim().length > 0) {
+      this.lastFinalText = text;
+      this.silenceTimer = setTimeout(() => {
+        log5.debug(`Turn ended after ${this.silenceTimeoutMs}ms silence`);
+        this._onTurnEnd?.();
+      }, this.silenceTimeoutMs);
+      return false;
+    }
+    if (!isFinal && text.trim().length > 0) {
+      this.clearTimer();
+    }
+    return false;
+  }
+  /** Force-trigger turn end */
+  forceTurnEnd() {
+    this.clearTimer();
+    this._onTurnEnd?.();
+  }
+  /** Reset state */
+  reset() {
+    this.clearTimer();
+    this.lastFinalText = "";
+  }
+  clearTimer() {
+    if (this.silenceTimer) {
+      clearTimeout(this.silenceTimer);
+      this.silenceTimer = null;
+    }
+  }
+};
+
+// src/core/barge-in.ts
+init_logger();
+var log6 = createLogger("BargeIn");
+var BargeIn = class {
+  abortController = null;
+  _interrupted = false;
+  _onInterrupt = null;
+  get interrupted() {
+    return this._interrupted;
+  }
+  /** Set the callback for when barge-in occurs */
+  set onInterrupt(cb) {
+    this._onInterrupt = cb;
+  }
+  /**
+   * Create a new AbortController for the current response cycle.
+   * Call this at the start of each STT->LLM->TTS cycle.
+   */
+  startCycle() {
+    this.abortController = new AbortController();
+    this._interrupted = false;
+    return this.abortController.signal;
+  }
+  /** Trigger barge-in. Called when STT detects speech during agent output. */
+  trigger() {
+    if (this._interrupted) return;
+    this._interrupted = true;
+    log6.info("Barge-in detected \u2014 cancelling current response");
+    if (this.abortController) {
+      this.abortController.abort();
+      this.abortController = null;
+    }
+    this._onInterrupt?.();
+  }
+  /** Reset after the interrupted cycle is cleaned up */
+  reset() {
+    this._interrupted = false;
+    this.abortController = null;
+  }
+};
+
+// src/core/pipeline.ts
+init_logger();
+var log7 = createLogger("Pipeline");
+var AUDIO_DRAIN_MS = 800;
+function sleep2(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+var Pipeline = class extends import_events.EventEmitter {
+  stt;
+  llm;
+  tts;
+  audioOutput;
+  context;
+  turnDetector;
+  bargeIn;
+  splitter;
+  respondMode;
+  agentName;
+  nameVariants;
+  beforeRespond;
+  memory;
+  /** Active STT streams, keyed by participant identity */
+  sttStreams = /* @__PURE__ */ new Map();
+  _processing = false;
+  _running = false;
+  _agentState = "idle";
+  /** Queued turn while current one is still processing */
+  pendingTurn = null;
+  constructor(options) {
+    super();
+    this.stt = options.stt;
+    this.llm = options.llm;
+    this.tts = options.tts;
+    this.audioOutput = options.audioOutput;
+    this.respondMode = options.respondMode ?? "always";
+    this.agentName = (options.agentName ?? "assistant").toLowerCase();
+    this.nameVariants = (options.nameVariants ?? []).map((n) => n.toLowerCase());
+    this.beforeRespond = options.beforeRespond;
+    this.memory = options.memory;
+    this.context = new ContextManager({
+      instructions: options.instructions
+    });
+    this.turnDetector = new TurnDetector({
+      silenceTimeoutMs: options.silenceTimeoutMs
+    });
+    this.bargeIn = new BargeIn();
+    this.splitter = new SentenceSplitter();
+    this.turnDetector.onTurnEnd = () => {
+    };
+    this.bargeIn.onInterrupt = () => {
+      this.audioOutput.flush();
+      this.splitter.reset();
+      this.setAgentState("idle");
+    };
+    if (this.llm.warmup) {
+      this.llm.warmup(options.instructions).catch((err) => {
+        log7.warn("LLM warmup failed:", err);
+      });
+    }
+    if (this.tts?.warmup) {
+      this.tts.warmup().catch((err) => {
+        log7.warn("TTS warmup failed:", err);
+      });
+    }
+  }
+  get processing() {
+    return this._processing;
+  }
+  get running() {
+    return this._running;
+  }
+  get agentState() {
+    return this._agentState;
+  }
+  setAgentState(state) {
+    if (this._agentState !== state) {
+      this._agentState = state;
+      this.emit("agentState", state);
+    }
+  }
+  addParticipant(identity) {
+    const existing = this.sttStreams.get(identity);
+    if (existing) {
+      existing.close();
+      this.sttStreams.delete(identity);
+      log7.info(`Replacing STT stream for "${identity}"`);
+    }
+    const stream = this.stt.createStream();
+    this.sttStreams.set(identity, stream);
+    this._running = true;
+    stream.on("transcription", (result) => {
+      this.handleTranscription(identity, result);
+    });
+    stream.on("error", (error) => {
+      log7.error(`STT error for ${identity}:`, error);
+      this.emit("error", error);
+    });
+    log7.info(`STT stream started for participant "${identity}"`);
+    return stream;
+  }
+  async removeParticipant(identity) {
+    const stream = this.sttStreams.get(identity);
+    if (stream) {
+      await stream.close();
+      this.sttStreams.delete(identity);
+      log7.info(`STT stream removed for participant "${identity}"`);
+    }
+  }
+  async stop() {
+    this._running = false;
+    this.turnDetector.reset();
+    this.bargeIn.reset();
+    this.splitter.reset();
+    for (const [, stream] of this.sttStreams) {
+      await stream.close();
+    }
+    this.sttStreams.clear();
+    log7.info("Pipeline stopped");
+  }
+  getContextManager() {
+    return this.context;
+  }
+  lastFinalAt = 0;
+  lastSttDuration = 0;
+  async handleTranscription(speaker, result) {
+    this.emit("transcription", { ...result, speaker });
+    if (!result.isFinal && result.text.trim()) {
+      this.setAgentState("listening");
+    }
+    if (this.audioOutput.playing && result.text.trim().length > 0) {
+      this.bargeIn.trigger();
+    }
+    if (result.isFinal && result.text.trim()) {
+      const text = result.text.trim();
+      this.lastFinalAt = performance.now();
+      this.lastSttDuration = result.sttDuration ?? 0;
+      this.memory?.storeTurn(speaker, text, false);
+      if (await this.shouldRespond(speaker, text)) {
+        this.processTurn(speaker, text);
+      } else {
+        log7.info(`Not responding to "${speaker}": "${text.slice(0, 60)}" (mode=${this.respondMode})`);
+        this.setAgentState("idle");
+      }
+    } else if (result.isFinal) {
+      this.setAgentState("idle");
+    }
+  }
+  /**
+   * Determine if the agent should respond to this turn.
+   * In 'always' mode: responds to everything.
+   * In 'addressed' mode: only when agent name is mentioned + optional beforeRespond hook.
+   */
+  async shouldRespond(speaker, text) {
+    if (this.respondMode === "always") return true;
+    const lower = text.toLowerCase();
+    const nameMatch = lower.includes(this.agentName) || this.nameVariants.some((v) => lower.includes(v));
+    if (!nameMatch) return false;
+    if (this.beforeRespond) {
+      return this.beforeRespond(speaker, text);
+    }
+    return true;
+  }
+  async processTurn(speaker, text) {
+    if (this._processing) {
+      log7.info(`Queuing turn (current still processing): "${text}"`);
+      this.pendingTurn = { speaker, text };
+      this.bargeIn.trigger();
+      return;
+    }
+    this._processing = true;
+    const tSpeechEnd = this.lastFinalAt;
+    const sttDuration = this.lastSttDuration;
+    let tLlmFirstToken = 0;
+    let tFirstSentence = 0;
+    let tFirstAudioPlayed = 0;
+    log7.info(`Processing turn from "${speaker}": ${text}`);
+    try {
+      this.context.addUserTurn(speaker, text);
+      if (this.context.shouldSummarize()) {
+        await this.context.summarize(this.llm);
+      }
+      const signal = this.bargeIn.startCycle();
+      let memoryContext = "";
+      if (this.memory) {
+        try {
+          memoryContext = await this.memory.searchRelevant(text);
+        } catch (err) {
+          log7.warn("Memory search failed:", err);
+        }
+      }
+      const messages = this.context.buildMessages(memoryContext || void 0);
+      let fullResponse = "";
+      this.setAgentState("thinking");
+      const sentenceQueue = [];
+      let producerDone = false;
+      let wakeConsumer = null;
+      const wake = () => {
+        wakeConsumer?.();
+      };
+      const producer = async () => {
+        let isFirstToken = true;
+        let isFirstSentence = true;
+        const llmStream = this.llm.chat(messages, signal);
+        try {
+          while (!signal.aborted) {
+            const { value: chunk, done } = await llmStream.next();
+            if (done || !chunk) break;
+            if (signal.aborted) break;
+            if (chunk.type === "token" && chunk.token) {
+              if (isFirstToken) {
+                tLlmFirstToken = performance.now();
+                isFirstToken = false;
+                log7.info(`llm_first_token: ${(tLlmFirstToken - tSpeechEnd).toFixed(0)}ms`);
+              }
+              fullResponse += chunk.token;
+              const sentences = this.splitter.push(chunk.token);
+              for (const sentence of sentences) {
+                if (signal.aborted) break;
+                if (isFirstSentence) {
+                  tFirstSentence = performance.now();
+                  isFirstSentence = false;
+                  log7.info(`first_sentence: ${(tFirstSentence - tSpeechEnd).toFixed(0)}ms \u2014 "${sentence.slice(0, 60)}"`);
+                }
+                sentenceQueue.push(sentence);
+                wake();
+              }
+            }
+          }
+        } finally {
+          await llmStream.return(void 0);
+        }
+        if (!signal.aborted) {
+          const remaining = this.splitter.flush();
+          if (remaining) {
+            if (isFirstSentence) {
+              tFirstSentence = performance.now();
+              isFirstSentence = false;
+              log7.info(`first_sentence (flush): ${(tFirstSentence - tSpeechEnd).toFixed(0)}ms \u2014 "${remaining.slice(0, 60)}"`);
+            }
+            sentenceQueue.push(remaining);
+            wake();
+          }
+        }
+        producerDone = true;
+        wake();
+      };
+      const consumer = async () => {
+        this.audioOutput.beginResponse();
+        try {
+          while (true) {
+            if (signal.aborted) break;
+            if (sentenceQueue.length > 0) {
+              const sentence = sentenceQueue.shift();
+              if (!/\w/.test(sentence)) {
+                log7.debug(`Skipping non-word sentence: "${sentence}"`);
+                continue;
+              }
+              await this.synthesizeAndPlay(sentence, signal, (t) => {
+                if (!tFirstAudioPlayed) {
+                  tFirstAudioPlayed = t;
+                  this.setAgentState("speaking");
+                }
+                this.emit("sentence", sentence);
+              });
+              continue;
+            }
+            if (producerDone) break;
+            await new Promise((resolve) => {
+              wakeConsumer = resolve;
+            });
+            wakeConsumer = null;
+          }
+        } finally {
+          if (!signal.aborted) {
+            await this.audioOutput.writeSilence(40);
+          }
+          this.audioOutput.endResponse();
+        }
+      };
+      await Promise.all([producer(), consumer()]);
+      const ttftMs = tLlmFirstToken ? tLlmFirstToken - tSpeechEnd : 0;
+      const llmMs = tFirstSentence ? tFirstSentence - tSpeechEnd : 0;
+      const ttsMs = tFirstAudioPlayed && tFirstSentence ? tFirstAudioPlayed - tFirstSentence : 0;
+      const overallMs = sttDuration + llmMs + ttsMs;
+      log7.info(
+        `LATENCY "${text.slice(0, 30)}": STT=${sttDuration.toFixed(0)}ms LLM=${llmMs.toFixed(0)}ms (TTFT=${ttftMs.toFixed(0)}ms) TTS=${ttsMs.toFixed(0)}ms Overall=${overallMs.toFixed(0)}ms`
+      );
+      if (fullResponse.trim()) {
+        this.context.addAgentTurn(fullResponse.trim());
+        this.memory?.storeTurn("assistant", fullResponse.trim(), true);
+        this.emit("response", fullResponse.trim());
+      }
+      await sleep2(AUDIO_DRAIN_MS);
+      this.setAgentState("idle");
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        log7.debug("Turn processing aborted (barge-in)");
+      } else {
+        log7.error("Error processing turn:", err);
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      this._processing = false;
+      this.bargeIn.reset();
+      if (this.pendingTurn) {
+        const { speaker: nextSpeaker, text: nextText } = this.pendingTurn;
+        this.pendingTurn = null;
+        log7.info(`Processing queued turn from "${nextSpeaker}": ${nextText}`);
+        this.processTurn(nextSpeaker, nextText);
+      }
+    }
+  }
+  /**
+   * Speak text directly via TTS, bypassing the LLM.
+   * Supports barge-in — if the student speaks, the greeting is cut short.
+   * Adds the text to conversation context so the LLM knows what was said.
+   */
+  async say(text) {
+    if (this._processing) {
+      log7.warn("say() called while processing \u2014 skipping");
+      return;
+    }
+    this._processing = true;
+    log7.info(`say(): "${text.slice(0, 60)}"`);
+    try {
+      const signal = this.bargeIn.startCycle();
+      this.audioOutput.beginResponse();
+      this.setAgentState("thinking");
+      await this.synthesizeAndPlay(text, signal, () => {
+        this.setAgentState("speaking");
+        this.emit("sentence", text);
+      });
+      if (!signal.aborted) {
+        await this.audioOutput.writeSilence(40);
+        this.context.addAgentTurn(text);
+        this.memory?.storeTurn("assistant", text, true);
+        this.emit("response", text);
+      }
+      await sleep2(AUDIO_DRAIN_MS);
+      this.setAgentState("idle");
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") {
+        log7.debug("say() aborted (barge-in)");
+      } else {
+        log7.error("Error in say():", err);
+        this.emit("error", err instanceof Error ? err : new Error(String(err)));
+      }
+    } finally {
+      this._processing = false;
+      this.audioOutput.endResponse();
+      this.bargeIn.reset();
+      if (this.pendingTurn) {
+        const { speaker: nextSpeaker, text: nextText } = this.pendingTurn;
+        this.pendingTurn = null;
+        log7.info(`Processing queued turn from "${nextSpeaker}": ${nextText}`);
+        this.processTurn(nextSpeaker, nextText);
+      }
+    }
+  }
+  async synthesizeAndPlay(text, signal, onFirstAudio) {
+    if (!this.tts || signal.aborted) {
+      log7.info(`[Agent says]: ${text}`);
+      return;
+    }
+    try {
+      const ttsStart = performance.now();
+      let firstChunk = true;
+      let ttsChunkCount = 0;
+      const ttsStream = this.tts.synthesize(text, signal);
+      const measuredStream = async function* () {
+        for await (const chunk of ttsStream) {
+          ttsChunkCount++;
+          if (firstChunk) {
+            firstChunk = false;
+            const now = performance.now();
+            log7.info(`tts_first_audio: ${(now - ttsStart).toFixed(0)}ms for "${text.slice(0, 40)}"`);
+            onFirstAudio(now);
+          }
+          yield chunk;
+        }
+      };
+      await this.audioOutput.writeStream(measuredStream(), signal);
+      log7.info(`synthesizeAndPlay done: ${(performance.now() - ttsStart).toFixed(0)}ms, ${ttsChunkCount} chunks for "${text.slice(0, 40)}"`);
+    } catch (err) {
+      if (err instanceof Error && err.name === "AbortError") return;
+      throw err;
+    }
+  }
+};
+
+// src/core/voice-agent.ts
+init_logger();
+var log11 = createLogger("VoiceAgent");
+var VoiceAgent = class extends import_events2.EventEmitter {
+  config;
+  connection = null;
+  pipeline = null;
+  audioInputs = /* @__PURE__ */ new Map();
+  audioOutput = null;
+  memory = null;
+  _running = false;
+  constructor(config) {
+    super();
+    this.config = config;
+  }
+  get running() {
+    return this._running;
+  }
+  get room() {
+    return this.connection?.room ?? null;
+  }
+  /** Enable saving raw TTS audio as WAV files to `dir` for debugging. */
+  enableAudioDump(dir) {
+    this._dumpDir = dir;
+    if (this.audioOutput) {
+      this.audioOutput.dumpDir = dir;
+    }
+  }
+  _dumpDir = null;
+  /**
+   * Speak text directly via TTS, bypassing the LLM.
+   * Use for greetings or announcements. Supports barge-in.
+   */
+  async say(text) {
+    if (!this.pipeline) {
+      throw new Error("Agent not started \u2014 call start() first");
+    }
+    await this.pipeline.say(text);
+  }
+  /** Start the agent — connect to room and begin listening. */
+  async start(options) {
+    if (this._running) {
+      throw new Error("Agent is already running");
+    }
+    log11.info(`Starting agent for room "${options.room}"...`);
+    if (this.config.memory?.enabled) {
+      const { RoomMemory: RoomMemory2 } = await Promise.resolve().then(() => (init_room_memory(), room_memory_exports));
+      this.memory = new RoomMemory2({
+        dbPath: this.config.memory.dbPath ?? "./data/memory.db",
+        room: options.room
+      });
+      await this.memory.init();
+      this.memory.startSession();
+      log11.info("Memory initialized");
+    }
+    this.connection = new RoomConnection();
+    await this.connection.connect({
+      room: options.room,
+      apiKey: options.apiKey,
+      apiSecret: options.apiSecret,
+      identity: options.identity ?? "agent",
+      name: options.name ?? options.identity ?? "AI Agent"
+    });
+    const source = await this.connection.publishAudioTrack();
+    this.audioOutput = new AudioOutput(source);
+    if (this._dumpDir) this.audioOutput.dumpDir = this._dumpDir;
+    this.audioOutput.startSilence();
+    this.pipeline = new Pipeline({
+      stt: this.config.stt,
+      llm: this.config.llm,
+      tts: this.config.tts,
+      instructions: this.config.instructions,
+      audioOutput: this.audioOutput,
+      respondMode: this.config.respondMode,
+      agentName: this.config.agentName,
+      nameVariants: this.config.nameVariants,
+      memory: this.memory ?? void 0
+    });
+    this.pipeline.on("transcription", (result) => this.emit("transcription", result));
+    this.pipeline.on("sentence", (text) => this.emit("sentence", text));
+    this.pipeline.on("response", (text) => this.emit("response", text));
+    this.pipeline.on("agentState", (state) => this.emit("agentState", state));
+    this.pipeline.on("error", (error) => this.emit("error", error));
+    for (const participant of this.connection.room.remoteParticipants.values()) {
+      for (const [, pub] of participant.trackPublications) {
+        if (pub.track) {
+          this.handleTrackSubscribed(pub.track, pub, participant);
+        }
+      }
+    }
+    this.connection.room.on("trackSubscribed", (track, pub, participant) => {
+      this.handleTrackSubscribed(track, pub, participant);
+    });
+    this.connection.room.on("trackUnsubscribed", (track, _pub, participant) => {
+      this.handleTrackUnsubscribed(track, participant);
+    });
+    this.connection.room.on("participantDisconnected", (participant) => {
+      this.handleParticipantDisconnected(participant);
+    });
+    this.connection.room.on("disconnected", (reason) => {
+      log11.info(`Room disconnected: ${reason}`);
+      this.emit("disconnected", reason);
+    });
+    if (this.config.onDataMessage) {
+      this.setupDataChannel(this.config.onDataMessage);
+    }
+    this._running = true;
+    this.emit("connected");
+    log11.info("Agent started and listening");
+  }
+  /** Stop the agent — disconnect and clean up. */
+  async stop() {
+    if (!this._running) return;
+    log11.info("Stopping agent...");
+    this._running = false;
+    if (this.pipeline) {
+      await this.pipeline.stop();
+      this.pipeline = null;
+    }
+    if (this.memory) {
+      try {
+        await this.memory.endSession(this.config.llm);
+        await this.memory.close();
+      } catch (err) {
+        log11.error("Error closing memory:", err);
+      }
+      this.memory = null;
+    }
+    for (const [, input] of this.audioInputs) {
+      input.close();
+    }
+    this.audioInputs.clear();
+    if (this.audioOutput) {
+      this.audioOutput.stop();
+      this.audioOutput = null;
+    }
+    if (this.connection) {
+      await this.connection.disconnect();
+      this.connection = null;
+    }
+    this.emit("disconnected", "agent_stopped");
+    log11.info("Agent stopped");
+  }
+  setupDataChannel(handler) {
+    if (!this.connection) return;
+    this.connection.room.on("dataReceived", (payload, participant, _kind, topic) => {
+      const identity = participant?.identity ?? "unknown";
+      handler(payload, identity, topic);
+    });
+    log11.info("Data channel handler registered");
+  }
+  handleTrackSubscribed(track, _publication, participant) {
+    const identity = participant.identity;
+    log11.info(`Track subscribed from "${identity}" (sid=${track.sid})`);
+    this.memory?.addParticipant(identity);
+    const existing = this.audioInputs.get(identity);
+    if (existing) {
+      log11.info(`Closing old AudioInput for "${identity}" (re-subscription)`);
+      existing.close();
+    }
+    const audioInput = new AudioInput(track, identity);
+    this.audioInputs.set(identity, audioInput);
+    const sttStream = this.pipeline.addParticipant(identity);
+    this.pipeAudioToSTT(audioInput, sttStream, identity);
+  }
+  handleTrackUnsubscribed(_track, participant) {
+    const identity = participant.identity;
+    log11.info(`Track unsubscribed from "${identity}"`);
+    const input = this.audioInputs.get(identity);
+    if (input) {
+      input.close();
+      this.audioInputs.delete(identity);
+    }
+  }
+  handleParticipantDisconnected(participant) {
+    const identity = participant.identity;
+    log11.info(`Participant disconnected: "${identity}"`);
+    const input = this.audioInputs.get(identity);
+    if (input) {
+      input.close();
+      this.audioInputs.delete(identity);
+    }
+    this.pipeline?.removeParticipant(identity);
+  }
+  async pipeAudioToSTT(input, sttStream, identity) {
+    try {
+      for await (const buffer of input.frames()) {
+        if (!this._running) break;
+        sttStream.sendAudio(buffer);
+      }
+    } catch (err) {
+      if (this._running) {
+        log11.error(`Audio pipe error for "${identity}":`, err);
+      }
+    }
+  }
+};
+
+// src/core/base-stt-stream.ts
+var import_events3 = require("events");
+var BaseSTTStream = class extends import_events3.EventEmitter {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  on(event, cb) {
+    return super.on(event, cb);
+  }
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+};
+
+// src/index.ts
+init_embedder();
+init_memory_store();
+init_room_memory();
+init_logger();
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AudioInput,
+  AudioOutput,
+  BargeIn,
+  BaseSTTStream,
+  ContextManager,
+  Embedder,
+  MemoryStore,
+  Pipeline,
+  RoomConnection,
+  RoomMemory,
+  SentenceSplitter,
+  TurnDetector,
+  VoiceAgent,
+  createLogger,
+  getLogLevel,
+  setLogLevel
+});
+//# sourceMappingURL=index.js.map