Skip to content

Personal AI, On Personal Devices

Python

fix(cli): wire router policy into jarvis ask (fixes #943) (#954)

Arush Wadhawan19477d08fbcc
diff --git a/src/openjarvis/cli/ask.py b/src/openjarvis/cli/ask.py
index 6e94b041..8d8c5d4d 100644
--- a/src/openjarvis/cli/ask.py
+++ b/src/openjarvis/cli/ask.py
@@ -787,6 +787,15 @@ def _print_profile(
"(overrides config). Pass 'none' to disable all persona files."
),
)
+ "--route",
+ "--router-policy",
+ "router_policy",
+ default=None,
+ help=(
+ "Routing policy to select model (e.g. heuristic, learned). Overrides config."
+ ),
+)
@click.pass_context
def ask(
ctx: click.Context,
@@ -806,6 +815,7 @@ def ask(
persona_name: str | None,
image_paths: tuple[str, ...] = (),
capture_screen: bool = False,
+ router_policy: str | None = None,
) -> None:
"""Ask Jarvis a question."""
quiet = (ctx.obj or {}).get("quiet", False) or output_json
@@ -976,9 +986,77 @@ def ask(
for ek, model_ids in all_models.items():
merge_discovered_models(ek, model_ids)
- # Resolve model via config fallback chain
+ # Resolve model via learning router policy or config fallback chain
if model_name is None:
- model_name = config.intelligence.default_model
+ effective_router_policy = router_policy
+ if not effective_router_policy and getattr(config.learning, "enabled", False):
+ effective_router_policy = getattr(config.learning.routing, "policy", "")
+
+ if effective_router_policy:
+ try:
+ from openjarvis.core.registry import RouterPolicyRegistry
+ from openjarvis.learning import ensure_registered
+ from openjarvis.learning.routing.router import build_routing_context
+
+ ensure_registered()
+ configured_default = config.intelligence.default_model
+ configured_fallback = config.intelligence.fallback_model
+ engine_models = all_models.get(engine_name, [])
+ available_models = set(engine_models)
+ # A configured fallback may belong to another engine.
+ candidates = list(
+ dict.fromkeys(
+ [
+ m
+ for m in [
+ configured_default,
+ *engine_models,
+ configured_fallback,
+ ]
+ if m and m in available_models
+ ]
+ )
+ )
+ if candidates and RouterPolicyRegistry.contains(
+ effective_router_policy
+ ):
+ preferred_model = (
+ configured_default
+ if configured_default in available_models
+ else candidates[0]
+ )
+ fallback_model = (
+ configured_fallback
+ if configured_fallback in available_models
+ else candidates[0]
+ )
+ policy = RouterPolicyRegistry.create(
+ effective_router_policy,
+ available_models=candidates,
+ default_model=preferred_model,
+ fallback_model=fallback_model,
+ )
+ routing_context = build_routing_context(
+ query_text,
+ model=preferred_model,
+ )
+ selected = policy.select_model(routing_context)
+ if selected in candidates:
+ logger.info(
+ "Router (%s) selected model %s for query",
+ effective_router_policy,
+ selected,
+ )
+ model_name = selected
+ except Exception as exc:
+ logger.debug(
+ "Failed to route model via %s: %s",
+ effective_router_policy,
+ exc,
+ )
+
+ if model_name is None:
+ model_name = config.intelligence.default_model
if not model_name:
# Try first available from engine
engine_models = all_models.get(engine_name, [])
diff --git a/tests/cli/test_ask_router.py b/tests/cli/test_ask_router.py
index bd6cf1a5..2424f8c6 100644
--- a/tests/cli/test_ask_router.py
+++ b/tests/cli/test_ask_router.py
@@ -5,6 +5,7 @@ from __future__ import annotations
import importlib
from unittest import mock
+import pytest
from click.testing import CliRunner
from openjarvis.cli import cli
@@ -151,3 +152,199 @@ class TestAskModelResolution:
result = CliRunner().invoke(cli, ["ask", "Hello"])
assert result.exit_code == 0, result.output
assert engine.generate.call_args.kwargs["model"] == "fallback-model"
+
+ def test_router_selects_code_model_for_code_query(self) -> None:
+ """When routing is enabled, a code query routes to coder model."""
+ engine = _mock_engine()
+ patches = _patch_engine(engine)
+ models = ["llama3.2:3b", "qwen2.5-coder:7b"]
+ with (
+ patches[0],
+ patches[1],
+ mock.patch.object(
+ _ask_mod,
+ "discover_models",
+ return_value={"mock": models},
+ ),
+ patches[3],
+ patches[4],
+ patches[5],
+ mock.patch.object(
+ _ask_mod,
+ "load_config",
+ return_value=JarvisConfig(),
+ ) as mock_config,
+ ):
+ cfg = mock_config.return_value
+ cfg.telemetry.enabled = False
+ cfg.learning.enabled = True
+ cfg.learning.routing.policy = "heuristic"
+ cfg.intelligence.default_model = "llama3.2:3b"
+ cfg.agent.default_agent = ""
+ result = CliRunner().invoke(
+ cli,
+ ["ask", "Write a Python function to parse JSON: def parse(): pass"],
+ )
+ assert result.exit_code == 0, result.output
+ assert engine.generate.call_args.kwargs["model"] == "qwen2.5-coder:7b"
+
+ @pytest.mark.parametrize("unavailable_setting", ["default", "fallback"])
+ def test_router_excludes_models_missing_from_active_engine(
+ self, unavailable_setting: str
+ ) -> None:
+ """Routing must not choose a configured model absent from this engine."""
+ engine = _mock_engine()
+ patches = _patch_engine(engine)
+ available_model = "llama3.2:3b"
+ unavailable_model = "qwen2.5-coder:7b"
+ with (
+ patches[0],
+ patches[1],
+ mock.patch.object(
+ _ask_mod,
+ "discover_models",
+ return_value={"mock": [available_model]},
+ ),
+ patches[3],
+ patches[4],
+ patches[5],
+ mock.patch.object(
+ _ask_mod,
+ "load_config",
+ return_value=JarvisConfig(),
+ ) as mock_config,
+ ):
+ cfg = mock_config.return_value
+ cfg.telemetry.enabled = False
+ cfg.learning.enabled = True
+ cfg.learning.routing.policy = "heuristic"
+ cfg.intelligence.default_model = (
+ unavailable_model
+ if unavailable_setting == "default"
+ else available_model
+ )
+ cfg.intelligence.fallback_model = (
+ unavailable_model
+ if unavailable_setting == "fallback"
+ else available_model
+ )
+ cfg.agent.default_agent = ""
+ result = CliRunner().invoke(
+ cli,
+ ["ask", "Write a Python function to parse JSON: def parse(): pass"],
+ )
+ assert result.exit_code == 0, result.output
+ assert engine.generate.call_args.kwargs["model"] == available_model
+
+ def test_router_selects_small_model_for_simple_query(self) -> None:
+ """When routing is enabled, a low complexity query routes to smallest model."""
+ from openjarvis.intelligence.model_catalog import register_builtin_models
+
+ register_builtin_models()
+ engine = _mock_engine()
+ patches = _patch_engine(engine)
+ models = ["llama3.2:3b", "qwen2.5-coder:7b"]
+ with (
+ patches[0],
+ patches[1],
+ mock.patch.object(
+ _ask_mod,
+ "discover_models",
+ return_value={"mock": models},
+ ),
+ patches[3],
+ patches[4],
+ patches[5],
+ mock.patch.object(
+ _ask_mod,
+ "load_config",
+ return_value=JarvisConfig(),
+ ) as mock_config,
+ ):
+ cfg = mock_config.return_value
+ cfg.telemetry.enabled = False
+ cfg.learning.enabled = True
+ cfg.learning.routing.policy = "heuristic"
+ cfg.intelligence.default_model = "qwen2.5-coder:7b"
+ cfg.agent.default_agent = ""
+ result = CliRunner().invoke(cli, ["ask", "hi"])
+ assert result.exit_code == 0, result.output
+ assert engine.generate.call_args.kwargs["model"] == "llama3.2:3b"
+
+ def test_cli_route_flag_overrides_config(self) -> None:
+ """The --route flag enables router even when learning is disabled in config."""
+ engine = _mock_engine()
+ patches = _patch_engine(engine)
+ models = ["llama3.2:3b", "qwen2.5-coder:7b"]
+ with (
+ patches[0],
+ patches[1],
+ mock.patch.object(
+ _ask_mod,
+ "discover_models",
+ return_value={"mock": models},
+ ),
+ patches[3],
+ patches[4],
+ patches[5],
+ mock.patch.object(
+ _ask_mod,
+ "load_config",
+ return_value=JarvisConfig(),
+ ) as mock_config,
+ ):
+ cfg = mock_config.return_value
+ cfg.telemetry.enabled = False
+ cfg.learning.enabled = False
+ cfg.intelligence.default_model = "llama3.2:3b"
+ cfg.agent.default_agent = ""
+ result = CliRunner().invoke(
+ cli,
+ [
+ "ask",
+ "--route",
+ "heuristic",
+ "Write a Python function to parse JSON: def parse(): pass",
+ ],
+ )
+ assert result.exit_code == 0, result.output
+ assert engine.generate.call_args.kwargs["model"] == "qwen2.5-coder:7b"
+
+ def test_explicit_model_flag_bypasses_router(self) -> None:
+ """The -m flag overrides router policy completely."""
+ engine = _mock_engine()
+ patches = _patch_engine(engine)
+ models = ["llama3.2:3b", "qwen2.5-coder:7b"]
+ with (
+ patches[0],
+ patches[1],
+ mock.patch.object(
+ _ask_mod,
+ "discover_models",
+ return_value={"mock": models},
+ ),
+ patches[3],
+ patches[4],
+ patches[5],
+ mock.patch.object(
+ _ask_mod,
+ "load_config",
+ return_value=JarvisConfig(),
+ ) as mock_config,
+ ):
+ cfg = mock_config.return_value
+ cfg.telemetry.enabled = False
+ cfg.learning.enabled = True
+ cfg.learning.routing.policy = "heuristic"
+ cfg.agent.default_agent = ""
+ result = CliRunner().invoke(
+ cli,
+ [
+ "ask",
+ "-m",
+ "forced-model",
+ "Write a Python function: def parse(): pass",
+ ],
+ )
+ assert result.exit_code == 0, result.output
+ assert engine.generate.call_args.kwargs["model"] == "forced-model"