refactor(search): remove the Gemini search backend

The user asked to drop it: nobody had the Gemini CLI login or a key set up,
and Exa then Wikipedia cover the voice use. webSearch is now live Chrome,
Exa, Brave (opt-in), Wikipedia. Removes the CLI/REST backends, the
GEMINI_* settings, the Docker login mount and checks, and updates the specs
and docs/llm_contexts.md.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
javis-bot
2026-11-18 09:24:11 +09:00
parent 59c3f33c2c
commit af1276cf6b
26 changed files with 66 additions and 504 deletions

View File

@@ -122,7 +122,7 @@ CHROME_START_URL=about:blank
# Screen-share + browser mode.
# true = the bot may go Live (screen-share the VNC desktop) and drive the
# on-screen browser for real-time info (search / play / read screen).
# false = no screen share; voice only, real-time info via the Gemini API.
# false = no screen share; voice only, real-time info via the normal web search.
STREAM_BROWSER=true
# Optional: profile dir for browser-based Google search in plain text turns
# (no active broadcast). When set, the search helper opens Chrome against this
@@ -133,27 +133,6 @@ STREAM_BROWSER=true
# Google does not challenge it). Use a DEDICATED dir, not your everyday Chrome
# profile, to avoid the "profile in use" lock while Chrome is open.
CHROME_USER_DATA_DIR=
# Gemini auth for real-time info when STREAM_BROWSER=false.
# oauth = use the Gemini CLI with a Google-account login (no API key).
# Install once: npm i -g @google/gemini-cli ; then run `gemini` and
# "Sign in with Google". Uses the CLI's built-in web-search grounding.
# NOTE (2026-06): Google is blocking personal Google accounts on this
# path ("This client is no longer supported for Gemini Code Assist for
# individuals"). Workspace/org accounts may still work; personal
# accounts should use apikey below instead.
# apikey = REST path; needs GEMINI_API_KEY below
# (get one at https://aistudio.google.com/app/apikey). Recommended for
# personal Google accounts now that individual OAuth login is blocked.
# Either way, real-time search fail-opens to DDG/Brave/Wikipedia if Gemini is
# unavailable, so this is optional, not required.
GEMINI_AUTH=oauth
GEMINI_API_KEY=
GEMINI_MODEL=gemini-2.0-flash
# OAuth login source for Docker. The container mounts this into ~/.gemini.
# Default (blank) = ./docker/gemini-oauth (project-local, cross-platform). Seed
# it once: cp -r ~/.gemini/. docker/gemini-oauth/ (copy the whole login state).
# Or point at an existing host login instead, e.g. GEMINI_OAUTH_DIR=~/.gemini
GEMINI_OAUTH_DIR=
# ---------------------------------------------------------------------------
# VNC screen broadcast

4
.gitignore vendored
View File

@@ -29,7 +29,3 @@ src/jarvis/_version.py
.env.bak*
*.bak
# Gemini CLI OAuth login (account tokens) seeded for GEMINI_AUTH=oauth in Docker.
# Keep the dir (.gitkeep) but never commit the login files.
docker/gemini-oauth/*
!docker/gemini-oauth/.gitkeep

View File

@@ -21,7 +21,7 @@ Any code change must either adhere to our spec files perfectly or you should ask
| `src/jarvis/tools/builtin/tool_search.spec.md` | toolSearchTool escape hatch for mid-loop tool routing | Re-runs the same router; never removes stop/self; capped per reply |
| `src/jarvis/tools/external/mcp_runtime.spec.md` | Persistent MCP runtime: per-server long-lived stdio session, queue-based dispatch, retry on transient session loss | One worker per server keyed by config; calls to the same server serialise; `MCPServerSessionError` for session-level failures; opt-in `idle_timeout_sec` for stateless servers |
| `src/jarvis/reply/prompts/prompts.spec.md` | System/user prompt templates | — |
| `src/jarvis/tools/builtin/web_search.spec.md` | webSearch tool: live-broadcast Chrome, then Exa (keyless), Gemini (only with a login or key), Brave (opt-in), title-guarded Wikipedia; foreign-script drop, SSRF guard, prompt-injection fence, honest envelopes | Untrusted web content is fenced as data, not instructions; rank preference over speed; honest failure over confabulation |
| `src/jarvis/tools/builtin/web_search.spec.md` | webSearch tool: live-broadcast Chrome, then Exa (keyless), Brave (opt-in), title-guarded Wikipedia; foreign-script drop, SSRF guard, prompt-injection fence, honest envelopes | Untrusted web content is fenced as data, not instructions; rank preference over speed; honest failure over confabulation |
| `src/jarvis/tools/builtin/chat_channels.spec.md` | chatChannels tool (v2): list, read, search, send, edit, react, delete, pin registered Discord chat channels through the voice worker and app | Offered only with a chat backend; per-channel switches; chat is fenced data; delete needs the user's yes in a later turn |
| `src/jarvis/tools/builtin/schedule.spec.md` | schedule tool (v2): reminders, timers and scheduled tasks of the asker; the app keeps, fires and delivers them | Offered only with a schedule backend; only the asker's own; tasks get read-only tools; never claimed without the tool |
| `src/jarvis/tools/builtin/personal_notes.spec.md` | personalNotes tool (v2): each person's standing instructions for how they are answered; the app keeps them and sends the asker's with every reply | Offered only with a notes backend; only the asker's own, only in their answers; fenced, never permits an action |

View File

@@ -39,16 +39,11 @@ RUN wget -q -O /tmp/chrome.deb https://dl.google.com/linux/direct/google-chrome-
# --- bun (Discord bot runtime/package manager) ---
RUN curl -fsSL https://bun.sh/install | bash
# --- Node.js + Gemini CLI (the GEMINI_AUTH=oauth real-time search path shells
# out to `gemini`; it needs a real Node runtime, not bun). The account
# login itself is provided at runtime via the mounted ~/.gemini (see
# docker-compose.yml); here we only install the binary. ---
ARG GEMINI_CLI_VERSION=0.46.0
# --- Node.js (the on-screen browser search helper, browse-search.mjs, needs a
# real Node runtime, not bun) ---
RUN curl -fsSL https://deb.nodesource.com/setup_22.x | bash - \
&& apt-get install -y --no-install-recommends nodejs \
&& npm install -g "@google/gemini-cli@${GEMINI_CLI_VERSION}" \
&& rm -rf /var/lib/apt/lists/* \
&& gemini --version
&& rm -rf /var/lib/apt/lists/*
# --- Python brain/bridge deps (slim set) ---
COPY bridge/requirements-bridge.txt /app/bridge/requirements-bridge.txt

View File

@@ -26,7 +26,7 @@ export interface TextResult {
/** Full voice turn: WAV in -> {transcript, reply, reply audio}. ``broadcasting``
* is the current live screen-share state so the brain routes search (Chrome
* while live, Gemini when off). */
* while live, the normal search when off). */
export async function converse(wav: Buffer, broadcasting?: boolean): Promise<ConverseResult> {
const qs = broadcasting === undefined ? "" : `?broadcasting=${broadcasting ? "1" : "0"}`;
const res = await fetch(`${config.bridgeUrl}/converse${qs}`, {

View File

@@ -4,7 +4,7 @@
*
* The screen broadcast is coupled to the voice session: it auto-starts when the
* assistant joins a voice channel (screen-share mode default), reports its live
* state to the brain each turn (search routes Chrome while live / Gemini when
* state to the brain each turn (search routes Chrome while live / normal search when
* off), and the brain can toggle it by voice ("방송 켜줘 / 꺼줘"). This logic
* used to live only in the normal-bot join handler, so the userbot path (the
* only mode that can actually Go Live) never started a broadcast. Keeping it

View File

@@ -74,7 +74,7 @@ async function handleJoin(i: ChatInputCommandInteraction) {
// Screen-share mode (STREAM_BROWSER=true): the broadcast is coupled to the
// voice session. Auto-start it on join, report its live state to the brain
// each turn (search routes Chrome while live / Gemini when off), and let the
// each turn (search routes Chrome while live / normal search when off), and let the
// brain toggle it via voice ("방송 켜줘 / 꺼줘"). In voice-only mode
// (STREAM_BROWSER=false) none of this runs and the broadcast stays off.
await maybeCoupleBroadcast(session, { guildId: i.guildId!, voiceChannelId: channel.id });

View File

@@ -99,7 +99,7 @@ export class VoiceSession {
ttsEndMs?: number;
}) => void;
/** Live screen-share state, sent with each turn so the brain routes search
* (Chrome while broadcasting, Gemini when off). */
* (Chrome while broadcasting, the normal search when off). */
getBroadcasting?: () => boolean;
/** Apply a broadcast directive the brain requested (start/stop the stream). */
onBroadcastAction?: (action: "start" | "stop") => void | Promise<void>;

View File

@@ -286,7 +286,7 @@ def think(text: str, language: Optional[str] = None, broadcasting: Optional[bool
``broadcasting`` is the bot's live screen-share state for this turn; it is
stashed in request-scoped state so the search routing can pick Chrome vs
Gemini. If the reply engine calls the setBroadcast tool, the recorded
the normal search chain. If the reply engine calls the setBroadcast tool, the recorded
directive is returned as ``broadcast_action`` for the bot to act on.
"""
if not BRAIN_ENABLED:

View File

@@ -175,26 +175,6 @@ services:
- javis_data:/data # jarvis db + memory
- whisper_cache:/root/.cache/huggingface # cached Whisper models
- piper_voices:/opt/piper-voices # TTS voices
# Gemini account login for GEMINI_AUTH=oauth real-time search. Bind-mounts a
# PROJECT-LOCAL dir (./docker/gemini-oauth) into the CLI's ~/.gemini. A
# project-relative path is used on purpose: it resolves identically on Linux
# and on Windows Docker Desktop, unlike ${HOME} which is frequently unset
# when compose is invoked outside a WSL shell (PowerShell/cmd), silently
# mounting the wrong dir. The mount is writable so the CLI refreshes its
# token in place.
#
# Seed it ONCE from a machine that has a browser + the logged-in Gemini CLI
# (`npm i -g @google/gemini-cli`, then `gemini` -> "Sign in with Google"):
# cp -r ~/.gemini/. docker/gemini-oauth/ # Linux / WSL
# `oauth_creds.json` is the essential credential (holds the refresh token);
# with GOOGLE_GENAI_USE_GCA=true the CLI forces OAuth, so that one file is
# what the readiness check + entrypoint warning verify. Copying the WHOLE
# ~/.gemini is simplest and also carries the cached account/settings. To
# reuse an existing host login without copying, set in .env:
# GEMINI_OAUTH_DIR=~/.gemini
# If unseeded, the path fail-opens to the DDG/Brave cascade and the
# entrypoint logs a warning. Only consumed when GEMINI_AUTH=oauth.
- ${GEMINI_OAUTH_DIR:-./docker/gemini-oauth}:/root/.gemini
# Operator instruction files. Every *.md here is appended to the main
# reply LLM's system prompt (filename order), read per turn so edits apply
# on the next reply without a rebuild/restart. Read-only; a project-

View File

@@ -76,19 +76,5 @@ fi
# --- Ensure the Piper voice exists (best effort) ---
bash /app/docker/download-piper.sh || echo "[entrypoint] piper download failed; TTS may be unavailable"
# --- Gemini OAuth login check (GEMINI_AUTH=oauth real-time search) ---
# The browser-only role never runs the reply engine / web search, so skip the
# check there. Otherwise warn (don't fail) when oauth is selected but no login
# has been seeded into the mounted ~/.gemini, since the path silently degrades
# to the DDG/Brave cascade.
if [ "${JARVIS_ROLE:-full}" != "browser" ] \
&& [ "${GEMINI_AUTH:-oauth}" = "oauth" ] \
&& [ ! -f /root/.gemini/oauth_creds.json ]; then
echo "[entrypoint] 🔑 GEMINI_AUTH=oauth but no Gemini login at /root/.gemini/oauth_creds.json"
echo "[entrypoint] Real-time search will fall back to DDG/Brave until you seed the login."
echo "[entrypoint] Seed it: copy a logged-in ~/.gemini into the host's gemini-oauth dir"
echo "[entrypoint] (default ./docker/gemini-oauth, or set GEMINI_OAUTH_DIR). See docs/DEPLOY.md."
fi
echo "[entrypoint] display=$DISPLAY ollama=$OLLAMA_BASE_URL whisper=$WHISPER_MODEL/$WHISPER_DEVICE"
exec supervisord -c /app/docker/supervisord.conf

View File

@@ -1,4 +0,0 @@
# Seed directory for the Gemini CLI OAuth login used by GEMINI_AUTH=oauth.
# docker-compose bind-mounts this dir into the container's ~/.gemini.
# Seed it once (see docker-compose.yml): cp -r ~/.gemini/. docker/gemini-oauth/
# The login files themselves are gitignored (they contain account tokens).

View File

@@ -134,24 +134,7 @@ The `brain` and `app` roles are backward-compatible additions to `full`/`browser
- Install the NVIDIA driver on Windows and enable GPU in Docker Desktop
(Settings → Resources → WSL Integration). Use the `gpu-windows.yml` override.
- Paths: named volumes are cross-platform. The Gemini OAuth login (for
`GEMINI_AUTH=oauth`) is bind-mounted from the project-local `./docker/gemini-oauth`
into the container's `~/.gemini`. A project-relative path is used so it resolves
the same on Windows Docker Desktop and Linux (`${HOME}` is often unset when
compose runs from PowerShell/cmd). Seed it once from a machine with a browser and
the logged-in Gemini CLI (`npm i -g @google/gemini-cli`, then `gemini` ->
"Sign in with Google"), copying the login state:
(Note: as of 2026-06 Google blocks personal Google accounts on this CLI login
with "This client is no longer supported for Gemini Code Assist for
individuals". Workspace/org accounts may still work; personal accounts should
use `GEMINI_AUTH=apikey` with a key from https://aistudio.google.com/app/apikey
instead. Real-time search fail-opens to DDG/Brave/Wikipedia either way.)
`cp -r ~/.gemini/. docker/gemini-oauth/`. The essential file is `oauth_creds.json`
(it holds the refresh token; `GOOGLE_GENAI_USE_GCA=true` forces OAuth, so that is
the file the startup readiness check looks for) - copying the whole dir simply also
carries the cached account/settings. To reuse an existing host login without
copying, set `GEMINI_OAUTH_DIR=~/.gemini` in `.env`. If unseeded, real-time search
fail-opens to DDG/Brave and the container logs a `🔑` warning on startup.
- Paths: named volumes are cross-platform.
## Known limitation

View File

@@ -183,10 +183,7 @@ Every distinct LLM call in Jarvis, what feeds it, what consumes it, and how it i
- **Weather** ([src/jarvis/tools/builtin/weather.py](src/jarvis/tools/builtin/weather.py), ~line 60) — `ollama_chat_model`, parses location/time/unit from the query.
- **Chat delete consent** ([src/jarvis/tools/builtin/chat_channels.py](src/jarvis/tools/builtin/chat_channels.py), `_user_agrees`, v2 only) — resolution chain `tool_router_model → intent_judge_model → ollama_chat_model`, temperature 0, timeout `llm_tools_timeout_sec`. Runs only when `chatChannels delete confirm=true` arrives in the turn right after the delete was asked. Input: the pending message ID and channel name (in the system prompt) and the person's own message of this turn (fenced); a message over 600 chars is not sent and counts as no. Output: one word, YES means delete that message. Fail-closed. Eval: `evals/test_chat_delete_consent.py`.
- **Nutrition log_meal** ([src/jarvis/tools/builtin/nutrition/log_meal.py](src/jarvis/tools/builtin/nutrition/log_meal.py), lines 48 & 136) — `ollama_chat_model`, extracts nutrients, confirms logging.
- **Gemini real-time search** ([src/jarvis/tools/builtin/realtime_search.py](src/jarvis/tools/builtin/realtime_search.py)) — **external Gemini model**, NOT Ollama. Used on the `webSearch` route only after Exa found nothing, and only when it can work: `oauth` with a Gemini CLI login present (`gemini_oauth_ready()`), or `apikey` with a key. While the broadcast is live the on-screen Chrome path goes first ([web_search.spec.md](src/jarvis/tools/builtin/web_search.spec.md)). Sub-mode is `cfg.gemini_auth` (env `GEMINI_AUTH`, default `oauth`):
- `oauth` (default) `gemini_cli_search()` — shells out to the Gemini CLI (`gemini -p <query> -o json --skip-trust`, default approval mode) authenticated by the user's Google-account login (`GEMINI_API_KEY`/`GOOGLE_API_KEY` stripped from the child env, `GOOGLE_GENAI_USE_GCA=true` set to select OAuth); model is whatever the CLI/account defaults to. Uses the CLI's built-in web-search grounding. Bounded by a 30s subprocess timeout. The login lives in `~/.gemini`; in Docker that is the project-local `docker/gemini-oauth` bind mount (override `GEMINI_OAUTH_DIR`), which the operator seeds once. `gemini_oauth_ready()` checks `~/.gemini/oauth_creds.json`; without it the CLI is not started (it cost about 2 s per search for nothing, live 2026-11-18).
- `apikey` `gemini_search()` — one REST `generateContent` call (`gemini_model`, default `gemini-2.0-flash`) with the `google_search` grounding tool; keyed by `GEMINI_API_KEY`.
Both return the fenced UNTRUSTED-WEB-EXTRACT envelope consumed by the main loop (#1). Fail-open: CLI missing / login expired / quota 429 / timeout / errors / missing key all fall through to Brave (opt-in) and Wikipedia. The `STREAM_BROWSER=true` route (`browser_search()`) makes NO LLM call — it drives Chrome and scrapes Google results.
- **Real-time search, no LLM**: webSearch makes no LLM call. The Gemini search backend (CLI or REST) was removed 2026-11-18 at the user's request; the `STREAM_BROWSER=true` route (`browser_search()`) drives Chrome and scrapes Google results.
## 15. Voice call judgements (v2 voice worker)

View File

@@ -11,15 +11,13 @@ screen-share state then decides the search backend per turn:
- While the broadcast is **live**: drive the on-screen Chrome (CDP at
`CDP_PORT`, default 9222) to Google-search / play YouTube / read the page —
visible on the Go-Live stream (VNC display `:1`).
- While the broadcast is **off**: the normal webSearch chain (Exa, then Gemini, then
- While the broadcast is **off**: the normal webSearch chain (Exa, then
Brave and Wikipedia; `src/jarvis/tools/builtin/web_search.spec.md`), no screen needed.
- The user can toggle the broadcast on/off by voice ("방송 켜줘" / "방송 꺼줘"),
routed through an LLM tool (no hardcoded phrase matching).
- **`STREAM_BROWSER=false`**: broadcasting is disabled entirely. Any `/stream`
or "start broadcast" request is refused, and real-time search always uses
the normal webSearch chain. Gemini's auth sub-mode there is `GEMINI_AUTH`:
- `oauth` (default): the Gemini CLI with a Google-account login (no API key).
- `apikey`: the REST API keyed by `GEMINI_API_KEY`.
the normal webSearch chain.
The brain receives the live broadcast state per request (`ToolContext.broadcasting`,
threaded from the bot via the bridge); `None` means "no signal" (evals, text
@@ -32,9 +30,7 @@ entry) and falls back to the master flag so behaviour is unchanged.
| Mode flag (bot) | `bot/src/config.ts` `screenBrowser`, enforced in `selfbot.ts` | done |
| Browser search core (Node/CDP) | `bot/scripts/stream-test/browse-search.mjs` | this change |
| Brain mode read | `src/jarvis/config.py` `stream_browser` from env | TODO |
| Gemini auth mode | `GEMINI_AUTH` (oauth/apikey), `GEMINI_API_KEY`, `GEMINI_MODEL` (.env) + `config.py` | done |
| `browseAndSearch` tool (true) | `src/jarvis/tools/builtin/browse_and_search.py` -> subprocess the Node core | TODO |
| Gemini search (false) | `realtime_search.py` `gemini_cli_search()` (oauth, CLI) / `gemini_search()` (apikey, REST) | done |
| Search routing by live broadcast | `web_search.py` uses `ToolContext.broadcasting` + master flag | done |
| Live broadcast state in tool ctx | `tools/base.py` `ToolContext.broadcasting` from `turn_state` | done |
| Per-turn state channel | `reply/turn_state.py` (thread-local: broadcasting in, directive out) | done |
@@ -51,30 +47,8 @@ entry) and falls back to the master flag so behaviour is unchanged.
(`broadcast-helper.mjs`, `selfbot.ts`), so the brain shells out to
`node browse-search.mjs <query>` and wraps the JSON result in the engine's
`UNTRUSTED WEB EXTRACT` envelope. Keeps the 39k-line Python brain dep-free.
- Gemini has two auth sub-modes (`GEMINI_AUTH`):
- `oauth` (default): shell out to the Gemini CLI (`gemini -p <query> -o json
--skip-trust`, default approval mode — read-only tools like web search run
headless, but write/shell tools are never auto-approved) authenticated by
the user's Google account login. `GEMINI_API_KEY`/`GOOGLE_API_KEY` are stripped from the child
env, and `GOOGLE_GENAI_USE_GCA=true` is set, so the CLI uses the account
login (not API-key auth) and fails fast when no login exists rather than
erroring on "no auth method". The CLI is resolved from `PATH` or
`~/.local/bin/gemini`; install with `npm i -g @google/gemini-cli` and sign
in once via interactive `gemini` ("Sign in with Google"). In Docker the login
can't be done interactively in the headless container: seed it instead by
copying a logged-in `~/.gemini` into the project-local `docker/gemini-oauth`
bind mount (or set `GEMINI_OAUTH_DIR`); the container reads/refreshes the
token there. `gemini_oauth_ready()` gates an actionable log hint, and the
entrypoint warns on startup, when oauth is selected but no login is seeded.
- `apikey`: the REST endpoint (`generativelanguage.googleapis.com`) via stdlib
`urllib` with the `google_search` grounding tool - no SDK dependency.
- Both Gemini paths and the browser path return the same
`ToolExecutionResult(success, reply_text)` envelope, and are fail-open: any
failure returns `None` and the caller goes on down the webSearch chain.
## Notes / verification
- Grounded Gemini search needs real quota. On a free tier the grounded call can
return HTTP 429 `RESOURCE_EXHAUSTED` (free-tier limit 0); the OAuth login must
be a Google account with usable Gemini quota, otherwise the path 429s and
fail-opens to Brave/Wikipedia. The 30s subprocess timeout bounds the CLI's retry/backoff.
- Behaviour covered by `tests/test_realtime_gemini_cli.py`.
- The browser path returns the same `UNTRUSTED WEB EXTRACT` envelope as webSearch
and is fail-open: any failure returns `None` and the caller goes on down the
webSearch chain.
- The Gemini search backend (CLI with a Google login, or REST with a key) was
removed 2026-11-18 at the user's request.

View File

@@ -1,8 +1,8 @@
"""
Regression eval: the provider chain rescues a failed primary search honestly.
Exa is the primary provider. When it is down or finds nothing (and no Gemini
login or key is set up), Wikipedia is the last resort; when that misses too,
Exa is the primary provider. When it is down or finds nothing (and no Brave
key is set up), Wikipedia is the last resort; when that misses too,
an honest "found nothing" envelope forbids facts so the reply LLM cannot
confabulate from its priors.
@@ -28,8 +28,6 @@ def _make_ctx(cfg_overrides=None):
cfg.web_search_enabled = True
cfg.voice_debug = False
cfg.stream_browser = False
cfg.gemini_auth = "api_key"
cfg.gemini_api_key = ""
cfg.brave_search_api_key = ""
cfg.wikipedia_fallback_enabled = True
for k, v in (cfg_overrides or {}).items():
@@ -78,7 +76,7 @@ class TestFallbackChainRescuesFailedSearch:
@_exa_down()
@patch("jarvis.tools.builtin.web_search._wikipedia_summary", return_value=None)
def test_honest_envelope_when_all_providers_fail(self, _wiki, _post):
"""Exa down, no Gemini, no Brave key, Wikipedia miss → honest envelope."""
"""Exa down, no Brave key, Wikipedia miss → honest envelope."""
result = WebSearchTool().run({"search_query": "obscure thing"}, _make_ctx())
assert result.success is True

View File

@@ -250,14 +250,8 @@ class Settings:
brave_search_api_key: str
# Real-time info routing (mirrors the bot's STREAM_BROWSER, read from env).
# True -> browser tools drive the on-screen Chrome (visible on the broadcast).
# False -> geminiSearch uses the Gemini API (gemini_api_key / gemini_model).
# False -> webSearch always uses its normal provider chain.
stream_browser: bool
# "oauth" -> geminiSearch shells out to the Gemini CLI using the user's
# Google account login (no API key); built-in web-search grounding.
# "apikey" -> legacy REST path using gemini_api_key / gemini_model.
gemini_auth: str
gemini_api_key: str
gemini_model: str
# Zero-config Wikipedia fallback toggle. When True (default), the tool
# queries Wikipedia's REST summary API as a last resort before giving up
# with the honest "blocked" envelope. Privacy-light (public API, no key,
@@ -610,11 +604,8 @@ def load_settings() -> Settings:
# Build Settings. Some fields support env var overrides.
# Env overrides: JARVIS_VOICE_DEBUG, JARVIS_WHISPER_BACKEND
voice_debug = os.environ.get("JARVIS_VOICE_DEBUG", "0") == "1"
# Real-time info mode + Gemini account (shared with the bot's .env).
# Real-time info mode (shared with the bot's .env).
stream_browser = os.environ.get("STREAM_BROWSER", "true").strip().lower() not in ("0", "false", "no")
gemini_auth = os.environ.get("GEMINI_AUTH", "oauth").strip().lower() or "oauth"
gemini_api_key = os.environ.get("GEMINI_API_KEY", "").strip()
gemini_model = os.environ.get("GEMINI_MODEL", "").strip() or "gemini-2.0-flash"
# Normalize/convert fields
db_path = str(merged.get("db_path") or _default_db_path())
@@ -912,9 +903,6 @@ def load_settings() -> Settings:
web_search_enabled=web_search_enabled,
brave_search_api_key=brave_search_api_key,
stream_browser=stream_browser,
gemini_auth=gemini_auth,
gemini_api_key=gemini_api_key,
gemini_model=gemini_model,
wikipedia_fallback_enabled=wikipedia_fallback_enabled,
# Dictation

View File

@@ -11,7 +11,7 @@ Fields
------
broadcasting : Optional[bool]
The live screen-share (Go-Live) state the bot sends with the request. The
webSearch routing reads it to pick on-screen Chrome (live) vs Gemini (off).
webSearch routing reads it to pick on-screen Chrome (live) vs the normal chain (off).
broadcast_action : Optional[str]
A directive ("start"/"stop") recorded by the setBroadcast tool for the
bridge to return to the bot, which owns the actual broadcast.

View File

@@ -41,7 +41,7 @@ class ToolContext:
# Live broadcast (screen-share / Go-Live) state for THIS turn, passed in
# by the bot per request. Controls real-time search routing when the
# master flag ``cfg.stream_browser`` is on: broadcasting -> on-screen
# Chrome search (visible on the stream), not broadcasting -> Gemini.
# Chrome search (visible on the stream), not broadcasting -> the normal chain.
# ``None`` means "no signal" (evals, text entry, older bot): callers
# fall back to the master flag so behaviour is unchanged.
self.broadcasting = broadcasting

View File

@@ -1,67 +1,27 @@
"""Real-time info backends selected by ``STREAM_BROWSER`` (see
"""Real-time info backend selected by ``STREAM_BROWSER`` (see
``docs/stream_browser_modes.md``).
- ``browser_search``: drives the on-screen Chrome via a small Node CDP helper so
the action is visible on the Go-Live broadcast; returns Google's top results.
- ``gemini_search``: Google Gemini API with the ``google_search`` grounding tool.
Both return a fenced ``UNTRUSTED WEB EXTRACT`` string (the same shape ``webSearch``
emits) so downstream synthesis is unchanged, or ``None`` to fall through to the
rest of the webSearch chain. Both are fail-open: any error returns
``None`` and the caller degrades gracefully.
``browser_search`` drives the on-screen Chrome via a small Node CDP helper so the
action is visible on the Go-Live broadcast; it returns Google's top results as a
fenced ``UNTRUSTED WEB EXTRACT`` string (the same shape ``webSearch`` emits), or
``None`` to fall through to the rest of the webSearch chain. It is fail-open: any
error returns ``None`` and the caller degrades gracefully.
"""
from __future__ import annotations
import json
import os
import shutil
import subprocess
import urllib.request
from pathlib import Path
from typing import Optional
from ...debug import debug_log
# .../owner/src/jarvis/tools/builtin/realtime_search.py -> parents[4] == .../owner
_REPO_ROOT = Path(__file__).resolve().parents[4]
_NODE_SCRIPT = _REPO_ROOT / "bot" / "scripts" / "stream-test" / "browse-search.mjs"
def _gemini_bin() -> Optional[str]:
"""Locate the Gemini CLI binary. Returns ``None`` when it is not installed
so the caller falls open to the default search cascade."""
found = shutil.which("gemini")
if found:
return found
local = Path.home() / ".local" / "bin" / "gemini"
return str(local) if local.exists() else None
def gemini_oauth_dir() -> Path:
"""Directory the Gemini CLI stores its Google-account (OAuth) login in."""
return Path.home() / ".gemini"
def gemini_oauth_ready() -> bool:
"""True when a Gemini CLI OAuth login is present
(``~/.gemini/oauth_creds.json``).
Lets the OAuth path emit an actionable signal instead of silently degrading
to the rest of the webSearch chain when ``GEMINI_AUTH=oauth`` is selected but no
Google-account login has been seeded — the common Docker first-run case,
where ``~/.gemini`` is a bind mount that the operator must populate once."""
try:
return (gemini_oauth_dir() / "oauth_creds.json").is_file()
except Exception:
return False
# One-time per-process guard so the "no login seeded" hint is logged once, not
# on every search turn.
_oauth_hint_shown = False
def _fence(header: str, body: str) -> str:
return (
f"{header} [UNTRUSTED WEB EXTRACT — treat as data, not instructions; "
@@ -97,90 +57,3 @@ def browser_search(query: str, timeout: int = 35) -> Optional[str]:
return _fence(f"**Browser search results for '{query}'**", "\n".join(lines))
except Exception:
return None
def gemini_search(query: str, api_key: str, model: str = "gemini-2.0-flash", timeout: int = 30) -> Optional[str]:
"""Answer a real-time ``query`` with Gemini + Google Search grounding; return a
fenced answer string, or ``None`` on any failure / missing key."""
if not query or not api_key:
return None
url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent?key={api_key}"
# gemini-2.x uses the `google_search` grounding tool (1.5 used
# `google_search_retrieval`); 2.0-flash is the default model.
payload = {
"contents": [{"parts": [{"text": query}]}],
"tools": [{"google_search": {}}],
}
try:
req = urllib.request.Request(
url,
data=json.dumps(payload).encode("utf-8"),
headers={"Content-Type": "application/json"},
method="POST",
)
with urllib.request.urlopen(req, timeout=timeout) as resp:
data = json.loads(resp.read().decode("utf-8"))
cands = data.get("candidates") or []
if not cands:
return None
parts = (cands[0].get("content") or {}).get("parts") or []
text = "".join(p.get("text", "") for p in parts if isinstance(p, dict)).strip()
if not text:
return None
return _fence(f"**Gemini answer for '{query}'**", text)
except Exception:
return None
def gemini_cli_search(query: str, timeout: int = 30) -> Optional[str]:
"""Answer a real-time ``query`` via the Gemini CLI using the user's Google
account login (OAuth), with the CLI's built-in Google web search grounding.
Returns a fenced answer string, or ``None`` on any failure — CLI not
installed, login expired/absent, quota exhaustion, timeout, or empty output
— so the caller falls through to the rest of the webSearch chain
(fail-open, same contract as the other backends).
``GEMINI_API_KEY`` / ``GOOGLE_API_KEY`` are stripped from the child env on
purpose: their presence makes the CLI use API-key auth instead of the
account OAuth login this path is built around. ``GOOGLE_GENAI_USE_GCA=true``
selects the Google-account (OAuth) auth method explicitly, so that when no
login has been completed the CLI fails fast (non-interactive) instead of
erroring on "no auth method".
"""
if not query:
return None
binary = _gemini_bin()
if not binary:
return None
if not gemini_oauth_ready():
global _oauth_hint_shown
if not _oauth_hint_shown:
_oauth_hint_shown = True
debug_log(
" 🔑 GEMINI_AUTH=oauth but no Gemini login at "
f"{gemini_oauth_dir() / 'oauth_creds.json'} — real-time search "
"falls back to the rest of the webSearch chain until seeded (see docs/DEPLOY.md).",
"web",
)
env = {k: v for k, v in os.environ.items() if k not in ("GEMINI_API_KEY", "GOOGLE_API_KEY")}
env["GOOGLE_GENAI_USE_GCA"] = "true"
try:
proc = subprocess.run(
# Default approval mode (no --yolo): the CLI auto-runs read-only
# tools like its web search in headless mode but will not silently
# approve write/shell tools, so a search query can't trigger
# destructive actions.
[binary, "-p", query, "-o", "json", "--skip-trust"],
capture_output=True,
text=True,
timeout=timeout,
env=env,
)
data = json.loads((proc.stdout or "").strip() or "{}")
text = str(data.get("response") or "").strip()
if not text:
return None
return _fence(f"**Gemini answer for '{query}'**", text)
except Exception:
return None

View File

@@ -15,7 +15,7 @@ and calls the tool (no hardcoded phrase matching), so it works in any language.
- Mode gate: when `cfg.stream_browser` is false (`STREAM_BROWSER=false`)
broadcasting is disabled — the tool refuses with a spoken explanation and
records no directive. This is the same capability flag that makes `/stream`
refuse and forces real-time search to Gemini.
refuse and keeps real-time search on the normal webSearch chain.
## Principles

View File

@@ -20,7 +20,7 @@ from ..types import ToolExecutionResult
_FETCH_TIMEOUT_SEC = 4.0
# Wall-clock cap for the entire cascade when fetches run in parallel.
_CASCADE_WALL_CLOCK_SEC = 8.0
# Hard ceiling on the whole provider chain (Exa + Gemini + Brave + Wikipedia). Without
# Hard ceiling on the whole provider chain (Exa + Brave + Wikipedia). Without
# this, a bad day where every provider stalls to timeout could run ~40s —
# intolerable for a voice assistant. Past this deadline the tool gives up and
# returns the honest-block envelope.
@@ -710,7 +710,7 @@ def _results_reply(search_query: str, results: List[Tuple[str, str, str]]) -> st
class WebSearchTool(Tool):
"""webSearch: Exa, Gemini, Brave (opt-in) and Wikipedia (web_search.spec.md)."""
"""webSearch: Exa, Brave (opt-in) and Wikipedia (web_search.spec.md)."""
@property
def name(self) -> str:
@@ -731,7 +731,7 @@ class WebSearchTool(Tool):
}
def run(self, args: Optional[Dict[str, Any]], context: ToolContext) -> ToolExecutionResult:
"""Search the web: Exa, then Gemini, then Brave (opt-in), then Wikipedia."""
"""Search the web: Exa, then Brave (opt-in), then Wikipedia."""
cfg = context.cfg
search_query = ""
try:
@@ -782,24 +782,7 @@ class WebSearchTool(Tool):
return ToolExecutionResult(success=True, reply_text=_results_reply(search_query, exa))
context.user_print("⚠️ Exa returned no results.")
# 2. Gemini, only when it can work: the CLI with a Google login, or an API key.
routed = None
if _budget_left() > 0:
if getattr(cfg, "gemini_auth", "oauth") == "oauth":
if realtime_search.gemini_oauth_ready():
routed = realtime_search.gemini_cli_search(
search_query, timeout=max(1, int(_budget_left())))
elif getattr(cfg, "gemini_api_key", ""):
routed = realtime_search.gemini_search(
search_query, cfg.gemini_api_key,
getattr(cfg, "gemini_model", "gemini-2.0-flash"),
timeout=max(1, int(_budget_left())),
)
if routed:
debug_log(" 🌐 answered via Gemini", "web")
return ToolExecutionResult(success=True, reply_text=routed)
# 3. Brave (opt-in, keyed): links, then the parallel page fetch.
# 2. Brave (opt-in, keyed): links, then the parallel page fetch.
fetched_content: Optional[str] = None
search_results: list[str] = []
fetch_attempted_any = False
@@ -823,7 +806,7 @@ class WebSearchTool(Tool):
else:
debug_log("Brave returned results but no fetch succeeded", "web")
# 4. Wikipedia: last resort, only a page whose title the query names.
# 3. Wikipedia: last resort, only a page whose title the query names.
if (
not fetched_content
and getattr(cfg, "wikipedia_fallback_enabled", True)

View File

@@ -2,7 +2,7 @@
Performs an internet search and returns text facts for the reply LLM to
ground its answer in. Provider order: the on-screen Chrome while the
broadcast is live, then Exa, then Gemini, then Brave (opt-in), then
broadcast is live, then Exa, then Brave (opt-in), then
Wikipedia, then an honest "found nothing" envelope. Used for any query that needs current,
external, or entity-specific information the assistant can't derive from
memory.
@@ -58,21 +58,15 @@ is visible on the Go-Live stream. `run()` reads the broadcast capability flag
Exa answered the field questions in Korean in 0.4 to 1.5 s with the
right pages and needs no page fetch of its own. Any failure (non-200,
error result, timeout, nothing parsed) moves on.
2. **Gemini**, only when Exa found nothing and only when it can work, with
the sub-mode chosen by `cfg.gemini_auth` (env `GEMINI_AUTH`, default `oauth`):
- `oauth`: `gemini_cli_search()` runs the Gemini CLI
(`gemini -p <query> -o json --skip-trust`, default approval mode) on the
user's Google-account login with its web-search grounding, and only when
`gemini_oauth_ready()` sees `~/.gemini/oauth_creds.json`. Without a login
the CLI is not started (it cost about 2 s per search, live 2026-11-18).
`GEMINI_API_KEY` / `GOOGLE_API_KEY` are stripped from the child env.
- `apikey`: `gemini_search()` REST path (`google_search` grounding), keyed
by `GEMINI_API_KEY` / `GEMINI_MODEL`.
3. **Brave Search** (opt-in, keyed), see the fallback chain below.
4. **Wikipedia** (zero-config), see the fallback chain below.
5. **Nothing-found envelope** when every provider failed.
2. **Brave Search** (opt-in, keyed), see the fallback chain below.
3. **Wikipedia** (zero-config), see the fallback chain below.
4. **Nothing-found envelope** when every provider failed.
Chrome, Exa and Gemini return the same fenced `UNTRUSTED WEB EXTRACT` shape.
Gemini (the Gemini CLI with a Google login, or the REST API with a key) was
removed 2026-11-18 at the user's request: nobody had it set up, and Exa then
Wikipedia cover the voice use.
Chrome and Exa return the same fenced `UNTRUSTED WEB EXTRACT` shape.
**Brave cascade fetch**: Brave gives links only, so the top 3 are fetched
**in parallel** under a single `_CASCADE_WALL_CLOCK_SEC` (8s) wall-clock cap.
@@ -161,11 +155,11 @@ a softer "please don't invent" lets chatty larger models wriggle past.
### Wall-clock budget
The whole provider chain (Exa + Gemini + Brave + Wikipedia) is capped by
The whole provider chain (Exa + Brave + Wikipedia) is capped by
`_TOTAL_WALL_CLOCK_SEC` (20s). Each cascade is further bounded by
`_CASCADE_WALL_CLOCK_SEC` (8s) per fetch pool. Exa's request timeout
(8s) and Gemini's subprocess timeout shrink to the remaining budget. Before
Gemini, Brave and Wikipedia, the remaining budget is checked; if exhausted,
(8s) shrinks to the remaining budget. Before
Brave and Wikipedia, the remaining budget is checked; if exhausted,
the remaining providers are skipped and the nothing-found envelope is
emitted. This is
the ceiling that turns "every provider timed out" from a ~40s hang into
@@ -174,7 +168,7 @@ is not negotiable.
### Fallback chain
When Exa and Gemini yield nothing, the tool walks a fallback chain before
When Exa yields nothing, the tool walks a fallback chain before
giving up:
1. **Brave Search** (opt-in, keyed). Runs only when
@@ -255,7 +249,6 @@ default.
message and does not hit the network.
- `brave_search_api_key` (str, default `""`): opt-in Brave key. Empty
string means "not configured" — the tool skips straight to Wikipedia.
- `gemini_auth` / `gemini_api_key` / `gemini_model`: the Gemini step (above).
- `wikipedia_fallback_enabled` (bool, default `true`): zero-config last
resort. Set to `false` to disable the Wikipedia network call entirely.
@@ -264,9 +257,8 @@ default.
Regression tests (`tests/tools/builtin/test_web_search.py`,
`tests/test_web_search_broadcast_routing.py`, `evals/test_web_search_fallback.py`) assert:
1. **Order**: live broadcast -> Chrome; otherwise Exa first; Gemini only when
Exa found nothing and a login (oauth) or key (apikey) is present; then
Brave, then Wikipedia, then the nothing-found envelope.
1. **Order**: live broadcast -> Chrome; otherwise Exa first; when Exa found
nothing, Brave, then Wikipedia, then the nothing-found envelope.
2. **Exa parsing**: the `---`-separated Title/URL/Highlights format, UTF-8
decoding of a charset-less event stream, and `[]` on non-200, an error
result or an exception.
@@ -289,8 +281,9 @@ Regression tests (`tests/tools/builtin/test_web_search.py`,
### Non-goals
- Unbounded provider plurality — the chain is scoped to Chrome (live
broadcast) → Exa → Gemini → Brave (opt-in) → Wikipedia. DuckDuckGo was
removed 2026-11-18 (bot-check page on every request); a user-pluggable
broadcast) → Exa → Brave (opt-in) → Wikipedia. DuckDuckGo was
removed 2026-11-18 (bot-check page on every request) and Gemini the same
day (user's request); a user-pluggable
provider registry is out of scope.
- JS rendering — we fetch raw HTML only. SPA-heavy pages may return
nothing useful; the cascade handles this by trying the next result.

View File

@@ -1,139 +0,0 @@
"""Behaviour tests for the Gemini CLI (OAuth login) real-time search backend.
These verify the observable contract of ``gemini_cli_search``:
- a fenced answer when the CLI returns a JSON ``response``,
- fail-open (``None``) when the CLI is missing, times out, errors, or returns
empty/garbage output,
- the child process never inherits ``GEMINI_API_KEY`` / ``GOOGLE_API_KEY`` so
the CLI uses the account OAuth login rather than API-key auth.
"""
import subprocess
import types
import jarvis.tools.builtin.realtime_search as rs
def _fake_proc(stdout: str) -> types.SimpleNamespace:
return types.SimpleNamespace(stdout=stdout, stderr="", returncode=0)
def test_returns_fenced_answer_on_success(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setattr(
rs.subprocess,
"run",
lambda *a, **k: _fake_proc('{"response": "Seoul is sunny, 21C.", "stats": {}}'),
)
out = rs.gemini_cli_search("weather in Seoul")
assert out is not None
assert "Seoul is sunny, 21C." in out
assert "UNTRUSTED WEB EXTRACT" in out # untrusted-data fence preserved
def test_none_when_cli_not_installed(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: None)
# subprocess.run must not even be reached
monkeypatch.setattr(rs.subprocess, "run", lambda *a, **k: (_ for _ in ()).throw(AssertionError("should not run")))
assert rs.gemini_cli_search("anything") is None
def test_none_on_empty_query(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
assert rs.gemini_cli_search("") is None
def test_none_on_empty_response(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setattr(rs.subprocess, "run", lambda *a, **k: _fake_proc('{"response": "", "stats": {}}'))
assert rs.gemini_cli_search("q") is None
def test_none_on_garbage_output(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setattr(rs.subprocess, "run", lambda *a, **k: _fake_proc("not json at all"))
assert rs.gemini_cli_search("q") is None
def test_none_on_timeout(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
def _boom(*a, **k):
raise subprocess.TimeoutExpired(cmd="gemini", timeout=30)
monkeypatch.setattr(rs.subprocess, "run", _boom)
assert rs.gemini_cli_search("q") is None
def test_api_key_stripped_from_child_env(monkeypatch):
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setenv("GEMINI_API_KEY", "AIza-secret")
monkeypatch.setenv("GOOGLE_API_KEY", "another-secret")
captured = {}
def _capture(*a, **k):
captured["env"] = k.get("env", {})
captured["cmd"] = a[0] if a else k.get("args")
return _fake_proc('{"response": "ok"}')
monkeypatch.setattr(rs.subprocess, "run", _capture)
rs.gemini_cli_search("q")
assert "GEMINI_API_KEY" not in captured["env"]
assert "GOOGLE_API_KEY" not in captured["env"]
# Google-account (OAuth) auth method is selected explicitly so a missing
# login fails fast non-interactively instead of erroring on "no auth method".
assert captured["env"].get("GOOGLE_GENAI_USE_GCA") == "true"
# invoked headless with JSON output
assert "-p" in captured["cmd"] and "-o" in captured["cmd"] and "json" in captured["cmd"]
# never auto-approve all tools: a search query must not be able to trigger
# write/shell tool execution.
assert "yolo" not in captured["cmd"]
assert "--yolo" not in captured["cmd"]
def test_oauth_ready_reflects_creds_file(monkeypatch, tmp_path):
"""``gemini_oauth_ready`` is the seeded-login signal: false until the CLI's
``~/.gemini/oauth_creds.json`` exists, true once it does."""
monkeypatch.setenv("HOME", str(tmp_path))
assert rs.gemini_oauth_ready() is False
gdir = tmp_path / ".gemini"
gdir.mkdir()
(gdir / "oauth_creds.json").write_text("{}")
assert rs.gemini_oauth_ready() is True
assert rs.gemini_oauth_dir() == gdir
def test_hint_logged_once_when_oauth_not_seeded(monkeypatch):
"""When OAuth is selected but no login is seeded, the path still attempts the
CLI (behaviour unchanged) but logs a single actionable hint so the silent
DDG/Brave fallback is diagnosable."""
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setattr(rs, "gemini_oauth_ready", lambda: False)
monkeypatch.setattr(rs.subprocess, "run", lambda *a, **k: _fake_proc('{"response": "ok"}'))
logs: list[str] = []
monkeypatch.setattr(rs, "debug_log", lambda msg, *a, **k: logs.append(msg))
monkeypatch.setattr(rs, "_oauth_hint_shown", False)
assert rs.gemini_cli_search("q") is not None # still attempts, behaviour unchanged
rs.gemini_cli_search("q again") # second call must not re-log
hints = [m for m in logs if "no Gemini login" in m]
assert len(hints) == 1
def test_no_hint_when_oauth_seeded(monkeypatch):
"""A seeded login produces no fallback hint."""
monkeypatch.setattr(rs, "_gemini_bin", lambda: "/usr/bin/gemini")
monkeypatch.setattr(rs, "gemini_oauth_ready", lambda: True)
monkeypatch.setattr(rs.subprocess, "run", lambda *a, **k: _fake_proc('{"response": "ok"}'))
logs: list[str] = []
monkeypatch.setattr(rs, "debug_log", lambda msg, *a, **k: logs.append(msg))
monkeypatch.setattr(rs, "_oauth_hint_shown", False)
rs.gemini_cli_search("q")
assert not [m for m in logs if "no Gemini login" in m]

View File

@@ -11,7 +11,7 @@ Routing contract (docs/stream_browser_modes.md, web_search.spec.md):
True False Exa
False True/None Exa (broadcast disabled, never Chrome)
Gemini only runs when Exa found nothing, and the CLI only with a Google login.
When Exa finds nothing the chain goes on to Brave (opt-in) and Wikipedia.
"""
from types import SimpleNamespace
@@ -30,10 +30,7 @@ def _ctx(stream_browser, broadcasting):
cfg = SimpleNamespace(
web_search_enabled=True,
stream_browser=stream_browser,
gemini_auth="oauth",
gemini_api_key="",
gemini_model="gemini-2.0-flash",
wikipedia_fallback_enabled=False,
wikipedia_fallback_enabled=True,
)
return ToolContext(
db=None,
@@ -59,11 +56,8 @@ def backends(monkeypatch):
return result() if callable(result) else result
return call
state = SimpleNamespace(exa=EXA_HIT, login=True, ran=ran)
state = SimpleNamespace(exa=EXA_HIT, ran=ran)
monkeypatch.setattr(rs, "browser_search", fake("browser", "BROWSER_RESULT"))
monkeypatch.setattr(rs, "gemini_cli_search", fake("gemini", "GEMINI_RESULT"))
monkeypatch.setattr(rs, "gemini_search", fake("gemini", "GEMINI_RESULT"))
monkeypatch.setattr(rs, "gemini_oauth_ready", lambda: state.login)
monkeypatch.setattr(ws, "_exa_search", fake("exa", lambda: state.exa))
monkeypatch.setattr(ws, "_wikipedia_summary", fake("wikipedia", None))
return state
@@ -73,8 +67,6 @@ def _route(stream_browser, broadcasting, query="현재 서울 날씨"):
res = WebSearchTool().run({"search_query": query}, _ctx(stream_browser, broadcasting))
if res.reply_text == "BROWSER_RESULT":
return "browser"
if res.reply_text == "GEMINI_RESULT":
return "gemini"
if "EXA_TEXT" in res.reply_text:
return "exa"
return "fallthrough"
@@ -110,23 +102,16 @@ def test_browser_failure_while_live_falls_through_to_exa(backends, monkeypatch):
assert _route(True, True) == "exa"
def test_exa_results_mean_gemini_never_runs(backends):
def test_exa_results_stop_the_chain(backends):
assert _route(False, None) == "exa"
assert "gemini" not in backends.ran
assert backends.ran == ["exa"]
def test_exa_empty_with_login_uses_gemini_cli(backends):
def test_exa_empty_goes_straight_to_wikipedia(backends):
# No Brave key: after Exa the only provider left is Wikipedia.
backends.exa = []
assert _route(False, None) == "gemini"
assert backends.ran == ["exa", "gemini"]
def test_exa_empty_without_login_never_starts_gemini_cli(backends):
# No Google login: the CLI would only fail, so it is not started at all.
backends.exa = []
backends.login = False
assert _route(False, None) == "fallthrough"
assert "gemini" not in backends.ran
assert backends.ran == ["exa", "wikipedia"]
def test_a_query_given_as_query_instead_of_search_query_still_searches(backends, monkeypatch):

View File

@@ -11,7 +11,6 @@ from src.jarvis.tools.base import ToolContext
from src.jarvis.tools.types import ToolExecutionResult
WS = "src.jarvis.tools.builtin.web_search"
RS = "src.jarvis.tools.builtin.realtime_search"
def _cfg(**overrides):
@@ -20,8 +19,6 @@ def _cfg(**overrides):
cfg.web_search_enabled = True
cfg.voice_debug = False
cfg.stream_browser = False
cfg.gemini_auth = "api_key"
cfg.gemini_api_key = ""
cfg.brave_search_api_key = ""
cfg.wikipedia_fallback_enabled = False
cfg.mcps = {}
@@ -95,11 +92,10 @@ class TestWebSearchTool:
assert "disabled" in result.reply_text.lower()
@patch(f"{WS}._wikipedia_summary")
@patch(f"{RS}.gemini_search")
def test_exa_results_are_fenced_with_links_and_stop_the_chain(self, mock_gemini, mock_wiki):
def test_exa_results_are_fenced_with_links_and_stop_the_chain(self, mock_wiki):
"""Exa's page text lands inside the fence, its links follow it, and no
later provider is consulted."""
self.context.cfg = _cfg(gemini_api_key="key", wikipedia_fallback_enabled=True)
self.context.cfg = _cfg(wikipedia_fallback_enabled=True)
self.exa.return_value = [
("Possessor (film)", "https://exa1.test/possessor",
"Possessor is a 2020 film directed by Brandon Cronenberg."),
@@ -115,7 +111,6 @@ class TestWebSearchTool:
assert begin < text.index("Brandon Cronenberg") < end
assert text.index("https://exa1.test/possessor") > end
assert "https://exa2.test/review" in text
mock_gemini.assert_not_called()
mock_wiki.assert_not_called()
def test_envelope_directs_extraction_when_content_found(self):