"""Skipped-tool guard: a native-tool model must not answer past a planned tool. M0 measurements on the v2 gaming PC (2026-11-10, Strata) caught capable models answering without calling a tool they had been given: a made-up "24 degrees and sunny" instead of calling the weather tool, and "timer set" without calling the timer tool. When the planner already named a concrete tool for the turn, the engine must run that tool itself instead of delivering the model's tool-less answer, and the synthesis turn must not see the made-up answer. """ from __future__ import annotations from unittest.mock import patch import pytest LARGE_NATIVE_MODEL = "gpt-oss:20b" # LARGE -> native tool calling, no text-tool direct-exec FABRICATED = "It is 24 degrees and sunny in Seoul right now." GROUNDED = "Seoul is 13 degrees and clear." QUERY = "do I need an umbrella in Seoul right now?" def _content(text: str) -> dict: return {"message": {"role": "assistant", "content": text}} def _native_call(name: str, args: dict) -> dict: return {"message": {"role": "assistant", "content": "", "tool_calls": [ {"id": "call_1", "type": "function", "function": {"name": name, "arguments": args}}]}} def _run(mock_config, db, dialogue_memory, *, plan, chat_replies, allowed): from jarvis.reply import engine as engine_mod from jarvis.tools.types import ToolExecutionResult mock_config.ollama_chat_model = LARGE_NATIVE_MODEL mock_config.evaluator_enabled = False seen_messages: list[list[dict]] = [] replies = iter(chat_replies) def fake_chat(*args, **kwargs): msgs = kwargs.get("messages") or (args[2] if len(args) > 2 else []) seen_messages.append([dict(m) for m in msgs]) return next(replies) invoked: list[tuple[str, dict]] = [] def fake_tool(db, cfg, tool_name, tool_args, **kwargs): invoked.append((tool_name, dict(tool_args or {}))) return ToolExecutionResult(success=True, reply_text="Seoul: 13C, clear sky, no rain.", error_message=None) with patch.object(engine_mod, "run_tool_with_retries", side_effect=fake_tool), \ patch.object(engine_mod, "chat_with_messages", side_effect=fake_chat), \ patch.object(engine_mod, "select_tools", return_value=allowed), \ patch.object(engine_mod, "extract_search_params_for_memory", return_value={"keywords": []}), \ patch.object(engine_mod, "plan_query", return_value=plan): reply = engine_mod.run_reply_engine(db=db, cfg=mock_config, tts=None, text=QUERY, dialogue_memory=dialogue_memory) return reply, invoked, seen_messages WEATHER_PLAN = ["getWeather location='Seoul'", "Reply to the user with the weather."] def test_tool_less_answer_is_replaced_by_running_the_planned_tool(mock_config, db, dialogue_memory): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=WEATHER_PLAN, chat_replies=[_content(FABRICATED), _content(GROUNDED)], allowed=["getWeather", "stop"], ) assert invoked == [("getWeather", {"location": "Seoul"})] assert reply == GROUNDED # The synthesis turn reads the tool result, never the made-up answer. final_turn = seen[-1] assert not any(FABRICATED in (m.get("content") or "") for m in final_turn) assert any(m.get("role") == "tool" and "13C" in (m.get("content") or "") for m in final_turn) def test_model_that_calls_the_tool_itself_is_left_alone(mock_config, db, dialogue_memory): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=WEATHER_PLAN, chat_replies=[_native_call("getWeather", {"location": "Seoul"}), _content(GROUNDED)], allowed=["getWeather", "stop"], ) assert invoked == [("getWeather", {"location": "Seoul"})] assert reply == GROUNDED assert len(seen) == 2 def test_reply_only_plan_delivers_the_first_answer(mock_config, db, dialogue_memory): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["Reply to the user."], chat_replies=[_content("Good evening.")], allowed=["getWeather", "stop"], ) assert invoked == [] assert reply == "Good evening." assert len(seen) == 1 def test_plan_naming_a_tool_that_does_not_exist_does_not_retry(mock_config, db, dialogue_memory): # No timer tool exists: the guard has nothing to run, so it must not burn a # second chat call; the honesty rules in the prompt cover what is said. reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["setTimer minutes='5'", "Reply to the user."], chat_replies=[_content("I have no timer, so I cannot set one.")], allowed=["getWeather", "stop"], ) assert invoked == [] assert reply == "I have no timer, so I cannot set one." assert len(seen) == 1 # Planners often emit just the tool step (no synthesis step), or a memory # directive plus one tool step. Both still name the tool to run. @pytest.mark.parametrize("plan", [ ["getWeather location='Seoul'"], ["searchMemory topic='user location'", "getWeather location='Seoul'"], ], ids=["lone tool step", "memory directive then tool step"]) def test_single_step_tool_plan_is_still_enforced(mock_config, db, dialogue_memory, plan): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=plan, chat_replies=[_content(FABRICATED), _content(GROUNDED)], allowed=["getWeather", "stop"], ) assert invoked == [("getWeather", {"location": "Seoul"})] assert reply == GROUNDED HONEST_FAILURE = "I could not check that just now." def _failed_tool_result_seen(messages: list[dict]) -> bool: return any(m.get("role") == "tool" and m.get("tool_failed") for m in messages) def test_unrunnable_plan_never_delivers_the_held_back_guess(mock_config, db, dialogue_memory): # The weather plan uses a key getWeather does not take, so the guard cannot # run it. The tool-less "24 degrees and sunny" answer must still not reach # the user: the model answers again from a failed-tool result. reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["getWeather town='Seoul'"], chat_replies=[_content(FABRICATED), _content(HONEST_FAILURE)], allowed=["getWeather", "stop"], ) assert invoked == [] assert reply == HONEST_FAILURE final_turn = seen[-1] assert not any(FABRICATED in (m.get("content") or "") for m in final_turn) assert _failed_tool_result_seen(final_turn) def test_planned_call_with_arguments_the_tool_does_not_take_is_not_forced(mock_config, db, dialogue_memory): # A weak planner mapped "set a timer" onto setBroadcast with a made-up # argument. The guard must not trigger that tool; the model is told the # planned call could not run and answers from that. reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["setBroadcast duration='5 minutes'"], chat_replies=[_content("Timer set for 5 minutes."), _content("I have no timer, so I cannot set one.")], allowed=["setBroadcast", "stop"], ) assert invoked == [] assert reply == "I have no timer, so I cannot set one." assert _failed_tool_result_seen(seen[-1]) def test_prose_shaped_step_is_not_reinterpreted_into_some_other_call(mock_config, db, dialogue_memory): # "setBroadcast duration=5 minutes" is not a call setBroadcast takes. The # guard must not ask an LLM to repair it (that turned a timer request into # starting the broadcast). from jarvis.reply import engine as engine_mod with patch.object(engine_mod, "_resolve_plan_step", return_value=("setBroadcast", {"action": "start"})): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["setBroadcast duration=5 minutes"], chat_replies=[_content("Timer set for 5 minutes."), _content("I have no timer, so I cannot set one.")], allowed=["setBroadcast", "stop"], ) assert invoked == [] assert reply == "I have no timer, so I cannot set one." def test_system_message_ends_with_the_tool_reminder_for_this_turns_tools(mock_config, db, dialogue_memory): reply, invoked, seen = _run( mock_config, db, dialogue_memory, plan=["Reply to the user."], chat_replies=[_content("Good evening.")], allowed=["getWeather", "stop"], ) system = seen[0][0]["content"] reminder = system[system.rindex("Before you answer:"):] listed = reminder.split("Your tools this turn:")[1].split(".")[0] assert "getWeather" in listed assert "stop" not in listed.split(", ") # Nothing but the reply-language lock (if any) may follow it. from jarvis.system_prompt import ENGLISH_ONLY_DIRECTIVE tail = reminder.split("\n", 1)[1].strip() if "\n" in reminder else "" assert tail in ("", ENGLISH_ONLY_DIRECTIVE) or tail.startswith("CRITICAL OUTPUT RULE")