ci: parallelize the test suite and cut install/coverage overhead (#580)

Run pytest with -n auto (pytest-xdist) and COVERAGE_CORE=sysmon, enable the uv cache, and switch test output to -q. Cuts the test job from ~40min to ~4min without changing what's tested or the 60% coverage gate.

.github/clone-stats/badge.json

@@ -1,7 +1,7 @@
 {
   "schemaVersion": 1,
   "label": "Git Clones",
-  "message": "125,214",
+  "message": "128,077",
   "color": "green",
   "namedLogo": "git"
 }

.github/clone-stats/clone-data.json

@@ -1,6 +1,6 @@
 {
-  "total_clones": 125214,
-  "last_updated": "2026-06-20T07:23:13Z",
+  "total_clones": 128077,
+  "last_updated": "2026-06-22T08:05:29Z",
   "daily": {
     "2026-03-27": 2189,
     "2026-03-28": 1874,
@@ -86,6 +86,8 @@
     "2026-06-16": 1317,
     "2026-06-17": 1170,
     "2026-06-18": 1408,
-    "2026-06-19": 1350
+    "2026-06-19": 1350,
+    "2026-06-20": 1437,
+    "2026-06-21": 1426
   }
 }

.github/workflows/ci.yml

@@ -23,6 +23,8 @@ jobs:
 
       - name: Install uv
         uses: astral-sh/setup-uv@v8.0.0
+        with:
+          enable-cache: true
 
       - name: Install dependencies
         run: uv sync --extra dev --extra framework-comparison --extra server
@@ -55,6 +57,8 @@ jobs:
 
       - name: Install uv
         uses: astral-sh/setup-uv@v8.0.0
+        with:
+          enable-cache: true
 
       - name: Install dependencies
         run: uv sync --extra dev --extra framework-comparison --extra server
@@ -63,8 +67,13 @@ jobs:
         run: uv run maturin develop --manifest-path rust/crates/openjarvis-python/Cargo.toml
 
       - name: Run tests
+        # COVERAGE_CORE=sysmon uses CPython 3.12's sys.monitoring backend,
+        # which is dramatically cheaper than the default C trace function.
+        # -n auto fans the suite out across all runner cores via pytest-xdist.
+        env:
+          COVERAGE_CORE: sysmon
         run: |
-          uv run pytest tests/ -v --tb=short -m "not live and not cloud and not hub" \
+          uv run pytest tests/ -n auto -q --tb=short -m "not live and not cloud and not hub" \
             --cov=openjarvis \
             --cov-report=term-missing \
             --cov-report=xml \
@@ -107,6 +116,8 @@ jobs:
 
       - name: Install uv
         uses: astral-sh/setup-uv@v8.0.0
+        with:
+          enable-cache: true
 
       - name: Install dependencies
         run: uv sync --extra dev --extra server

pyproject.toml

@@ -48,6 +48,7 @@ dev = [
     "pytest>=8",
     "pytest-asyncio>=0.24",
     "pytest-cov>=5",
+    "pytest-xdist>=3",
     "respx>=0.22",
     "ruff>=0.4",
     "pre-commit>=3.0",

src/openjarvis/engine/ollama.py

@@ -22,6 +22,49 @@ from openjarvis.engine._stubs import StreamChunk
 
 logger = logging.getLogger(__name__)
 
+# Qwen3 treats ``/think`` and ``/no_think`` as soft-switch control tokens that
+# toggle reasoning mode. Small models (e.g. qwen3:14b) fed a multi-line prompt
+# sometimes emit one of these as the sole tool argument, e.g.
+# ``{"command": "/no_think"}`` instead of the real command. Ollama parses that
+# into a fully-formed tool_call via the model's chat template, so we have to
+# drop it on our side before the agent executes garbage.
+_QWEN_CONTROL_TOKENS = frozenset({"/think", "/no_think"})
+
+
+def _is_control_token_only_args(raw_args: Any) -> bool:
+    """Return True if tool-call arguments contain nothing but a Qwen3 token.
+
+    ``raw_args`` may be a dict (Ollama's native shape) or a JSON / bare string.
+    A call is considered degenerate only when it carries at least one control
+    token and no other usable content, so legitimate calls such as
+    ``{"command": "date"}`` or ``{"command": "echo /no_think"}`` are kept.
+    """
+    parsed: Any = raw_args
+    if isinstance(raw_args, str):
+        try:
+            parsed = json.loads(raw_args)
+        except (json.JSONDecodeError, TypeError):
+            parsed = raw_args
+
+    if isinstance(parsed, str):
+        return parsed.strip().lower() in _QWEN_CONTROL_TOKENS
+
+    if not isinstance(parsed, dict) or not parsed:
+        return False
+
+    saw_token = False
+    for value in parsed.values():
+        if not isinstance(value, str):
+            return False  # a non-string value is real content
+        stripped = value.strip()
+        if not stripped:
+            continue
+        if stripped.lower() in _QWEN_CONTROL_TOKENS:
+            saw_token = True
+        else:
+            return False  # real string content
+    return saw_token
+
 
 def _default_num_ctx() -> int:
     """Default context window (tokens). Override with ``JARVIS_NUM_CTX``.
@@ -168,14 +211,19 @@ class OllamaEngine(InferenceEngine):
         if raw_tool_calls:
             tool_calls = []
             for i, tc in enumerate(raw_tool_calls):
-                raw_args = tc.get("function", {}).get(
-                    "arguments",
-                    "{}",
-                )
+                fn = tc.get("function", {})
+                raw_args = fn.get("arguments", "{}")
+                if _is_control_token_only_args(raw_args):
+                    logger.warning(
+                        "Dropping Qwen3 control-token tool call %s(%r)",
+                        fn.get("name", ""),
+                        raw_args,
+                    )
+                    continue
                 tool_calls.append(
                     {
                         "id": tc.get("id", f"call_{i}"),
-                        "name": tc.get("function", {}).get("name", ""),
+                        "name": fn.get("name", ""),
                         "arguments": (
                             json.dumps(raw_args)
                             if isinstance(raw_args, dict)
@@ -183,7 +231,8 @@ class OllamaEngine(InferenceEngine):
                         ),
                     }
                 )
-            result["tool_calls"] = tool_calls
+            if tool_calls:
+                result["tool_calls"] = tool_calls
         return result
 
     async def stream(
@@ -340,14 +389,22 @@ class OllamaEngine(InferenceEngine):
                         # OpenAI-delta fragment shape that agent_manager_routes
                         # expects in _merge_tool_call_fragments.
                         fragments: List[Dict[str, Any]] = []
-                        for i, tc in enumerate(raw_tool_calls):
+                        for tc in raw_tool_calls:
                             fn = tc.get("function", {}) or {}
                             raw_args = fn.get("arguments", "{}")
+                            if _is_control_token_only_args(raw_args):
+                                logger.warning(
+                                    "Dropping Qwen3 control-token tool call %s(%r)",
+                                    fn.get("name", ""),
+                                    raw_args,
+                                )
+                                continue
                             args_str = (
                                 json.dumps(raw_args)
                                 if isinstance(raw_args, dict)
                                 else str(raw_args)
                             )
+                            i = len(fragments)
                             fragments.append(
                                 {
                                     "index": i,
@@ -359,8 +416,9 @@ class OllamaEngine(InferenceEngine):
                                     },
                                 }
                             )
-                        yield StreamChunk(tool_calls=fragments)
-                        finish_reason = "tool_calls"
+                        if fragments:
+                            yield StreamChunk(tool_calls=fragments)
+                            finish_reason = "tool_calls"
 
                     if chunk.get("done", False):
                         reported_prompt = chunk.get("prompt_eval_count", 0)

tests/engine/test_ollama.py

@@ -11,7 +11,7 @@ import respx
 from openjarvis.core.registry import EngineRegistry
 from openjarvis.core.types import Message, Role
 from openjarvis.engine._base import EngineConnectionError
-from openjarvis.engine.ollama import OllamaEngine
+from openjarvis.engine.ollama import OllamaEngine, _is_control_token_only_args
 
 
 @pytest.fixture()
@@ -82,6 +82,181 @@ class TestOllamaHealth:
             assert engine.health() is False
 
 
+class TestControlTokenFilter:
+    """Qwen3 ``/think`` / ``/no_think`` soft-switch tokens sometimes leak into
+    tool-call arguments on small models (e.g. ``{"command": "/no_think"}``).
+    Such a call is never valid and must be dropped before execution.
+    """
+
+    @pytest.mark.parametrize(
+        "raw_args",
+        [
+            {"command": "/no_think"},
+            {"command": "/think"},
+            {"command": "  /no_think  "},
+            {"command": "/NO_THINK"},
+            "/no_think",
+            json.dumps({"command": "/no_think"}),
+            {"command": "/no_think", "note": ""},
+        ],
+    )
+    def test_detects_control_token_only(self, raw_args) -> None:
+        assert _is_control_token_only_args(raw_args) is True
+
+    @pytest.mark.parametrize(
+        "raw_args",
+        [
+            {"command": "date"},
+            {"command": "echo /no_think"},
+            {"query": "what is /no_think"},
+            {"command": "date", "note": "/no_think"},
+            {"timeout": 30},
+            {},
+            "date",
+            "not json at all",
+        ],
+    )
+    def test_keeps_legitimate_args(self, raw_args) -> None:
+        assert _is_control_token_only_args(raw_args) is False
+
+
+class TestOllamaGenerateControlToken:
+    def test_generate_drops_control_token_tool_call(self, engine: OllamaEngine) -> None:
+        with respx.mock:
+            respx.post("http://testhost:11434/api/chat").mock(
+                return_value=httpx.Response(
+                    200,
+                    json={
+                        "message": {
+                            "role": "assistant",
+                            "content": "",
+                            "tool_calls": [
+                                {
+                                    "function": {
+                                        "name": "shell_exec",
+                                        "arguments": {"command": "/no_think"},
+                                    }
+                                }
+                            ],
+                        },
+                        "model": "qwen3:14b",
+                    },
+                )
+            )
+            result = engine.generate(
+                [Message(role=Role.USER, content="run date")],
+                model="qwen3:14b",
+                tools=[{"type": "function", "function": {"name": "shell_exec"}}],
+            )
+        assert not result.get("tool_calls")
+
+    def test_generate_keeps_valid_tool_call(self, engine: OllamaEngine) -> None:
+        with respx.mock:
+            respx.post("http://testhost:11434/api/chat").mock(
+                return_value=httpx.Response(
+                    200,
+                    json={
+                        "message": {
+                            "role": "assistant",
+                            "content": "",
+                            "tool_calls": [
+                                {
+                                    "function": {
+                                        "name": "shell_exec",
+                                        "arguments": {"command": "date"},
+                                    }
+                                }
+                            ],
+                        },
+                        "model": "qwen3:14b",
+                    },
+                )
+            )
+            result = engine.generate(
+                [Message(role=Role.USER, content="run date")],
+                model="qwen3:14b",
+                tools=[{"type": "function", "function": {"name": "shell_exec"}}],
+            )
+        assert len(result["tool_calls"]) == 1
+        assert json.loads(result["tool_calls"][0]["arguments"]) == {"command": "date"}
+
+    def test_generate_drops_only_control_token_among_many(
+        self, engine: OllamaEngine
+    ) -> None:
+        with respx.mock:
+            respx.post("http://testhost:11434/api/chat").mock(
+                return_value=httpx.Response(
+                    200,
+                    json={
+                        "message": {
+                            "role": "assistant",
+                            "content": "",
+                            "tool_calls": [
+                                {
+                                    "function": {
+                                        "name": "shell_exec",
+                                        "arguments": {"command": "/no_think"},
+                                    }
+                                },
+                                {
+                                    "function": {
+                                        "name": "shell_exec",
+                                        "arguments": {"command": "date"},
+                                    }
+                                },
+                            ],
+                        },
+                        "model": "qwen3:14b",
+                    },
+                )
+            )
+            result = engine.generate(
+                [Message(role=Role.USER, content="run date")],
+                model="qwen3:14b",
+                tools=[{"type": "function", "function": {"name": "shell_exec"}}],
+            )
+        assert len(result["tool_calls"]) == 1
+        assert json.loads(result["tool_calls"][0]["arguments"]) == {"command": "date"}
+
+
+class TestOllamaStreamFullControlToken:
+    @pytest.mark.asyncio
+    async def test_stream_full_drops_control_token_tool_call(
+        self, engine: OllamaEngine
+    ) -> None:
+        lines = [
+            json.dumps(
+                {
+                    "message": {
+                        "content": "",
+                        "tool_calls": [
+                            {
+                                "function": {
+                                    "name": "shell_exec",
+                                    "arguments": {"command": "/no_think"},
+                                }
+                            }
+                        ],
+                    },
+                    "done": True,
+                }
+            ),
+        ]
+        body = "\n".join(lines)
+        with respx.mock:
+            respx.post("http://testhost:11434/api/chat").mock(
+                return_value=httpx.Response(200, text=body)
+            )
+            chunks = []
+            async for chunk in engine.stream_full(
+                [Message(role=Role.USER, content="run date")],
+                model="qwen3:14b",
+                tools=[{"type": "function", "function": {"name": "shell_exec"}}],
+            ):
+                chunks.append(chunk)
+        assert all(not c.tool_calls for c in chunks)
+
+
 class TestOllamaStream:
     @pytest.mark.asyncio
     async def test_stream_yields_content(self, engine: OllamaEngine) -> None: