When the skipped-tool guard could not run the planned call (not a literal call, or arguments the tool does not take) it delivered the answer it had held back, which was given without the tool and could be a made-up value. The planned call is now recorded as a failed tool result and the model answers from that, so the user hears that it could not check or do it. M0 kit: a case passes only when the final answer uses the tool result (13 degrees, not a made-up 24) or, for the no-tool request, says it cannot do it; the no-tool request now counts. The kit mirrors the engine's failed-result path, and a failing model moves on to the next candidate on these stricter checks. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
209 lines
8.8 KiB
Python
209 lines
8.8 KiB
Python
"""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")
|