@radaros/core 0.3.6 → 0.3.7

package/dist/index.js

@@ -65,9 +65,11 @@ var InMemoryStorage = class {
 // src/session/session-manager.ts
 var NAMESPACE = "sessions";
 var SessionManager = class {
-  constructor(storage) {
+  constructor(storage, config) {
     this.storage = storage;
+    this.maxMessages = config?.maxMessages;
   }
+  maxMessages;
   async getOrCreate(sessionId, userId) {
     const existing = await this.storage.get(NAMESPACE, sessionId);
     if (existing) return existing;
@@ -83,16 +85,21 @@ var SessionManager = class {
     return session;
   }
   async appendMessage(sessionId, msg) {
-    const session = await this.getOrCreate(sessionId);
-    session.messages.push(msg);
-    session.updatedAt = /* @__PURE__ */ new Date();
-    await this.storage.set(NAMESPACE, sessionId, session);
+    return this.appendMessages(sessionId, [msg]);
   }
   async appendMessages(sessionId, msgs) {
     const session = await this.getOrCreate(sessionId);
     session.messages.push(...msgs);
+    let overflow = [];
+    if (this.maxMessages && session.messages.length > this.maxMessages) {
+      overflow = session.messages.splice(
+        0,
+        session.messages.length - this.maxMessages
+      );
+    }
     session.updatedAt = /* @__PURE__ */ new Date();
     await this.storage.set(NAMESPACE, sessionId, session);
+    return { overflow };
   }
   async getHistory(sessionId, limit) {
     const session = await this.storage.get(NAMESPACE, sessionId);
@@ -782,7 +789,9 @@ var Agent = class {
     if (typeof storage.initialize === "function") {
       this.storageInitPromise = storage.initialize();
     }
-    this.sessionManager = new SessionManager(storage);
+    this.sessionManager = new SessionManager(storage, {
+      maxMessages: config.numHistoryRuns ? config.numHistoryRuns * 2 : void 0
+    });
     this.logger = new Logger({
       level: config.logLevel ?? "silent",
       prefix: config.name
@@ -844,26 +853,24 @@ var Agent = class {
           }
         }
       }
-      await this.sessionManager.appendMessages(sessionId, [
+      const newMessages = [
         { role: "user", content: inputText },
         { role: "assistant", content: output.text }
-      ]);
+      ];
+      const { overflow } = await this.sessionManager.appendMessages(
+        sessionId,
+        newMessages
+      );
       await this.sessionManager.updateState(sessionId, ctx.sessionState);
-      if (this.config.memory) {
-        await this.config.memory.addMessages(sessionId, [
-          { role: "user", content: inputText },
-          { role: "assistant", content: output.text }
-        ]);
+      if (this.config.memory && overflow.length > 0) {
+        this.config.memory.summarize(sessionId, overflow, this.config.model).catch(
+          (e) => this.logger.warn(`Memory summarization failed: ${e}`)
+        );
       }
       if (this.config.userMemory && userId) {
-        this.config.userMemory.extractAndStore(
-          userId,
-          [
-            { role: "user", content: inputText },
-            { role: "assistant", content: output.text }
-          ],
-          this.config.model
-        ).catch((e) => this.logger.warn(`UserMemory extraction failed: ${e}`));
+        this.config.userMemory.extractAndStore(userId, newMessages, this.config.model).catch(
+          (e) => this.logger.warn(`UserMemory extraction failed: ${e}`)
+        );
       }
       if (this.config.hooks?.afterRun) {
         await this.config.hooks.afterRun(ctx, output);
@@ -956,26 +963,24 @@ var Agent = class {
       throw err;
     } finally {
       if (streamOk) {
-        await this.sessionManager.appendMessages(sessionId, [
+        const newMessages = [
           { role: "user", content: inputText },
           { role: "assistant", content: fullText }
-        ]);
+        ];
+        const { overflow } = await this.sessionManager.appendMessages(
+          sessionId,
+          newMessages
+        );
         await this.sessionManager.updateState(sessionId, ctx.sessionState);
-        if (this.config.memory) {
-          await this.config.memory.addMessages(sessionId, [
-            { role: "user", content: inputText },
-            { role: "assistant", content: fullText }
-          ]);
+        if (this.config.memory && overflow.length > 0) {
+          this.config.memory.summarize(sessionId, overflow, this.config.model).catch(
+            (e) => this.logger.warn(`Memory summarization failed: ${e}`)
+          );
         }
         if (this.config.userMemory && userId) {
-          this.config.userMemory.extractAndStore(
-            userId,
-            [
-              { role: "user", content: inputText },
-              { role: "assistant", content: fullText }
-            ],
-            this.config.model
-          ).catch((e) => this.logger.warn(`UserMemory extraction failed: ${e}`));
+          this.config.userMemory.extractAndStore(userId, newMessages, this.config.model).catch(
+            (e) => this.logger.warn(`UserMemory extraction failed: ${e}`)
+          );
         }
         this.eventBus.emit("run.complete", {
           runId: ctx.runId,
@@ -3879,15 +3884,235 @@ var GoogleEmbedding = class {
 
 // src/knowledge/knowledge-base.ts
 import { z } from "zod";
+
+// src/vector/bm25.ts
+var STOP_WORDS = /* @__PURE__ */ new Set([
+  "a",
+  "an",
+  "and",
+  "are",
+  "as",
+  "at",
+  "be",
+  "but",
+  "by",
+  "for",
+  "from",
+  "had",
+  "has",
+  "have",
+  "he",
+  "her",
+  "his",
+  "how",
+  "i",
+  "in",
+  "is",
+  "it",
+  "its",
+  "my",
+  "no",
+  "not",
+  "of",
+  "on",
+  "or",
+  "our",
+  "she",
+  "so",
+  "than",
+  "that",
+  "the",
+  "their",
+  "them",
+  "then",
+  "there",
+  "these",
+  "they",
+  "this",
+  "to",
+  "up",
+  "was",
+  "we",
+  "were",
+  "what",
+  "when",
+  "which",
+  "who",
+  "will",
+  "with",
+  "you",
+  "your"
+]);
+function tokenize(text) {
+  return text.toLowerCase().replace(/[^a-z0-9\s]/g, " ").split(/\s+/).filter((t) => t.length > 1 && !STOP_WORDS.has(t));
+}
+var BM25Index = class {
+  docs = /* @__PURE__ */ new Map();
+  docFreqs = /* @__PURE__ */ new Map();
+  avgDocLength = 0;
+  /** BM25 free parameter: term frequency saturation. */
+  k1;
+  /** BM25 free parameter: document length normalization. */
+  b;
+  constructor(opts) {
+    this.k1 = opts?.k1 ?? 1.5;
+    this.b = opts?.b ?? 0.75;
+  }
+  get size() {
+    return this.docs.size;
+  }
+  add(doc) {
+    this.remove(doc.id);
+    const tokens = tokenize(doc.content);
+    const termFreqs = /* @__PURE__ */ new Map();
+    for (const token of tokens) {
+      termFreqs.set(token, (termFreqs.get(token) ?? 0) + 1);
+    }
+    const entry = {
+      id: doc.id,
+      content: doc.content,
+      metadata: doc.metadata,
+      termFreqs,
+      length: tokens.length
+    };
+    this.docs.set(doc.id, entry);
+    for (const term of termFreqs.keys()) {
+      this.docFreqs.set(term, (this.docFreqs.get(term) ?? 0) + 1);
+    }
+    this.recomputeAvgLength();
+  }
+  addBatch(docs) {
+    for (const doc of docs) {
+      this.add(doc);
+    }
+  }
+  remove(id) {
+    const existing = this.docs.get(id);
+    if (!existing) return;
+    for (const term of existing.termFreqs.keys()) {
+      const count = this.docFreqs.get(term) ?? 1;
+      if (count <= 1) {
+        this.docFreqs.delete(term);
+      } else {
+        this.docFreqs.set(term, count - 1);
+      }
+    }
+    this.docs.delete(id);
+    this.recomputeAvgLength();
+  }
+  clear() {
+    this.docs.clear();
+    this.docFreqs.clear();
+    this.avgDocLength = 0;
+  }
+  search(query, opts) {
+    const queryTokens = tokenize(query);
+    if (queryTokens.length === 0) return [];
+    const N = this.docs.size;
+    if (N === 0) return [];
+    const topK = opts?.topK ?? 10;
+    const results = [];
+    for (const doc of this.docs.values()) {
+      if (opts?.filter) {
+        let match = true;
+        for (const [k, v] of Object.entries(opts.filter)) {
+          if (doc.metadata?.[k] !== v) {
+            match = false;
+            break;
+          }
+        }
+        if (!match) continue;
+      }
+      let score = 0;
+      for (const term of queryTokens) {
+        const tf = doc.termFreqs.get(term) ?? 0;
+        if (tf === 0) continue;
+        const df = this.docFreqs.get(term) ?? 0;
+        const idf = Math.log(1 + (N - df + 0.5) / (df + 0.5));
+        const numerator = tf * (this.k1 + 1);
+        const denominator = tf + this.k1 * (1 - this.b + this.b * (doc.length / this.avgDocLength));
+        score += idf * (numerator / denominator);
+      }
+      if (score > 0 && (opts?.minScore == null || score >= opts.minScore)) {
+        results.push({
+          id: doc.id,
+          content: doc.content,
+          score,
+          metadata: doc.metadata
+        });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, topK);
+  }
+  recomputeAvgLength() {
+    if (this.docs.size === 0) {
+      this.avgDocLength = 0;
+      return;
+    }
+    let total = 0;
+    for (const doc of this.docs.values()) {
+      total += doc.length;
+    }
+    this.avgDocLength = total / this.docs.size;
+  }
+};
+
+// src/vector/rrf.ts
+function reciprocalRankFusion(rankedLists, options) {
+  const k = options?.k ?? 60;
+  const topK = options?.topK ?? 10;
+  const weights = options?.weights ?? rankedLists.map(() => 1);
+  const fusedScores = /* @__PURE__ */ new Map();
+  for (let listIdx = 0; listIdx < rankedLists.length; listIdx++) {
+    const list = rankedLists[listIdx];
+    const weight = weights[listIdx] ?? 1;
+    for (let rank = 0; rank < list.length; rank++) {
+      const item = list[rank];
+      const rrfScore = weight / (k + rank + 1);
+      const existing = fusedScores.get(item.id);
+      if (existing) {
+        existing.score += rrfScore;
+      } else {
+        fusedScores.set(item.id, {
+          score: rrfScore,
+          item: { ...item }
+        });
+      }
+    }
+  }
+  const results = Array.from(fusedScores.values()).map(({ score, item }) => ({
+    ...item,
+    score
+  }));
+  results.sort((a, b) => b.score - a.score);
+  if (options?.minScore != null) {
+    const min = options.minScore;
+    return results.filter((r) => r.score >= min).slice(0, topK);
+  }
+  return results.slice(0, topK);
+}
+
+// src/knowledge/knowledge-base.ts
 var KnowledgeBase = class {
   name;
   collection;
   store;
   initialized = false;
+  bm25;
+  defaultSearchMode;
+  hybridConfig;
   constructor(config) {
     this.name = config.name;
     this.store = config.vectorStore;
     this.collection = config.collection ?? config.name.toLowerCase().replace(/\s+/g, "_");
+    this.defaultSearchMode = config.searchMode ?? "vector";
+    this.hybridConfig = {
+      vectorWeight: config.hybridConfig?.vectorWeight ?? 1,
+      keywordWeight: config.hybridConfig?.keywordWeight ?? 1,
+      rrfK: config.hybridConfig?.rrfK ?? 60
+    };
+    this.bm25 = new BM25Index();
   }
   async initialize() {
     if (this.initialized) return;
@@ -3897,14 +4122,27 @@ var KnowledgeBase = class {
   async add(doc) {
     await this.ensureInit();
     await this.store.upsert(this.collection, doc);
+    this.bm25.add({ id: doc.id, content: doc.content, metadata: doc.metadata });
   }
   async addDocuments(docs) {
     await this.ensureInit();
     await this.store.upsertBatch(this.collection, docs);
+    this.bm25.addBatch(
+      docs.map((d) => ({ id: d.id, content: d.content, metadata: d.metadata }))
+    );
   }
   async search(query, options) {
     await this.ensureInit();
-    return this.store.search(this.collection, query, options);
+    const mode = options?.searchMode ?? this.defaultSearchMode;
+    switch (mode) {
+      case "keyword":
+        return this.keywordSearch(query, options);
+      case "hybrid":
+        return this.hybridSearch(query, options);
+      case "vector":
+      default:
+        return this.store.search(this.collection, query, options);
+    }
   }
   async get(id) {
     await this.ensureInit();
@@ -3913,9 +4151,11 @@ var KnowledgeBase = class {
   async delete(id) {
     await this.ensureInit();
     await this.store.delete(this.collection, id);
+    this.bm25.remove(id);
   }
   async clear() {
     await this.store.dropCollection(this.collection);
+    this.bm25.clear();
   }
   async close() {
     await this.store.close();
@@ -3928,6 +4168,7 @@ var KnowledgeBase = class {
     const topK = config.topK ?? 5;
     const minScore = config.minScore;
     const filter = config.filter;
+    const searchMode = config.searchMode;
     const toolName = config.toolName ?? `search_${this.collection}`;
     const description = config.description ?? `Search the "${this.name}" knowledge base for relevant information. Use this before answering questions related to ${this.name}.`;
     const formatResults = config.formatResults ?? defaultFormatResults;
@@ -3942,7 +4183,8 @@ var KnowledgeBase = class {
         const results = await kb.search(args.query, {
           topK,
           minScore,
-          filter
+          filter,
+          searchMode
         });
         if (results.length === 0) {
           return "No relevant documents found in the knowledge base.";
@@ -3951,6 +4193,60 @@ var KnowledgeBase = class {
       }
     };
   }
+  keywordSearch(query, options) {
+    const results = this.bm25.search(query, {
+      topK: options?.topK ?? 10,
+      filter: options?.filter
+    });
+    return results.map((r) => ({
+      id: r.id,
+      content: r.content,
+      score: r.score,
+      metadata: r.metadata
+    }));
+  }
+  async hybridSearch(query, options) {
+    const topK = options?.topK ?? 10;
+    const fetchK = topK * 2;
+    const [vectorResults, keywordResults] = await Promise.all([
+      this.store.search(this.collection, query, {
+        ...options,
+        topK: fetchK
+      }),
+      Promise.resolve(
+        this.bm25.search(query, {
+          topK: fetchK,
+          filter: options?.filter
+        })
+      )
+    ]);
+    const vectorRanked = vectorResults.map((r) => ({
+      id: r.id,
+      content: r.content,
+      score: r.score,
+      metadata: r.metadata
+    }));
+    const keywordRanked = keywordResults.map((r) => ({
+      id: r.id,
+      content: r.content,
+      score: r.score,
+      metadata: r.metadata
+    }));
+    const fused = reciprocalRankFusion(
+      [vectorRanked, keywordRanked],
+      {
+        k: this.hybridConfig.rrfK,
+        topK,
+        weights: [this.hybridConfig.vectorWeight, this.hybridConfig.keywordWeight]
+      }
+    );
+    return fused.map((r) => ({
+      id: r.id,
+      content: r.content,
+      score: r.score,
+      metadata: r.metadata
+    }));
+  }
   async ensureInit() {
     if (!this.initialized) await this.initialize();
   }
@@ -3968,61 +4264,105 @@ ${lines.join("\n\n")}`;
 }
 
 // src/memory/memory.ts
-var SHORT_TERM_NS = "memory:short";
 var LONG_TERM_NS = "memory:long";
+var SUMMARIZE_PROMPT = `Summarize the following conversation chunk in 2-3 concise sentences. Focus on key topics discussed, decisions made, and important information shared. Do not include greetings or filler.
+
+Conversation:
+{conversation}
+
+Summary:`;
 var Memory = class {
   storage;
-  maxShortTermMessages;
-  enableLongTerm;
+  model;
+  maxSummaries;
+  initPromise = null;
   constructor(config) {
     this.storage = config?.storage ?? new InMemoryStorage();
-    this.maxShortTermMessages = config?.maxShortTermMessages ?? 50;
-    this.enableLongTerm = config?.enableLongTerm ?? false;
-  }
-  async addMessages(sessionId, messages) {
-    const existing = await this.storage.get(SHORT_TERM_NS, sessionId) ?? [];
-    const updated = [...existing, ...messages];
-    if (updated.length > this.maxShortTermMessages) {
-      const overflow = updated.splice(
-        0,
-        updated.length - this.maxShortTermMessages
+    this.model = config?.model;
+    this.maxSummaries = config?.maxSummaries ?? 20;
+  }
+  ensureInitialized() {
+    if (!this.initPromise) {
+      this.initPromise = (async () => {
+        if (typeof this.storage.initialize === "function") {
+          await this.storage.initialize();
+        }
+      })();
+    }
+    return this.initPromise;
+  }
+  /**
+   * Summarize overflow messages and store the summary.
+   * Uses the configured LLM model; falls back to basic concatenation if no model.
+   */
+  async summarize(sessionId, messages, fallbackModel) {
+    await this.ensureInitialized();
+    const textParts = messages.filter((m) => m.content).map((m) => `${m.role}: ${getTextContent(m.content)}`);
+    if (textParts.length === 0) return;
+    const model = this.model ?? fallbackModel;
+    let summary;
+    if (model) {
+      try {
+        const prompt = SUMMARIZE_PROMPT.replace(
+          "{conversation}",
+          textParts.join("\n")
+        );
+        const response = await model.generate(
+          [{ role: "user", content: prompt }],
+          { temperature: 0, maxTokens: 300 }
+        );
+        summary = typeof response.message.content === "string" ? response.message.content.trim() : textParts.join(" | ").slice(0, 500);
+      } catch {
+        summary = textParts.join(" | ").slice(0, 500);
+      }
+    } else {
+      summary = textParts.join(" | ").slice(0, 500);
+    }
+    const entry = {
+      key: `${sessionId}:${Date.now()}`,
+      summary,
+      createdAt: /* @__PURE__ */ new Date()
+    };
+    await this.storage.set(LONG_TERM_NS, entry.key, entry);
+    const all = await this.storage.list(LONG_TERM_NS, sessionId);
+    if (all.length > this.maxSummaries) {
+      const sorted = all.sort(
+        (a, b) => new Date(a.value.createdAt).getTime() - new Date(b.value.createdAt).getTime()
       );
-      if (this.enableLongTerm && overflow.length > 0) {
-        await this.summarizeAndStore(sessionId, overflow);
+      const toDelete = sorted.slice(0, all.length - this.maxSummaries);
+      for (const item of toDelete) {
+        await this.storage.delete(LONG_TERM_NS, item.key);
       }
     }
-    await this.storage.set(SHORT_TERM_NS, sessionId, updated);
-  }
-  async getMessages(sessionId) {
-    return await this.storage.get(SHORT_TERM_NS, sessionId) ?? [];
   }
+  /** Get all stored summaries for a session. */
   async getSummaries(sessionId) {
-    if (!this.enableLongTerm) return [];
+    await this.ensureInitialized();
     const entries = await this.storage.list(
       LONG_TERM_NS,
       sessionId
     );
-    return entries.map((e) => e.value.summary);
+    return entries.sort(
+      (a, b) => new Date(a.value.createdAt).getTime() - new Date(b.value.createdAt).getTime()
+    ).map((e) => e.value.summary);
   }
+  /** Get summaries formatted as a context string for injection into the system prompt. */
   async getContextString(sessionId) {
     const summaries = await this.getSummaries(sessionId);
     if (summaries.length === 0) return "";
-    return `Previous context:
+    return `Previous conversation context:
 ${summaries.join("\n")}`;
   }
-  async summarizeAndStore(sessionId, messages) {
-    const textParts = messages.filter((m) => m.content).map((m) => `${m.role}: ${getTextContent(m.content)}`);
-    if (textParts.length === 0) return;
-    const summary = textParts.join(" | ").slice(0, 500);
-    const entry = {
-      key: `${sessionId}:${Date.now()}`,
-      summary,
-      createdAt: /* @__PURE__ */ new Date()
-    };
-    await this.storage.set(LONG_TERM_NS, entry.key, entry);
-  }
+  /** Clear all summaries for a session. */
   async clear(sessionId) {
-    await this.storage.delete(SHORT_TERM_NS, sessionId);
+    await this.ensureInitialized();
+    const entries = await this.storage.list(
+      LONG_TERM_NS,
+      sessionId
+    );
+    for (const entry of entries) {
+      await this.storage.delete(LONG_TERM_NS, entry.key);
+    }
   }
 };
 
@@ -4556,6 +4896,733 @@ var A2ARemoteAgent = class {
   }
 };
 
+// src/voice/voice-agent.ts
+import { EventEmitter as EventEmitter2 } from "events";
+import { v4 as uuidv46 } from "uuid";
+var VoiceSessionImpl = class extends EventEmitter2 {
+  connection;
+  constructor(connection) {
+    super();
+    this.connection = connection;
+  }
+  sendAudio(data) {
+    this.connection.sendAudio(data);
+  }
+  sendText(text) {
+    this.connection.sendText(text);
+  }
+  interrupt() {
+    this.connection.interrupt();
+  }
+  async close() {
+    await this.connection.close();
+  }
+  on(event, handler) {
+    return super.on(event, handler);
+  }
+  off(event, handler) {
+    return super.off(event, handler);
+  }
+};
+var VoiceAgent = class {
+  name;
+  config;
+  eventBus;
+  logger;
+  toolExecutor;
+  constructor(config) {
+    this.name = config.name;
+    this.config = config;
+    this.eventBus = config.eventBus ?? new EventBus();
+    this.logger = new Logger({
+      level: config.logLevel ?? "silent",
+      prefix: config.name
+    });
+    this.toolExecutor = config.tools && config.tools.length > 0 ? new ToolExecutor(config.tools) : null;
+  }
+  async connect(opts) {
+    const toolDefs = this.toolExecutor?.getToolDefinitions() ?? [];
+    const sessionId = opts?.sessionId ?? this.config.sessionId ?? `voice_${uuidv46()}`;
+    const userId = opts?.userId ?? this.config.userId;
+    let instructions = this.config.instructions ?? "";
+    if (this.config.userMemory && userId) {
+      const userContext = await this.config.userMemory.getContextString(userId);
+      if (userContext) {
+        instructions = instructions ? `${instructions}
+
+${userContext}` : userContext;
+        const facts = await this.config.userMemory.getFacts(userId);
+        this.logger.info(
+          `Loaded ${facts.length} user facts for "${userId}"`
+        );
+      }
+    }
+    const sessionConfig = {
+      instructions,
+      voice: this.config.voice,
+      tools: toolDefs,
+      inputAudioFormat: this.config.inputAudioFormat,
+      outputAudioFormat: this.config.outputAudioFormat,
+      turnDetection: this.config.turnDetection,
+      temperature: this.config.temperature,
+      maxResponseOutputTokens: this.config.maxResponseOutputTokens,
+      apiKey: opts?.apiKey
+    };
+    this.logger.info("Connecting to realtime provider...");
+    const connection = await this.config.provider.connect(sessionConfig);
+    const session = new VoiceSessionImpl(connection);
+    const ctx = new RunContext({
+      sessionId,
+      userId,
+      eventBus: this.eventBus
+    });
+    const transcripts = [];
+    let persisted = false;
+    this.wireEvents(connection, session, ctx, transcripts);
+    const onSessionEnd = async () => {
+      if (persisted) return;
+      persisted = true;
+      await this.persistSession(sessionId, userId, transcripts);
+    };
+    session.on("disconnected", () => {
+      onSessionEnd().catch(
+        (e) => this.logger.warn(`Session persist failed: ${e}`)
+      );
+    });
+    const originalClose = session.close.bind(session);
+    session.close = async () => {
+      await originalClose();
+      await onSessionEnd();
+    };
+    this.eventBus.emit("voice.connected", { agentName: this.name });
+    this.logger.info(
+      `Voice session connected (session=${sessionId}, user=${userId ?? "anonymous"})`
+    );
+    return session;
+  }
+  /**
+   * Consolidate transcript deltas into full messages.
+   * Voice transcripts arrive as many small chunks (one per word/syllable).
+   * Consecutive entries with the same role are merged into a single message.
+   */
+  consolidateTranscripts(transcripts) {
+    const consolidated = [];
+    let current = null;
+    for (const t of transcripts) {
+      if (current && current.role === t.role) {
+        current.content += t.text;
+      } else {
+        if (current && current.content.trim()) {
+          consolidated.push(current);
+        }
+        current = { role: t.role, content: t.text };
+      }
+    }
+    if (current && current.content.trim()) {
+      consolidated.push(current);
+    }
+    return consolidated;
+  }
+  async persistSession(_sessionId, userId, transcripts) {
+    if (transcripts.length === 0) return;
+    const messages = this.consolidateTranscripts(transcripts);
+    this.logger.info(
+      `Consolidated ${transcripts.length} transcript deltas into ${messages.length} messages`
+    );
+    for (const m of messages) {
+      this.logger.info(`  [${m.role}] ${m.content.substring(0, 100)}`);
+    }
+    if (this.config.userMemory && userId) {
+      try {
+        await this.config.userMemory.extractAndStore(
+          userId,
+          messages,
+          this.config.model
+        );
+        const facts = await this.config.userMemory.getFacts(userId);
+        this.logger.info(
+          `Extracted user facts for "${userId}" \u2014 total: ${facts.length}`
+        );
+      } catch (e) {
+        this.logger.warn(`UserMemory extraction failed: ${e.message ?? e}`);
+      }
+    }
+  }
+  wireEvents(connection, session, ctx, transcripts) {
+    connection.on("audio", (data) => {
+      session.emit("audio", data);
+      this.eventBus.emit("voice.audio", {
+        agentName: this.name,
+        data: data.data
+      });
+    });
+    connection.on("text", (data) => {
+      session.emit("text", data);
+    });
+    connection.on("transcript", (data) => {
+      session.emit("transcript", data);
+      transcripts.push({ role: data.role, text: data.text });
+      this.eventBus.emit("voice.transcript", {
+        agentName: this.name,
+        text: data.text,
+        role: data.role
+      });
+      this.logger.info(`[${data.role}] ${data.text}`);
+    });
+    connection.on("tool_call", (toolCall) => {
+      this.handleToolCall(connection, session, ctx, toolCall);
+    });
+    connection.on("interrupted", () => {
+      session.emit("interrupted", {});
+      this.logger.debug("Response interrupted by user speech");
+    });
+    connection.on("error", (data) => {
+      session.emit("error", data);
+      this.eventBus.emit("voice.error", {
+        agentName: this.name,
+        error: data.error
+      });
+      this.logger.error(`Error: ${data.error.message}`);
+    });
+    connection.on("disconnected", () => {
+      session.emit("disconnected", {});
+      this.eventBus.emit("voice.disconnected", { agentName: this.name });
+      this.logger.info("Voice session disconnected");
+    });
+  }
+  async handleToolCall(connection, session, ctx, toolCall) {
+    if (!this.toolExecutor) {
+      this.logger.warn(
+        `Tool call "${toolCall.name}" received but no tools registered`
+      );
+      connection.sendToolResult(
+        toolCall.id,
+        JSON.stringify({ error: "No tools available" })
+      );
+      return;
+    }
+    let parsedArgs = {};
+    try {
+      parsedArgs = JSON.parse(toolCall.arguments || "{}");
+    } catch {
+      parsedArgs = {};
+    }
+    session.emit("tool_call_start", {
+      name: toolCall.name,
+      args: parsedArgs
+    });
+    this.eventBus.emit("voice.tool.call", {
+      agentName: this.name,
+      toolName: toolCall.name,
+      args: parsedArgs
+    });
+    this.logger.info(`Tool call: ${toolCall.name}`);
+    try {
+      const results = await this.toolExecutor.executeAll(
+        [{ id: toolCall.id, name: toolCall.name, arguments: parsedArgs }],
+        ctx
+      );
+      const result = results[0];
+      const resultContent = typeof result.result === "string" ? result.result : result.result.content;
+      connection.sendToolResult(toolCall.id, resultContent);
+      session.emit("tool_result", {
+        name: toolCall.name,
+        result: resultContent
+      });
+      this.eventBus.emit("voice.tool.result", {
+        agentName: this.name,
+        toolName: toolCall.name,
+        result: resultContent
+      });
+      this.logger.info(
+        `Tool result: ${toolCall.name} -> ${resultContent.substring(0, 100)}`
+      );
+    } catch (error) {
+      const errMsg = error?.message ?? "Tool execution failed";
+      connection.sendToolResult(
+        toolCall.id,
+        JSON.stringify({ error: errMsg })
+      );
+      this.logger.error(`Tool error: ${toolCall.name} -> ${errMsg}`);
+    }
+  }
+};
+
+// src/voice/providers/openai-realtime.ts
+import { EventEmitter as EventEmitter3 } from "events";
+import { createRequire as createRequire16 } from "module";
+var _require16 = createRequire16(import.meta.url);
+function toOpenAIAudioFormat(fmt) {
+  if (!fmt) return "pcm16";
+  switch (fmt) {
+    case "pcm16":
+      return "pcm16";
+    case "g711_ulaw":
+      return "g711_ulaw";
+    case "g711_alaw":
+      return "g711_alaw";
+    default:
+      return "pcm16";
+  }
+}
+var OpenAIRealtimeConnection = class extends EventEmitter3 {
+  ws;
+  closed = false;
+  constructor(ws) {
+    super();
+    this.ws = ws;
+  }
+  sendAudio(data) {
+    if (this.closed) return;
+    this.send({
+      type: "input_audio_buffer.append",
+      audio: data.toString("base64")
+    });
+  }
+  sendText(text) {
+    if (this.closed) return;
+    this.send({
+      type: "conversation.item.create",
+      item: {
+        type: "message",
+        role: "user",
+        content: [{ type: "input_text", text }]
+      }
+    });
+    this.send({ type: "response.create" });
+  }
+  sendToolResult(callId, result) {
+    if (this.closed) return;
+    this.send({
+      type: "conversation.item.create",
+      item: {
+        type: "function_call_output",
+        call_id: callId,
+        output: result
+      }
+    });
+    this.send({ type: "response.create" });
+  }
+  interrupt() {
+    if (this.closed) return;
+    this.send({ type: "response.cancel" });
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      this.ws.close();
+    } catch {
+    }
+    this.emit("disconnected", {});
+  }
+  on(event, handler) {
+    return super.on(event, handler);
+  }
+  off(event, handler) {
+    return super.off(event, handler);
+  }
+  send(event) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(event));
+    }
+  }
+  /** Called by the provider to set up server event handling. */
+  _bindServerEvents() {
+    this.ws.on("message", (raw) => {
+      try {
+        const data = JSON.parse(typeof raw === "string" ? raw : raw.toString());
+        this.handleServerEvent(data);
+      } catch {
+      }
+    });
+    this.ws.on("error", (err) => {
+      this.emit("error", { error: err });
+    });
+    this.ws.on("close", () => {
+      if (!this.closed) {
+        this.closed = true;
+        this.emit("disconnected", {});
+      }
+    });
+  }
+  pendingFunctionCalls = /* @__PURE__ */ new Map();
+  handleServerEvent(event) {
+    switch (event.type) {
+      case "session.created":
+        this.emit("connected", {});
+        break;
+      case "response.audio.delta":
+        if (event.delta) {
+          this.emit("audio", {
+            data: Buffer.from(event.delta, "base64"),
+            mimeType: "audio/pcm"
+          });
+        }
+        break;
+      case "response.audio_transcript.delta":
+        if (event.delta) {
+          this.emit("transcript", { text: event.delta, role: "assistant" });
+        }
+        break;
+      case "response.text.delta":
+        if (event.delta) {
+          this.emit("text", { text: event.delta });
+        }
+        break;
+      case "input_audio_buffer.speech_started":
+        this.emit("interrupted", {});
+        break;
+      case "conversation.item.input_audio_transcription.completed":
+        if (event.transcript) {
+          this.emit("transcript", { text: event.transcript, role: "user" });
+        }
+        break;
+      case "response.function_call_arguments.delta":
+        if (event.item_id) {
+          const pending = this.pendingFunctionCalls.get(event.item_id);
+          if (pending) {
+            pending.args += event.delta ?? "";
+          }
+        }
+        break;
+      case "response.output_item.added":
+        if (event.item?.type === "function_call") {
+          this.pendingFunctionCalls.set(event.item.id, {
+            name: event.item.name ?? "",
+            args: ""
+          });
+        }
+        break;
+      case "response.output_item.done":
+        if (event.item?.type === "function_call") {
+          const pending = this.pendingFunctionCalls.get(event.item.id);
+          const toolCall = {
+            id: event.item.call_id ?? event.item.id,
+            name: pending?.name ?? event.item.name ?? "",
+            arguments: pending?.args ?? event.item.arguments ?? "{}"
+          };
+          this.pendingFunctionCalls.delete(event.item.id);
+          this.emit("tool_call", toolCall);
+        }
+        break;
+      case "error":
+        this.emit("error", {
+          error: new Error(event.error?.message ?? "Realtime API error")
+        });
+        break;
+    }
+  }
+};
+var OpenAIRealtimeProvider = class {
+  providerId = "openai-realtime";
+  modelId;
+  apiKey;
+  baseURL;
+  constructor(modelId, config) {
+    this.modelId = modelId ?? "gpt-4o-realtime-preview";
+    this.apiKey = config?.apiKey;
+    this.baseURL = config?.baseURL;
+  }
+  async connect(config) {
+    let WebSocket;
+    try {
+      WebSocket = _require16("ws");
+    } catch {
+      throw new Error("ws package is required for OpenAIRealtimeProvider. Install it: npm install ws");
+    }
+    const key = config.apiKey ?? this.apiKey ?? process.env.OPENAI_API_KEY;
+    if (!key) {
+      throw new Error(
+        "No OpenAI API key provided for realtime connection. Set OPENAI_API_KEY env var or pass apiKey."
+      );
+    }
+    const base = this.baseURL ?? "wss://api.openai.com";
+    const url = `${base}/v1/realtime?model=${encodeURIComponent(this.modelId)}`;
+    const ws = new WebSocket(url, {
+      headers: {
+        Authorization: `Bearer ${key}`,
+        "OpenAI-Beta": "realtime=v1"
+      }
+    });
+    const connection = new OpenAIRealtimeConnection(ws);
+    return new Promise((resolve, reject) => {
+      const TIMEOUT_MS = 3e4;
+      const timeout = setTimeout(() => {
+        reject(new Error(`OpenAI Realtime connection timed out after ${TIMEOUT_MS / 1e3}s`));
+        try {
+          ws.close();
+        } catch {
+        }
+      }, TIMEOUT_MS);
+      ws.on("open", () => {
+        clearTimeout(timeout);
+        connection._bindServerEvents();
+        const sessionUpdate = {
+          type: "session.update",
+          session: this.buildSessionPayload(config)
+        };
+        ws.send(JSON.stringify(sessionUpdate));
+        resolve(connection);
+      });
+      ws.on("error", (err) => {
+        clearTimeout(timeout);
+        reject(new Error(`OpenAI Realtime WebSocket error: ${err.message}`));
+      });
+      ws.on("unexpected-response", (_req, res) => {
+        clearTimeout(timeout);
+        let body = "";
+        res.on("data", (chunk) => {
+          body += chunk.toString();
+        });
+        res.on("end", () => {
+          reject(new Error(`OpenAI Realtime rejected (HTTP ${res.statusCode}): ${body}`));
+        });
+      });
+    });
+  }
+  buildSessionPayload(config) {
+    const session = {
+      modalities: ["text", "audio"],
+      model: this.modelId
+    };
+    if (config.instructions) {
+      session.instructions = config.instructions;
+    }
+    if (config.voice) {
+      session.voice = config.voice;
+    }
+    if (config.inputAudioFormat) {
+      session.input_audio_format = toOpenAIAudioFormat(config.inputAudioFormat);
+    }
+    if (config.outputAudioFormat) {
+      session.output_audio_format = toOpenAIAudioFormat(config.outputAudioFormat);
+    }
+    if (config.turnDetection !== void 0) {
+      if (config.turnDetection === null) {
+        session.turn_detection = null;
+      } else {
+        session.turn_detection = {
+          type: config.turnDetection.type,
+          ...config.turnDetection.threshold !== void 0 && {
+            threshold: config.turnDetection.threshold
+          },
+          ...config.turnDetection.prefixPaddingMs !== void 0 && {
+            prefix_padding_ms: config.turnDetection.prefixPaddingMs
+          },
+          ...config.turnDetection.silenceDurationMs !== void 0 && {
+            silence_duration_ms: config.turnDetection.silenceDurationMs
+          }
+        };
+      }
+    }
+    if (config.temperature !== void 0) {
+      session.temperature = config.temperature;
+    }
+    if (config.maxResponseOutputTokens !== void 0) {
+      session.max_response_output_tokens = config.maxResponseOutputTokens;
+    }
+    session.input_audio_transcription = { model: "whisper-1" };
+    if (config.tools && config.tools.length > 0) {
+      session.tools = config.tools.map((t) => ({
+        type: "function",
+        name: t.name,
+        description: t.description,
+        parameters: t.parameters
+      }));
+    }
+    return session;
+  }
+};
+
+// src/voice/providers/google-live.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { createRequire as createRequire17 } from "module";
+var _require17 = createRequire17(import.meta.url);
+var GoogleLiveConnection = class extends EventEmitter4 {
+  session;
+  closed = false;
+  constructor(session) {
+    super();
+    this.session = session;
+  }
+  sendAudio(data) {
+    if (this.closed) return;
+    this.session.sendRealtimeInput({
+      audio: {
+        data: data.toString("base64"),
+        mimeType: "audio/pcm;rate=16000"
+      }
+    });
+  }
+  sendText(text) {
+    if (this.closed) return;
+    this.session.sendClientContent({
+      turns: text,
+      turnComplete: true
+    });
+  }
+  sendToolResult(callId, result) {
+    if (this.closed) return;
+    let responseObj;
+    try {
+      responseObj = JSON.parse(result);
+    } catch {
+      responseObj = { result };
+    }
+    this.session.sendToolResponse({
+      functionResponses: [
+        {
+          id: callId,
+          name: callId,
+          response: responseObj
+        }
+      ]
+    });
+  }
+  interrupt() {
+  }
+  async close() {
+    if (this.closed) return;
+    this.closed = true;
+    try {
+      this.session.close();
+    } catch {
+    }
+    this.emit("disconnected", {});
+  }
+  on(event, handler) {
+    return super.on(event, handler);
+  }
+  off(event, handler) {
+    return super.off(event, handler);
+  }
+  /** Internal: handle server messages from the Live API. */
+  _handleMessage(message) {
+    if (message.serverContent?.interrupted) {
+      this.emit("interrupted", {});
+      return;
+    }
+    if (message.toolCall?.functionCalls) {
+      for (const fc of message.toolCall.functionCalls) {
+        const toolCall = {
+          id: fc.id ?? fc.name,
+          name: fc.name,
+          arguments: JSON.stringify(fc.args ?? {})
+        };
+        this.emit("tool_call", toolCall);
+      }
+      return;
+    }
+    if (message.serverContent?.modelTurn?.parts) {
+      for (const part of message.serverContent.modelTurn.parts) {
+        if (part.inlineData && part.inlineData.data) {
+          const mimeType = part.inlineData.mimeType ?? "audio/pcm";
+          const buf = typeof part.inlineData.data === "string" ? Buffer.from(part.inlineData.data, "base64") : Buffer.from(part.inlineData.data);
+          this.emit("audio", { data: buf, mimeType });
+        }
+        if (part.text) {
+          this.emit("text", { text: part.text });
+          this.emit("transcript", { text: part.text, role: "assistant" });
+        }
+        if (part.functionCall) {
+          const toolCall = {
+            id: part.functionCall.id ?? part.functionCall.name,
+            name: part.functionCall.name,
+            arguments: JSON.stringify(part.functionCall.args ?? {})
+          };
+          this.emit("tool_call", toolCall);
+        }
+      }
+    }
+  }
+};
+var GoogleLiveProvider = class {
+  providerId = "google-live";
+  modelId;
+  apiKey;
+  constructor(modelId, config) {
+    this.modelId = modelId ?? "gemini-2.5-flash-native-audio-preview-12-2025";
+    this.apiKey = config?.apiKey;
+  }
+  async connect(config) {
+    let GoogleGenAI;
+    let Modality;
+    try {
+      const mod = _require17("@google/genai");
+      GoogleGenAI = mod.GoogleGenAI;
+      Modality = mod.Modality;
+    } catch {
+      throw new Error(
+        "@google/genai package is required for GoogleLiveProvider. Install it: npm install @google/genai"
+      );
+    }
+    const key = config.apiKey ?? this.apiKey ?? process.env.GOOGLE_API_KEY;
+    if (!key) {
+      throw new Error(
+        "No Google API key provided for live connection. Set GOOGLE_API_KEY env var or pass apiKey."
+      );
+    }
+    const ai = new GoogleGenAI({ apiKey: key });
+    const liveConfig = {
+      responseModalities: [Modality.AUDIO]
+    };
+    if (config.instructions) {
+      liveConfig.systemInstruction = config.instructions;
+    }
+    if (config.voice) {
+      liveConfig.speechConfig = { voiceConfig: { prebuiltVoiceConfig: { voiceName: config.voice } } };
+    }
+    if (config.temperature !== void 0) {
+      liveConfig.temperature = config.temperature;
+    }
+    if (config.tools && config.tools.length > 0) {
+      liveConfig.tools = [
+        {
+          functionDeclarations: config.tools.map((t) => ({
+            name: t.name,
+            description: t.description,
+            parameters: t.parameters
+          }))
+        }
+      ];
+    }
+    const connection = new GoogleLiveConnection(null);
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error("Google Live connection timed out after 15s"));
+      }, 15e3);
+      ai.live.connect({
+        model: this.modelId,
+        config: liveConfig,
+        callbacks: {
+          onopen: () => {
+            clearTimeout(timeout);
+            connection.emit("connected", {});
+          },
+          onmessage: (message) => {
+            connection._handleMessage(message);
+          },
+          onerror: (e) => {
+            const err = e?.error ?? e?.message ?? e;
+            const error = err instanceof Error ? err : new Error(String(err));
+            connection.emit("error", { error });
+          },
+          onclose: () => {
+            connection.emit("disconnected", {});
+          }
+        }
+      }).then((session) => {
+        connection.session = session;
+        resolve(connection);
+      }).catch((err) => {
+        clearTimeout(timeout);
+        reject(err);
+      });
+    });
+  }
+};
+
 // src/toolkits/base.ts
 var Toolkit = class {
 };
@@ -4666,8 +5733,8 @@ Snippet: ${r.snippet ?? ""}
 
 // src/toolkits/gmail.ts
 import { z as z5 } from "zod";
-import { createRequire as createRequire16 } from "module";
-var _require16 = createRequire16(import.meta.url);
+import { createRequire as createRequire18 } from "module";
+var _require18 = createRequire18(import.meta.url);
 var GmailToolkit = class extends Toolkit {
   name = "gmail";
   config;
@@ -4679,7 +5746,7 @@ var GmailToolkit = class extends Toolkit {
   async getGmailClient() {
     if (this.gmail) return this.gmail;
     if (this.config.authClient) {
-      const { google: google3 } = _require16("googleapis");
+      const { google: google3 } = _require18("googleapis");
       this.gmail = google3.gmail({ version: "v1", auth: this.config.authClient });
       return this.gmail;
     }
@@ -4690,7 +5757,7 @@ var GmailToolkit = class extends Toolkit {
         "GmailToolkit: Provide credentialsPath + tokenPath, or an authClient. Set GMAIL_CREDENTIALS_PATH and GMAIL_TOKEN_PATH env vars, or pass them in config."
       );
     }
-    const { google: google2 } = _require16("googleapis");
+    const { google: google2 } = _require18("googleapis");
     const fs = await import("fs");
     const creds = JSON.parse(fs.readFileSync(credPath, "utf-8"));
     const token = JSON.parse(fs.readFileSync(tokenPath, "utf-8"));
@@ -5221,11 +6288,13 @@ export {
   A2ARemoteAgent,
   Agent,
   AnthropicProvider,
+  BM25Index,
   BaseVectorStore,
   DuckDuckGoToolkit,
   EventBus,
   GmailToolkit,
   GoogleEmbedding,
+  GoogleLiveProvider,
   GoogleProvider,
   HackerNewsToolkit,
   InMemoryStorage,
@@ -5241,6 +6310,7 @@ export {
   OllamaProvider,
   OpenAIEmbedding,
   OpenAIProvider,
+  OpenAIRealtimeProvider,
   PgVectorStore,
   PostgresStorage,
   QdrantVectorStore,
@@ -5253,6 +6323,7 @@ export {
   Toolkit,
   UserMemory,
   VertexAIProvider,
+  VoiceAgent,
   WebSearchToolkit,
   WhatsAppToolkit,
   Workflow,
@@ -5263,6 +6334,7 @@ export {
   isMultiModal,
   ollama,
   openai,
+  reciprocalRankFusion,
   registry,
   vertex,
   withRetry