@radaros/core 0.3.6 → 0.3.8

package/dist/index.js

@@ -1,5 +1,5 @@
 // src/agent/agent.ts
-import { v4 as uuidv42 } from "uuid";
+import { v4 as uuidv43 } from "uuid";
 
 // src/events/event-bus.ts
 import { EventEmitter } from "events";
@@ -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);
@@ -119,17 +126,224 @@ var SessionManager = class {
 
 // src/tools/tool-executor.ts
 import { createRequire } from "module";
+
+// src/tools/sandbox.ts
+import { fork } from "child_process";
+import { fileURLToPath } from "url";
+import path from "path";
+var DEFAULT_TIMEOUT = 3e4;
+var DEFAULT_MAX_MEMORY_MB = 256;
+function resolveSandboxConfig(toolLevel, agentLevel) {
+  if (toolLevel === false) return null;
+  const effective = toolLevel ?? agentLevel;
+  if (!effective) return null;
+  if (effective === true) return { enabled: true };
+  if (effective.enabled === false) return null;
+  return { ...effective, enabled: true };
+}
+var Sandbox = class {
+  config;
+  constructor(config) {
+    this.config = {
+      ...config,
+      enabled: config.enabled !== false,
+      timeout: config.timeout ?? DEFAULT_TIMEOUT,
+      maxMemoryMB: config.maxMemoryMB ?? DEFAULT_MAX_MEMORY_MB
+    };
+  }
+  async execute(toolExecuteFn, args, ctx) {
+    const fnSource = toolExecuteFn.toString();
+    const wrappedBody = `
+      const __fn = ${fnSource};
+      return await __fn(args, {});
+    `;
+    return new Promise((resolve, reject) => {
+      const workerPath = this.getWorkerPath();
+      const execArgv = [
+        `--max-old-space-size=${this.config.maxMemoryMB}`
+      ];
+      const env = {};
+      if (this.config.env) {
+        for (const [key, val] of Object.entries(this.config.env)) {
+          env[key] = val;
+        }
+      }
+      if (!this.config.allowNetwork) {
+        env.__SANDBOX_NO_NETWORK = "1";
+      }
+      const child = fork(workerPath, [], {
+        execArgv,
+        env: { ...env, NODE_OPTIONS: execArgv.join(" ") },
+        stdio: ["pipe", "pipe", "pipe", "ipc"],
+        serialization: "json"
+      });
+      const timer = setTimeout(() => {
+        child.kill("SIGKILL");
+        reject(new Error(`Sandbox execution timed out after ${this.config.timeout}ms`));
+      }, this.config.timeout);
+      child.on("message", (msg) => {
+        clearTimeout(timer);
+        if (msg.type === "result") {
+          resolve(msg.value);
+        } else if (msg.type === "error") {
+          reject(new Error(`Sandbox error: ${msg.message}`));
+        }
+        child.kill();
+      });
+      child.on("error", (err) => {
+        clearTimeout(timer);
+        reject(new Error(`Sandbox process error: ${err.message}`));
+      });
+      child.on("exit", (code, signal) => {
+        clearTimeout(timer);
+        if (signal === "SIGKILL") return;
+        if (code !== 0 && code !== null) {
+          reject(new Error(`Sandbox process exited with code ${code}`));
+        }
+      });
+      child.send({
+        type: "execute",
+        functionBody: wrappedBody,
+        args
+      });
+    });
+  }
+  getWorkerPath() {
+    const currentFile = fileURLToPath(import.meta.url);
+    const distDir = path.dirname(currentFile);
+    return path.join(distDir, "tools", "sandbox-worker.js");
+  }
+};
+
+// src/tools/approval.ts
+import { v4 as uuidv4 } from "uuid";
+var DEFAULT_TIMEOUT2 = 3e5;
+var ApprovalManager = class {
+  policy;
+  onApproval;
+  timeout;
+  eventBus;
+  pending = /* @__PURE__ */ new Map();
+  constructor(config) {
+    this.policy = config.policy;
+    this.onApproval = config.onApproval;
+    this.timeout = config.timeout ?? DEFAULT_TIMEOUT2;
+    this.eventBus = config.eventBus;
+  }
+  needsApproval(toolName, args, toolRequiresApproval) {
+    if (toolRequiresApproval !== void 0) {
+      if (typeof toolRequiresApproval === "function") {
+        return toolRequiresApproval(args);
+      }
+      return toolRequiresApproval;
+    }
+    if (this.policy === "none") return false;
+    if (this.policy === "all") return true;
+    return this.policy.includes(toolName);
+  }
+  async check(toolName, args, ctx, agentName) {
+    const request = {
+      requestId: uuidv4(),
+      toolName,
+      args,
+      agentName,
+      runId: ctx.runId
+    };
+    this.eventBus?.emit("tool.approval.request", request);
+    if (this.onApproval) {
+      return this.callbackMode(request);
+    }
+    return this.eventMode(request);
+  }
+  /** Externally approve a pending request (for event-driven mode). */
+  approve(requestId, reason) {
+    const entry = this.pending.get(requestId);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    const decision = { approved: true, reason };
+    this.eventBus?.emit("tool.approval.response", { requestId, ...decision });
+    entry.resolve(decision);
+  }
+  /** Externally deny a pending request (for event-driven mode). */
+  deny(requestId, reason) {
+    const entry = this.pending.get(requestId);
+    if (!entry) return;
+    clearTimeout(entry.timer);
+    this.pending.delete(requestId);
+    const decision = { approved: false, reason };
+    this.eventBus?.emit("tool.approval.response", { requestId, ...decision });
+    entry.resolve(decision);
+  }
+  async callbackMode(request) {
+    const timer = setTimeout(() => {
+    }, this.timeout);
+    try {
+      const result = await Promise.race([
+        this.onApproval(request),
+        new Promise(
+          (resolve) => setTimeout(
+            () => resolve({ approved: false, reason: "Approval timed out" }),
+            this.timeout
+          )
+        )
+      ]);
+      this.eventBus?.emit("tool.approval.response", {
+        requestId: request.requestId,
+        ...result
+      });
+      return result;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  eventMode(request) {
+    return new Promise((resolve) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(request.requestId);
+        const decision = {
+          approved: false,
+          reason: "Approval timed out"
+        };
+        this.eventBus?.emit("tool.approval.response", {
+          requestId: request.requestId,
+          ...decision
+        });
+        resolve(decision);
+      }, this.timeout);
+      this.pending.set(request.requestId, { resolve, timer });
+    });
+  }
+};
+
+// src/tools/tool-executor.ts
 var _require = createRequire(import.meta.url);
 var ToolExecutor = class {
   tools;
   concurrency;
   cache = /* @__PURE__ */ new Map();
   cachedDefs = null;
-  constructor(tools, concurrency = 5) {
+  agentSandbox;
+  approvalManager;
+  agentName;
+  constructor(tools, configOrConcurrency) {
     this.tools = new Map(tools.map((t) => [t.name, t]));
-    this.concurrency = concurrency;
+    if (typeof configOrConcurrency === "number" || configOrConcurrency === void 0) {
+      this.concurrency = configOrConcurrency ?? 5;
+      this.agentName = "";
+    } else {
+      this.concurrency = configOrConcurrency.concurrency ?? 5;
+      this.agentSandbox = configOrConcurrency.sandbox;
+      this.agentName = configOrConcurrency.agentName ?? "";
+      if (configOrConcurrency.approval && configOrConcurrency.approval.policy !== "none") {
+        this.approvalManager = new ApprovalManager(configOrConcurrency.approval);
+      }
+    }
     this.cachedDefs = this.buildToolDefinitions();
   }
+  getApprovalManager() {
+    return this.approvalManager;
+  }
   clearCache() {
     this.cache.clear();
   }
@@ -197,6 +411,35 @@ var ToolExecutor = class {
       toolName: toolCall.name,
       args: toolCall.arguments
     });
+    if (this.approvalManager) {
+      const needs = this.approvalManager.needsApproval(
+        toolCall.name,
+        toolCall.arguments,
+        tool.requiresApproval
+      );
+      if (needs) {
+        const decision = await this.approvalManager.check(
+          toolCall.name,
+          toolCall.arguments,
+          ctx,
+          this.agentName
+        );
+        if (!decision.approved) {
+          const reason = decision.reason ?? "Tool call denied by human reviewer";
+          ctx.eventBus.emit("tool.result", {
+            runId: ctx.runId,
+            toolName: toolCall.name,
+            result: reason
+          });
+          return {
+            toolCallId: toolCall.id,
+            toolName: toolCall.name,
+            result: `[DENIED] ${reason}`,
+            error: reason
+          };
+        }
+      }
+    }
     const cachedResult = this.getCached(toolCall.name, toolCall.arguments);
     if (cachedResult !== void 0) {
       const resultContent2 = typeof cachedResult === "string" ? cachedResult : cachedResult.content;
@@ -227,7 +470,14 @@ var ToolExecutor = class {
       });
       return result;
     }
-    const rawResult = await tool.execute(parsed.data, ctx);
+    const sandboxConfig = resolveSandboxConfig(tool.sandbox, this.agentSandbox);
+    let rawResult;
+    if (sandboxConfig) {
+      const sandbox = new Sandbox(sandboxConfig);
+      rawResult = await sandbox.execute(tool.execute, parsed.data, ctx);
+    } else {
+      rawResult = await tool.execute(parsed.data, ctx);
+    }
     const resultContent = typeof rawResult === "string" ? rawResult : rawResult.content;
     this.setCache(toolCall.name, toolCall.arguments, rawResult);
     ctx.eventBus.emit("tool.result", {
@@ -724,7 +974,7 @@ var LLMLoop = class {
 };
 
 // src/agent/run-context.ts
-import { v4 as uuidv4 } from "uuid";
+import { v4 as uuidv42 } from "uuid";
 var RunContext = class {
   runId;
   sessionId;
@@ -733,7 +983,7 @@ var RunContext = class {
   eventBus;
   sessionState;
   constructor(opts) {
-    this.runId = opts.runId ?? uuidv4();
+    this.runId = opts.runId ?? uuidv42();
     this.sessionId = opts.sessionId;
     this.userId = opts.userId;
     this.metadata = opts.metadata ?? {};
@@ -758,6 +1008,7 @@ var Agent = class {
   llmLoop;
   logger;
   storageInitPromise = null;
+  _toolExecutor = null;
   get tools() {
     return this.config.tools ?? [];
   }
@@ -770,6 +1021,9 @@ var Agent = class {
   get hasStructuredOutput() {
     return !!this.config.structuredOutput;
   }
+  get approvalManager() {
+    return this._toolExecutor?.getApprovalManager() ?? null;
+  }
   get structuredOutputSchema() {
     return this.config.structuredOutput;
   }
@@ -782,13 +1036,19 @@ 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
     });
-    const toolExecutor = config.tools && config.tools.length > 0 ? new ToolExecutor(config.tools) : null;
-    this.llmLoop = new LLMLoop(config.model, toolExecutor, {
+    this._toolExecutor = config.tools && config.tools.length > 0 ? new ToolExecutor(config.tools, {
+      sandbox: config.sandbox,
+      approval: config.approval ? { ...config.approval, eventBus: this.eventBus } : void 0,
+      agentName: config.name
+    }) : null;
+    this.llmLoop = new LLMLoop(config.model, this._toolExecutor, {
       maxToolRoundtrips: config.maxToolRoundtrips ?? 10,
       temperature: config.temperature,
       structuredOutput: config.structuredOutput,
@@ -799,7 +1059,7 @@ var Agent = class {
   }
   async run(input, opts) {
     const startTime = Date.now();
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv42();
+    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv43();
     const userId = opts?.userId ?? this.config.userId;
     const inputText = typeof input === "string" ? input : getTextContent(input);
     if (this.storageInitPromise) await this.storageInitPromise;
@@ -844,26 +1104,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);
@@ -891,7 +1149,7 @@ var Agent = class {
     }
   }
   async *stream(input, opts) {
-    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv42();
+    const sessionId = opts?.sessionId ?? this.config.sessionId ?? uuidv43();
     const userId = opts?.userId ?? this.config.userId;
     const inputText = typeof input === "string" ? input : getTextContent(input);
     if (this.storageInitPromise) await this.storageInitPromise;
@@ -956,26 +1214,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,
@@ -1062,7 +1318,7 @@ ${userContext}` : userContext;
 };
 
 // src/team/team.ts
-import { v4 as uuidv43 } from "uuid";
+import { v4 as uuidv44 } from "uuid";
 
 // src/team/types.ts
 var TeamMode = /* @__PURE__ */ ((TeamMode2) => {
@@ -1085,7 +1341,7 @@ var Team = class {
   }
   async run(input, opts) {
     const ctx = new RunContext({
-      sessionId: opts?.sessionId ?? uuidv43(),
+      sessionId: opts?.sessionId ?? uuidv44(),
       userId: opts?.userId,
       metadata: opts?.metadata ?? {},
       eventBus: this.eventBus,
@@ -1325,7 +1581,7 @@ Synthesize these responses into a single coherent answer.`;
 };
 
 // src/workflow/workflow.ts
-import { v4 as uuidv44 } from "uuid";
+import { v4 as uuidv45 } from "uuid";
 
 // src/workflow/step-runner.ts
 function isAgentStep(step) {
@@ -1557,7 +1813,7 @@ var Workflow = class {
   }
   async run(opts) {
     const ctx = new RunContext({
-      sessionId: opts?.sessionId ?? uuidv44(),
+      sessionId: opts?.sessionId ?? uuidv45(),
       userId: opts?.userId,
       eventBus: this.eventBus,
       sessionState: {}
@@ -2951,182 +3207,665 @@ var VertexAIProvider = class {
   }
 };
 
-// src/models/registry.ts
-var ModelRegistry = class {
-  factories = /* @__PURE__ */ new Map();
-  register(providerId, factory) {
-    this.factories.set(providerId, factory);
-  }
-  resolve(providerId, modelId, config) {
-    const factory = this.factories.get(providerId);
-    if (!factory) {
-      throw new Error(
-        `Unknown provider "${providerId}". Register it first with registry.register().`
-      );
-    }
-    return factory(modelId, config);
-  }
-  has(providerId) {
-    return this.factories.has(providerId);
-  }
-};
-var registry = new ModelRegistry();
-registry.register(
-  "openai",
-  (modelId, config) => new OpenAIProvider(modelId, config)
-);
-registry.register(
-  "anthropic",
-  (modelId, config) => new AnthropicProvider(modelId, config)
-);
-registry.register(
-  "google",
-  (modelId, config) => new GoogleProvider(modelId, config)
-);
-registry.register(
-  "ollama",
-  (modelId, config) => new OllamaProvider(modelId, config)
-);
-function openai(modelId, config) {
-  return registry.resolve("openai", modelId, config);
-}
-function anthropic(modelId, config) {
-  return registry.resolve("anthropic", modelId, config);
-}
-function google(modelId, config) {
-  return registry.resolve("google", modelId, config);
-}
-function ollama(modelId, config) {
-  return registry.resolve("ollama", modelId, config);
-}
-registry.register(
-  "vertex",
-  (modelId, config) => new VertexAIProvider(
-    modelId,
-    config
-  )
-);
-function vertex(modelId, config) {
-  return registry.resolve("vertex", modelId, config);
-}
-
-// src/tools/define-tool.ts
-function defineTool(config) {
-  return {
-    name: config.name,
-    description: config.description,
-    parameters: config.parameters,
-    execute: config.execute,
-    cache: config.cache
-  };
-}
-
-// src/storage/sqlite.ts
+// src/voice/providers/openai-realtime.ts
+import { EventEmitter as EventEmitter2 } from "events";
 import { createRequire as createRequire8 } from "module";
 var _require8 = createRequire8(import.meta.url);
-var SqliteStorage = class {
-  db;
-  constructor(dbPath) {
-    try {
-      const Database = _require8("better-sqlite3");
-      this.db = new Database(dbPath);
-      this.db.pragma("journal_mode = WAL");
-      this.db.exec(`
-        CREATE TABLE IF NOT EXISTS kv_store (
-          namespace TEXT NOT NULL,
-          key TEXT NOT NULL,
-          value TEXT NOT NULL,
-          updated_at TEXT DEFAULT (datetime('now')),
-          PRIMARY KEY (namespace, key)
-        )
-      `);
-    } catch {
-      throw new Error(
-        "better-sqlite3 is required for SqliteStorage. Install it: npm install better-sqlite3"
-      );
-    }
+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";
   }
-  async get(namespace, key) {
-    const row = this.db.prepare("SELECT value FROM kv_store WHERE namespace = ? AND key = ?").get(namespace, key);
-    if (!row) return null;
-    return JSON.parse(row.value);
+}
+var OpenAIRealtimeConnection = class extends EventEmitter2 {
+  ws;
+  closed = false;
+  constructor(ws) {
+    super();
+    this.ws = ws;
   }
-  async set(namespace, key, value) {
-    this.db.prepare(
-      `INSERT INTO kv_store (namespace, key, value, updated_at)
-         VALUES (?, ?, ?, datetime('now'))
-         ON CONFLICT(namespace, key)
-         DO UPDATE SET value = excluded.value, updated_at = datetime('now')`
-    ).run(namespace, key, JSON.stringify(value));
+  sendAudio(data) {
+    if (this.closed) return;
+    this.send({
+      type: "input_audio_buffer.append",
+      audio: data.toString("base64")
+    });
   }
-  async delete(namespace, key) {
-    this.db.prepare("DELETE FROM kv_store WHERE namespace = ? AND key = ?").run(namespace, key);
+  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" });
   }
-  async list(namespace, prefix) {
-    const rows = prefix ? this.db.prepare(
-      "SELECT key, value FROM kv_store WHERE namespace = ? AND key LIKE ?"
-    ).all(namespace, `${prefix}%`) : this.db.prepare("SELECT key, value FROM kv_store WHERE namespace = ?").all(namespace);
-    return rows.map((row) => ({
-      key: row.key,
-      value: JSON.parse(row.value)
-    }));
+  interrupt() {
+    if (this.closed) return;
+    this.send({ type: "response.cancel" });
   }
   async close() {
-    this.db.close();
-  }
-};
-
-// src/storage/postgres.ts
-import { createRequire as createRequire9 } from "module";
-var _require9 = createRequire9(import.meta.url);
-var PostgresStorage = class {
-  pool;
-  constructor(connectionString) {
+    if (this.closed) return;
+    this.closed = true;
     try {
-      const { Pool } = _require9("pg");
-      this.pool = new Pool({ connectionString });
+      this.ws.close();
     } catch {
-      throw new Error(
-        "pg is required for PostgresStorage. Install it: npm install pg"
-      );
     }
+    this.emit("disconnected", {});
   }
-  async initialize() {
-    await this.pool.query(`
-      CREATE TABLE IF NOT EXISTS kv_store (
-        namespace TEXT NOT NULL,
-        key TEXT NOT NULL,
-        value JSONB NOT NULL,
-        updated_at TIMESTAMPTZ DEFAULT NOW(),
-        PRIMARY KEY (namespace, key)
-      )
-    `);
-  }
-  async get(namespace, key) {
-    const result = await this.pool.query(
-      "SELECT value FROM kv_store WHERE namespace = $1 AND key = $2",
-      [namespace, key]
-    );
-    if (result.rows.length === 0) return null;
-    return result.rows[0].value;
+  on(event, handler) {
+    return super.on(event, handler);
   }
-  async set(namespace, key, value) {
-    await this.pool.query(
-      `INSERT INTO kv_store (namespace, key, value, updated_at)
-       VALUES ($1, $2, $3, NOW())
-       ON CONFLICT (namespace, key)
-       DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()`,
-      [namespace, key, JSON.stringify(value)]
-    );
+  off(event, handler) {
+    return super.off(event, handler);
   }
-  async delete(namespace, key) {
-    await this.pool.query(
-      "DELETE FROM kv_store WHERE namespace = $1 AND key = $2",
-      [namespace, key]
-    );
+  send(event) {
+    if (this.ws.readyState === 1) {
+      this.ws.send(JSON.stringify(event));
+    }
   }
-  async list(namespace, prefix) {
-    const result = prefix ? await this.pool.query(
+  /** 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 = _require8("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 EventEmitter3 } from "events";
+import { createRequire as createRequire9 } from "module";
+var _require9 = createRequire9(import.meta.url);
+var GoogleLiveConnection = class extends EventEmitter3 {
+  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 = _require9("@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/models/registry.ts
+var ModelRegistry = class {
+  factories = /* @__PURE__ */ new Map();
+  register(providerId, factory) {
+    this.factories.set(providerId, factory);
+  }
+  resolve(providerId, modelId, config) {
+    const factory = this.factories.get(providerId);
+    if (!factory) {
+      throw new Error(
+        `Unknown provider "${providerId}". Register it first with registry.register().`
+      );
+    }
+    return factory(modelId, config);
+  }
+  has(providerId) {
+    return this.factories.has(providerId);
+  }
+};
+var registry = new ModelRegistry();
+registry.register(
+  "openai",
+  (modelId, config) => new OpenAIProvider(modelId, config)
+);
+registry.register(
+  "anthropic",
+  (modelId, config) => new AnthropicProvider(modelId, config)
+);
+registry.register(
+  "google",
+  (modelId, config) => new GoogleProvider(modelId, config)
+);
+registry.register(
+  "ollama",
+  (modelId, config) => new OllamaProvider(modelId, config)
+);
+function openai(modelId, config) {
+  return registry.resolve("openai", modelId, config);
+}
+function anthropic(modelId, config) {
+  return registry.resolve("anthropic", modelId, config);
+}
+function google(modelId, config) {
+  return registry.resolve("google", modelId, config);
+}
+function ollama(modelId, config) {
+  return registry.resolve("ollama", modelId, config);
+}
+registry.register(
+  "vertex",
+  (modelId, config) => new VertexAIProvider(
+    modelId,
+    config
+  )
+);
+function vertex(modelId, config) {
+  return registry.resolve("vertex", modelId, config);
+}
+function openaiRealtime(modelId, config) {
+  return new OpenAIRealtimeProvider(modelId, config);
+}
+function googleLive(modelId, config) {
+  return new GoogleLiveProvider(modelId, config);
+}
+
+// src/tools/define-tool.ts
+function defineTool(config) {
+  return {
+    name: config.name,
+    description: config.description,
+    parameters: config.parameters,
+    execute: config.execute,
+    cache: config.cache,
+    sandbox: config.sandbox,
+    requiresApproval: config.requiresApproval
+  };
+}
+
+// src/storage/sqlite.ts
+import { createRequire as createRequire10 } from "module";
+var _require10 = createRequire10(import.meta.url);
+var SqliteStorage = class {
+  db;
+  constructor(dbPath) {
+    try {
+      const Database = _require10("better-sqlite3");
+      this.db = new Database(dbPath);
+      this.db.pragma("journal_mode = WAL");
+      this.db.exec(`
+        CREATE TABLE IF NOT EXISTS kv_store (
+          namespace TEXT NOT NULL,
+          key TEXT NOT NULL,
+          value TEXT NOT NULL,
+          updated_at TEXT DEFAULT (datetime('now')),
+          PRIMARY KEY (namespace, key)
+        )
+      `);
+    } catch {
+      throw new Error(
+        "better-sqlite3 is required for SqliteStorage. Install it: npm install better-sqlite3"
+      );
+    }
+  }
+  async get(namespace, key) {
+    const row = this.db.prepare("SELECT value FROM kv_store WHERE namespace = ? AND key = ?").get(namespace, key);
+    if (!row) return null;
+    return JSON.parse(row.value);
+  }
+  async set(namespace, key, value) {
+    this.db.prepare(
+      `INSERT INTO kv_store (namespace, key, value, updated_at)
+         VALUES (?, ?, ?, datetime('now'))
+         ON CONFLICT(namespace, key)
+         DO UPDATE SET value = excluded.value, updated_at = datetime('now')`
+    ).run(namespace, key, JSON.stringify(value));
+  }
+  async delete(namespace, key) {
+    this.db.prepare("DELETE FROM kv_store WHERE namespace = ? AND key = ?").run(namespace, key);
+  }
+  async list(namespace, prefix) {
+    const rows = prefix ? this.db.prepare(
+      "SELECT key, value FROM kv_store WHERE namespace = ? AND key LIKE ?"
+    ).all(namespace, `${prefix}%`) : this.db.prepare("SELECT key, value FROM kv_store WHERE namespace = ?").all(namespace);
+    return rows.map((row) => ({
+      key: row.key,
+      value: JSON.parse(row.value)
+    }));
+  }
+  async close() {
+    this.db.close();
+  }
+};
+
+// src/storage/postgres.ts
+import { createRequire as createRequire11 } from "module";
+var _require11 = createRequire11(import.meta.url);
+var PostgresStorage = class {
+  pool;
+  constructor(connectionString) {
+    try {
+      const { Pool } = _require11("pg");
+      this.pool = new Pool({ connectionString });
+    } catch {
+      throw new Error(
+        "pg is required for PostgresStorage. Install it: npm install pg"
+      );
+    }
+  }
+  async initialize() {
+    await this.pool.query(`
+      CREATE TABLE IF NOT EXISTS kv_store (
+        namespace TEXT NOT NULL,
+        key TEXT NOT NULL,
+        value JSONB NOT NULL,
+        updated_at TIMESTAMPTZ DEFAULT NOW(),
+        PRIMARY KEY (namespace, key)
+      )
+    `);
+  }
+  async get(namespace, key) {
+    const result = await this.pool.query(
+      "SELECT value FROM kv_store WHERE namespace = $1 AND key = $2",
+      [namespace, key]
+    );
+    if (result.rows.length === 0) return null;
+    return result.rows[0].value;
+  }
+  async set(namespace, key, value) {
+    await this.pool.query(
+      `INSERT INTO kv_store (namespace, key, value, updated_at)
+       VALUES ($1, $2, $3, NOW())
+       ON CONFLICT (namespace, key)
+       DO UPDATE SET value = EXCLUDED.value, updated_at = NOW()`,
+      [namespace, key, JSON.stringify(value)]
+    );
+  }
+  async delete(namespace, key) {
+    await this.pool.query(
+      "DELETE FROM kv_store WHERE namespace = $1 AND key = $2",
+      [namespace, key]
+    );
+  }
+  async list(namespace, prefix) {
+    const result = prefix ? await this.pool.query(
       "SELECT key, value FROM kv_store WHERE namespace = $1 AND key LIKE $2",
       [namespace, `${prefix}%`]
     ) : await this.pool.query(
@@ -3144,15 +3883,15 @@ var PostgresStorage = class {
 };
 
 // src/storage/mongodb.ts
-import { createRequire as createRequire10 } from "module";
-var _require10 = createRequire10(import.meta.url);
+import { createRequire as createRequire12 } from "module";
+var _require12 = createRequire12(import.meta.url);
 var MongoDBStorage = class {
   constructor(uri, dbName = "radaros", collectionName = "kv_store") {
     this.uri = uri;
     this.dbName = dbName;
     this.collectionName = collectionName;
     try {
-      const { MongoClient } = _require10("mongodb");
+      const { MongoClient } = _require12("mongodb");
       this.client = new MongoClient(uri);
     } catch {
       throw new Error(
@@ -3312,8 +4051,8 @@ var InMemoryVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/pgvector.ts
-import { createRequire as createRequire11 } from "module";
-var _require11 = createRequire11(import.meta.url);
+import { createRequire as createRequire13 } from "module";
+var _require13 = createRequire13(import.meta.url);
 var PgVectorStore = class extends BaseVectorStore {
   pool;
   dimensions;
@@ -3322,7 +4061,7 @@ var PgVectorStore = class extends BaseVectorStore {
     super(embedder);
     this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
     try {
-      const { Pool } = _require11("pg");
+      const { Pool } = _require13("pg");
       this.pool = new Pool({ connectionString: config.connectionString });
     } catch {
       throw new Error(
@@ -3441,9 +4180,9 @@ var PgVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/qdrant.ts
-import { createRequire as createRequire12 } from "module";
+import { createRequire as createRequire14 } from "module";
 import { createHash } from "crypto";
-var _require12 = createRequire12(import.meta.url);
+var _require14 = createRequire14(import.meta.url);
 var UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 function stringToUUID(str) {
   const hex = createHash("md5").update(str).digest("hex");
@@ -3468,7 +4207,7 @@ var QdrantVectorStore = class extends BaseVectorStore {
     super(embedder);
     this.dimensions = config.dimensions ?? embedder?.dimensions ?? 1536;
     try {
-      const { QdrantClient } = _require12("@qdrant/js-client-rest");
+      const { QdrantClient } = _require14("@qdrant/js-client-rest");
       this.client = new QdrantClient({
         url: config.url ?? "http://localhost:6333",
         apiKey: config.apiKey,
@@ -3601,8 +4340,8 @@ var QdrantVectorStore = class extends BaseVectorStore {
 };
 
 // src/vector/mongodb.ts
-import { createRequire as createRequire13 } from "module";
-var _require13 = createRequire13(import.meta.url);
+import { createRequire as createRequire15 } from "module";
+var _require15 = createRequire15(import.meta.url);
 var MongoDBVectorStore = class extends BaseVectorStore {
   client;
   db;
@@ -3614,7 +4353,7 @@ var MongoDBVectorStore = class extends BaseVectorStore {
     this.indexName = config.indexName ?? "vector_index";
     this.dbName = config.dbName ?? "radaros_vectors";
     try {
-      const { MongoClient } = _require13("mongodb");
+      const { MongoClient } = _require15("mongodb");
       this.client = new MongoClient(config.uri);
     } catch {
       throw new Error(
@@ -3785,8 +4524,8 @@ function cosine(a, b) {
 }
 
 // src/vector/embeddings/openai.ts
-import { createRequire as createRequire14 } from "module";
-var _require14 = createRequire14(import.meta.url);
+import { createRequire as createRequire16 } from "module";
+var _require16 = createRequire16(import.meta.url);
 var MODEL_DIMENSIONS = {
   "text-embedding-3-small": 1536,
   "text-embedding-3-large": 3072,
@@ -3800,7 +4539,7 @@ var OpenAIEmbedding = class {
     this.model = config.model ?? "text-embedding-3-small";
     this.dimensions = config.dimensions ?? MODEL_DIMENSIONS[this.model] ?? 1536;
     try {
-      const mod = _require14("openai");
+      const mod = _require16("openai");
       const OpenAI = mod.default ?? mod;
       this.client = new OpenAI({
         apiKey: config.apiKey ?? process.env.OPENAI_API_KEY,
@@ -3831,8 +4570,8 @@ var OpenAIEmbedding = class {
 };
 
 // src/vector/embeddings/google.ts
-import { createRequire as createRequire15 } from "module";
-var _require15 = createRequire15(import.meta.url);
+import { createRequire as createRequire17 } from "module";
+var _require17 = createRequire17(import.meta.url);
 var MODEL_DIMENSIONS2 = {
   "text-embedding-004": 768,
   "embedding-001": 768
@@ -3845,7 +4584,7 @@ var GoogleEmbedding = class {
     this.model = config.model ?? "text-embedding-004";
     this.dimensions = config.dimensions ?? MODEL_DIMENSIONS2[this.model] ?? 768;
     try {
-      const { GoogleGenAI } = _require15("@google/genai");
+      const { GoogleGenAI } = _require17("@google/genai");
       this.ai = new GoogleGenAI({
         apiKey: config.apiKey ?? process.env.GOOGLE_API_KEY
       });
@@ -3879,15 +4618,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 +4856,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 +4885,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 +4902,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 +4917,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 +4927,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,66 +4998,110 @@ ${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);
+    }
   }
 };
 
 // src/memory/user-memory.ts
-import { v4 as uuidv45 } from "uuid";
+import { v4 as uuidv46 } from "uuid";
 import { z as z2 } from "zod";
 var USER_MEMORY_NS = "memory:user";
 var EXTRACTION_PROMPT = `You are a memory extraction assistant. Analyze the conversation below and extract important facts about the user that would be useful for future personalization.
@@ -4082,7 +5156,7 @@ var UserMemory = class {
       const normalized = fact.trim();
       if (!normalized || existingSet.has(normalized.toLowerCase())) continue;
       newFacts.push({
-        id: uuidv45(),
+        id: uuidv46(),
         fact: normalized,
         createdAt: /* @__PURE__ */ new Date(),
         source
@@ -4556,6 +5630,258 @@ var A2ARemoteAgent = class {
   }
 };
 
+// src/voice/voice-agent.ts
+import { EventEmitter as EventEmitter4 } from "events";
+import { v4 as uuidv47 } from "uuid";
+var VoiceSessionImpl = class extends EventEmitter4 {
+  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_${uuidv47()}`;
+    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/toolkits/base.ts
 var Toolkit = class {
 };
@@ -4666,8 +5992,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 +6005,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 +6016,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 +6547,14 @@ export {
   A2ARemoteAgent,
   Agent,
   AnthropicProvider,
+  ApprovalManager,
+  BM25Index,
   BaseVectorStore,
   DuckDuckGoToolkit,
   EventBus,
   GmailToolkit,
   GoogleEmbedding,
+  GoogleLiveProvider,
   GoogleProvider,
   HackerNewsToolkit,
   InMemoryStorage,
@@ -5241,10 +6570,12 @@ export {
   OllamaProvider,
   OpenAIEmbedding,
   OpenAIProvider,
+  OpenAIRealtimeProvider,
   PgVectorStore,
   PostgresStorage,
   QdrantVectorStore,
   RunContext,
+  Sandbox,
   SessionManager,
   SqliteStorage,
   Team,
@@ -5253,6 +6584,7 @@ export {
   Toolkit,
   UserMemory,
   VertexAIProvider,
+  VoiceAgent,
   WebSearchToolkit,
   WhatsAppToolkit,
   Workflow,
@@ -5260,10 +6592,14 @@ export {
   defineTool,
   getTextContent,
   google,
+  googleLive,
   isMultiModal,
   ollama,
   openai,
+  openaiRealtime,
+  reciprocalRankFusion,
   registry,
+  resolveSandboxConfig,
   vertex,
   withRetry
 };