Files
javis_bot/tests/test_engine_skipped_tool_guard.py
javis-bot 8cb7e57cda fix(reply): never deliver the tool-less answer when the planned call cannot run
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>
2026-11-10 15:19:30 +09:00

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")