@agenticmail/enterprise 0.5.367 → 0.5.369

package/dist/chunk-LICMHA7V.js

@@ -0,0 +1,2583 @@
+import {
+  errorResult,
+  jsonResult,
+  readNumberParam,
+  readStringParam,
+  textResult
+} from "./chunk-ZB3VC2MR.js";
+
+// src/agent-tools/tools/browser.ts
+import * as path from "path";
+import * as os from "os";
+import { promises as fs, existsSync } from "fs";
+var BROWSER_ACTIONS = ["navigate", "screenshot", "click", "type", "scroll", "evaluate", "content", "close"];
+var DEFAULT_VIEWPORT_WIDTH = 1280;
+var DEFAULT_VIEWPORT_HEIGHT = 720;
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DEFAULT_MAX_CONTEXTS = 5;
+var DEFAULT_IDLE_TIMEOUT_MS = 5 * 6e4;
+var browsers = { headless: null, headed: null, chrome: null };
+var agentContexts = /* @__PURE__ */ new Map();
+var idleCleanupTimer = null;
+function findChromePath() {
+  const candidates = [
+    // macOS
+    "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
+    "/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary",
+    // Linux
+    "/usr/bin/google-chrome",
+    "/usr/bin/google-chrome-stable",
+    "/usr/bin/chromium-browser",
+    "/snap/bin/chromium",
+    // Windows (common paths)
+    "C:\\Program Files\\Google\\Chrome\\Application\\chrome.exe",
+    "C:\\Program Files (x86)\\Google\\Chrome\\Application\\chrome.exe"
+  ];
+  for (const p of candidates) {
+    try {
+      if (existsSync(p)) return p;
+    } catch {
+    }
+  }
+  return null;
+}
+function startIdleCleanup() {
+  if (idleCleanupTimer) return;
+  idleCleanupTimer = setInterval(function() {
+    var now = Date.now();
+    for (var [key, ctx] of agentContexts) {
+      var timeout = key.endsWith(":chrome") || key.endsWith(":headed") ? 2 * 60 * 6e4 : DEFAULT_IDLE_TIMEOUT_MS;
+      if (now - ctx.lastUsed > timeout) {
+        ctx.context.close().catch(() => {
+        });
+        agentContexts.delete(key);
+      }
+    }
+    for (var mode of ["headless", "headed", "chrome"]) {
+      var prefix = `:${mode}`;
+      var hasContexts = false;
+      for (var [key] of agentContexts) {
+        if (key.endsWith(prefix)) {
+          hasContexts = true;
+          break;
+        }
+      }
+      if (!hasContexts && browsers[mode]) {
+        browsers[mode].close().catch(() => {
+        });
+        browsers[mode] = null;
+      }
+    }
+    if (!browsers.headless && !browsers.headed && !browsers.chrome && idleCleanupTimer) {
+      clearInterval(idleCleanupTimer);
+      idleCleanupTimer = null;
+    }
+  }, 6e4);
+  if (idleCleanupTimer && typeof idleCleanupTimer === "object" && "unref" in idleCleanupTimer) {
+    idleCleanupTimer.unref();
+  }
+}
+async function ensureBrowser(headless, agentId, useChrome) {
+  var mode = useChrome ? "chrome" : headless ? "headless" : "headed";
+  var contextKey = `${agentId}:${mode}`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (agentContexts.size >= DEFAULT_MAX_CONTEXTS) {
+    var oldestId = null;
+    var oldestTime = Infinity;
+    for (var [id, ctx] of agentContexts) {
+      if (ctx.lastUsed < oldestTime) {
+        oldestTime = ctx.lastUsed;
+        oldestId = id;
+      }
+    }
+    if (oldestId) {
+      var evicted = agentContexts.get(oldestId);
+      if (evicted) {
+        evicted.context.close().catch(() => {
+        });
+        agentContexts.delete(oldestId);
+      }
+    }
+  }
+  try {
+    var pw = await import("playwright");
+    if (mode === "headless") {
+      if (!browsers[mode]) {
+        browsers[mode] = await pw.chromium.launch({ headless: true });
+        console.log(`[browser] Launched headless Chromium`);
+        startIdleCleanup();
+      }
+      var context = await browsers[mode].newContext({
+        viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT },
+        userAgent: "AgenticMail-Agent/1.0"
+      });
+      var page = await context.newPage();
+      agentContexts.set(contextKey, { context, page, lastUsed: Date.now() });
+      return { page };
+    }
+    const { mkdirSync } = await import("fs");
+    const { join: join4 } = await import("path");
+    const userDataDir = join4("/tmp", "agenticmail-browser", agentId, mode);
+    mkdirSync(userDataDir, { recursive: true });
+    var launchArgs = [
+      "--disable-blink-features=AutomationControlled",
+      // NOTE: do NOT use --use-fake-device-for-media-stream — it overrides real audio devices
+      // We need Chrome to use the system's real audio input (BlackHole/VB-CABLE) for meeting voice
+      "--use-fake-ui-for-media-stream",
+      // Auto-accept mic/camera permission prompts
+      "--auto-select-desktop-capture-source=Entire screen",
+      "--enable-usermedia-screen-capturing",
+      "--disable-infobars",
+      "--no-first-run",
+      "--no-default-browser-check"
+    ];
+    var launchOpts = {
+      headless: false,
+      args: launchArgs,
+      viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT },
+      userAgent: "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/145.0.0.0 Safari/537.36",
+      permissions: ["microphone", "camera", "notifications"]
+    };
+    if (mode === "chrome") {
+      const chromePath = findChromePath();
+      if (!chromePath) {
+        throw new Error("Native Google Chrome not found. Install: brew install --cask google-chrome");
+      }
+      launchOpts.executablePath = chromePath;
+    }
+    var persistentContext = await pw.chromium.launchPersistentContext(userDataDir, launchOpts);
+    await persistentContext.addInitScript(() => {
+      Object.defineProperty(navigator, "webdriver", { get: () => void 0 });
+    });
+    var page = persistentContext.pages()[0] || await persistentContext.newPage();
+    console.log(`[browser] Launched ${mode} persistent browser for ${agentId} (profile: ${userDataDir})`);
+    agentContexts.set(contextKey, { context: persistentContext, page, lastUsed: Date.now() });
+    startIdleCleanup();
+    return { page };
+  } catch (error) {
+    throw new Error(
+      "Browser launch failed. " + (mode === "chrome" ? "Ensure Google Chrome is installed." : "Install Playwright: npm install playwright") + "\nError: " + (error.message || "unknown")
+    );
+  }
+}
+var activeSshTunnels = /* @__PURE__ */ new Map();
+async function ensureSshTunnel(tunnelCmd, agentId) {
+  var tunnelKey = `ssh-tunnel:${agentId}`;
+  var existing = activeSshTunnels.get(tunnelKey);
+  if (existing && !existing.killed) {
+    try {
+      existing.kill(0);
+      return;
+    } catch {
+      activeSshTunnels.delete(tunnelKey);
+    }
+  }
+  console.log(`[browser] Establishing SSH tunnel for ${agentId}: ${tunnelCmd}`);
+  const { spawn } = await import("child_process");
+  var args = tunnelCmd.replace(/^ssh\s+/, "").split(/\s+/).filter(Boolean);
+  if (!args.includes("-N")) args.push("-N");
+  if (!args.some((a) => a.includes("StrictHostKeyChecking"))) {
+    args.push("-o", "StrictHostKeyChecking=accept-new");
+  }
+  if (!args.some((a) => a.includes("ServerAliveInterval"))) {
+    args.push("-o", "ServerAliveInterval=30");
+  }
+  var proc = spawn("ssh", args, { stdio: "pipe", detached: false });
+  activeSshTunnels.set(tunnelKey, proc);
+  proc.on("exit", () => {
+    activeSshTunnels.delete(tunnelKey);
+  });
+  proc.on("error", (err) => {
+    console.error(`[browser] SSH tunnel error for ${agentId}:`, err.message);
+    activeSshTunnels.delete(tunnelKey);
+  });
+  var localPortMatch = tunnelCmd.match(/-L\s*(\d+):/);
+  if (localPortMatch) {
+    var port = parseInt(localPortMatch[1]);
+    var maxWait = 15e3;
+    var start = Date.now();
+    const net = await import("net");
+    while (Date.now() - start < maxWait) {
+      var connected = await new Promise((resolve) => {
+        var sock = net.connect({ port, host: "127.0.0.1" }, () => {
+          sock.destroy();
+          resolve(true);
+        });
+        sock.on("error", () => resolve(false));
+        sock.setTimeout(1e3, () => {
+          sock.destroy();
+          resolve(false);
+        });
+      });
+      if (connected) {
+        console.log(`[browser] SSH tunnel ready on port ${port} for ${agentId}`);
+        return;
+      }
+      await new Promise((r) => setTimeout(r, 500));
+    }
+    console.warn(`[browser] SSH tunnel port ${port} not ready after ${maxWait}ms \u2014 proceeding anyway`);
+  } else {
+    await new Promise((r) => setTimeout(r, 3e3));
+  }
+}
+async function connectRemoteCDP(cfg, agentId) {
+  var contextKey = `${agentId}:remote-cdp`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (cfg.sshTunnel) {
+    await ensureSshTunnel(cfg.sshTunnel, agentId);
+  }
+  var pw = await import("playwright");
+  var cdpUrl = cfg.cdpUrl;
+  if (!cdpUrl) throw new Error("CDP WebSocket URL not configured. Go to Settings \u2192 Browser \u2192 Remote CDP and enter the WebSocket URL.");
+  if (!cdpUrl.startsWith("ws://") && !cdpUrl.startsWith("wss://")) {
+    var httpUrl = cdpUrl.startsWith("http") ? cdpUrl : `http://${cdpUrl}`;
+    if (!httpUrl.includes("/json/version")) httpUrl = httpUrl.replace(/\/$/, "") + "/json/version";
+    try {
+      var resp = await fetch(httpUrl, {
+        signal: AbortSignal.timeout(cfg.cdpTimeout || 1e4),
+        headers: cfg.cdpAuthToken ? { "Authorization": `Bearer ${cfg.cdpAuthToken}` } : {}
+      });
+      var versionData = await resp.json();
+      cdpUrl = versionData.webSocketDebuggerUrl;
+      if (!cdpUrl) throw new Error("No webSocketDebuggerUrl in /json/version response");
+      console.log(`[browser] Auto-discovered CDP WebSocket: ${cdpUrl}`);
+    } catch (e) {
+      throw new Error(`Cannot discover CDP endpoint from ${httpUrl}: ${e.message}. Provide a full ws:// URL instead.`);
+    }
+  }
+  var timeout = cfg.cdpTimeout || 3e4;
+  var headers = {};
+  if (cfg.cdpAuthToken) headers["Authorization"] = `Bearer ${cfg.cdpAuthToken}`;
+  console.log(`[browser] Connecting to remote CDP: ${cdpUrl} (agent: ${agentId})`);
+  var browser = await pw.chromium.connectOverCDP(cdpUrl, { timeout, headers });
+  var contexts = browser.contexts();
+  var context = contexts[0] || await browser.newContext({
+    viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT }
+  });
+  var page = context.pages()[0] || await context.newPage();
+  agentContexts.set(contextKey, { context: browser, page, lastUsed: Date.now() });
+  startIdleCleanup();
+  console.log(`[browser] Connected to remote CDP for ${agentId}`);
+  return { page };
+}
+async function connectBrowserless(cfg, agentId) {
+  var contextKey = `${agentId}:browserless`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (!cfg.browserlessToken) throw new Error("Browserless API token not configured. Go to Settings \u2192 Browser and enter your token.");
+  var pw = await import("playwright");
+  var endpoint = cfg.browserlessEndpoint || "wss://chrome.browserless.io";
+  if (endpoint.startsWith("http://")) endpoint = endpoint.replace("http://", "ws://");
+  if (endpoint.startsWith("https://")) endpoint = endpoint.replace("https://", "wss://");
+  if (!endpoint.startsWith("ws://") && !endpoint.startsWith("wss://")) endpoint = "wss://" + endpoint;
+  var connectUrl = `${endpoint}?token=${encodeURIComponent(cfg.browserlessToken)}`;
+  if (cfg.browserlessStealth) connectUrl += "&stealth";
+  if (cfg.browserlessProxy) connectUrl += `&--proxy-server=${encodeURIComponent(cfg.browserlessProxy)}`;
+  console.log(`[browser] Connecting to Browserless for ${agentId}`);
+  var browser = await pw.chromium.connectOverCDP(connectUrl, { timeout: 3e4 });
+  var context = await browser.newContext({
+    viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT }
+  });
+  var page = await context.newPage();
+  agentContexts.set(contextKey, { context: browser, page, lastUsed: Date.now() });
+  startIdleCleanup();
+  console.log(`[browser] Connected to Browserless for ${agentId}`);
+  return { page };
+}
+async function connectBrowserbase(cfg, agentId) {
+  var contextKey = `${agentId}:browserbase`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (!cfg.browserbaseApiKey) throw new Error("Browserbase API key not configured. Go to Settings \u2192 Browser and enter your API key.");
+  if (!cfg.browserbaseProjectId) throw new Error("Browserbase Project ID not configured. Go to Settings \u2192 Browser and enter your project ID.");
+  console.log(`[browser] Creating Browserbase session for ${agentId}`);
+  var sessionResp = await fetch("https://www.browserbase.com/v1/sessions", {
+    method: "POST",
+    headers: { "x-bb-api-key": cfg.browserbaseApiKey, "Content-Type": "application/json" },
+    body: JSON.stringify({
+      projectId: cfg.browserbaseProjectId,
+      browserSettings: {
+        recordSession: cfg.browserbaseRecording !== false
+      },
+      keepAlive: cfg.browserbaseKeepAlive || false
+    }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!sessionResp.ok) {
+    var errBody = await sessionResp.text().catch(() => "");
+    throw new Error(`Browserbase session creation failed (${sessionResp.status}): ${errBody}`);
+  }
+  var sessionData = await sessionResp.json();
+  var connectUrl = sessionData.connectUrl || `wss://connect.browserbase.com?apiKey=${cfg.browserbaseApiKey}&sessionId=${sessionData.id}`;
+  var pw = await import("playwright");
+  var browser = await pw.chromium.connectOverCDP(connectUrl, { timeout: 3e4 });
+  var context = browser.contexts()[0] || await browser.newContext({
+    viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT }
+  });
+  var page = context.pages()[0] || await context.newPage();
+  agentContexts.set(contextKey, { context: browser, page, lastUsed: Date.now() });
+  startIdleCleanup();
+  console.log(`[browser] Connected to Browserbase session ${sessionData.id} for ${agentId}`);
+  return { page };
+}
+async function connectSteel(cfg, agentId) {
+  var contextKey = `${agentId}:steel`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (!cfg.steelApiKey) throw new Error("Steel API key not configured. Go to Settings \u2192 Browser and enter your API key.");
+  var endpoint = cfg.steelEndpoint || "https://api.steel.dev";
+  var duration = (cfg.steelSessionDuration || 15) * 60;
+  console.log(`[browser] Creating Steel session for ${agentId}`);
+  var sessionResp = await fetch(`${endpoint}/v1/sessions`, {
+    method: "POST",
+    headers: { "Authorization": `Bearer ${cfg.steelApiKey}`, "Content-Type": "application/json" },
+    body: JSON.stringify({ timeout: duration, useProxy: false }),
+    signal: AbortSignal.timeout(15e3)
+  });
+  if (!sessionResp.ok) {
+    var errBody = await sessionResp.text().catch(() => "");
+    throw new Error(`Steel session creation failed (${sessionResp.status}): ${errBody}`);
+  }
+  var sessionData = await sessionResp.json();
+  var connectUrl = sessionData.connectUrl || sessionData.websocketUrl || sessionData.cdpUrl;
+  if (!connectUrl) throw new Error("Steel session created but no connection URL returned");
+  var pw = await import("playwright");
+  var browser = await pw.chromium.connectOverCDP(connectUrl, { timeout: 3e4 });
+  var context = browser.contexts()[0] || await browser.newContext({
+    viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT }
+  });
+  var page = context.pages()[0] || await context.newPage();
+  agentContexts.set(contextKey, { context: browser, page, lastUsed: Date.now() });
+  startIdleCleanup();
+  console.log(`[browser] Connected to Steel session ${sessionData.id} for ${agentId}`);
+  return { page };
+}
+async function connectScrapingBee(cfg, agentId) {
+  var contextKey = `${agentId}:scrapingbee`;
+  var existing = agentContexts.get(contextKey);
+  if (existing) {
+    existing.lastUsed = Date.now();
+    return { page: existing.page };
+  }
+  if (!cfg.scrapingbeeApiKey) throw new Error("ScrapingBee API key not configured. Go to Settings \u2192 Browser and enter your API key.");
+  var pw = await import("playwright");
+  var proxyUrl = `http://${cfg.scrapingbeeApiKey}:${cfg.scrapingbeeJsRendering !== false ? "render_js" : "norender"}${cfg.scrapingbeePremiumProxy ? "&premium_proxy=true" : ""}${cfg.scrapingbeeCountry ? `&country_code=${cfg.scrapingbeeCountry}` : ""}@proxy.scrapingbee.com:8886`;
+  console.log(`[browser] Launching browser with ScrapingBee proxy for ${agentId}`);
+  var browser = await pw.chromium.launch({
+    headless: true,
+    proxy: { server: proxyUrl }
+  });
+  var context = await browser.newContext({
+    viewport: { width: DEFAULT_VIEWPORT_WIDTH, height: DEFAULT_VIEWPORT_HEIGHT },
+    ignoreHTTPSErrors: true
+    // ScrapingBee proxy uses self-signed certs
+  });
+  var page = await context.newPage();
+  agentContexts.set(contextKey, { context: browser, page, lastUsed: Date.now() });
+  startIdleCleanup();
+  console.log(`[browser] ScrapingBee proxy browser ready for ${agentId}`);
+  return { page };
+}
+async function ensureBrowserFromConfig(cfg, agentId, modeOverride) {
+  var provider = cfg?.provider || "local";
+  if (modeOverride === "chrome" || modeOverride === "headed") {
+    return ensureBrowser(false, agentId, modeOverride === "chrome");
+  }
+  switch (provider) {
+    case "remote-cdp":
+      return connectRemoteCDP(cfg, agentId);
+    case "browserless":
+      return connectBrowserless(cfg, agentId);
+    case "browserbase":
+      return connectBrowserbase(cfg, agentId);
+    case "steel":
+      return connectSteel(cfg, agentId);
+    case "scrapingbee":
+      return connectScrapingBee(cfg, agentId);
+    case "local":
+    default:
+      return ensureBrowser(cfg?.headless !== false, agentId, false);
+  }
+}
+function createBrowserTool(options) {
+  var browserConfig = options?.config?.browser;
+  if (browserConfig?.enabled === false) return null;
+  var headless = browserConfig?.headless !== false;
+  var timeoutMs = browserConfig?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+  var agentId = options?.agentId || "default";
+  var sandboxed = options?.sandboxed ?? false;
+  var ssrfGuard = options?.ssrfGuard;
+  var providerConfig = browserConfig;
+  return {
+    name: "browser",
+    label: "Browser",
+    description: "Automate a browser for web interaction. Supports navigation, screenshots, clicking, typing, scrolling, and JavaScript evaluation. Requires Playwright.",
+    category: "browser",
+    risk: "critical",
+    parameters: {
+      type: "object",
+      properties: {
+        action: {
+          type: "string",
+          description: "Action to perform: navigate, screenshot, click, type, scroll, evaluate, content, close.",
+          enum: BROWSER_ACTIONS
+        },
+        url: { type: "string", description: "URL to navigate to (for navigate action)." },
+        selector: { type: "string", description: "CSS selector for click/type actions." },
+        text: { type: "string", description: "Text to type (for type action)." },
+        script: { type: "string", description: "JavaScript to evaluate in page context." },
+        direction: { type: "string", description: "Scroll direction: up or down." },
+        pixels: { type: "number", description: "Pixels to scroll (default 500)." },
+        headless: { type: "string", description: 'Browser mode: "true" (default) = headless Chromium. "false" = visible Chromium window (use for Google Meet, Google services, and anything that needs to persist login). Do NOT use "chrome" unless explicitly told to.' }
+      },
+      required: ["action"]
+    },
+    execute: async function(_toolCallId, args) {
+      var params = args;
+      var action = readStringParam(params, "action", { required: true });
+      var useChrome = params.headless === "chrome";
+      var useHeadless = useChrome ? false : params.headless === "false" || params.headless === false ? false : headless;
+      if (action === "close") {
+        for (var mode of ["headless", "headed"]) {
+          var key = `${agentId}:${mode}`;
+          var ctx = agentContexts.get(key);
+          if (ctx) {
+            ctx.context.close().catch(() => {
+            });
+            agentContexts.delete(key);
+          }
+        }
+        return textResult("Browser closed.");
+      }
+      try {
+        if (!useChrome && action !== "close") {
+          var chromeKey = `${agentId}:chrome`;
+          if (agentContexts.has(chromeKey) && browsers["chrome"]) {
+            useChrome = true;
+            useHeadless = false;
+          }
+        }
+        var modeOverride = useChrome ? "chrome" : !useHeadless ? "headed" : void 0;
+        var hasCloudProvider = providerConfig?.provider && providerConfig.provider !== "local";
+        var { page } = hasCloudProvider && !modeOverride ? await ensureBrowserFromConfig(providerConfig, agentId) : await ensureBrowser(useHeadless, agentId, useChrome);
+        switch (action) {
+          case "navigate": {
+            var url = readStringParam(params, "url", { required: true });
+            if (ssrfGuard && !url.startsWith("file://") && !url.startsWith("file:///")) {
+              try {
+                await ssrfGuard.validateUrl(url);
+              } catch (err) {
+                return errorResult("Navigation blocked: " + err.message);
+              }
+            }
+            if (/meet\.google\.com\/[a-z]/.test(url)) {
+              const tools = globalThis.__currentSessionTools;
+              const meetJoin = tools?.find((t) => t.name === "meeting_join");
+              if (meetJoin?.execute) {
+                console.log(`[browser] Intercepted Meet URL \u2014 redirecting to meeting_join: ${url}`);
+                return await meetJoin.execute("meeting_join", { url });
+              }
+              return errorResult(
+                'Cannot navigate to Google Meet URLs. Use meeting_join(url: "' + url + '") instead. Call request_tools(sets: ["meeting_lifecycle", "meeting_voice"]) first if meeting_join is not available.'
+              );
+            }
+            await page.goto(url, { timeout: timeoutMs, waitUntil: "domcontentloaded" });
+            var title = await page.title();
+            return jsonResult({ action: "navigate", url, title, status: "loaded" });
+          }
+          case "screenshot": {
+            var buf = await page.screenshot({ type: "png", fullPage: false });
+            var screenshotDir = path.join(os.tmpdir(), "agenticmail-screenshots");
+            await fs.mkdir(screenshotDir, { recursive: true });
+            var screenshotFile = `screenshot-${Date.now()}.png`;
+            var screenshotPath = path.join(screenshotDir, screenshotFile);
+            await fs.writeFile(screenshotPath, buf);
+            return {
+              content: [
+                { type: "text", text: `Screenshot of: ${page.url()}
+Saved to: ${screenshotPath}
+Filename: ${screenshotFile}
+Size: ${buf.length} bytes` },
+                { type: "image", data: buf.toString("base64"), mimeType: "image/png" }
+              ]
+            };
+          }
+          case "click": {
+            var selector = readStringParam(params, "selector", { required: true });
+            await page.click(selector, { timeout: timeoutMs });
+            return textResult("Clicked: " + selector);
+          }
+          case "type": {
+            var selector = readStringParam(params, "selector", { required: true });
+            var text = readStringParam(params, "text", { required: true });
+            await page.fill(selector, text, { timeout: timeoutMs });
+            return textResult("Typed into: " + selector);
+          }
+          case "scroll": {
+            var direction = readStringParam(params, "direction") || "down";
+            var pixels = readNumberParam(params, "pixels", { integer: true }) ?? 500;
+            var delta = direction === "up" ? -pixels : pixels;
+            await page.evaluate(function(d) {
+              window.scrollBy(0, d);
+            }, delta);
+            return textResult("Scrolled " + direction + " " + pixels + "px");
+          }
+          case "evaluate": {
+            if (sandboxed) {
+              return errorResult("JavaScript evaluation is disabled in sandboxed mode.");
+            }
+            var script = readStringParam(params, "script", { required: true });
+            var result = await page.evaluate(script);
+            return jsonResult({ action: "evaluate", result });
+          }
+          case "content": {
+            var html = await page.content();
+            var title = await page.title();
+            var textContent = html.replace(/<script[\s\S]*?<\/script>/gi, "").replace(/<style[\s\S]*?<\/style>/gi, "").replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim();
+            if (textContent.length > 5e4) textContent = textContent.slice(0, 5e4) + "... (truncated)";
+            return jsonResult({ action: "content", title, url: page.url(), text: textContent });
+          }
+          default:
+            return errorResult("Unknown browser action: " + action);
+        }
+      } catch (err) {
+        return errorResult("Browser error: " + (err.message || "unknown"));
+      }
+    }
+  };
+}
+
+// src/engine/meeting-monitor.ts
+var MeetingMonitor = class {
+  page;
+  agentId;
+  sessionId;
+  sendMessage;
+  flushIntervalMs;
+  onMeetingEnd;
+  sendChatIndicator;
+  flushTimer = null;
+  running = false;
+  _lastCaptionCount = 0;
+  _lastChatCount = 0;
+  consecutiveEmpty = 0;
+  consecutiveSendFailures = 0;
+  /** Pending captions accumulated across flush cycles (for debouncing) */
+  pendingCaptions = [];
+  /** Pending chat messages (chat is NOT debounced — always flush immediately) */
+  pendingChat = [];
+  /** Timestamp of last new caption arrival — used for silence gap detection */
+  lastCaptionArrival = 0;
+  /** Minimum silence gap in ms before flushing captions (wait for speaker to finish) */
+  silenceGapMs = 2e3;
+  /** Minimum total caption text length to flush (skip filler fragments) */
+  minCaptionLength = 20;
+  constructor(config) {
+    this.page = config.page;
+    this.agentId = config.agentId;
+    this.sessionId = config.sessionId;
+    this.sendMessage = config.sendMessage;
+    this.flushIntervalMs = config.flushIntervalMs || 2e3;
+    this.onMeetingEnd = config.onMeetingEnd;
+    this.sendChatIndicator = config.sendChatIndicator;
+  }
+  /**
+   * Start monitoring. Injects DOM observers and begins flushing.
+   */
+  async start() {
+    if (this.running) return;
+    this.running = true;
+    await this.injectObserver();
+    this.flushTimer = setInterval(() => this.flush().catch((err) => {
+      console.error(`[meeting-monitor:${this.agentId}] Flush error:`, err.message);
+    }), this.flushIntervalMs);
+    console.log(`[meeting-monitor:${this.agentId}] Started monitoring (flush every ${this.flushIntervalMs}ms)`);
+  }
+  /**
+   * Stop monitoring and clean up.
+   */
+  stop() {
+    this.running = false;
+    if (this.flushTimer) {
+      clearInterval(this.flushTimer);
+      this.flushTimer = null;
+    }
+    try {
+      import("./meeting-voice-intelligence-RZZCAD6G.js").then(({ getActiveVoiceIntelligence }) => {
+        getActiveVoiceIntelligence(this.agentId)?.stopAll();
+      }).catch(() => {
+      });
+    } catch {
+    }
+    console.log(`[meeting-monitor:${this.agentId}] Stopped`);
+  }
+  /**
+   * Inject MutationObserver-based caption/chat capture into the page.
+   * Uses window.__meetingBuffer as the shared state.
+   */
+  async injectObserver() {
+    await this.page.evaluate(() => {
+      window.__meetingBuffer = {
+        captions: [],
+        chat: [],
+        ended: false,
+        lastCaptionText: ""
+      };
+      const buf = window.__meetingBuffer;
+      const captionPoller = setInterval(() => {
+        if (!location.href.includes("meet.google.com")) {
+          buf.ended = true;
+          clearInterval(captionPoller);
+          return;
+        }
+        const bodyText = document.body.innerText || "";
+        if (bodyText.includes("You've left the meeting") || bodyText.includes("Call ended") || bodyText.includes("Return to home screen")) {
+          buf.ended = true;
+          clearInterval(captionPoller);
+          return;
+        }
+        const region = document.querySelector('[aria-label="Captions"]');
+        if (!region) return;
+        const entries = [];
+        const children = region.querySelectorAll(":scope > div");
+        for (const child of children) {
+          const divs = child.querySelectorAll(":scope > div");
+          if (divs.length >= 2) {
+            entries.push({
+              speaker: divs[0].textContent?.trim() || "",
+              text: divs[1].textContent?.trim() || ""
+            });
+          } else if (child.textContent?.trim()) {
+            entries.push({ speaker: "", text: child.textContent.trim() });
+          }
+        }
+        if (entries.length === 0) return;
+        const currentText = entries.map((e) => `${e.speaker}: ${e.text}`).join(" | ");
+        if (currentText === buf.lastCaptionText) return;
+        buf.lastCaptionText = currentText;
+        const ts = Date.now();
+        for (const e of entries) {
+          buf.captions.push({ speaker: e.speaker, text: e.text, ts });
+        }
+      }, 2e3);
+      const chatObserver = new MutationObserver(() => {
+        const panel = document.querySelector('[aria-label="Side panel"]') || document.querySelector('[aria-label*="In-call messages"]');
+        if (!panel) return;
+        const msgEls = panel.querySelectorAll("[data-message-text]");
+        const currentCount = msgEls.length;
+        const prevCount = window.__lastChatCount || 0;
+        if (currentCount > prevCount) {
+          for (let i = prevCount; i < currentCount; i++) {
+            const el = msgEls[i];
+            const text = el.getAttribute("data-message-text") || el.textContent?.trim() || "";
+            let sender = "";
+            const parentMsg = el.closest('[class*="message"]') || el.parentElement?.parentElement;
+            if (parentMsg) {
+              const nameEl = parentMsg.querySelector('[class*="sender"], [class*="name"], [data-sender-id]');
+              if (nameEl) sender = nameEl.textContent?.trim() || "";
+            }
+            if (text) {
+              buf.chat.push({ sender, text, ts: Date.now() });
+            }
+          }
+          window.__lastChatCount = currentCount;
+        }
+      });
+      chatObserver.observe(document.body, { childList: true, subtree: true });
+      let lastChatSnapshot = "";
+      setInterval(() => {
+        const panel = document.querySelector('[aria-label="Side panel"]') || document.querySelector('[aria-label*="In-call messages"]');
+        if (!panel) return;
+        const text = panel.innerText || "";
+        const lines = text.split("\n").filter(
+          (l) => l.trim().length > 0 && l.trim() !== "In-call messages" && !l.includes("Continuous chat") && !l.includes("Messages won't be saved") && !l.includes("No chat messages") && !l.includes("Send a message") && !l.includes("pin a message") && l.trim().length < 500
+        );
+        const snapshot = lines.join("\n");
+        if (snapshot !== lastChatSnapshot && snapshot.length > 0) {
+          lastChatSnapshot = snapshot;
+        }
+      }, 3e3);
+    });
+  }
+  /**
+   * Read buffered content from the page and decide whether to send to agent.
+   * 
+   * KEY DESIGN: Captions are DEBOUNCED. We accumulate them and only flush when:
+   * 1. There's a silence gap (no new captions for 8+ seconds) — speaker finished talking
+   * 2. Accumulated text is substantial enough (30+ chars) — skip "um", "eh" fragments
+   * 3. Hard cap of 60 seconds — flush regardless to prevent infinite buffering
+   * 
+   * Chat messages are NOT debounced — they flush immediately (someone typed a message).
+   */
+  async flush() {
+    if (!this.running) return;
+    let bufferData;
+    try {
+      bufferData = await this.page.evaluate(() => {
+        const buf = window.__meetingBuffer;
+        if (!buf) return { captions: [], chat: [], ended: false };
+        const result = {
+          captions: [...buf.captions],
+          chat: [...buf.chat],
+          ended: buf.ended
+        };
+        buf.captions = [];
+        buf.chat = [];
+        return result;
+      });
+    } catch (err) {
+      console.log(`[meeting-monitor:${this.agentId}] Page closed, stopping monitor`);
+      this.stop();
+      this.onMeetingEnd?.();
+      return;
+    }
+    if (bufferData.ended) {
+      try {
+        const { getActiveVoiceIntelligence, removeVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+        const voiceIntel = getActiveVoiceIntelligence(this.agentId);
+        if (voiceIntel) voiceIntel.stopAll();
+        removeVoiceIntelligence(this.agentId);
+      } catch {
+      }
+      if (this.pendingCaptions.length > 0) {
+        await this.sendUpdate(this.pendingCaptions, []);
+        this.pendingCaptions = [];
+      }
+      console.log(`[meeting-monitor:${this.agentId}] Meeting ended`);
+      try {
+        await this.sendMessage(
+          this.sessionId,
+          `[Meeting Monitor] The meeting has ended. Please save any meeting notes and email a summary to your manager if appropriate.`
+        );
+      } catch {
+      }
+      this.stop();
+      this.onMeetingEnd?.();
+      return;
+    }
+    if (bufferData.captions.length > 0) {
+      try {
+        const { getActiveVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+        const voiceIntel = getActiveVoiceIntelligence(this.agentId);
+        if (voiceIntel?.shouldDiscardCaptions) {
+          this.pendingCaptions = [];
+          bufferData.captions = [];
+          return;
+        }
+      } catch {
+      }
+    }
+    if (bufferData.captions.length > 0) {
+      this.pendingCaptions.push(...bufferData.captions);
+      this.lastCaptionArrival = Date.now();
+    }
+    if (bufferData.chat.length > 0) {
+      this.pendingChat.push(...bufferData.chat);
+    }
+    const now = Date.now();
+    const timeSinceLastCaption = now - this.lastCaptionArrival;
+    const hasPendingCaptions = this.pendingCaptions.length > 0;
+    const hasPendingChat = this.pendingChat.length > 0;
+    if (hasPendingChat && !hasPendingCaptions) {
+      const chat = [...this.pendingChat];
+      this.pendingChat = [];
+      await this.sendUpdate([], chat);
+      return;
+    }
+    if (!hasPendingCaptions && !hasPendingChat) {
+      this.consecutiveEmpty++;
+      return;
+    }
+    const totalText = this.pendingCaptions.map((c) => c.text).join(" ");
+    const oldestCaption = this.pendingCaptions[0]?.timestamp || now;
+    const pendingAge = now - oldestCaption;
+    const silenceGapReached = timeSinceLastCaption >= this.silenceGapMs;
+    const hardCapReached = pendingAge >= 3e4;
+    const textSubstantial = totalText.length >= this.minCaptionLength;
+    if ((silenceGapReached || hardCapReached) && textSubstantial) {
+      const captions = [...this.pendingCaptions];
+      const chat = [...this.pendingChat];
+      this.pendingCaptions = [];
+      this.pendingChat = [];
+      this.consecutiveEmpty = 0;
+      await this.sendUpdate(captions, chat);
+    } else if (silenceGapReached && !textSubstantial) {
+      console.log(`[meeting-monitor:${this.agentId}] Discarding short caption fragment: "${totalText.slice(0, 50)}"`);
+      this.pendingCaptions = [];
+    }
+  }
+  /**
+   * Send accumulated captions and/or chat to the agent session.
+   */
+  async sendUpdate(captions, chat) {
+    if (captions.length > 0) {
+      try {
+        const { getActiveVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+        const voiceIntel = getActiveVoiceIntelligence(this.agentId);
+        if (voiceIntel?.isReady || voiceIntel?.isVoiceDegraded) {
+          voiceIntel.playHum().catch(() => {
+          });
+        } else if (this.sendChatIndicator) {
+          this.sendChatIndicator(this.page, "...").catch(() => {
+          });
+        }
+      } catch {
+        if (this.sendChatIndicator && captions.length > 0) {
+          this.sendChatIndicator(this.page, "...").catch(() => {
+          });
+        }
+      }
+    }
+    const parts = ["[Meeting Monitor \u2014 Live Update]"];
+    if (captions.length > 0) {
+      parts.push("\n--- CAPTIONS (what people are saying) ---");
+      const consolidated = this.consolidateCaptions(captions);
+      for (const c of consolidated) {
+        parts.push(c.speaker ? `${c.speaker}: ${c.text}` : c.text);
+      }
+    }
+    if (chat.length > 0) {
+      parts.push("\n--- CHAT MESSAGES ---");
+      for (const m of chat) {
+        parts.push(m.sender ? `${m.sender}: ${m.text}` : m.text);
+      }
+    }
+    parts.push("\n--- END UPDATE ---");
+    parts.push("If someone addressed you or asked a question, respond using meeting_speak to talk out loud. Otherwise, just note the content silently \u2014 do NOT respond to every caption update.");
+    try {
+      await this.sendMessage(this.sessionId, parts.join("\n"));
+      this.consecutiveSendFailures = 0;
+      console.log(`[meeting-monitor:${this.agentId}] Flushed ${captions.length} captions, ${chat.length} chat msgs`);
+    } catch (err) {
+      this.consecutiveSendFailures++;
+      console.error(`[meeting-monitor:${this.agentId}] Failed to send to session (${this.consecutiveSendFailures}/5): ${err.message}`);
+      if (this.consecutiveSendFailures >= 5) {
+        console.error(`[meeting-monitor:${this.agentId}] Too many send failures \u2014 stopping monitor`);
+        this.stop();
+        this.onMeetingEnd?.();
+      }
+    }
+  }
+  /**
+   * Consolidate consecutive captions from the same speaker.
+   */
+  consolidateCaptions(captions) {
+    if (captions.length === 0) return [];
+    const result = [];
+    let current = { speaker: captions[0].speaker, text: captions[0].text };
+    for (let i = 1; i < captions.length; i++) {
+      const c = captions[i];
+      if (c.speaker === current.speaker) {
+        if (!current.text.includes(c.text)) {
+          current.text += " " + c.text;
+        }
+      } else {
+        result.push(current);
+        current = { speaker: c.speaker, text: c.text };
+      }
+    }
+    result.push(current);
+    return result;
+  }
+};
+var activeMonitors = /* @__PURE__ */ new Map();
+function getActiveMonitor(agentId) {
+  return activeMonitors.get(agentId);
+}
+function registerMonitor(agentId, monitor) {
+  const existing = activeMonitors.get(agentId);
+  if (existing) existing.stop();
+  activeMonitors.set(agentId, monitor);
+}
+function removeMonitor(agentId) {
+  const existing = activeMonitors.get(agentId);
+  if (existing) {
+    existing.stop();
+    activeMonitors.delete(agentId);
+  }
+}
+
+// src/agent-tools/tools/google/meeting-voice.ts
+import * as path2 from "path";
+import * as os2 from "os";
+import { promises as fs2 } from "fs";
+var ELEVENLABS_BASE = "https://api.elevenlabs.io/v1";
+var VoiceCapabilityManager = class _VoiceCapabilityManager {
+  statusByAgent = /* @__PURE__ */ new Map();
+  static instance;
+  _announcedChatFallback = /* @__PURE__ */ new Set();
+  static getInstance() {
+    if (!this.instance) this.instance = new _VoiceCapabilityManager();
+    return this.instance;
+  }
+  /** Full preflight check — call before/during meeting join */
+  async preflight(agentId, getApiKey, voiceId, voiceName, audioDevice) {
+    const setup = await checkAudioSetup();
+    const apiKey = await getApiKey();
+    const issues = [];
+    if (!apiKey) issues.push("No ElevenLabs API key");
+    if (!setup.hasBlackHole) issues.push("No virtual audio device");
+    if (!setup.hasSox) issues.push("sox not installed");
+    if (apiKey) {
+      try {
+        const res = await fetch(`${ELEVENLABS_BASE}/voices?page_size=1`, {
+          headers: { "xi-api-key": apiKey },
+          signal: AbortSignal.timeout(5e3)
+        });
+        if (!res.ok) {
+          const body = await res.text().catch(() => "");
+          issues.push(`ElevenLabs API error: ${res.status} \u2014 ${body.slice(0, 100)}`);
+        }
+      } catch (e) {
+        issues.push(`ElevenLabs unreachable: ${e.message}`);
+      }
+    }
+    const prev = this.statusByAgent.get(agentId);
+    const resolvedVoiceId = voiceId || DEFAULT_VOICES["rachel"];
+    const defaultDevice = setup.platform === "darwin" ? "BlackHole 2ch" : setup.platform === "win32" ? "CABLE Input (VB-Audio Virtual Cable)" : "virtual";
+    const status = {
+      available: issues.length === 0,
+      mode: issues.length === 0 ? "voice" : "chat-only",
+      hasApiKey: !!apiKey,
+      hasVirtualAudio: setup.hasBlackHole,
+      hasSox: setup.hasSox,
+      platform: setup.platform,
+      voiceName: voiceName || "rachel",
+      voiceId: resolvedVoiceId,
+      audioDevice: audioDevice || defaultDevice,
+      issues,
+      lastCheck: Date.now(),
+      lastSpeakSuccess: prev?.lastSpeakSuccess || null,
+      lastSpeakFailure: prev?.lastSpeakFailure || null,
+      consecutiveFailures: prev?.consecutiveFailures || 0,
+      degraded: false
+    };
+    this.statusByAgent.set(agentId, status);
+    return status;
+  }
+  /** Get cached status (or run preflight if stale / missing) */
+  async getStatus(agentId, getApiKey, voiceId, voiceName, audioDevice) {
+    const cached = this.statusByAgent.get(agentId);
+    if (cached && Date.now() - cached.lastCheck < 3e5) return cached;
+    return this.preflight(agentId, getApiKey, voiceId, voiceName, audioDevice);
+  }
+  /** Record a successful speak */
+  recordSuccess(agentId) {
+    const s = this.statusByAgent.get(agentId);
+    if (!s) return;
+    s.lastSpeakSuccess = Date.now();
+    s.consecutiveFailures = 0;
+    s.degraded = false;
+    s.mode = "voice";
+  }
+  /** Record a failed speak — auto-degrade after 3 consecutive failures */
+  recordFailure(agentId) {
+    const s = this.statusByAgent.get(agentId);
+    if (!s) return;
+    s.lastSpeakFailure = Date.now();
+    s.consecutiveFailures++;
+    if (s.consecutiveFailures >= 3) {
+      s.degraded = true;
+      s.mode = "chat-only";
+      console.warn(`[voice:${agentId}] Degraded to chat-only after ${s.consecutiveFailures} consecutive failures`);
+    }
+  }
+  /** Force re-check (e.g., after recovery attempt) */
+  invalidate(agentId) {
+    this.statusByAgent.delete(agentId);
+  }
+  /** Check if voice should be attempted (respects degradation) */
+  shouldUseVoice(agentId) {
+    const s = this.statusByAgent.get(agentId);
+    if (!s) return false;
+    if (s.mode === "chat-only") {
+      if (s.degraded && s.lastSpeakFailure && Date.now() - s.lastSpeakFailure > 12e4) {
+        console.log(`[voice:${agentId}] Attempting voice recovery...`);
+        return true;
+      }
+      return false;
+    }
+    return s.available;
+  }
+  /** Build a system prompt block describing voice status */
+  buildPromptBlock(agentId) {
+    const s = this.statusByAgent.get(agentId);
+    if (!s) return `
+## Voice Status
+Voice not checked yet. Use meeting_speak to talk \u2014 it will fall back to chat if voice is unavailable.
+`;
+    if (s.available && !s.degraded) {
+      return `
+## Voice: ENABLED
+You CAN speak in this meeting using your voice (${s.voiceName}).
+- Use meeting_speak(text: "...") to talk \u2014 participants will HEAR you
+- Use meeting_action(action: "chat", message: "...") for text chat
+- PREFER voice for important points, questions, and responses
+- Use chat for links, code snippets, or long lists
+- Keep spoken messages concise (1-3 sentences) for natural conversation
+- Wait for others to finish (check captions) before speaking`;
+    }
+    if (s.degraded) {
+      return `
+## Voice: DEGRADED \u2014 Using Chat Fallback
+Voice was working but has failed ${s.consecutiveFailures} times. Automatically switched to chat.
+- Use meeting_action(action: "chat", message: "...") to communicate
+- meeting_speak will auto-retry voice periodically \u2014 if it works, voice is restored
+- Issues: ${s.issues.join(", ") || "transient playback failures"}`;
+    }
+    return `
+## Voice: UNAVAILABLE \u2014 Chat Only
+Voice is not available for this meeting. Communicate via chat only.
+- Use meeting_action(action: "chat", message: "...") for all communication
+- Issues: ${s.issues.join(", ")}
+- To enable voice: Dashboard \u2192 Settings \u2192 Integrations \u2192 ElevenLabs, then select a voice in agent profile`;
+  }
+};
+var voiceCapability = VoiceCapabilityManager.getInstance();
+var DEFAULT_VOICES = {
+  "rachel": "21m00Tcm4TlvDq8ikWAM",
+  // Female, warm
+  "drew": "29vD33N1CtxCmqQRPOHJ",
+  // Male, confident
+  "clyde": "2EiwWnXFnvU5JabPnv8n",
+  // Male, deep
+  "domi": "AZnzlk1XvdvUeBnXmlld",
+  // Female, strong
+  "dave": "CYw3kZ02Hs0563khs1Fj",
+  // Male, conversational
+  "fin": "D38z5RcWu1voky8WS1ja",
+  // Male, British
+  "sarah": "EXAVITQu4vr4xnSDxMaL",
+  // Female, soft
+  "antoni": "ErXwobaYiN019PkySvjV",
+  // Male, well-rounded
+  "elli": "MF3mGyEYCl7XYWbV9V6O",
+  // Female, youthful
+  "josh": "TxGEqnHWrfWFTfGW9XjX",
+  // Male, deep, narrative
+  "arnold": "VR6AewLTigWG4xSOukaG",
+  // Male, crisp
+  "adam": "pNInz6obpgDQGcFmaJgB",
+  // Male, deep
+  "sam": "yoZ06aMxZJJ28mfd3POQ"
+  // Male, raspy
+};
+async function generateSpeech(apiKey, text, voiceId, options) {
+  const res = await _fetchTTSStream(apiKey, text, voiceId, options);
+  const chunks = [];
+  const reader = res.body.getReader();
+  while (true) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks);
+}
+var activeResponsePlayers = /* @__PURE__ */ new Map();
+async function streamSpeechToDevice(apiKey, text, voiceId, device, options, agentId) {
+  const { spawn } = await import("child_process");
+  const platform = process.platform;
+  const startTime = Date.now();
+  let playerArgs;
+  let playerCmd;
+  if (platform === "darwin") {
+    playerCmd = "sox";
+    playerArgs = ["-t", "mp3", "-", "-t", "coreaudio", device];
+  } else if (platform === "linux") {
+    playerCmd = "paplay";
+    playerArgs = device ? ["--device=" + device, "--raw"] : ["--raw"];
+  } else if (platform === "win32") {
+    playerCmd = "sox";
+    playerArgs = ["-t", "mp3", "-", "-t", "waveaudio", device];
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+  const player = spawn(playerCmd, playerArgs, {
+    stdio: ["pipe", "ignore", "pipe"],
+    timeout: 6e4
+  });
+  if (agentId) {
+    activeResponsePlayers.set(agentId, player);
+    globalThis.__activeResponsePlayers = activeResponsePlayers;
+    player.on("close", () => {
+      activeResponsePlayers.delete(agentId);
+    });
+  }
+  const fetchStart = Date.now();
+  const res = await _fetchTTSStream(apiKey, text, voiceId, options);
+  console.log(`[voice] TTS API responded in ${Date.now() - fetchStart}ms`);
+  const reader = res.body.getReader();
+  let totalBytes = 0;
+  let firstChunk = true;
+  player.stdin.on("error", () => {
+  });
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (firstChunk) {
+        console.log(`[voice] First audio chunk in ${Date.now() - fetchStart}ms (${value.length} bytes)`);
+        firstChunk = false;
+      }
+      totalBytes += value.length;
+      try {
+        const canWrite = player.stdin.write(Buffer.from(value));
+        if (!canWrite) {
+          await new Promise((resolve) => player.stdin.once("drain", resolve));
+        }
+      } catch {
+        break;
+      }
+    }
+    try {
+      player.stdin.end();
+    } catch {
+    }
+  } catch (e) {
+    try {
+      player.kill();
+    } catch {
+    }
+    throw new Error(`Stream pipe failed: ${e.message}`);
+  }
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      player.kill();
+      reject(new Error("Playback timed out"));
+    }, 6e4);
+    player.on("close", (code) => {
+      clearTimeout(timeout);
+      if (code === 0 || code === null) resolve();
+      else reject(new Error(`Player exited with code ${code}`));
+    });
+    player.on("error", (err) => {
+      clearTimeout(timeout);
+      reject(err);
+    });
+  });
+  return { audioSize: totalBytes, durationMs: Date.now() - startTime };
+}
+async function _fetchTTSStream(apiKey, text, voiceId, options) {
+  const model = options?.model || "eleven_turbo_v2_5";
+  const url = `${ELEVENLABS_BASE}/text-to-speech/${voiceId}/stream`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      "xi-api-key": apiKey,
+      "Content-Type": "application/json",
+      "Accept": "audio/mpeg"
+    },
+    body: JSON.stringify({
+      text,
+      model_id: model,
+      voice_settings: {
+        stability: options?.stability ?? 0.5,
+        similarity_boost: options?.similarity ?? 0.75,
+        style: 0,
+        use_speaker_boost: true
+      },
+      output_format: "mp3_22050_32",
+      // Lower bitrate = smaller chunks = faster first-byte
+      optimize_streaming_latency: 4
+      // Maximum latency optimization (may reduce quality slightly)
+    })
+  });
+  if (!res.ok) {
+    const err = await res.text().catch(() => "");
+    throw new Error(`ElevenLabs API ${res.status}: ${err}`);
+  }
+  return res;
+}
+async function playAudioToDevice(audioPath, device) {
+  const { exec: execCb } = await import("child_process");
+  const { promisify } = await import("util");
+  const exec = promisify(execCb);
+  if (process.platform === "darwin") {
+    if (device) {
+      try {
+        await exec(`sox "${audioPath}" -t coreaudio "${device}"`, { timeout: 3e4 });
+        return;
+      } catch {
+        console.warn(`[meeting-voice] sox failed for device "${device}", falling back to afplay`);
+      }
+    }
+    await exec(`afplay "${audioPath}"`, { timeout: 3e4 });
+  } else if (process.platform === "linux") {
+    if (device) {
+      try {
+        await exec(`paplay --device="${device}" "${audioPath}"`, { timeout: 3e4 });
+      } catch {
+        await exec(`aplay -D "${device}" "${audioPath}"`, { timeout: 3e4 });
+      }
+    } else {
+      try {
+        await exec(`paplay "${audioPath}"`, { timeout: 3e4 });
+      } catch {
+        await exec(`aplay "${audioPath}"`, { timeout: 3e4 });
+      }
+    }
+  } else if (process.platform === "win32") {
+    if (device) {
+      try {
+        await exec(`sox "${audioPath}" -t waveaudio "${device}"`, { timeout: 3e4 });
+        return;
+      } catch {
+        console.warn(`[meeting-voice] sox device routing failed on Windows, using default playback`);
+      }
+    }
+    try {
+      await exec(`powershell -Command "(New-Object System.Media.SoundPlayer '${audioPath}').PlaySync()"`, { timeout: 3e4 });
+    } catch {
+      await exec(`ffplay -nodisp -autoexit "${audioPath}"`, { timeout: 3e4 });
+    }
+  } else {
+    throw new Error(`Unsupported platform for audio playback: ${process.platform}`);
+  }
+}
+async function checkAudioSetup() {
+  const { exec: execCb } = await import("child_process");
+  const { promisify } = await import("util");
+  const exec = promisify(execCb);
+  const platform = process.platform;
+  let hasBlackHole = false;
+  let hasSox = false;
+  let devices = [];
+  if (platform === "darwin") {
+    try {
+      const { stdout } = await exec("system_profiler SPAudioDataType 2>/dev/null");
+      if (stdout.includes("BlackHole")) hasBlackHole = true;
+      const lines = stdout.split("\n");
+      for (const line of lines) {
+        const match = line.match(/^\s+(BlackHole|Built-in|External|USB|Aggregate|DELL|Mac mini)/);
+        if (match) devices.push(line.trim());
+      }
+    } catch {
+    }
+    if (!hasBlackHole) {
+      try {
+        const { existsSync: existsSync2 } = await import("fs");
+        if (existsSync2("/Library/Audio/Plug-Ins/HAL/BlackHole2ch.driver")) {
+          hasBlackHole = true;
+          devices.push("BlackHole 2ch (driver installed, may need coreaudiod restart)");
+        }
+      } catch {
+      }
+    }
+    if (!hasBlackHole) {
+      try {
+        const { stdout } = await exec("SwitchAudioSource -a -t output 2>/dev/null");
+        if (stdout.includes("BlackHole")) {
+          hasBlackHole = true;
+          devices.push("BlackHole 2ch");
+        }
+      } catch {
+      }
+    }
+    if (!hasBlackHole) {
+      try {
+        const { existsSync: existsSync2 } = await import("fs");
+        if (existsSync2("/Library/Audio/Plug-Ins/HAL/BlackHole2ch.driver")) {
+          console.log("[audio] BlackHole driver installed but not loaded \u2014 attempting coreaudiod restart...");
+          try {
+            await exec("sudo launchctl kickstart -kp system/com.apple.audio.coreaudiod 2>/dev/null", { timeout: 1e4 });
+            await new Promise((r) => setTimeout(r, 3e3));
+            try {
+              const { stdout } = await exec("SwitchAudioSource -a -t output 2>/dev/null");
+              if (stdout.includes("BlackHole")) {
+                hasBlackHole = true;
+                devices.push("BlackHole 2ch (loaded after coreaudiod restart)");
+                console.log("[audio] \u2705 BlackHole now available after coreaudiod restart");
+              }
+            } catch {
+            }
+          } catch {
+            console.warn("[audio] BlackHole driver exists but coreaudiod restart needs sudo. Run: sudo launchctl kickstart -kp system/com.apple.audio.coreaudiod");
+          }
+        }
+      } catch {
+      }
+    }
+    try {
+      await exec("which sox");
+      hasSox = true;
+    } catch {
+    }
+  } else if (platform === "linux") {
+    try {
+      const { stdout } = await exec("pactl list short sinks 2>/dev/null");
+      devices = stdout.split("\n").filter(Boolean);
+      hasBlackHole = devices.some((d) => d.includes("virtual") || d.includes("null") || d.includes("pipewire"));
+    } catch {
+    }
+    try {
+      await exec("which sox");
+      hasSox = true;
+    } catch {
+    }
+  } else if (platform === "win32") {
+    try {
+      const { stdout } = await exec('powershell -Command "Get-AudioDevice -List 2>$null | Select-Object -ExpandProperty Name"', { timeout: 1e4 });
+      devices = stdout.split("\n").map((d) => d.trim()).filter(Boolean);
+      hasBlackHole = devices.some((d) => /cable|virtual|vb-audio/i.test(d));
+    } catch {
+      try {
+        const { stdout } = await exec("sox --help 2>&1");
+        if (stdout.includes("waveaudio")) hasSox = true;
+      } catch {
+      }
+    }
+    try {
+      await exec("where sox");
+      hasSox = true;
+    } catch {
+    }
+  }
+  return { hasBlackHole, hasSox, devices, platform };
+}
+function createMeetingVoiceTools(config, _options) {
+  const agentId = _options?.agentId || "default";
+  const getApiKey = async () => {
+    if (config.elevenLabsApiKey) return config.elevenLabsApiKey;
+    if (config.elevenLabsKeyResolver) {
+      try {
+        return await config.elevenLabsKeyResolver();
+      } catch {
+        return null;
+      }
+    }
+    return process.env.ELEVENLABS_API_KEY || null;
+  };
+  return [
+    // ─── Speak in Meeting ──────────────────────────────
+    {
+      name: "meeting_speak",
+      description: `Speak in a meeting using your voice. Participants will HEAR you through the virtual microphone. Audio streams in real-time (near-zero latency). Auto-falls back to meeting chat if voice fails.
+
+IMPORTANT: When meeting_speak succeeds (status: "spoken"), DO NOT also send the same message via chat. That would duplicate your message. Only use meeting chat for links, code, or data that's better as text.
+
+Tips:
+- Keep messages SHORT: 1-2 sentences per turn, like a real conversation
+- Wait for others to finish (check captions) before speaking
+- For long content, break it into multiple short meeting_speak calls`,
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          text: { type: "string", description: "Text to speak in the meeting" },
+          voice: { type: "string", description: "Voice name or ElevenLabs voice ID. Built-in voices: rachel (female, warm), drew (male, confident), sarah (female, soft), josh (male, deep), adam (male, deep), sam (male, raspy). Default: agent's configured voice." },
+          model: { type: "string", description: 'ElevenLabs model: "eleven_turbo_v2_5" (fastest, default), "eleven_multilingual_v2" (best quality, supports 29 languages)' }
+        },
+        required: ["text"]
+      },
+      async execute(_id, params) {
+        try {
+          const text = params.text;
+          if (!text || text.trim().length === 0) {
+            return errorResult("No text to speak.");
+          }
+          const vcm = voiceCapability;
+          const status = await vcm.getStatus(agentId, getApiKey, config.voiceId, config.voiceName, config.audioDevice);
+          const fallbackToChat = async (reason) => {
+            console.log(`[voice:${agentId}] Falling back to chat: ${reason}`);
+            vcm.recordFailure(agentId);
+            try {
+              const { getActiveVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+              const voiceIntel = getActiveVoiceIntelligence(agentId);
+              if (voiceIntel) {
+                voiceIntel.stopAll();
+                voiceIntel.shutdown();
+              }
+            } catch {
+            }
+            try {
+              const { ensureBrowser: ensureBrowser3, sendChatMessage: sendChatMessage2 } = await import("./meetings-TL77WLKW.js");
+              const { page } = await ensureBrowser3(false, agentId, false);
+              if (!vcm._announcedChatFallback?.has(agentId)) {
+                if (!vcm._announcedChatFallback) vcm._announcedChatFallback = /* @__PURE__ */ new Set();
+                vcm._announcedChatFallback.add(agentId);
+                await sendChatMessage2(page, `Sorry, something is wrong with my microphone so I'll be responding via chat for now!`);
+              }
+              const chatResult = await sendChatMessage2(page, text);
+              if (chatResult.sent) {
+                return jsonResult({
+                  action: "meeting_speak",
+                  status: "sent_as_chat",
+                  method: "chat_fallback",
+                  text,
+                  reason,
+                  chatMethod: chatResult.method,
+                  note: "Voice unavailable \u2014 message sent as meeting chat instead."
+                });
+              }
+            } catch (chatErr) {
+              console.error(`[voice:${agentId}] Chat fallback also failed: ${chatErr.message}`);
+            }
+            return jsonResult({
+              action: "meeting_speak",
+              status: "failed",
+              text,
+              reason,
+              hint: "Both voice and chat failed. Check meeting connection and audio setup."
+            });
+          };
+          if (!vcm.shouldUseVoice(agentId)) {
+            return fallbackToChat(status.degraded ? `Voice degraded (${status.consecutiveFailures} consecutive failures)` : `Voice unavailable: ${status.issues.join(", ")}`);
+          }
+          const apiKey = await getApiKey();
+          if (!apiKey) {
+            return fallbackToChat("No ElevenLabs API key");
+          }
+          let voiceId = config.voiceId || DEFAULT_VOICES["rachel"];
+          if (params.voice) {
+            const lower = params.voice.toLowerCase();
+            if (DEFAULT_VOICES[lower]) {
+              voiceId = DEFAULT_VOICES[lower];
+            } else if (params.voice.length > 10) {
+              voiceId = params.voice;
+            }
+          }
+          try {
+            const { getActiveVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+            const voiceIntel = getActiveVoiceIntelligence(agentId);
+            if (voiceIntel) {
+              voiceIntel.stopAll();
+              await new Promise((r) => setTimeout(r, 100));
+              voiceIntel.markSpeaking(text);
+            }
+          } catch {
+          }
+          const device = config.audioDevice || status.audioDevice || "BlackHole 2ch";
+          try {
+            const result = await streamSpeechToDevice(apiKey, text, voiceId, device, {
+              model: params.model
+            }, agentId);
+            vcm.recordSuccess(agentId);
+            try {
+              const { getActiveVoiceIntelligence: getVI } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+              getVI(agentId)?.markDoneSpeaking();
+            } catch {
+            }
+            return jsonResult({
+              action: "meeting_speak",
+              status: "spoken",
+              method: "voice",
+              text,
+              voiceId,
+              voiceName: config.voiceName || Object.entries(DEFAULT_VOICES).find(([, id]) => id === voiceId)?.[0] || "custom",
+              audioSize: result.audioSize,
+              durationMs: result.durationMs,
+              streaming: true
+            });
+          } catch (streamErr) {
+            console.warn(`[voice:${agentId}] Streaming failed (${streamErr.message}), trying file-based playback...`);
+            try {
+              const audioBuffer = await generateSpeech(apiKey, text, voiceId, { model: params.model });
+              const audioDir = path2.join(os2.tmpdir(), "agenticmail-voice");
+              await fs2.mkdir(audioDir, { recursive: true });
+              const audioFile = path2.join(audioDir, `speak-${Date.now()}.mp3`);
+              await fs2.writeFile(audioFile, audioBuffer);
+              await playAudioToDevice(audioFile, device);
+              vcm.recordSuccess(agentId);
+              return jsonResult({
+                action: "meeting_speak",
+                status: "spoken",
+                method: "voice",
+                text,
+                voiceId,
+                voiceName: config.voiceName || Object.entries(DEFAULT_VOICES).find(([, id]) => id === voiceId)?.[0] || "custom",
+                audioFile,
+                audioSize: audioBuffer.length,
+                streaming: false
+              });
+            } catch (fileErr) {
+              try {
+                const { getActiveVoiceIntelligence: getVI } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+                getVI(agentId)?.markDoneSpeaking();
+              } catch {
+              }
+              return fallbackToChat(`Voice failed: ${streamErr.message}, file fallback: ${fileErr.message}`);
+            }
+          }
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── Check Audio Setup ─────────────────────────────
+    {
+      name: "meeting_audio_setup",
+      description: "Check if the machine has the required audio setup for meeting voice (virtual audio device, sox, etc.). Run this before using meeting_speak to verify the setup.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {},
+        required: []
+      },
+      async execute(_id, _params) {
+        try {
+          const setup = await checkAudioSetup();
+          const apiKey = await getApiKey();
+          const issues = [];
+          if (!apiKey) issues.push('ElevenLabs API key not configured. Add it in Dashboard \u2192 Settings \u2192 Integrations (key name: "elevenlabs"), or set ELEVENLABS_API_KEY env var.');
+          if (!setup.hasBlackHole) {
+            if (setup.platform === "darwin") issues.push("BlackHole virtual audio not found (install: brew install blackhole-2ch)");
+            else if (setup.platform === "linux") issues.push("No virtual audio sink found (create one: pactl load-module module-null-sink sink_name=virtual)");
+            else if (setup.platform === "win32") issues.push("No virtual audio cable found (install VB-CABLE from https://vb-audio.com/Cable/ or choco install vb-cable)");
+          }
+          if (!setup.hasSox) {
+            if (setup.platform === "darwin") issues.push("sox not found (install: brew install sox)");
+            else if (setup.platform === "linux") issues.push("sox not found (install: sudo apt install sox)");
+            else if (setup.platform === "win32") issues.push("sox not found (install: choco install sox.portable or winget install sox.sox)");
+          }
+          const defaultDevice = setup.platform === "darwin" ? "BlackHole 2ch" : setup.platform === "win32" ? "CABLE Input (VB-Audio Virtual Cable)" : "virtual";
+          return jsonResult({
+            action: "meeting_audio_setup",
+            ready: issues.length === 0,
+            issues,
+            platform: setup.platform,
+            hasElevenLabsKey: !!apiKey,
+            hasVirtualAudio: setup.hasBlackHole,
+            hasSox: setup.hasSox,
+            audioDevices: setup.devices,
+            configuredVoice: config.voiceName || config.voiceId || "rachel (default)",
+            configuredDevice: config.audioDevice || `${defaultDevice} (default)`,
+            availableVoices: Object.keys(DEFAULT_VOICES),
+            setupInstructions: issues.length > 0 ? [
+              "macOS: brew install blackhole-2ch sox",
+              "Linux: sudo apt install pulseaudio-utils sox && pactl load-module module-null-sink sink_name=virtual",
+              "Windows: choco install sox.portable vb-cable (or winget install sox.sox + VB-CABLE from vb-audio.com)",
+              "Then add ElevenLabs API key in Dashboard \u2192 Settings \u2192 Integrations",
+              "Optionally select a voice in agent profile \u2192 Personal Details \u2192 Voice"
+            ] : ["All good \u2014 meeting voice is ready to use."]
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── List Available Voices ──────────────────────────
+    {
+      name: "meeting_voices",
+      description: "List available ElevenLabs voices for meeting speech. Shows built-in voices and optionally fetches your custom voices from ElevenLabs.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          includeCustom: { type: "string", description: '"true" to fetch custom voices from your ElevenLabs account' }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const builtIn = Object.entries(DEFAULT_VOICES).map(([name, id]) => ({ name, id, source: "built-in" }));
+          if (params.includeCustom === "true") {
+            const apiKey = await getApiKey();
+            if (!apiKey) return jsonResult({ voices: builtIn, note: "Add ElevenLabs key in Dashboard \u2192 Settings \u2192 Integrations to see custom voices" });
+            try {
+              const res = await fetch(`${ELEVENLABS_BASE}/voices`, {
+                headers: { "xi-api-key": apiKey }
+              });
+              if (res.ok) {
+                const data = await res.json();
+                const custom = (data.voices || []).map((v) => ({
+                  name: v.name,
+                  id: v.voice_id,
+                  category: v.category,
+                  source: "elevenlabs"
+                }));
+                return jsonResult({ voices: [...builtIn, ...custom] });
+              }
+            } catch {
+            }
+          }
+          return jsonResult({ voices: builtIn, currentVoice: config.voiceName || config.voiceId || "rachel" });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+// src/agent-tools/tools/google/meetings.ts
+import * as path3 from "path";
+import * as os3 from "os";
+import { promises as fs3 } from "fs";
+var ensureBrowser2 = ensureBrowser;
+var CALENDAR_BASE = "https://www.googleapis.com/calendar/v3";
+async function calendarApi(token, path4, opts) {
+  const url = new URL(CALENDAR_BASE + path4);
+  if (opts?.query) for (const [k, v] of Object.entries(opts.query)) {
+    if (v) url.searchParams.set(k, v);
+  }
+  const res = await fetch(url.toString(), {
+    method: opts?.method || "GET",
+    headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+    body: opts?.body ? JSON.stringify(opts.body) : void 0
+  });
+  if (!res.ok) throw new Error(`Calendar API ${res.status}: ${await res.text()}`);
+  return res.json();
+}
+function extractMeetingLink(event) {
+  if (event.conferenceData?.entryPoints) {
+    for (const ep of event.conferenceData.entryPoints) {
+      if (ep.entryPointType === "video" && ep.uri) return { platform: "google_meet", url: ep.uri };
+    }
+  }
+  if (event.hangoutLink) return { platform: "google_meet", url: event.hangoutLink };
+  const text = [event.description || "", event.location || ""].join(" ");
+  const zoomMatch = text.match(/https:\/\/[\w.-]*zoom\.us\/[jw]\/[\d?=&\w]+/i);
+  if (zoomMatch) return { platform: "zoom", url: zoomMatch[0] };
+  const teamsMatch = text.match(/https:\/\/teams\.microsoft\.com\/l\/meetup-join\/[^\s"<>]+/i);
+  if (teamsMatch) return { platform: "teams", url: teamsMatch[0] };
+  const genericMeet = text.match(/https:\/\/meet\.google\.com\/[a-z-]+/i);
+  if (genericMeet) return { platform: "google_meet", url: genericMeet[0] };
+  return null;
+}
+function parseEventTime(event) {
+  const startStr = event.start?.dateTime || event.start?.date;
+  const endStr = event.end?.dateTime || event.end?.date;
+  if (!startStr) return null;
+  return {
+    start: new Date(startStr),
+    end: endStr ? new Date(endStr) : new Date(new Date(startStr).getTime() + 36e5)
+  };
+}
+function delay(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+async function saveScreenshot(page) {
+  const buf = await page.screenshot({ type: "png", fullPage: false });
+  const dir = path3.join(os3.tmpdir(), "agenticmail-screenshots");
+  await fs3.mkdir(dir, { recursive: true });
+  const file = `meeting-${Date.now()}.png`;
+  const filePath = path3.join(dir, file);
+  await fs3.writeFile(filePath, buf);
+  return { path: filePath, base64: buf.toString("base64") };
+}
+async function ariaClick(page, labels, timeout = 5e3) {
+  for (const label of labels) {
+    try {
+      await page.click(`[aria-label*="${label}" i]`, { timeout });
+      return true;
+    } catch {
+    }
+  }
+  for (const label of labels) {
+    try {
+      await page.getByRole("button", { name: new RegExp(label, "i") }).click({ timeout: 2e3 });
+      return true;
+    } catch {
+    }
+  }
+  return false;
+}
+async function readCaptionsFromDOM(page) {
+  return page.evaluate(() => {
+    const region = document.querySelector('[aria-label="Captions"]');
+    if (region) {
+      const entries = [];
+      const children = region.querySelectorAll(":scope > div");
+      for (const child of children) {
+        const divs = child.querySelectorAll(":scope > div");
+        if (divs.length >= 2) {
+          entries.push({ speaker: divs[0].textContent?.trim() || "", text: divs[1].textContent?.trim() || "" });
+        } else if (child.textContent?.trim()) {
+          entries.push({ speaker: "", text: child.textContent.trim() });
+        }
+      }
+      if (entries.length > 0) return entries;
+    }
+    const container = document.querySelector(".a4cQT");
+    if (container) {
+      const allText = container.innerText || "";
+      const lines = allText.split("\n").filter(
+        (l) => l.trim().length > 0 && !l.includes("BETA") && !l.includes("caption") && !l.includes("Font size") && !l.includes("Font color") && l.trim().length < 500
+      );
+      if (lines.length > 0) return [{ speaker: "", text: lines.join(" ") }];
+    }
+    return [];
+  });
+}
+async function sendChatMessage(page, message) {
+  const MAX_CHUNK = 450;
+  if (message.length > MAX_CHUNK) {
+    const chunks = splitMessageIntoChunks(message, MAX_CHUNK);
+    let allSent = true;
+    let lastMethod = "";
+    for (let i = 0; i < chunks.length; i++) {
+      const prefix = chunks.length > 1 ? `(${i + 1}/${chunks.length}) ` : "";
+      const result = await sendChatMessage(page, prefix + chunks[i]);
+      if (!result.sent) {
+        return { sent: false, method: result.method, error: `Failed on chunk ${i + 1}/${chunks.length}: ${result.error}` };
+      }
+      lastMethod = result.method;
+      if (i < chunks.length - 1) await delay(800);
+    }
+    return { sent: allSent, method: `chunked (${chunks.length}x) via ${lastMethod}` };
+  }
+  try {
+    const chatOpen = await page.evaluate(() => {
+      const panel = document.querySelector('[aria-label="Side panel"]');
+      if (!panel) return false;
+      const text = panel.innerText || "";
+      return text.includes("In-call messages") || text.includes("Send a message");
+    });
+    if (!chatOpen) {
+      const clicked = await ariaClick(page, ["Chat with everyone", "Open chat"], 3e3);
+      if (!clicked) {
+        await page.keyboard.press("d");
+      }
+      await delay(1500);
+    }
+  } catch {
+  }
+  const selectors = [
+    'textarea[aria-label*="Send a message" i]',
+    'input[aria-label*="Send a message" i]',
+    '[aria-label*="Send a message" i][contenteditable]',
+    'textarea[placeholder*="Send" i]',
+    '[data-is-persistent="true"] textarea'
+  ];
+  for (const selector of selectors) {
+    try {
+      const el = page.locator(selector).first();
+      const visible = await el.isVisible({ timeout: 2e3 }).catch(() => false);
+      if (!visible) continue;
+      await el.click({ timeout: 2e3 });
+      await delay(200);
+      await page.keyboard.press("Control+a");
+      await delay(100);
+      await page.keyboard.press("Backspace");
+      await delay(100);
+      try {
+        const inserted = await page.evaluate((text) => {
+          const active = document.activeElement;
+          if (active && "value" in active) {
+            const setter = Object.getOwnPropertyDescriptor(HTMLTextAreaElement.prototype, "value")?.set || Object.getOwnPropertyDescriptor(HTMLInputElement.prototype, "value")?.set;
+            if (setter) {
+              setter.call(active, text);
+              active.dispatchEvent(new Event("input", { bubbles: true }));
+              active.dispatchEvent(new Event("change", { bubbles: true }));
+              return true;
+            }
+          }
+          return document.execCommand("insertText", false, text);
+        }, message);
+        if (!inserted) throw new Error("insertText returned false");
+        await delay(300);
+      } catch {
+        try {
+          await page.evaluate(async (text) => {
+            await navigator.clipboard.writeText(text);
+          }, message);
+          const isMac = process.platform === "darwin";
+          await page.keyboard.press(isMac ? "Meta+v" : "Control+v");
+          await delay(300);
+        } catch {
+          if (message.length <= 100) {
+            await page.keyboard.type(message, { delay: 20 });
+            await delay(300);
+          } else {
+            continue;
+          }
+        }
+      }
+      await page.keyboard.press("Enter");
+      await delay(500);
+      const inputEmpty = await el.inputValue().then((v) => v.trim() === "").catch(() => true);
+      if (inputEmpty) {
+        return { sent: true, method: `paste + selector: ${selector}` };
+      }
+    } catch {
+    }
+  }
+  return { sent: false, method: "all strategies failed", error: 'Could not find or interact with the chat input. Try meeting_action(action: "screenshot") to see the current state.' };
+}
+function splitMessageIntoChunks(text, maxLen) {
+  const chunks = [];
+  let remaining = text;
+  while (remaining.length > maxLen) {
+    let breakIdx = -1;
+    for (const sep of ["\n\n", "\n", ". ", "! ", "? ", ", "]) {
+      const idx = remaining.lastIndexOf(sep, maxLen);
+      if (idx > maxLen * 0.3) {
+        breakIdx = idx + sep.length;
+        break;
+      }
+    }
+    if (breakIdx <= 0) breakIdx = maxLen;
+    chunks.push(remaining.slice(0, breakIdx).trim());
+    remaining = remaining.slice(breakIdx).trim();
+  }
+  if (remaining) chunks.push(remaining);
+  return chunks;
+}
+async function configureAudioInput() {
+  const { exec: execCb } = await import("child_process");
+  const { promisify } = await import("util");
+  const exec = promisify(execCb);
+  const platform = process.platform;
+  try {
+    if (platform === "darwin") {
+      const { stdout: inputs } = await exec("SwitchAudioSource -a -t input 2>/dev/null");
+      if (inputs.includes("BlackHole")) {
+        await exec('SwitchAudioSource -t input -s "BlackHole 2ch"');
+        console.log("[audio] \u2705 Set system audio input to BlackHole 2ch");
+        return { configured: true, device: "BlackHole 2ch" };
+      }
+      return { configured: false, error: "BlackHole not found as input device" };
+    } else if (platform === "linux") {
+      try {
+        const { stdout } = await exec("pactl list short sources 2>/dev/null");
+        const virtualSource = stdout.split("\n").find((l) => /virtual|null/.test(l));
+        if (virtualSource) {
+          const sourceName = virtualSource.split("	")[1];
+          await exec(`pactl set-default-source ${sourceName}`);
+          console.log(`[audio] \u2705 Set PulseAudio default source to ${sourceName}`);
+          return { configured: true, device: sourceName };
+        }
+      } catch {
+      }
+      return { configured: false, error: "No virtual audio source found" };
+    } else if (platform === "win32") {
+      try {
+        await exec('nircmd setdefaultsounddevice "CABLE Output" 2');
+        console.log("[audio] \u2705 Set default recording device to VB-CABLE");
+        return { configured: true, device: "CABLE Output (VB-Audio)" };
+      } catch {
+        return { configured: false, error: "Could not set VB-CABLE as default input" };
+      }
+    }
+    return { configured: false, error: `Unsupported platform: ${platform}` };
+  } catch (e) {
+    return { configured: false, error: e.message };
+  }
+}
+async function joinGoogleMeet(page, url) {
+  const audioConfig = await configureAudioInput();
+  if (audioConfig.configured) {
+    console.log(`[meeting-join] Audio input configured: ${audioConfig.device}`);
+  } else {
+    console.warn(`[meeting-join] Audio input not configured: ${audioConfig.error}`);
+  }
+  await page.goto(url, { timeout: 6e4, waitUntil: "domcontentloaded" });
+  await delay(2e3);
+  for (let i = 0; i < 3; i++) {
+    const dismissed = await ariaClick(page, ["Close"], 1500);
+    if (!dismissed) break;
+    await delay(300);
+  }
+  const joined = await ariaClick(page, ["Ask to join", "Join now", "Join"], 1e4);
+  if (!joined) {
+    const screenshot2 = await saveScreenshot(page);
+    return { joined: false, error: "Could not find Join button.", screenshot: screenshot2.path, screenshotBase64: screenshot2.base64 };
+  }
+  await delay(3e3);
+  const state = await page.evaluate(() => {
+    const text = document.body.innerText || "";
+    if (text.includes("Please wait until a meeting host")) return "waiting_room";
+    if (text.includes("You have joined the call") || text.includes("Leave call")) return "in_call";
+    if (text.includes("Ask to join")) return "pre_join";
+    return "unknown";
+  });
+  const screenshot = await saveScreenshot(page);
+  return {
+    joined: state === "in_call" || state === "waiting_room",
+    state,
+    url: page.url(),
+    screenshot: screenshot.path,
+    screenshotBase64: screenshot.base64
+  };
+}
+function createMeetingTools(config, _options) {
+  const tp = config.tokenProvider;
+  const agentId = _options?.agentId || "default";
+  const runtimeRef = _options?.runtimeRef;
+  return [
+    // ─── Upcoming Meetings ─────────────────────────────
+    {
+      name: "meetings_upcoming",
+      description: "List upcoming meetings with join links, times, and attendees from Google Calendar.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          hours: { type: "number", description: "Look ahead this many hours (default: 24)" },
+          calendarId: { type: "string", description: 'Calendar ID (default: "primary")' },
+          includeDeclined: { type: "string", description: '"true" to include declined meetings' }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const hours = params.hours || 24;
+          const now = /* @__PURE__ */ new Date();
+          const later = new Date(now.getTime() + hours * 36e5);
+          const calendarId = params.calendarId || "primary";
+          const data = await calendarApi(token, `/calendars/${encodeURIComponent(calendarId)}/events`, {
+            query: {
+              timeMin: now.toISOString(),
+              timeMax: later.toISOString(),
+              singleEvents: "true",
+              orderBy: "startTime",
+              maxResults: "50"
+            }
+          });
+          const meetings = (data.items || []).map((event) => {
+            const times = parseEventTime(event);
+            const meetingLink = extractMeetingLink(event);
+            const myStatus = (event.attendees || []).find((a) => a.self)?.responseStatus;
+            if (params.includeDeclined !== "true" && myStatus === "declined") return null;
+            return {
+              id: event.id,
+              title: event.summary,
+              start: times?.start?.toISOString(),
+              end: times?.end?.toISOString(),
+              startsIn: times ? Math.round((times.start.getTime() - now.getTime()) / 6e4) + " minutes" : null,
+              isNow: times ? now >= times.start && now <= times.end : false,
+              meetingLink: meetingLink?.url || null,
+              platform: meetingLink?.platform || null,
+              organizer: event.organizer?.email,
+              attendees: (event.attendees || []).map((a) => ({
+                email: a.email,
+                name: a.displayName,
+                status: a.responseStatus,
+                self: a.self || false
+              })),
+              myStatus,
+              description: event.description?.slice(0, 500),
+              location: event.location
+            };
+          }).filter(Boolean);
+          return jsonResult({
+            meetings,
+            total: meetings.length,
+            withMeetingLinks: meetings.filter((m) => m.meetingLink).length,
+            happeningNow: meetings.filter((m) => m.isNow).length,
+            nextMeeting: meetings[0] || null
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── Join Meeting ──────────────────────────────────
+    {
+      name: "meeting_join",
+      description: `Join a Google Meet video meeting. After joining:
+- Captions are auto-enabled
+- A MeetingMonitor starts streaming captions and chat to you in real-time
+- You will receive "[Meeting Monitor \u2014 Live Update]" messages with new captions/chat
+- When someone talks to you, respond using meeting_action(action: "chat", message: "...")
+- You do NOT need to manually poll for captions \u2014 they come to you automatically
+- The monitor will tell you when the meeting ends`,
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          url: { type: "string", description: "Meeting URL (Google Meet link)" },
+          eventId: { type: "string", description: "Google Calendar event ID \u2014 will auto-extract the meeting link" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          let meetingUrl = params.url;
+          if (!meetingUrl && params.eventId) {
+            const event = await calendarApi(token, `/calendars/primary/events/${params.eventId}`);
+            const link = extractMeetingLink(event);
+            if (!link) return errorResult("No meeting link found in calendar event: " + (event.summary || params.eventId));
+            meetingUrl = link.url;
+          }
+          if (!meetingUrl) return errorResult("No meeting URL provided. Pass url or eventId.");
+          const { page } = await ensureBrowser2(false, agentId, false);
+          const result = await joinGoogleMeet(page, meetingUrl);
+          if (result.joined) {
+            if (result.state === "in_call" || result.state === "unknown") {
+              try {
+                await page.keyboard.press("c");
+                await delay(1e3);
+              } catch {
+              }
+              try {
+                await page.keyboard.press("d");
+                await delay(1500);
+                const voiceConfig = _options?.voiceConfig || {};
+                if (!voiceConfig.voiceId) {
+                  const chatResult = await sendChatMessage(page, `Hi, I'm joining to take notes. I'll communicate via chat.`);
+                  console.log(`[meeting-join:${agentId}] Intro chat: ${chatResult.sent ? "sent" : "failed"} (${chatResult.method})`);
+                }
+              } catch {
+              }
+            }
+            if (runtimeRef?.sendMessage && runtimeRef?.getCurrentSessionId) {
+              const sessionId = runtimeRef.getCurrentSessionId();
+              if (sessionId) {
+                if (runtimeRef.setKeepAlive) {
+                  runtimeRef.setKeepAlive(sessionId, true);
+                }
+                const startMonitor = async () => {
+                  const monitor = new MeetingMonitor({
+                    page,
+                    agentId,
+                    sessionId,
+                    sendMessage: runtimeRef.sendMessage,
+                    flushIntervalMs: 2500,
+                    sendChatIndicator: async (p, text) => {
+                      try {
+                        await sendChatMessage(p, text);
+                      } catch {
+                      }
+                    },
+                    onMeetingEnd: () => {
+                      console.log(`[meeting-join:${agentId}] Monitor detected meeting end`);
+                      removeMonitor(agentId);
+                      if (runtimeRef.setKeepAlive) {
+                        runtimeRef.setKeepAlive(sessionId, false);
+                      }
+                    }
+                  });
+                  registerMonitor(agentId, monitor);
+                  await monitor.start();
+                  console.log(`[meeting-join:${agentId}] \u2705 MeetingMonitor started for session ${sessionId}, keep-alive ON`);
+                };
+                if (result.state === "in_call" || result.state === "unknown") {
+                  await startMonitor();
+                }
+                if (result.state === "waiting_room") {
+                  console.log(`[meeting-join:${agentId}] In waiting room \u2014 monitor will start after admission`);
+                  const admissionWatcher = setInterval(async () => {
+                    try {
+                      const currentState = await page.evaluate(() => {
+                        const text = document.body.innerText || "";
+                        if (text.includes("Please wait until a meeting host")) return "waiting_room";
+                        if (text.includes("Leave call")) return "in_call";
+                        if (text.includes("You've left the meeting") || text.includes("Call ended")) return "ended";
+                        return "unknown";
+                      });
+                      if (currentState === "in_call" || currentState === "unknown") {
+                        clearInterval(admissionWatcher);
+                        console.log(`[meeting-join:${agentId}] \u2705 Admitted to meeting!`);
+                        try {
+                          await page.keyboard.press("c");
+                          await delay(1e3);
+                        } catch {
+                        }
+                        try {
+                          await page.keyboard.press("d");
+                          await delay(1500);
+                          const voiceConfig = _options?.voiceConfig || {};
+                          if (!voiceConfig.voiceId) {
+                            await sendChatMessage(page, `Hi, I'm joining to take notes. I'll communicate via chat.`);
+                          }
+                        } catch {
+                        }
+                        try {
+                          await startMonitor();
+                        } catch (e) {
+                          console.error(`[meeting-join:${agentId}] Failed to start monitor after admission: ${e.message}`);
+                        }
+                        try {
+                          await runtimeRef.sendMessage(
+                            sessionId,
+                            `[Meeting Monitor] You have been admitted to the meeting! Captions are now enabled. Chat panel is open. You will start receiving live updates.`
+                          );
+                        } catch {
+                        }
+                      } else if (currentState === "ended") {
+                        clearInterval(admissionWatcher);
+                        console.log(`[meeting-join:${agentId}] Meeting ended while in waiting room`);
+                        if (runtimeRef.setKeepAlive) runtimeRef.setKeepAlive(sessionId, false);
+                      }
+                    } catch {
+                      clearInterval(admissionWatcher);
+                    }
+                  }, 5e3);
+                }
+              }
+            } else {
+              console.warn(`[meeting-join:${agentId}] No runtimeRef \u2014 MeetingMonitor NOT started`);
+            }
+          }
+          let voiceStatus = null;
+          try {
+            const voiceConfig = _options?.voiceConfig || {};
+            const elevenLabsKeyResolver = _options?.elevenLabsKeyResolver;
+            const getApiKey = async () => {
+              if (process.env.ELEVENLABS_API_KEY) return process.env.ELEVENLABS_API_KEY;
+              if (elevenLabsKeyResolver) try {
+                return await elevenLabsKeyResolver();
+              } catch {
+                return null;
+              }
+              return null;
+            };
+            voiceStatus = await voiceCapability.preflight(
+              agentId,
+              getApiKey,
+              voiceConfig.voiceId,
+              voiceConfig.voiceName,
+              voiceConfig.audioDevice
+            );
+            console.log(`[meeting-join:${agentId}] Voice: ${voiceStatus.mode} (${voiceStatus.available ? "ready" : voiceStatus.issues.join(", ")})`);
+            if (voiceStatus?.available) {
+              const apiKey = await getApiKey();
+              console.log(`[meeting-join:${agentId}] Voice Intelligence: apiKey=${apiKey ? "present" : "MISSING"}`);
+              if (apiKey) {
+                const { createMeetingVoiceIntelligence } = await import("./meeting-voice-intelligence-RZZCAD6G.js");
+                console.log(`[meeting-join:${agentId}] Creating Voice Intelligence instance...`);
+                const voiceIntel = createMeetingVoiceIntelligence({
+                  agentId,
+                  agentName: _options?.agentName || "AI Assistant",
+                  agentAliases: _options?.agentAliases || [],
+                  voiceId: voiceConfig.voiceId || voiceStatus.voiceId,
+                  voiceName: voiceConfig.voiceName || voiceStatus.voiceName,
+                  audioDevice: voiceConfig.audioDevice || voiceStatus.audioDevice,
+                  apiKey,
+                  modelSpeed: "fast"
+                  // Assume fast model for meetings (Sonnet)
+                });
+                voiceIntel.initialize().then((result2) => {
+                  console.log(`[meeting-join:${agentId}] Voice Intelligence: ${result2.generated} audio clips ready (${result2.durationMs}ms)`);
+                }).catch((e) => {
+                  console.warn(`[meeting-join:${agentId}] Voice Intelligence init failed: ${e.message}`);
+                });
+              }
+            }
+          } catch (e) {
+            console.warn(`[meeting-join:${agentId}] Voice preflight failed: ${e.message}`);
+          }
+          const _voiceBlock = voiceStatus ? voiceCapability.buildPromptBlock(agentId) : "\n## Voice: NOT CHECKED\nUse meeting_speak to talk \u2014 it auto-falls back to chat if voice fails.\n";
+          const hasVoice = voiceStatus?.available === true;
+          const monitorActive = !!getActiveMonitor(agentId);
+          const communicationInstructions = hasVoice ? 'You have a VOICE in this meeting. Use meeting_speak(text: "...") to talk out loud \u2014 participants will hear you. Use meeting_action(action: "chat", message: "...") for links/code/long text. meeting_speak auto-falls back to chat if voice fails.' : 'You do NOT have a microphone. Communicate via meeting chat: meeting_action(action: "chat", message: "...").';
+          const joinResult = {
+            ...result,
+            screenshotBase64: void 0,
+            monitorActive,
+            voiceAvailable: hasVoice,
+            voiceMode: voiceStatus?.mode || "chat-only",
+            voiceName: voiceStatus?.voiceName || null,
+            instructions: result.joined ? monitorActive ? `You are in the meeting. A MeetingMonitor is streaming captions and chat to you automatically. ${communicationInstructions} You do NOT need to call read_captions \u2014 updates come to you.` : `You are in the meeting. Captions are enabled. ${communicationInstructions} Call meeting_action(action: "read_captions") periodically to see what people are saying.` : "Join failed. Check screenshot.",
+            voiceStatusDetail: voiceStatus ? {
+              mode: voiceStatus.mode,
+              voice: voiceStatus.voiceName,
+              issues: voiceStatus.issues
+            } : null
+          };
+          if (result.screenshotBase64) {
+            return {
+              content: [
+                { type: "text", text: JSON.stringify(joinResult, null, 2) },
+                { type: "image", data: result.screenshotBase64, mimeType: "image/png" }
+              ]
+            };
+          }
+          return jsonResult(joinResult);
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── Meeting Actions ───────────────────────────────
+    {
+      name: "meeting_action",
+      description: `Perform actions during an active Google Meet meeting:
+- screenshot: Take a screenshot of the current meeting state
+- read_captions: Read live captions (Note: if MeetingMonitor is active, captions come to you automatically \u2014 use this only for on-demand reads)
+- read_chat: Read in-call chat messages
+- chat: Send a message in the meeting chat (requires "message" param). Uses robust multi-strategy input.
+- participants: List meeting participants
+- toggle_captions: Turn captions on/off
+- share_screen: Share your entire screen with meeting participants
+- share_tab: Share a specific browser tab (optional "url" param to open a URL in a new tab and share it)
+- stop_sharing: Stop any active screen/tab sharing
+- leave: Leave the meeting and stop the monitor`,
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          action: { type: "string", description: "Action to perform" },
+          message: { type: "string", description: 'Chat message to send (for "chat" action)' },
+          url: { type: "string", description: 'URL to open and share (for "share_tab" action)' }
+        },
+        required: ["action"]
+      },
+      async execute(_id, params) {
+        try {
+          const action = params.action;
+          let page;
+          try {
+            const result = await ensureBrowser2(false, agentId, false);
+            page = result.page;
+          } catch (err) {
+            return errorResult("No active browser session. Join a meeting first with meeting_join.");
+          }
+          const pageUrl = page.url() || "";
+          if (!pageUrl.includes("meet.google.com")) {
+            return errorResult(`Not on a Google Meet page (current URL: ${pageUrl}). Join a meeting first.`);
+          }
+          switch (action) {
+            case "screenshot": {
+              const screenshot = await saveScreenshot(page);
+              return {
+                content: [
+                  { type: "text", text: `Meeting screenshot taken.
+URL: ${pageUrl}
+Saved: ${screenshot.path}` },
+                  { type: "image", data: screenshot.base64, mimeType: "image/png" }
+                ]
+              };
+            }
+            case "read_captions": {
+              const captionsOn = await page.evaluate(() => !!document.querySelector('[aria-label*="Turn off captions"]'));
+              if (!captionsOn) {
+                await page.keyboard.press("c");
+                await delay(1500);
+              }
+              const captions = await readCaptionsFromDOM(page);
+              const monitor = getActiveMonitor(agentId);
+              return jsonResult({
+                action: "read_captions",
+                captions,
+                count: captions.length,
+                captionsEnabled: true,
+                monitorActive: !!monitor,
+                note: monitor ? "MeetingMonitor is active \u2014 captions are being streamed to you automatically. You only need this tool for on-demand reads." : "No monitor active. Call this periodically to stay updated."
+              });
+            }
+            case "toggle_captions": {
+              await page.keyboard.press("c");
+              await delay(500);
+              const isOn = await page.evaluate(() => !!document.querySelector('[aria-label*="Turn off captions"]'));
+              return jsonResult({ action: "toggle_captions", captionsOn: isOn });
+            }
+            case "read_chat": {
+              await ariaClick(page, ["Chat with everyone", "Open chat"], 3e3);
+              await delay(1e3);
+              const messages = await page.evaluate(() => {
+                const msgs = [];
+                const panel = document.querySelector('[aria-label="Side panel"]') || document.querySelector('[aria-label*="In-call messages"]');
+                if (!panel) return msgs;
+                const msgEls = panel.querySelectorAll("[data-message-text]");
+                for (const el of msgEls) {
+                  const text = el.getAttribute("data-message-text") || el.textContent?.trim() || "";
+                  let sender = "";
+                  const parent = el.closest('[class*="message"]') || el.parentElement?.parentElement;
+                  if (parent) {
+                    const nameEl = parent.querySelector('[class*="sender"], [class*="name"]');
+                    if (nameEl) sender = nameEl.textContent?.trim() || "";
+                  }
+                  if (text) msgs.push({ sender, text });
+                }
+                if (msgs.length === 0) {
+                  const allText = panel.innerText || "";
+                  const lines = allText.split("\n").filter(
+                    (l) => l.trim().length > 0 && l.trim() !== "In-call messages" && !l.includes("Continuous chat") && !l.includes("Messages won't be saved") && !l.includes("No chat messages") && !l.includes("Send a message") && !l.includes("pin a message") && l.trim().length < 500
+                  );
+                  for (const line of lines) msgs.push({ sender: "", text: line.trim() });
+                }
+                return msgs;
+              });
+              return jsonResult({ action: "read_chat", messages, count: messages.length });
+            }
+            case "chat": {
+              const message = params.message;
+              if (!message) return errorResult('No message provided. Set the "message" parameter.');
+              const result = await sendChatMessage(page, message);
+              if (result.sent) {
+                return jsonResult({ action: "chat", status: "sent", message, method: result.method });
+              } else {
+                return errorResult(`Failed to send chat message: ${result.error}. Method: ${result.method}`);
+              }
+            }
+            case "participants": {
+              await ariaClick(page, ["People"], 3e3);
+              await delay(1e3);
+              const participants = await page.evaluate(() => {
+                const names = [];
+                const panel = document.querySelector('[aria-label="Side panel"]');
+                if (!panel) return names;
+                const items = panel.querySelectorAll('[class*="participant"], [data-participant-id], [role="listitem"]');
+                for (const item of items) {
+                  const name = item.textContent?.trim();
+                  if (name && name.length < 100) names.push(name);
+                }
+                if (names.length === 0) {
+                  const tiles = document.querySelectorAll("[data-self-name], [data-participant-id]");
+                  for (const t of tiles) {
+                    const n = t.getAttribute("data-self-name") || t.textContent?.trim();
+                    if (n && n.length < 100) names.push(n);
+                  }
+                }
+                return [...new Set(names)];
+              });
+              await ariaClick(page, ["Close"], 1500);
+              return jsonResult({ action: "participants", participants, count: participants.length });
+            }
+            case "share_screen": {
+              try {
+                const clicked = await ariaClick(page, ["Present now", "Share screen", "Present"], 5e3);
+                if (!clicked) return errorResult('Could not find "Present now" button. Are you in an active meeting?');
+                await delay(1500);
+                const entireScreen = await ariaClick(page, ["Your entire screen", "Entire screen", "A window"], 5e3);
+                if (!entireScreen) {
+                  const firstOption = await page.evaluate(() => {
+                    const options = document.querySelectorAll('[role="menuitem"], [role="option"], [data-is-tooltip-wrapper]');
+                    for (const opt of options) {
+                      const text = opt.textContent?.toLowerCase() || "";
+                      if (text.includes("entire screen") || text.includes("your screen") || text.includes("a window")) {
+                        opt.click();
+                        return true;
+                      }
+                    }
+                    return false;
+                  });
+                  if (!firstOption) return errorResult("Could not select screen sharing option. The sharing menu may have changed.");
+                }
+                await delay(2e3);
+                const isSharing = await page.evaluate(() => {
+                  const indicators = document.querySelectorAll('[aria-label*="Stop presenting"], [aria-label*="stop sharing"], [aria-label*="You are presenting"]');
+                  return indicators.length > 0;
+                });
+                return jsonResult({
+                  action: "share_screen",
+                  status: isSharing ? "sharing" : "initiated",
+                  type: "entire_screen",
+                  note: isSharing ? 'Screen sharing is active. Use meeting_action(action: "stop_sharing") to stop.' : "Screen sharing was initiated. The OS picker may require manual confirmation if auto-select did not work."
+                });
+              } catch (e) {
+                return errorResult(`Failed to share screen: ${e.message}`);
+              }
+            }
+            case "share_tab": {
+              const targetUrl = params.url || params.targetUrl;
+              try {
+                if (targetUrl) {
+                  const newPage = await page.context().newPage();
+                  await newPage.goto(targetUrl, { waitUntil: "domcontentloaded", timeout: 15e3 });
+                  await delay(1e3);
+                  await page.bringToFront();
+                  await delay(500);
+                }
+                const clicked = await ariaClick(page, ["Present now", "Share screen", "Present"], 5e3);
+                if (!clicked) return errorResult('Could not find "Present now" button.');
+                await delay(1500);
+                const tabOption = await ariaClick(page, ["A tab", "Chrome tab", "Browser tab"], 5e3);
+                if (!tabOption) {
+                  const found = await page.evaluate(() => {
+                    const items = document.querySelectorAll('[role="menuitem"], [role="option"], [data-is-tooltip-wrapper]');
+                    for (const item of items) {
+                      const text = item.textContent?.toLowerCase() || "";
+                      if (text.includes("tab")) {
+                        item.click();
+                        return true;
+                      }
+                    }
+                    return false;
+                  });
+                  if (!found) return errorResult('Could not find "A tab" option in sharing menu.');
+                }
+                await delay(2e3);
+                const isSharing = await page.evaluate(() => {
+                  const indicators = document.querySelectorAll('[aria-label*="Stop presenting"], [aria-label*="stop sharing"], [aria-label*="You are presenting"]');
+                  return indicators.length > 0;
+                });
+                return jsonResult({
+                  action: "share_tab",
+                  status: isSharing ? "sharing" : "initiated",
+                  type: "browser_tab",
+                  targetUrl: targetUrl || null,
+                  note: isSharing ? 'Tab sharing is active. Use meeting_action(action: "stop_sharing") to stop.' : "Tab sharing initiated. You may need to select the tab in the browser picker."
+                });
+              } catch (e) {
+                return errorResult(`Failed to share tab: ${e.message}`);
+              }
+            }
+            case "stop_sharing": {
+              try {
+                const stopped = await ariaClick(page, ["Stop presenting", "Stop sharing", "Stop presentation"], 3e3);
+                if (stopped) {
+                  await delay(500);
+                  return jsonResult({ action: "stop_sharing", status: "stopped" });
+                }
+                const clickedStop = await page.evaluate(() => {
+                  const buttons = document.querySelectorAll("button");
+                  for (const btn of buttons) {
+                    const text = btn.textContent?.toLowerCase() || "";
+                    const label = btn.getAttribute("aria-label")?.toLowerCase() || "";
+                    if (text.includes("stop") && (text.includes("present") || text.includes("shar")) || label.includes("stop") && (label.includes("present") || label.includes("shar"))) {
+                      btn.click();
+                      return true;
+                    }
+                  }
+                  return false;
+                });
+                if (clickedStop) {
+                  await delay(500);
+                  return jsonResult({ action: "stop_sharing", status: "stopped" });
+                }
+                return jsonResult({ action: "stop_sharing", status: "no_active_share", note: "No active screen share was detected." });
+              } catch (e) {
+                return errorResult(`Failed to stop sharing: ${e.message}`);
+              }
+            }
+            case "leave": {
+              removeMonitor(agentId);
+              if (runtimeRef?.setKeepAlive && runtimeRef?.getCurrentSessionId) {
+                const sid = runtimeRef.getCurrentSessionId();
+                if (sid) runtimeRef.setKeepAlive(sid, false);
+              }
+              await ariaClick(page, ["Leave call"], 3e3);
+              return jsonResult({ action: "leave", status: "left_meeting", monitorStopped: true, keepAliveReleased: true });
+            }
+            default:
+              return errorResult(`Unknown action: "${action}". Supported: screenshot, read_captions, read_chat, chat, participants, toggle_captions, share_screen, share_tab, stop_sharing, leave`);
+          }
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── Detect Meeting Invites in Email ───────────────
+    {
+      name: "meetings_scan_inbox",
+      description: "Scan recent emails for meeting invitations and extract meeting links.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          hours: { type: "number", description: "Scan emails from last N hours (default: 24)" },
+          maxResults: { type: "number", description: "Max emails to scan (default: 30)" }
+        },
+        required: []
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const hours = params.hours || 24;
+          const after = new Date(Date.now() - hours * 36e5);
+          const dateStr = `${after.getFullYear()}/${String(after.getMonth() + 1).padStart(2, "0")}/${String(after.getDate()).padStart(2, "0")}`;
+          const GMAIL_BASE = "https://gmail.googleapis.com/gmail/v1/users/me";
+          const query = `after:${dateStr} (meet.google.com OR zoom.us OR teams.microsoft.com OR "meeting invitation" OR filename:ics)`;
+          const searchUrl = new URL(`${GMAIL_BASE}/messages`);
+          searchUrl.searchParams.set("q", query);
+          searchUrl.searchParams.set("maxResults", String(params.maxResults || 30));
+          const searchRes = await fetch(searchUrl.toString(), { headers: { Authorization: `Bearer ${token}` } });
+          if (!searchRes.ok) throw new Error(`Gmail search failed: ${searchRes.status}`);
+          const searchData = await searchRes.json();
+          if (!searchData.messages?.length) {
+            return jsonResult({ meetings: [], count: 0, message: "No meeting invites found in the last " + hours + " hours" });
+          }
+          const meetings = [];
+          for (const msg of searchData.messages.slice(0, 20)) {
+            try {
+              let walkParts2 = function(part) {
+                if (part.body?.data) bodyText += Buffer.from(part.body.data.replace(/-/g, "+").replace(/_/g, "/"), "base64").toString("utf-8") + " ";
+                if (part.parts) part.parts.forEach(walkParts2);
+              };
+              var walkParts = walkParts2;
+              const msgRes = await fetch(`${GMAIL_BASE}/messages/${msg.id}?format=full`, { headers: { Authorization: `Bearer ${token}` } });
+              if (!msgRes.ok) continue;
+              const msgData = await msgRes.json();
+              const headers = msgData.payload?.headers || [];
+              const subject = headers.find((h) => h.name?.toLowerCase() === "subject")?.value || "";
+              const from = headers.find((h) => h.name?.toLowerCase() === "from")?.value || "";
+              const date = headers.find((h) => h.name?.toLowerCase() === "date")?.value || "";
+              let bodyText = "";
+              walkParts2(msgData.payload);
+              const meetLinks = [];
+              const patterns = [
+                { regex: /https:\/\/meet\.google\.com\/[a-z-]+/gi, platform: "google_meet" },
+                { regex: /https:\/\/[\w.-]*zoom\.us\/[jw]\/[\d?=&\w]+/gi, platform: "zoom" },
+                { regex: /https:\/\/teams\.microsoft\.com\/l\/meetup-join\/[^\s"<>]+/gi, platform: "teams" }
+              ];
+              for (const p of patterns) {
+                const matches = bodyText.match(p.regex);
+                if (matches) for (const url of [...new Set(matches)]) meetLinks.push({ platform: p.platform, url });
+              }
+              if (meetLinks.length > 0) meetings.push({ messageId: msg.id, subject, from, date, meetingLinks: meetLinks, snippet: msgData.snippet?.slice(0, 200) });
+            } catch {
+            }
+          }
+          return jsonResult({ meetings, count: meetings.length, scannedEmails: searchData.messages.length });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    },
+    // ─── RSVP to Meeting ───────────────────────────────
+    {
+      name: "meeting_rsvp",
+      description: "Accept or decline a Google Calendar meeting invitation.",
+      category: "utility",
+      parameters: {
+        type: "object",
+        properties: {
+          eventId: { type: "string", description: "Calendar event ID (required)" },
+          response: { type: "string", description: '"accepted", "declined", or "tentative" (required)' },
+          calendarId: { type: "string", description: 'Calendar ID (default: "primary")' }
+        },
+        required: ["eventId", "response"]
+      },
+      async execute(_id, params) {
+        try {
+          const token = await tp.getAccessToken();
+          const calendarId = params.calendarId || "primary";
+          const email = tp.getEmail();
+          const event = await calendarApi(token, `/calendars/${encodeURIComponent(calendarId)}/events/${params.eventId}`);
+          const attendees = (event.attendees || []).map((a) => {
+            if (a.self || a.email === email) return { ...a, responseStatus: params.response };
+            return a;
+          });
+          if (!attendees.find((a) => a.self || a.email === email)) {
+            attendees.push({ email, responseStatus: params.response });
+          }
+          const updated = await calendarApi(token, `/calendars/${encodeURIComponent(calendarId)}/events/${params.eventId}`, {
+            method: "PATCH",
+            query: { sendUpdates: "all" },
+            body: { attendees }
+          });
+          const link = extractMeetingLink(updated);
+          return jsonResult({
+            rsvp: params.response,
+            eventId: params.eventId,
+            title: updated.summary,
+            start: updated.start?.dateTime || updated.start?.date,
+            meetingLink: link?.url
+          });
+        } catch (e) {
+          return errorResult(e.message);
+        }
+      }
+    }
+  ];
+}
+
+export {
+  createBrowserTool,
+  createMeetingVoiceTools,
+  ensureBrowser2 as ensureBrowser,
+  sendChatMessage,
+  createMeetingTools
+};