mercury-agent 0.4.5

package/examples/extensions/voice-transcribe/index.ts

@@ -0,0 +1,381 @@
+import { execFile as execFileCb } from "node:child_process";
+import { existsSync } from "node:fs";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { promisify } from "node:util";
+
+const execFile = promisify(execFileCb);
+
+const EXT = "voice-transcribe";
+const DEFAULT_MODEL = "mike249/whisper-tiny-he-2";
+const DEFAULT_PROVIDER = "local";
+const DEFAULT_LOCAL_ENGINE = "transformers";
+/** Classic HF Inference API (serverless). */
+const HF_INFERENCE_BASE = "https://api-inference.huggingface.co/models";
+
+const SCRIPT_PATH = path.join(
+  path.dirname(fileURLToPath(import.meta.url)),
+  "scripts",
+  "transcribe.py",
+);
+
+type Attachment = { path: string; type: string; mimeType: string };
+
+function parseTranscriptionJson(raw: string): string {
+  try {
+    const data = JSON.parse(raw) as unknown;
+    if (typeof data === "object" && data !== null && "text" in data) {
+      const t = (data as { text: unknown }).text;
+      if (typeof t === "string") return t.trim();
+    }
+    if (Array.isArray(data) && data.length > 0) {
+      const first = data[0] as { text?: string };
+      if (typeof first?.text === "string") return first.text.trim();
+    }
+  } catch {
+    /* ignore */
+  }
+  return "";
+}
+
+async function transcribeWithApi(
+  filePath: string,
+  mimeType: string,
+  modelId: string,
+  token: string,
+): Promise<string> {
+  const body = await readFile(filePath);
+  const url = `${HF_INFERENCE_BASE}/${encodeURIComponent(modelId)}`;
+  const res = await fetch(url, {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      "Content-Type":
+        mimeType.split(";")[0].trim() || "application/octet-stream",
+    },
+    body,
+  });
+  const raw = await res.text();
+  if (!res.ok) {
+    throw new Error(`HF inference ${res.status}: ${raw.slice(0, 240)}`);
+  }
+  return parseTranscriptionJson(raw);
+}
+
+function parseLastJsonLine(stdout: string): {
+  text?: string;
+  error?: string;
+} {
+  const lines = stdout.trim().split(/\r?\n/).filter(Boolean);
+  const line = lines[lines.length - 1] ?? "";
+  try {
+    return JSON.parse(line) as { text?: string; error?: string };
+  } catch {
+    return {};
+  }
+}
+
+function execFileStdout(e: unknown): string {
+  if (!e || typeof e !== "object" || !("stdout" in e)) return "";
+  const v = (e as { stdout?: Buffer | string }).stdout;
+  return Buffer.isBuffer(v) ? v.toString("utf8") : String(v ?? "");
+}
+
+/** Best-effort parse of `execFile` failures (non-zero exit, timeout kill, etc.). */
+function describeLocalTranscribeExecError(
+  e: unknown,
+  timeoutMs: number,
+): { message: string; meta: Record<string, unknown> } {
+  const fallback = e instanceof Error ? e.message : String(e);
+  if (!e || typeof e !== "object") {
+    return { message: fallback, meta: {} };
+  }
+  const o = e as Record<string, unknown>;
+  const stderr = Buffer.isBuffer(o.stderr)
+    ? o.stderr.toString("utf8")
+    : String(o.stderr ?? "");
+  const stdout = Buffer.isBuffer(o.stdout)
+    ? o.stdout.toString("utf8")
+    : String(o.stdout ?? "");
+  const stderrTail = stderr.trim().slice(-1200);
+  const stdoutTail = stdout.trim().slice(-600);
+  const code =
+    typeof o.code === "number"
+      ? o.code
+      : typeof o.code === "string"
+        ? o.code
+        : undefined;
+  const killed = o.killed === true;
+  const signal = typeof o.signal === "string" ? o.signal : undefined;
+  const errno = e as NodeJS.ErrnoException;
+  const errnoCode = typeof errno.code === "string" ? errno.code : undefined;
+  const msgLower = fallback.toLowerCase();
+
+  const looksTimedOut =
+    killed ||
+    errnoCode === "ETIMEDOUT" ||
+    msgLower.includes("etimedout") ||
+    msgLower.includes("timed out");
+
+  if (looksTimedOut) {
+    return {
+      message: `Local transcribe exceeded timeout (${timeoutMs}ms). First run often downloads the HF model — raise MERCURY_VOICE_TRANSCRIBE_TIMEOUT_MS, warm-cache the model, or use provider=api.`,
+      meta: {
+        reason: "timeout",
+        timeoutMs,
+        signal,
+        stderrTail: stderrTail || undefined,
+        stdoutTail: stdoutTail || undefined,
+      },
+    };
+  }
+
+  return {
+    message: fallback,
+    meta: {
+      reason: "exec_failed",
+      exitCode: typeof code === "number" ? code : undefined,
+      exitCodeString: typeof code === "string" ? code : undefined,
+      signal,
+      stderrTail: stderrTail || undefined,
+      stdoutTail: stdoutTail || undefined,
+    },
+  };
+}
+
+async function transcribeWithLocal(
+  scriptPath: string,
+  audioPath: string,
+  modelId: string,
+  localEngine: string,
+  pythonBin: string,
+  timeoutMs: number,
+): Promise<string> {
+  const opts = {
+    timeout: timeoutMs,
+    maxBuffer: 50 * 1024 * 1024,
+    windowsHide: true,
+    env: {
+      ...process.env,
+      PYTHONUNBUFFERED: "1",
+    },
+  };
+  try {
+    const { stdout } = await execFile(
+      pythonBin,
+      [
+        scriptPath,
+        "--audio",
+        audioPath,
+        "--model",
+        modelId,
+        "--local-engine",
+        localEngine,
+      ],
+      opts,
+    );
+    const data = parseLastJsonLine(stdout);
+    if (data.error) throw new Error(data.error);
+    return (data.text ?? "").trim();
+  } catch (e) {
+    const fromStdout = parseLastJsonLine(execFileStdout(e));
+    if (fromStdout.error) throw new Error(fromStdout.error);
+    if (fromStdout.text !== undefined && !fromStdout.error) {
+      return (fromStdout.text ?? "").trim();
+    }
+    throw e;
+  }
+}
+
+function resolveHostPath(workspace: string, attPath: string): string {
+  return path.isAbsolute(attPath) ? attPath : path.join(workspace, attPath);
+}
+
+function defaultPython(): string {
+  const fromEnv = process.env.MERCURY_VOICE_PYTHON?.trim();
+  if (fromEnv) return fromEnv;
+  return process.platform === "win32" ? "python" : "python3";
+}
+
+function localTimeoutMs(): number {
+  const raw = process.env.MERCURY_VOICE_TRANSCRIBE_TIMEOUT_MS?.trim();
+  if (raw) {
+    const n = Number.parseInt(raw, 10);
+    if (!Number.isNaN(n) && n > 0) return n;
+  }
+  return 300_000;
+}
+
+export default function (mercury: {
+  permission(opts: { defaultRoles: string[] }): void;
+  env(def: { from: string }): void;
+  config(
+    key: string,
+    def: {
+      description: string;
+      default: string;
+      validate?: (v: string) => boolean;
+    },
+  ): void;
+  skill(relativePath: string): void;
+  on(
+    event: "before_container",
+    handler: (
+      event: {
+        spaceId: string;
+        prompt: string;
+        callerId: string;
+        workspace: string;
+        containerWorkspace: string;
+        attachments?: Attachment[];
+      },
+      ctx: {
+        db: { getSpaceConfig: (spaceId: string, key: string) => string | null };
+        log: {
+          info: (msg: string, extra?: unknown) => void;
+          warn: (msg: string, extra?: unknown) => void;
+          error: (msg: string, extra?: unknown) => void;
+        };
+        hasCallerPermission: (
+          spaceId: string,
+          callerId: string,
+          permission: string,
+        ) => boolean;
+      },
+    ) => Promise<{ promptAppend?: string } | undefined>,
+  ): void;
+}) {
+  mercury.permission({ defaultRoles: ["admin", "member"] });
+  mercury.env({ from: "MERCURY_HF_TOKEN" });
+  mercury.config("provider", {
+    description:
+      '"local" = Python+transformers on Mercury host (see skill); "api" = Hugging Face Inference API (needs MERCURY_HF_TOKEN)',
+    default: DEFAULT_PROVIDER,
+    validate: (v) => v === "local" || v === "api",
+  });
+  mercury.config("model", {
+    description:
+      "Hugging Face model id (e.g. mike249/whisper-tiny-he-2 for local Hebrew; openai/whisper-large-v3 for api)",
+    default: DEFAULT_MODEL,
+  });
+  mercury.config("local_engine", {
+    description:
+      'local ASR only: "transformers" (default) or "faster_whisper" (CTranslate2 / Hugging Face CT2 repos, e.g. ivrit-ai/*-ct2)',
+    default: DEFAULT_LOCAL_ENGINE,
+    validate: (v) => v === "transformers" || v === "faster_whisper",
+  });
+  mercury.skill("./skill");
+
+  mercury.on("before_container", async (event, ctx) => {
+    if (!ctx.hasCallerPermission(event.spaceId, event.callerId, EXT)) {
+      return undefined;
+    }
+
+    const atts = event.attachments?.filter(
+      (a) => a.type === "voice" || a.type === "audio",
+    );
+    if (!atts?.length) return undefined;
+
+    const provider =
+      ctx.db.getSpaceConfig(event.spaceId, `${EXT}.provider`)?.trim() ||
+      DEFAULT_PROVIDER;
+    const model =
+      ctx.db.getSpaceConfig(event.spaceId, `${EXT}.model`)?.trim() ||
+      DEFAULT_MODEL;
+    const rawLocalEngine = ctx.db
+      .getSpaceConfig(event.spaceId, `${EXT}.local_engine`)
+      ?.trim();
+    const localEngine =
+      rawLocalEngine === "faster_whisper" || rawLocalEngine === "transformers"
+        ? rawLocalEngine
+        : DEFAULT_LOCAL_ENGINE;
+
+    let token: string | undefined;
+    if (provider === "api") {
+      token = process.env.MERCURY_HF_TOKEN?.trim();
+      if (!token) {
+        ctx.log.warn(
+          "MERCURY_HF_TOKEN not set; skipping voice transcription (api provider)",
+          { extension: EXT },
+        );
+        return undefined;
+      }
+    } else if (provider === "local") {
+      if (!existsSync(SCRIPT_PATH)) {
+        ctx.log.error("Local transcribe script missing", {
+          extension: EXT,
+          scriptPath: SCRIPT_PATH,
+        });
+        return undefined;
+      }
+    }
+
+    const lines: string[] = [];
+    const timeoutMs = localTimeoutMs();
+    const pythonBin = defaultPython();
+
+    for (const att of atts) {
+      const hostPath = resolveHostPath(event.workspace, att.path);
+      try {
+        let text: string;
+        if (provider === "api") {
+          text = await transcribeWithApi(
+            hostPath,
+            att.mimeType,
+            model,
+            token as string,
+          );
+        } else {
+          ctx.log.info("Voice transcription starting (local)", {
+            extension: EXT,
+            path: hostPath,
+            model,
+            localEngine,
+            timeoutMs,
+            pythonBin,
+          });
+          text = await transcribeWithLocal(
+            SCRIPT_PATH,
+            hostPath,
+            model,
+            localEngine,
+            pythonBin,
+            timeoutMs,
+          );
+        }
+        if (text) lines.push(text);
+      } catch (e) {
+        if (provider === "local") {
+          const { message, meta } = describeLocalTranscribeExecError(
+            e,
+            timeoutMs,
+          );
+          ctx.log.error("Voice transcription failed", {
+            extension: EXT,
+            path: hostPath,
+            provider,
+            model,
+            localEngine,
+            error: message,
+            ...meta,
+          });
+        } else {
+          ctx.log.error("Voice transcription failed", {
+            extension: EXT,
+            path: hostPath,
+            provider,
+            model,
+            error: e instanceof Error ? e.message : String(e),
+          });
+        }
+      }
+    }
+
+    if (lines.length === 0) return undefined;
+
+    return {
+      promptAppend: `[Voice transcript]\n${lines.join("\n")}`,
+    };
+  });
+}

package/examples/extensions/voice-transcribe/requirements.txt

@@ -0,0 +1,8 @@
+# Local transcription (voice-transcribe.provider=local). Install on the Mercury host:
+#   pip install -r requirements.txt
+transformers>=4.40.0
+torch>=2.0.0
+# Optional local engine when voice-transcribe.local_engine=faster_whisper (CTranslate2 models on Hub).
+faster-whisper>=1.0.0
+# Ships a platform ffmpeg binary when the `ffmpeg` command is missing (Telegram .ogg / Opus).
+imageio-ffmpeg>=0.4.9

package/examples/extensions/voice-transcribe/scripts/transcribe.py

@@ -0,0 +1,179 @@
+#!/usr/bin/env python3
+"""Transcribe a single audio file; print one JSON line to stdout: {\"text\":\"...\"} or {\"error\":\"...\"}."""
+
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import shutil
+import sys
+import tempfile
+
+
+def _ensure_ffmpeg_on_path() -> None:
+    """
+    Transformers and faster-whisper decode via ffmpeg on PATH.
+    imageio-ffmpeg ships a versioned .exe (e.g. ffmpeg-win-x86_64-v7.1.exe). On Windows,
+    Popen([...]) without shell=True will not run a .bat shim — it needs a real `ffmpeg.exe`
+    on PATH. We hardlink (or copy) the vendored binary to `<temp>/mercury-voice-ffmpeg/ffmpeg.exe`.
+    """
+    if shutil.which("ffmpeg"):
+        return
+    try:
+        import imageio_ffmpeg
+    except ImportError:
+        return
+    src = imageio_ffmpeg.get_ffmpeg_exe()
+    if not src or not os.path.isfile(src):
+        return
+
+    shim_root = os.path.join(tempfile.gettempdir(), "mercury-voice-ffmpeg")
+    os.makedirs(shim_root, exist_ok=True)
+    dst = os.path.join(shim_root, "ffmpeg.exe" if sys.platform == "win32" else "ffmpeg")
+
+    if not os.path.exists(dst):
+        try:
+            os.link(src, dst)
+        except OSError:
+            try:
+                shutil.copy2(src, dst)
+            except OSError:
+                return
+    elif sys.platform != "win32":
+        try:
+            os.chmod(dst, 0o755)
+        except OSError:
+            pass
+
+    os.environ["PATH"] = f"{shim_root}{os.pathsep}{os.environ.get('PATH', '')}"
+
+
+def _asr_device_torch():
+    """Resolve torch device for Transformers. Env: MERCURY_VOICE_ASR_DEVICE=cpu|cuda|auto (default auto)."""
+    import torch
+
+    raw = (os.environ.get("MERCURY_VOICE_ASR_DEVICE") or "").strip().lower()
+    if not raw or raw == "auto":
+        # Windows often reports CUDA but inference fails (drivers, OOM); CPU is the reliable default.
+        if sys.platform == "win32":
+            raw = "cpu"
+        else:
+            raw = "cuda" if torch.cuda.is_available() else "cpu"
+    if raw in ("cpu", "-1"):
+        return torch.device("cpu")
+    if raw in ("cuda", "gpu", "cuda:0", "0"):
+        if torch.cuda.is_available():
+            return torch.device("cuda:0")
+        return torch.device("cpu")
+    return torch.device("cpu")
+
+
+def _cuda_available() -> bool:
+    try:
+        import torch
+
+        return bool(torch.cuda.is_available())
+    except ImportError:
+        return False
+
+
+def _fw_device_str() -> str:
+    """faster-whisper device string: cpu | cuda. Same MERCURY_VOICE_ASR_DEVICE semantics as Transformers."""
+    raw = (os.environ.get("MERCURY_VOICE_ASR_DEVICE") or "").strip().lower()
+    if not raw or raw == "auto":
+        if sys.platform == "win32":
+            return "cpu"
+        return "cuda" if _cuda_available() else "cpu"
+    if raw in ("cpu", "-1"):
+        return "cpu"
+    if raw in ("cuda", "gpu", "cuda:0", "0"):
+        return "cuda" if _cuda_available() else "cpu"
+    return "cpu"
+
+
+def _fw_compute_type(device: str) -> str:
+    override = (os.environ.get("MERCURY_VOICE_FW_COMPUTE_TYPE") or "").strip()
+    if override:
+        return override
+    return "int8" if device == "cuda" else "float32"
+
+
+def _fw_language() -> str | None:
+    lang = (os.environ.get("MERCURY_VOICE_LANGUAGE") or "").strip()
+    return lang if lang else None
+
+
+def _run_transformers(audio_path: str, model_id: str) -> str:
+    try:
+        from transformers import pipeline
+    except ImportError as e:
+        raise ImportError(f"transformers import failed: {e}") from e
+
+    _ensure_ffmpeg_on_path()
+    device = _asr_device_torch()
+    pipe = pipeline(
+        "automatic-speech-recognition",
+        model=model_id,
+        device=device,
+    )
+    result = pipe(audio_path)
+    if isinstance(result, dict):
+        return (result.get("text") or "").strip()
+    return str(result).strip()
+
+
+def _run_faster_whisper(audio_path: str, model_id: str) -> str:
+    try:
+        from faster_whisper import WhisperModel
+    except ImportError as e:
+        raise ImportError(
+            "faster-whisper is required when local_engine=faster_whisper. "
+            "Install: pip install faster-whisper"
+        ) from e
+
+    _ensure_ffmpeg_on_path()
+    device = _fw_device_str()
+    compute_type = _fw_compute_type(device)
+    lang = _fw_language()
+
+    model = WhisperModel(model_id, device=device, compute_type=compute_type)
+    kwargs: dict = {}
+    if lang:
+        kwargs["language"] = lang
+    segments, _info = model.transcribe(audio_path, **kwargs)
+    parts: list[str] = []
+    for seg in segments:
+        parts.append(seg.text)
+    return "".join(parts).strip()
+
+
+def main() -> None:
+    ap = argparse.ArgumentParser(description="ASR for Mercury voice-transcribe (local provider)")
+    ap.add_argument("--audio", required=True, help="Path to audio file on disk")
+    ap.add_argument("--model", required=True, help="Hugging Face model id")
+    ap.add_argument(
+        "--local-engine",
+        choices=("transformers", "faster_whisper"),
+        default="transformers",
+        help="Local ASR backend (default: transformers)",
+    )
+    args = ap.parse_args()
+
+    try:
+        if args.local_engine == "faster_whisper":
+            text = _run_faster_whisper(args.audio, args.model)
+        else:
+            text = _run_transformers(args.audio, args.model)
+    except ImportError as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(2)
+    except Exception as e:
+        print(json.dumps({"error": str(e)}))
+        sys.exit(1)
+
+    print(json.dumps({"text": text}))
+
+
+if __name__ == "__main__":
+    main()

package/examples/extensions/voice-transcribe/skill/SKILL.md

@@ -0,0 +1,53 @@
+---
+name: voice-transcribe
+description: Voice notes are transcribed to text before the agent runs (local Python or Hugging Face Inference API).
+---
+
+# Voice transcription
+
+When a user sends a **voice note** or **audio** attachment, Mercury runs the `voice-transcribe` extension **before** the container starts. The transcript is appended to the user message as a `[Voice transcript]` block. You receive normal text — you do not need to read or play audio files for intent.
+
+## Configuration (per space)
+
+| Key | Purpose |
+|-----|---------|
+| `voice-transcribe.provider` | `local` (default) or `api` |
+| `voice-transcribe.model` | Hugging Face model id (see below) |
+| `voice-transcribe.local_engine` | Local only: `transformers` (default) or `faster_whisper` (CTranslate2 Hub repos) |
+
+### Local provider (`local`)
+
+Runs `scripts/transcribe.py` on the **Mercury host**.
+
+**Transformers (default)** — `voice-transcribe.local_engine=transformers` uses [Transformers](https://huggingface.co/docs/transformers) `pipeline("automatic-speech-recognition", model=...)`. Use standard PyTorch Whisper / compatible Hub ids (e.g. [mike249/whisper-tiny-he-2](https://huggingface.co/mike249/whisper-tiny-he-2)).
+
+**Faster-Whisper** — set `voice-transcribe.local_engine=faster_whisper` and [faster-whisper](https://github.com/SYSTRAN/faster-whisper) loads **CTranslate2** checkpoints from the Hub. Set `voice-transcribe.model` to a **CT2** repo (not plain PyTorch Whisper weights). Examples for Hebrew: [ivrit-ai/faster-whisper-v2-d4](https://huggingface.co/ivrit-ai/faster-whisper-v2-d4), [ivrit-ai/whisper-large-v3-turbo-ct2](https://huggingface.co/ivrit-ai/whisper-large-v3-turbo-ct2).
+
+1. Install on the same machine that runs Mercury:
+
+   ```bash
+   pip install -r /path/to/.mercury/extensions/voice-transcribe/requirements.txt
+   ```
+
+   Or: `pip install "transformers>=4.40.0" "torch>=2.0.0" "faster-whisper>=1.0.0" "imageio-ffmpeg>=0.4.9"`
+
+   **Telegram voice** is usually `.ogg` (Opus). Both backends shell out to an executable named `ffmpeg`; `transcribe.py` uses `imageio-ffmpeg`’s binary and exposes it as `ffmpeg` / `ffmpeg.exe` on `PATH` (hardlink or copy under `%TEMP%\\mercury-voice-ffmpeg` on Windows). Installing system ffmpeg on `PATH` also works (e.g. `winget install Gyan.FFmpeg`).
+
+2. Optional host `.env`:
+   - `MERCURY_VOICE_PYTHON` — Python executable (default: `python` on Windows, `python3` elsewhere)
+   - `MERCURY_VOICE_TRANSCRIBE_TIMEOUT_MS` — subprocess timeout in ms (default `300000`)
+   - `MERCURY_VOICE_ASR_DEVICE` — `cpu`, `cuda`, or `auto`. Used by **both** local engines. On Windows the default is **CPU** (CUDA often looks available but fails at inference). Set `cuda` if you have a working GPU stack.
+   - `MERCURY_VOICE_FW_COMPUTE_TYPE` — **Faster-Whisper only**: e.g. `int8`, `float16`, `float32`. If unset: `int8` on CUDA, `float32` on CPU.
+   - `MERCURY_VOICE_LANGUAGE` — **Faster-Whisper only**: ISO code passed to `transcribe(..., language=...)` (e.g. `he`). If unset, language is auto-detected.
+
+Hub messages like *Xet Storage… hf_xet* are warnings only, not the cause of failures.
+
+First run downloads the model into the Hugging Face cache (size depends on the model). **Each voice note spawns a new Python process**, so the first transcription after Mercury starts can be slow while the model loads (no in-process reuse yet).
+
+### API provider (`api`)
+
+POSTs audio to `https://api-inference.huggingface.co/models/<model>`. Requires `MERCURY_HF_TOKEN` on the host. Pick a model that has an [Inference Provider](https://huggingface.co/docs/api-inference) on its Hub page (e.g. `openai/whisper-large-v3`). Hebrew-tuned models such as [mike249/whisper-tiny-he-2](https://huggingface.co/mike249/whisper-tiny-he-2) often have **no** hosted provider — use **`local`** for those. CT2 / Faster-Whisper Hub repos are for the **local** engine only, not this API.
+
+## RBAC
+
+Only callers with the `voice-transcribe` permission (default: admin + member) get transcription. Others keep the raw message without an appended transcript.

package/examples/extensions/web-search/index.ts

@@ -0,0 +1,22 @@
+import type { MercuryExtensionAPI } from "../../../src/extensions/types.js";
+
+export default function (mercury: MercuryExtensionAPI) {
+  // pinchtab CLI is already declared by the pinchtab extension — do NOT re-declare here.
+  mercury.permission({ defaultRoles: ["admin", "member"] });
+  mercury.skill("./skill");
+
+  // The pinchtab extension injects "always use Brave Search, never use Google" into the
+  // system prompt. Structured real-world searches (flights, hotels, etc.) legitimately
+  // need Google Travel products and other specialist sites. Append an explicit exception
+  // so the agent follows the web-search skill rather than defaulting to Brave.
+  mercury.on("before_container", async () => {
+    return {
+      systemPrompt:
+        "Exception to the Brave Search rule: for structured real-world searches " +
+        "(flights, hotels, car rentals, cars for purchase, apartments/rentals), " +
+        "follow the web-search skill — use the specific sites it specifies " +
+        "(e.g. Google Flights, Google Hotels, AutoScout24, Airbnb). " +
+        "Do NOT route these requests to Brave Search.",
+    };
+  });
+}