Personal AI, On Personal Devices
Python
Add provider-aware search support to hybrid orchestration agents (#558)
Elliot Slusky4bf39af9bd3a
diff --git a/src/openjarvis/agents/hybrid/_base.py b/src/openjarvis/agents/hybrid/_base.pyindex 5a334551..e9c32840 100644--- a/src/openjarvis/agents/hybrid/_base.py+++ b/src/openjarvis/agents/hybrid/_base.py@@ -73,12 +73,19 @@ WEB_SEARCH_COST_PER_CALL = 0.01# $0.01/call number — kept as a separate constant so it can drift.OPENAI_WEB_SEARCH_COST_PER_CALL = 0.01-# Gemini Google-Search grounding: billed at $35 per 1000 grounded-# *requests* (2025-12 public list price for the Grounding-with-Google-Search-# tool, charged once per request that uses the tool regardless of how many-# internal queries it issues). We charge per grounded request, not per-# `web_search_queries` entry.-GEMINI_SEARCH_COST_PER_CALL = 0.035+# Gemini 3 Google-Search grounding: billed at $14 per 1000 search queries.+# `_call_gemini_agent` reports the model's `web_search_queries`, so this is+# charged per query, not per outer generate_content request.+GEMINI_SEARCH_COST_PER_CALL = 0.014++# Tavily Search, advanced depth: 2 API credits per search request at $0.008+# per credit on the public pay-as-you-go plan. WebSearchTool captures actual+# credits when Tavily returns usage metadata; this is the fallback estimate.+TAVILY_SEARCH_COST_PER_CREDIT = 0.008+TAVILY_ADVANCED_SEARCH_CREDITS = 2+TAVILY_SEARCH_COST_PER_CALL = (+ TAVILY_SEARCH_COST_PER_CREDIT * TAVILY_ADVANCED_SEARCH_CREDITS+)ANTHROPIC_WEB_SEARCH_TOOL = {"type": "web_search_20250305",@@ -101,6 +108,40 @@ def build_web_search_tool(max_uses: int = 8) -> Dict[str, Any]:}+def tavily_search_context(+ query: str,+ *,+ max_results: int = 5,+) -> Dict[str, Any]:+ """Run OpenJarvis WebSearchTool and return accounting-friendly metadata."""+ from openjarvis.tools.web_search import WebSearchTool++ tool = WebSearchTool(max_results=max_results)+ res = tool.execute(query=query, max_results=max_results)+ meta = dict(res.metadata or {})+ engine = str(meta.get("engine") or "unknown")+ credits = 0+ cost_usd = 0.0+ if engine == "tavily":+ try:+ credits = int(meta.get("credits") or TAVILY_ADVANCED_SEARCH_CREDITS)+ except (TypeError, ValueError):+ credits = TAVILY_ADVANCED_SEARCH_CREDITS+ cost_usd = credits * TAVILY_SEARCH_COST_PER_CREDIT+ text = res.content or ""+ if not res.success and not text:+ text = "(no search results)"+ return {+ "text": text,+ "success": bool(res.success),+ "engine": engine,+ "credits": credits,+ "cost_usd": cost_usd,+ "n_searches": 1 if (query or "").strip() else 0,+ "error": None if res.success else text,+ }++def web_search_cfg(method_cfg: Optional[Dict[str, Any]]) -> Tuple[bool, int]:"""Parse ``method_cfg.web_search = { enabled, max_uses }``.@@ -1322,6 +1363,9 @@ __all__ = ["LocalCloudAgent","NO_TEMP_PREFIXES","OPENAI_WEB_SEARCH_COST_PER_CALL",+ "TAVILY_ADVANCED_SEARCH_CREDITS",+ "TAVILY_SEARCH_COST_PER_CALL",+ "TAVILY_SEARCH_COST_PER_CREDIT","WEB_SEARCH_COST_PER_CALL","_bump_cloud_calls","_bump_local_calls",@@ -1329,5 +1373,6 @@ __all__ = ["estimate_cost","is_gpt5_family","supports_temperature",+ "tavily_search_context","web_search_cfg",]diff --git a/src/openjarvis/agents/hybrid/_prices.py b/src/openjarvis/agents/hybrid/_prices.pyindex c146496b..2b518e50 100644--- a/src/openjarvis/agents/hybrid/_prices.py+++ b/src/openjarvis/agents/hybrid/_prices.py@@ -15,13 +15,16 @@ PRICES: dict[str, tuple[float, float]] = {"claude-sonnet-4-6": (3.00, 15.0),"claude-haiku-4-5": (1.00, 5.00),"claude-haiku-4-5-20251001": (1.00, 5.00),+ "gpt-5.5": (5.00, 30.0),"gpt-5": (1.25, 10.0),"gpt-5-mini": (0.25, 2.00),"gpt-5-mini-2025-08-07": (0.25, 2.00),"gpt-4o": (0.15, 0.60),- # Gemini Developer API prices (USD per 1M tokens), 2025-12 list price.- # 2.5 Pro uses tiered pricing (>200K context = $2.50/$15); we charge the- # low-context tier since GAIA / SWE-bench prompts stay well under 200K.+ # Gemini Developer API prices (USD per 1M tokens). Pro models use tiered+ # pricing above 200K prompt tokens; GAIA prompts stay under that tier, so+ # charge the low-context standard rate.+ "gemini-3.1-pro-preview": (2.00, 12.0),+ "gemini-3.1-pro-preview-customtools": (2.00, 12.0),"gemini-2.5-pro": (1.25, 10.0),"gemini-2.5-flash": (0.30, 2.50),"gemini-2.5-flash-lite": (0.10, 0.40),@@ -61,7 +64,11 @@ def is_reasoning_model(model: str) -> bool:before emitting visible answer text. At max_tokens=4096 these silentlytruncate with empty answers on GAIA (26/100 GPT-5, 18/100 Gemini Pro)."""m = (model or "").lower()- return is_gpt5_family(model) or "gemini-2.5-pro" in m+ return (+ is_gpt5_family(model)+ or "gemini-2.5-pro" in m+ or "gemini-3.1-pro" in m+ )def default_max_output_tokens(model: str) -> int:diff --git a/src/openjarvis/agents/hybrid/advisors.py b/src/openjarvis/agents/hybrid/advisors.pyindex 307f3fc3..6e8c9f3e 100644--- a/src/openjarvis/agents/hybrid/advisors.py+++ b/src/openjarvis/agents/hybrid/advisors.py@@ -34,6 +34,7 @@ from openjarvis.agents.hybrid._base import (WEB_SEARCH_COST_PER_CALL,LocalCloudAgent,build_web_search_tool,+ tavily_search_context,web_search_cfg,)from openjarvis.agents.hybrid.mini_swe_agent import (@@ -135,7 +136,12 @@ class AdvisorsAgent(LocalCloudAgent):advisor_temperature = float(cfg.get("advisor_temperature", 0.2))ws_enabled, ws_max_uses = web_search_cfg(cfg)- if ws_enabled and self._cloud_endpoint not in _SEARCH_CAPABLE_ENDPOINTS:+ search_backend = str(cfg.get("search_backend", "provider")).lower()+ if (+ ws_enabled+ and search_backend != "tavily"+ and self._cloud_endpoint not in _SEARCH_CAPABLE_ENDPOINTS+ ):raise ValueError(f"web_search.enabled=true but cloud_endpoint={self._cloud_endpoint!r}; ""server-side web_search is wired for anthropic / openai / gemini "@@ -146,19 +152,23 @@ class AdvisorsAgent(LocalCloudAgent):use_ws = ws_enabledgaia_max_turns = int(cfg.get("gaia_max_turns", 8))n_searches_total = 0+ search_cost_total = 0.0# 1. Initial executor pass — advisor (Qwen) doesn't get tools;# only the cloud executor passes do. With web_search on, dispatch# to the search-capable agent loop for the configured provider.if use_ws:- initial_resp, e1_in, e1_out, n_s1, e1_turns = self._executor_search(+ (initial_resp, e1_in, e1_out, n_s1, e1_turns,+ e1_search_cost) = self._executor_search(user=f"Question:\n{question}",system=EXECUTOR_INITIAL_SYS,max_tokens=executor_max_tokens,ws_max_uses=ws_max_uses,max_turns=gaia_max_turns,+ query=question,)n_searches_total += n_s1+ search_cost_total += e1_search_costelse:initial_resp, e1_in, e1_out = self._call_cloud(user=f"Question:\n{question}",@@ -196,14 +206,17 @@ class AdvisorsAgent(LocalCloudAgent):f"answer-format rules.")if use_ws:- final_answer, e2_in, e2_out, n_s2, e2_turns = self._executor_search(+ (final_answer, e2_in, e2_out, n_s2, e2_turns,+ e2_search_cost) = self._executor_search(user=final_user,system=EXECUTOR_FINAL_SYS,max_tokens=executor_max_tokens,ws_max_uses=ws_max_uses,max_turns=gaia_max_turns,+ query=question,)n_searches_total += n_s2+ search_cost_total += e2_search_costelse:final_answer, e2_in, e2_out = self._call_cloud(user=final_user,@@ -216,7 +229,10 @@ class AdvisorsAgent(LocalCloudAgent):tokens_local = adv_in + adv_outtokens_cloud = e1_in + e1_out + e2_in + e2_outcost = self.cost_usd(self._cloud_model, e1_in + e2_in, e1_out + e2_out)- cost += n_searches_total * _search_cost_per_call(self._cloud_endpoint)+ if search_backend == "tavily":+ cost += search_cost_total+ else:+ cost += n_searches_total * _search_cost_per_call(self._cloud_endpoint)meta: Dict[str, Any] = {"tokens_local": tokens_local,@@ -233,7 +249,9 @@ class AdvisorsAgent(LocalCloudAgent):"initial_response": initial_resp,"advisor_feedback": advisor_text,"web_search_enabled": use_ws,+ "search_backend": search_backend,"n_web_searches": n_searches_total,+ "search_cost_usd": search_cost_total,"note": "inference-only advisor (untrained); lower bound on the technique.",},}@@ -251,16 +269,40 @@ class AdvisorsAgent(LocalCloudAgent):max_tokens: int,ws_max_uses: int,max_turns: int,- ) -> Tuple[str, int, int, int, int]:+ query: Optional[str] = None,+ ) -> Tuple[str, int, int, int, int, float]:"""Run a search-capable executor pass for the configured cloud.Dispatches by ``self._cloud_endpoint`` to the matching ``_base``- agent loop. Returns the shared 5-tuple ``(text, p_tok, c_tok,- n_searches, turns)``. The endpoint is assumed already validated- against ``_SEARCH_CAPABLE_ENDPOINTS`` by the caller.+ agent loop, or through Tavily when ``method_cfg.search_backend`` is+ ``"tavily"``. Returns ``(text, p_tok, c_tok, n_searches, turns,+ search_cost_usd)``."""+ if str(self._cfg.get("search_backend", "provider")).lower() == "tavily":+ res = tavily_search_context(+ query or user,+ max_results=int(self._cfg.get("tavily_max_results", 5)),+ )+ grounded_user = (+ f"Web search results:\n{res['text']}\n\n"+ f"Using the search results above, answer this request:\n{user}"+ )+ text, p, c = self._call_cloud(+ user=grounded_user,+ system=system,+ max_tokens=max_tokens,+ temperature=0.0,+ )+ return (+ text,+ p,+ c,+ int(res["n_searches"]),+ 1,+ float(res["cost_usd"]),+ )if self._cloud_endpoint == "anthropic":- return self._call_anthropic_agent(+ text, p, c, n_searches, turns = self._call_anthropic_agent(self._cloud_model,user=user,system=system,@@ -269,8 +311,9 @@ class AdvisorsAgent(LocalCloudAgent):tools=[build_web_search_tool(ws_max_uses)],max_turns=max_turns,)+ return text, p, c, n_searches, turns, 0.0if self._cloud_endpoint == "openai":- return self._call_openai_agent(+ text, p, c, n_searches, turns = self._call_openai_agent(self._cloud_model,user=user,system=system,@@ -278,8 +321,9 @@ class AdvisorsAgent(LocalCloudAgent):temperature=0.0,max_turns=max_turns,)+ return text, p, c, n_searches, turns, 0.0if self._cloud_endpoint == "gemini":- return self._call_gemini_agent(+ text, p, c, n_searches, turns = self._call_gemini_agent(self._cloud_model,user=user,system=system,@@ -287,6 +331,7 @@ class AdvisorsAgent(LocalCloudAgent):temperature=0.0,max_turns=max_turns,)+ return text, p, c, n_searches, turns, 0.0# Genuinely unsupported (openrouter / vllm / unknown). The caller# guard should have caught this; raise defensively.raise ValueError(diff --git a/src/openjarvis/agents/hybrid/conductor.py b/src/openjarvis/agents/hybrid/conductor.pyindex 46dbb1bc..e326059f 100644--- a/src/openjarvis/agents/hybrid/conductor.py+++ b/src/openjarvis/agents/hybrid/conductor.py@@ -46,6 +46,7 @@ from openjarvis.agents.hybrid._base import (WEB_SEARCH_COST_PER_CALL,LocalCloudAgent,build_web_search_tool,+ tavily_search_context,web_search_cfg,)from openjarvis.agents.hybrid._prices import (@@ -456,8 +457,14 @@ def _format_worker_pool(workers: List[Dict[str, Any]]) -> str:)-def _search_capable_indices(workers: List[Dict[str, Any]]) -> List[int]:+def _search_capable_indices(+ workers: List[Dict[str, Any]],+ *,+ search_backend: str = "provider",+) -> List[int]:"""Indices of workers whose endpoint can run server-side web search."""+ if search_backend == "tavily":+ return [w["id"] for w in workers]return [w["id"] for w in workersif (w.get("endpoint") or "openai").lower()@@ -470,6 +477,7 @@ def _build_conductor_prompt(workers: List[Dict[str, Any]],*,web_search_enabled: bool = False,+ search_backend: str = "provider",) -> str:"""Build the planner prompt.@@ -485,12 +493,16 @@ def _build_conductor_prompt()if not web_search_enabled:return base- capable = _search_capable_indices(workers)+ capable = _search_capable_indices(workers, search_backend=search_backend)if capable:cap_str = ", ".join(str(i) for i in capable)+ if search_backend == "tavily":+ capability = "External Tavily search results will be prepended to worker prompts"+ else:+ capability = "Only these model indices can perform live web search"constraint = ("\n\nWEB SEARCH CONSTRAINT:\n"- f"Only these model indices can perform live web search: [{cap_str}]. "+ f"{capability}: [{cap_str}]. ""Any step that needs to look up facts, current events, or other ""information not reliably known from memory MUST be routed to one ""of those indices. Steps routed to any other model can only use "@@ -550,8 +562,8 @@ def _call_worker(*,web_search_tool: Optional[Dict[str, Any]] = None,web_search_max_uses: int = 8,-) -> Tuple[str, int, int, bool, int]:- """Returns (text, p_tok, c_tok, is_local, n_web_searches).+) -> Tuple[str, int, int, bool, int, float]:+ """Returns (text, p_tok, c_tok, is_local, n_web_searches, extra_cost).``web_search_tool``: a truthy marker that web_search is enabled forthis run. When set AND the worker endpoint is search-capable@@ -565,6 +577,22 @@ def _call_worker(max_tok = int(cfg.get("worker_max_tokens", 4096))temp = float(cfg.get("worker_temperature", 0.2))use_ws = web_search_tool is not None+ search_backend = str(cfg.get("search_backend", "provider")).lower()+ extra_cost = 0.0+ if use_ws and search_backend == "tavily":+ res = tavily_search_context(+ prompt,+ max_results=int(cfg.get("tavily_max_results", 5)),+ )+ prompt = (+ f"Web search results:\n{res['text']}\n\n"+ f"Using the search results above, answer this request:\n{prompt}"+ )+ extra_cost = float(res["cost_usd"])+ use_ws = False+ tavily_searches = int(res["n_searches"])+ else:+ tavily_searches = 0if ep == "vllm":text, p, c = LocalCloudAgent._call_vllm(@@ -575,7 +603,7 @@ def _call_worker(temperature=temp,enable_thinking=False,)- return text, p, c, True, 0+ return text, p, c, True, tavily_searches, extra_costif ep == "openai":if use_ws:text, p, c, n_searches, _ = LocalCloudAgent._call_openai_agent(@@ -584,14 +612,14 @@ def _call_worker(max_tokens=max_tok,temperature=(1.0 if is_gpt5_family(worker["model"]) else temp),)- return text, p, c, False, n_searches+ return text, p, c, False, n_searches, 0.0text, p, c = LocalCloudAgent._call_openai(worker["model"],user=prompt,max_tokens=max_tok,temperature=(1.0 if is_gpt5_family(worker["model"]) else temp),)- return text, p, c, False, 0+ return text, p, c, False, tavily_searches, extra_costif ep == "openrouter":# OpenRouter is OpenAI-compatible; the helper handles the# base_url + OPENROUTER_API_KEY plumbing. No server-side web@@ -607,7 +635,7 @@ def _call_worker(temperature=temp,extra_body=extra_body if isinstance(extra_body, dict) else None,)- return text, p, c, False, 0+ return text, p, c, False, tavily_searches, extra_costif ep == "anthropic":eff_temp = temp if supports_temperature(worker["model"]) else 0.0anthropic_kwargs: Dict[str, Any] = dict(@@ -620,7 +648,7 @@ def _call_worker(text, p, c, n_searches = LocalCloudAgent._call_anthropic(worker["model"], **anthropic_kwargs)- return text, p, c, False, n_searches+ return text, p, c, False, n_searches or tavily_searches, extra_costif ep == "gemini":# Gemini Developer API via google-genai. With web_search on, route# through the Google-Search-grounded agent loop; otherwise plain@@ -632,14 +660,14 @@ def _call_worker(max_tokens=max_tok,temperature=temp,)- return text, p, c, False, n_searches+ return text, p, c, False, n_searches, 0.0text, p, c = LocalCloudAgent._call_gemini(worker["model"],user=prompt,max_tokens=max_tok,temperature=temp,)- return text, p, c, False, 0+ return text, p, c, False, tavily_searches, extra_costraise ValueError(f"unsupported worker endpoint: {ep!r}")@@ -672,7 +700,7 @@ def _swe_worker_step(# backbones today (the loop's tool-call format is Anthropic- or# OpenAI-via-vllm-shaped only). Fall back to one-shot for those —# SWE-bench-wise they were already weak; this preserves behavior.- text, p, c, is_local, n_searches = _call_worker(worker, prompt, cfg)+ text, p, c, is_local, n_searches, _extra = _call_worker(worker, prompt, cfg)return text, p, c, is_local, n_searches, 0out = run_swe_agent_loop(task,@@ -753,13 +781,17 @@ class ConductorAgent(LocalCloudAgent):and bool(task_meta_early.get("base_commit")))ws_enabled, ws_max_uses = web_search_cfg(cfg)+ search_backend = str(cfg.get("search_backend", "provider")).lower()planner_ws = ws_enabled and not swe_mode_early# 1. Plan — when web_search is on (GAIA), the prompt names which# worker indices can actually search, so the planner routes# research steps to a search-capable worker.user = _build_conductor_prompt(- question, workers, web_search_enabled=planner_ws,+ question,+ workers,+ web_search_enabled=planner_ws,+ search_backend=search_backend,)plan_text, p_in, p_out = self._call_cloud(user=user,@@ -833,7 +865,7 @@ class ConductorAgent(LocalCloudAgent):# memory. Fail loud instead of degrading silently.# ``ws_enabled`` / ``ws_max_uses`` computed up front for the planner# constraint — reuse them here.- if ws_enabled and not swe_mode:+ if ws_enabled and search_backend != "tavily" and not swe_mode:search_workers = [w for w in workersif (w.get("endpoint") or "openai").lower()@@ -894,7 +926,7 @@ class ConductorAgent(LocalCloudAgent):# may legitimately not need search; see Task-3 planner# constraint that tries to prevent this upfront).if (- ws_enabled and not swe_mode+ ws_enabled and search_backend != "tavily" and not swe_modeand worker_ep not in _SEARCH_CAPABLE_WORKER_ENDPOINTS):self.record_trace_event({@@ -911,6 +943,7 @@ class ConductorAgent(LocalCloudAgent):),})+ extra_cost = 0.0if swe_mode:text, w_in, w_out, is_local, n_searches, bash_turns = (_swe_worker_step(@@ -919,7 +952,9 @@ class ConductorAgent(LocalCloudAgent):)tool_calls += bash_turnselse:- text, w_in, w_out, is_local, n_searches = _call_worker(+ (+ text, w_in, w_out, is_local, n_searches, extra_cost+ ) = _call_worker(worker, prompt, cfg,web_search_tool=ws_tool,web_search_max_uses=ws_max_uses,@@ -930,7 +965,10 @@ class ConductorAgent(LocalCloudAgent):else:tokens_cloud += w_in + w_outcost += self.cost_usd(worker["model"], w_in, w_out)- cost += n_searches * _worker_search_cost_per_call(worker_ep)+ if search_backend != "tavily":+ cost += n_searches * _worker_search_cost_per_call(worker_ep)+ if search_backend == "tavily":+ cost += extra_costn_web_searches_total += n_searchestool_calls += n_searchessteps.append({@@ -981,6 +1019,7 @@ class ConductorAgent(LocalCloudAgent):"plan": plan,"fallback_used": fallback_used,"web_search_enabled": ws_enabled,+ "search_backend": search_backend,"n_web_searches": n_web_searches_total,"parse_attempts": parse_attempts,"workers": [diff --git a/src/openjarvis/agents/hybrid/minions.py b/src/openjarvis/agents/hybrid/minions.pyindex da5ab9b6..a5902017 100644--- a/src/openjarvis/agents/hybrid/minions.py+++ b/src/openjarvis/agents/hybrid/minions.py@@ -48,12 +48,13 @@ from openjarvis.agents.hybrid._base import (WEB_SEARCH_COST_PER_CALL,LocalCloudAgent,build_web_search_tool,+ tavily_search_context,web_search_cfg,)from openjarvis.agents.hybrid._openai_retry import (patch_openai_globally as _patch_openai_globally,)-from openjarvis.agents.hybrid._prices import NO_TEMP_PREFIXES+from openjarvis.agents.hybrid._prices import NO_TEMP_PREFIXES, default_max_output_tokensfrom openjarvis.agents.hybrid.mini_swe_agent import run_swe_agent_loopfrom openjarvis.core.registry import AgentRegistry@@ -362,6 +363,8 @@ def _prefetch_context(cloud_endpoint: str,cloud_model: str,max_uses: int = 8,+ search_backend: str = "provider",+ tavily_max_results: int = 5,) -> Dict[str, Any]:"""Use Anthropic web_search to fetch real source material the worker can read.@@ -375,6 +378,22 @@ def _prefetch_context(out: Dict[str, Any] = {"text": "", "tokens": 0, "cost_usd": 0.0, "n_searches": 0,}+ if search_backend == "tavily":+ try:+ res = tavily_search_context(question, max_results=tavily_max_results)+ out.update(+ text=res["text"],+ cost_usd=float(res["cost_usd"]),+ n_searches=int(res["n_searches"]),+ tokens=0,+ engine=res.get("engine"),+ credits=res.get("credits"),+ )+ if res.get("error"):+ out["error"] = res["error"]+ except Exception as e:+ out["error"] = f"{type(e).__name__}: {e}"+ return outif cloud_endpoint != "anthropic" or not (question or "").strip():return outtry:@@ -498,18 +517,22 @@ class MinionsAgent(LocalCloudAgent):max_tokens=cfg.get("worker_max_tokens", 4096),local=True,)+ cloud_max_tokens = int(+ cfg.get("cloud_max_tokens")+ or default_max_output_tokens(self._cloud_model)+ )if self._cloud_endpoint == "openai":cloud_client = OpenAIClient(model_name=self._cloud_model,temperature=0.0,- max_tokens=4096,+ max_tokens=cloud_max_tokens,)elif self._cloud_endpoint == "anthropic":# Temperature stripping is handled by the global patch above for Opus 4.7+.cloud_client = AnthropicClient(model_name=self._cloud_model,temperature=0.0,- max_tokens=4096,+ max_tokens=cloud_max_tokens,)elif self._cloud_endpoint == "gemini":# The vendored Minion library already special-cases GeminiClient@@ -520,7 +543,7 @@ class MinionsAgent(LocalCloudAgent):cloud_client = GeminiClient(model_name=self._cloud_model,temperature=0.0,- max_tokens=4096,+ max_tokens=cloud_max_tokens,)else:raise ValueError(f"unsupported cloud endpoint: {self._cloud_endpoint!r}")@@ -560,6 +583,8 @@ class MinionsAgent(LocalCloudAgent):self._cloud_endpoint,self._cloud_model,max_uses=ws_max_uses,+ search_backend=str(cfg.get("search_backend", "provider")).lower(),+ tavily_max_results=int(cfg.get("tavily_max_results", 5)),)if prefetch.get("text"):diff --git a/src/openjarvis/agents/hybrid/skillorchestra.py b/src/openjarvis/agents/hybrid/skillorchestra.pyindex 8b179ea7..510275bd 100644--- a/src/openjarvis/agents/hybrid/skillorchestra.py+++ b/src/openjarvis/agents/hybrid/skillorchestra.py@@ -149,6 +149,17 @@ def _build_router_schema(agent_ids: List[str]) -> Dict[str, Any]:}+def _openai_response_format(schema: Dict[str, Any]) -> Dict[str, Any]:+ return {+ "type": "json_schema",+ "json_schema": {+ "name": "skillorchestra_route",+ "schema": schema["format"]["schema"],+ "strict": True,+ },+ }++def _parse_router_json(text: str) -> Dict[str, Any]:s = (text or "").strip()try:@@ -196,6 +207,70 @@ class SkillOrchestraAgent(LocalCloudAgent):agent_id = "skillorchestra"+ def _route_call(+ self,+ *,+ question: str,+ router_sys: str,+ router_schema: Dict[str, Any],+ router_max: int,+ ) -> Tuple[str, int, int]:+ user = f"Question:\n{question}"+ if self._cloud_endpoint == "anthropic":+ kwargs: Dict[str, Any] = {+ "user": user,+ "system": router_sys,+ "max_tokens": router_max,+ "output_config": router_schema,+ }+ if supports_temperature(self._cloud_model):+ kwargs["temperature"] = 0.0+ text, r_in, r_out, _ = self._call_anthropic(+ self._cloud_model,+ **kwargs,+ )+ return text, r_in, r_out+ if self._cloud_endpoint == "openai":+ return self._call_openai(+ self._cloud_model,+ user=user,+ system=router_sys,+ max_tokens=router_max,+ temperature=0.0,+ response_format=_openai_response_format(router_schema),+ )+ if self._cloud_endpoint == "gemini":+ return self._call_gemini(+ self._cloud_model,+ user=user,+ system=router_sys,+ max_tokens=router_max,+ temperature=0.0,+ )+ raise ValueError(+ f"SkillOrchestra router unsupported cloud_endpoint={self._cloud_endpoint!r}"+ )++ def _executor_call(+ self,+ *,+ question: str,+ max_tokens: int,+ ) -> Tuple[str, int, int]:+ if self._cloud_endpoint == "anthropic":+ text, w_in, w_out, _ = self._call_anthropic(+ self._cloud_model,+ user=question,+ max_tokens=max_tokens,+ temperature=0.0,+ )+ return text, w_in, w_out+ return self._call_cloud(+ user=question,+ max_tokens=max_tokens,+ temperature=0.0,+ )+def _is_soft_failure(self, exc: BaseException) -> Optional[str]:# Empty/unbalanced router JSON — treat as soft failure to match the# hybrid adapter's behavior (matches `err=1` rows in the n=30 cell).@@ -220,33 +295,13 @@ class SkillOrchestraAgent(LocalCloudAgent):router_sys = _build_router_sys(competence, cost)router_schema = _build_router_schema(agent_ids)- # 1. Route — Anthropic only (output_config schema is Anthropic-specific- # in the hybrid adapter). If you need OpenAI routing, swap the prompt- # to JSON-mode and bypass output_config.- if self._cloud_endpoint != "anthropic":- raise ValueError(- "SkillOrchestra router requires cloud_endpoint='anthropic'; "- f"got {self._cloud_endpoint!r}"- )router_max = int(cfg.get("router_max_tokens", 1024))- # Strip temperature for Opus 4.7+; Anthropic's output_config does the schema.- if supports_temperature(self._cloud_model):- router_text, r_in, r_out, _ = self._call_anthropic(- self._cloud_model,- user=f"Question:\n{question}",- system=router_sys,- max_tokens=router_max,- temperature=0.0,- output_config=router_schema,- )- else:- router_text, r_in, r_out, _ = self._call_anthropic(- self._cloud_model,- user=f"Question:\n{question}",- system=router_sys,- max_tokens=router_max,- output_config=router_schema,- )+ router_text, r_in, r_out = self._route_call(+ question=question,+ router_sys=router_sys,+ router_schema=router_schema,+ router_max=router_max,+ )decision = _parse_router_json(router_text)skill_weights: Dict[str, float] = decision.get("skill_weights") or {}@@ -329,11 +384,9 @@ class SkillOrchestraAgent(LocalCloudAgent):tokens_cloud += out["tokens_in"] + out["tokens_out"]run_cost += out["cost_usd"]else:- ans, w_in, w_out, _ = self._call_anthropic(- self._cloud_model,- user=question,+ ans, w_in, w_out = self._executor_call(+ question=question,max_tokens=int(cfg.get("cloud_max_tokens", 4096)),- temperature=0.0,)tokens_cloud += w_in + w_outrun_cost += self.cost_usd(self._cloud_model, w_in, w_out)diff --git a/src/openjarvis/agents/hybrid/skillorchestra/orchestrator.py b/src/openjarvis/agents/hybrid/skillorchestra/orchestrator.pyindex a221dbc9..8d252066 100644--- a/src/openjarvis/agents/hybrid/skillorchestra/orchestrator.py+++ b/src/openjarvis/agents/hybrid/skillorchestra/orchestrator.py@@ -31,7 +31,14 @@ from .stage_router import (get_routing_strategy,parse_skill_analysis,)-from .tools import anthropic_tools, openai_tools, run_answer, run_code, run_search+from .tools import (+ anthropic_tools,+ gemini_tools,+ openai_tools,+ run_answer,+ run_code,+ run_search,+)# tool name -> routing stage (stage_router uses "reasoning" for code)._TOOL_STAGE = {@@ -115,10 +122,49 @@ def _orchestrate_step(u = resp.usagep = getattr(u, "prompt_tokens", 0) if u else 0c = getattr(u, "completion_tokens", 0) if u else 0+ elif endpoint == "gemini":+ from google import genai+ from google.genai import types++ client = genai.Client(+ http_options=types.HttpOptions(timeout=600_000)+ )+ cfg = types.GenerateContentConfig(+ temperature=1.0,+ max_output_tokens=max_tokens,+ tools=[types.Tool(function_declarations=gemini_tools())],+ )+ resp = client.models.generate_content(+ model=model,+ contents=user,+ config=cfg,+ )+ text = (resp.text or "") if hasattr(resp, "text") else ""+ tool_calls = []+ try:+ parts = resp.candidates[0].content.parts or []+ except Exception: # noqa: BLE001+ parts = []+ for part in parts:+ fc = getattr(part, "function_call", None)+ if fc is None:+ continue+ name = getattr(fc, "name", None)+ if not isinstance(name, str) or not name:+ continue+ args = getattr(fc, "args", None) or {}+ try:+ args = dict(args)+ except Exception: # noqa: BLE001+ args = {}+ tool_calls.append({"name": name, "input": args})+ um = getattr(resp, "usage_metadata", None)+ p = int(getattr(um, "prompt_token_count", 0) or 0) if um else 0+ c = int(getattr(um, "candidates_token_count", 0) or 0) if um else 0else:raise ValueError(f"orchestrator endpoint {endpoint!r} unsupported — route the "- "orchestrator through anthropic/openai (set method_cfg."+ "orchestrator through anthropic/openai/gemini (set method_cfg.""orchestrator_endpoint).")@@ -192,6 +238,8 @@ def run_orchestrator(code_timeout = int(cfg.get("code_timeout_s", 60))answer_max_tokens = int(cfg.get("answer_max_tokens", 40000))ws_max_uses = int(cfg.get("web_search_max_uses", 5))+ search_backend = str(cfg.get("search_backend", "provider")).lower()+ tavily_max_results = int(cfg.get("tavily_max_results", 5))# The orchestrator model: a fixed model per run (the original's# MODEL_NAME). Defaults to the cell's cloud model when that endpoint@@ -203,7 +251,7 @@ def run_orchestrator(orch_model = (cfg.get("orchestrator_model")or cfg.get("router_model")or agent._cloud_model)- if orch_endpoint not in ("anthropic", "openai"):+ if orch_endpoint not in ("anthropic", "openai", "gemini"):orch_endpoint, orch_model = "anthropic", "claude-opus-4-7"orch_max_tokens = int(cfg.get("orchestrator_max_tokens", 4096))@@ -306,6 +354,8 @@ def run_orchestrator(res = run_search(agent, spec, context_str=context_str, problem=problem,retriever_url=retriever_url, web_search_max_uses=ws_max_uses,+ search_backend=search_backend,+ tavily_max_results=tavily_max_results,)docs = res["search_results_data"]joined = "\n---\n".join(d for d in docs if d)[:char_cap]diff --git a/src/openjarvis/agents/hybrid/skillorchestra/tools.py b/src/openjarvis/agents/hybrid/skillorchestra/tools.pyindex 59a0ad2f..8401b443 100644--- a/src/openjarvis/agents/hybrid/skillorchestra/tools.py+++ b/src/openjarvis/agents/hybrid/skillorchestra/tools.py@@ -27,6 +27,7 @@ from .._base import (OPENAI_WEB_SEARCH_COST_PER_CALL,WEB_SEARCH_COST_PER_CALL,build_web_search_tool,+ tavily_search_context,)from .pool import ModelSpec, call_alias@@ -110,6 +111,26 @@ def openai_tools() -> List[Dict[str, Any]]:return out+def gemini_tools() -> List[Dict[str, Any]]:+ """The 3 orchestrator tools in Gemini function-declaration shape."""+ out = []+ for name, desc in (+ ("search", _SEARCH_DESC),+ ("enhance_reasoning", _CODE_DESC),+ ("answer", _ANSWER_DESC),+ ):+ out.append({+ "name": name,+ "description": desc,+ "parameters": {+ "type": "object",+ "properties": {"model": _model_prop(name)},+ "required": ["model"],+ },+ })+ return out++# ---------------------------------------------------------------------------# enhance_reasoning / code — eval_frames.py:659-812# ---------------------------------------------------------------------------@@ -256,6 +277,8 @@ def run_search(retriever_url: Optional[str] = None,topk: int = 150,web_search_max_uses: int = 5,+ search_backend: str = "provider",+ tavily_max_results: int = 5,) -> Dict[str, Any]:"""Write a search query with ``spec``, then retrieve documents.@@ -283,7 +306,12 @@ def run_search(contents: List[str] = []search_uses = 0- if retriever_url:+ if search_backend == "tavily":+ res = tavily_search_context(query, max_results=tavily_max_results)+ contents.append(res["text"])+ search_uses = int(res["n_searches"])+ cost += float(res["cost_usd"])+ elif retriever_url:# Faithful path — the original FAISS retriever service.import requestsdiff --git a/src/openjarvis/agents/hybrid/toolorchestra.py b/src/openjarvis/agents/hybrid/toolorchestra.pyindex d5ebd78d..50ae93f6 100644--- a/src/openjarvis/agents/hybrid/toolorchestra.py+++ b/src/openjarvis/agents/hybrid/toolorchestra.py@@ -16,7 +16,8 @@ Two modes, gated by ``method_cfg.orchestrator_mode``:(``answer-1``, ``reasoner-2``, ``search-3``, …) is mapped to a realbackend through ``EXPERT_MODEL_MAPPING`` — by default the frontierAnthropic worker for `*-1` slots, gpt-5-mini for `*-2`, local Qwen- for `*-3`. Search routes to the Anthropic server-side web_search.+ for `*-3`. Search routes to the configured provider's server-side+ web-search helper when available.We do NOT reproduce the upstream Tavily / FAISS-wiki retriever, thecode-interpreter sandbox, or the multi-vLLM mix (Llama-3.3-70B,@@ -43,8 +44,8 @@ Prompted-mode pipeline:prompt; fallback to strongest worker on parse failure.Workers come from ``cfg["workers"]`` or a sensible default pool (local-Qwen if vLLM up, plus a web-search tool via Anthropic, Opus 4.7,-gpt-5-mini).+Qwen if vLLM up, plus provider-native web search, the configured frontier+cloud model, and gpt-5-mini)."""from __future__ import annotations@@ -59,8 +60,11 @@ from typing import Any, Dict, List, Optional, Tuplefrom openjarvis.agents._stubs import AgentContextfrom openjarvis.agents.hybrid._base import (ANTHROPIC_WEB_SEARCH_TOOL,+ GEMINI_SEARCH_COST_PER_CALL,+ OPENAI_WEB_SEARCH_COST_PER_CALL,WEB_SEARCH_COST_PER_CALL,LocalCloudAgent,+ tavily_search_context,)from openjarvis.agents.hybrid._prices import (PRICES,@@ -197,10 +201,23 @@ def _expert_for(slot: str, local_model: Optional[str],cost tier for mid OpenAI calls)- `*-3` (local tier) -> local vLLM (`local_model`)- `answer-math-*` -> same tiers as the numeric suffix- - `search-*` -> always the Anthropic web_search tool (the- upstream uses Tavily; we have web_search)+ - `search-*` -> provider-native web search when the cloud+ endpoint supports it; otherwise Anthropic"""if slot.startswith("search"):+ ep = (cloud_endpoint or "anthropic").lower()+ if ep == "openai":+ return {+ "name": f"search:{slot}",+ "type": "openai-web-search",+ "model": cloud_model,+ }+ if ep == "gemini":+ return {+ "name": f"search:{slot}",+ "type": "gemini-web-search",+ "model": cloud_model,+ }return {"name": f"search:{slot}","type": "anthropic-web-search",@@ -340,21 +357,18 @@ def _paper_expert_for(# ---- Tavily + Modal helpers --------------------------------------------------def _call_tavily_search(query: str, max_results: int = 5) -> Tuple[str, int, int]:- """One-shot Tavily search. Returns (text, p_tok=0, c_tok=0).+def _call_tavily_search(+ query: str,+ max_results: int = 5,+) -> Tuple[str, int, int, float, int]:+ """One-shot Tavily search. Returns (text, p_tok=0, c_tok=0, cost, uses).Token counts are reported as zero (no LLM was billed); the OpenJarvisaccounting layer separately tallies tool-call counts. Falls back toDuckDuckGo if Tavily is unreachable (see ``WebSearchTool``)."""- from openjarvis.tools.web_search import WebSearchTool-- tool = WebSearchTool(max_results=max_results)- res = tool.execute(query=query, max_results=max_results)- text = res.content or ""- if not res.success and not text:- text = "(no results)"- return text, 0, 0+ res = tavily_search_context(query, max_results=max_results)+ return res["text"], 0, 0, float(res["cost_usd"]), int(res["n_searches"])_MODAL_APP_NAME = "openjarvis-toolorchestra-sandbox"@@ -674,13 +688,25 @@ def _default_pool("concise extraction, formatting, arithmetic on given data."),})+ if ep == "openai":+ search_type = "openai-web-search"+ search_model = cloud_model+ search_desc = "OpenAI hosted web search on the configured frontier model."+ elif ep == "gemini":+ search_type = "gemini-web-search"+ search_model = cloud_model+ search_desc = "Gemini Google Search grounding on the configured frontier model."+ else:+ search_type = "anthropic-web-search"+ search_model = _DEFAULT_WEB_SEARCH_MODEL+ search_desc = "Anthropic server-side web_search."pool.append({"id": len(pool),"name": "web-search",- "type": "anthropic-web-search",- "model": "claude-haiku-4-5",+ "type": search_type,+ "model": search_model,"description": (- "Anthropic server-side web_search. Use for facts that need a lookup "+ f"{search_desc} Use for facts that need a lookup ""(recent events, rare names/dates, niche sources). Returns a digest."),})@@ -717,8 +743,13 @@ def _default_pool(# `modal-python` — One-shot Python exec in a fresh Modal Sandbox (the# paper's "Python sandbox" inside `enhance_reasoning`)._TOOLORCH_VALID_TYPES = (- "vllm", "openai", "anthropic", "anthropic-web-search", "gemini",- "tavily-search", "openrouter", "modal-python",+ "vllm", "openai", "anthropic", "anthropic-web-search",+ "openai-web-search", "gemini", "gemini-web-search", "tavily-search",+ "openrouter", "modal-python",+)+_TOOLORCH_SEARCH_TYPES = (+ "anthropic-web-search", "openai-web-search", "gemini-web-search",+ "tavily-search",)# Default model used when an `anthropic-web-search` entry omits `model`.@@ -739,10 +770,12 @@ def _resolve_worker_pool(the override is absent.Each user-supplied entry must be a dict with keys ``id``, ``name``,- ``type``, and (for non-search types) ``model``. ``type`` must be one- of ``vllm`` / ``openai`` / ``anthropic`` / ``anthropic-web-search``.- ``anthropic-web-search`` entries may omit ``model`` — it defaults to- ``claude-haiku-4-5``.+ ``type``, and (for non-search types) ``model``. Search worker types are+ ``anthropic-web-search``, ``openai-web-search``, ``gemini-web-search``,+ and ``tavily-search``. ``anthropic-web-search`` entries may omit+ ``model`` — it defaults to ``claude-haiku-4-5``. OpenAI and Gemini+ search workers default to the configured cloud model. Tavily does not+ require a model.Substitution: ``model = "$local"`` (or ``"<local>"``) resolves to``local_model``; ``model = "$cloud"`` / ``"<cloud>"`` to ``cloud_model``.@@ -804,14 +837,24 @@ def _resolve_worker_pool(elif isinstance(model, str) and model in ("$cloud", "<cloud>"):model = cloud_modelentry["model"] = model- if wtype == "anthropic-web-search":+ if wtype in _TOOLORCH_SEARCH_TYPES:if model in (None, ""):- model = _DEFAULT_WEB_SEARCH_MODEL+ if wtype == "anthropic-web-search":+ model = _DEFAULT_WEB_SEARCH_MODEL+ elif wtype in ("openai-web-search", "gemini-web-search"):+ model = cloud_model+ else:+ model = wtypeentry["model"] = modelelif not isinstance(model, str):raise ValueError(f"Invalid worker_pool entry [{wid}]: 'model' must be a string when set")+ if wtype in ("openai-web-search", "gemini-web-search") and model not in PRICES:+ raise ValueError(+ f"Invalid worker_pool entry [{wid}]: model {model!r} "+ f"is not in PRICES (known: {sorted(PRICES)})"+ )# Search workers don't satisfy the "needs a solver" requirement.else:if not isinstance(model, str) or not model:@@ -843,7 +886,7 @@ def _resolve_worker_pool(if not has_non_search:raise ValueError("Invalid worker_pool entry [-]: worker_pool must contain at least "- "one non-search worker (vllm / openai / anthropic)"+ "one non-search worker (vllm / openai / anthropic / gemini)")return resolved@@ -910,13 +953,31 @@ def _call_worker()extra = n_searches * WEB_SEARCH_COST_PER_CALLreturn text, p, c, False, extra, n_searches+ if wtype == "openai-web-search":+ eff_temp = 1.0 if is_gpt5_family(worker["model"]) else temp+ text, p, c, n_searches, _ = LocalCloudAgent._call_openai_agent(+ worker["model"],+ user=prompt,+ max_tokens=max(max_tok, 16384) if is_gpt5_family(worker["model"]) else max_tok,+ temperature=eff_temp,+ )+ extra = n_searches * OPENAI_WEB_SEARCH_COST_PER_CALL+ return text, p, c, False, extra, n_searches+ if wtype == "gemini-web-search":+ text, p, c, n_searches, _ = LocalCloudAgent._call_gemini_agent(+ worker["model"],+ user=prompt,+ max_tokens=max_tok,+ temperature=temp,+ )+ extra = n_searches * GEMINI_SEARCH_COST_PER_CALL+ return text, p, c, False, extra, n_searchesif wtype == "tavily-search":- # Tavily costs are flat per call; charge `WEB_SEARCH_COST_PER_CALL`- # for parity with the Anthropic web-search worker. One call = one- # "n_search" for accounting.max_results = int(cfg.get("tavily_max_results", 5))- text, p, c = _call_tavily_search(str(prompt), max_results=max_results)- return text, p, c, False, WEB_SEARCH_COST_PER_CALL, 1+ text, p, c, extra, n_searches = _call_tavily_search(+ str(prompt), max_results=max_results,+ )+ return text, p, c, False, extra, n_searchesif wtype == "openrouter":text, p, c = LocalCloudAgent._call_openrouter(worker["model"],@@ -951,7 +1012,7 @@ def _swe_call_worker(caller can surface ``tool_calls`` per row. Fallbacks to one-shotworkers return 0 bash turns (no agent loop ran)."""wtype = worker.get("type", "openai")- if wtype == "anthropic-web-search":+ if wtype in _TOOLORCH_SEARCH_TYPES:# Search workers stay one-shot.text, p, c, is_local, extra, n_searches = _call_worker(worker, prompt, cfg)return text, p, c, is_local, extra, n_searches, 0@@ -1197,7 +1258,8 @@ class ToolOrchestraAgent(LocalCloudAgent):# Search workers are excluded — they answer fact-lookup# questions, not synthesis.non_search = [- w for w in workers if w.get("type") != "anthropic-web-search"+ w for w in workers+ if w.get("type") not in _TOOLORCH_SEARCH_TYPES] or workersworker = max(non_search,diff --git a/src/openjarvis/tools/web_search.py b/src/openjarvis/tools/web_search.pyindex a90d0cec..3d71f5de 100644--- a/src/openjarvis/tools/web_search.py+++ b/src/openjarvis/tools/web_search.py@@ -165,7 +165,10 @@ class WebSearchTool(BaseTool):client = TavilyClient(api_key=self._api_key)response = client.search(- query, max_results=max_results, search_depth="advanced"+ query,+ max_results=max_results,+ search_depth="advanced",+ include_usage=True,)results = response.get("results", [])formatted_parts = []@@ -182,7 +185,11 @@ class WebSearchTool(BaseTool):tool_name="web_search",content=formatted or "No results found.",success=True,- metadata={"num_results": len(results), "engine": "tavily"},+ metadata={+ "num_results": len(results),+ "engine": "tavily",+ "credits": (response.get("usage") or {}).get("credits"),+ },)except Exception as exc:logger.debug(diff --git a/tests/tools/test_web_search.py b/tests/tools/test_web_search.pyindex 570c3019..5ada6770 100644--- a/tests/tools/test_web_search.py+++ b/tests/tools/test_web_search.py@@ -171,7 +171,7 @@ class TestWebSearchTool:tool = WebSearchTool(api_key="test-key", max_results=3)tool.execute(query="test", max_results=7)mock_client.search.assert_called_once_with(- "test", max_results=7, search_depth="advanced"+ "test", max_results=7, search_depth="advanced", include_usage=True)def test_to_openai_function(self):