Files
javis_bot/tests/test_engine_skipped_tool_guard.py
javis-bot 903e0eb9de fix(reply): stop models answering past an available tool
M0 on Strata caught both v2 models skipping a tool they had been given:
the recommended model made up "24 degrees, sunny" instead of calling the
weather tool, and the fast model said "timer set" without calling the
timer tool (3 of 3 each). qwen2.5:7b does the same through the engine.

- Prompt: TOOL_HONESTY_RULES in the persona (live facts only from a tool
  result this turn, actions only claimed after a tool reports success, no
  answer text next to a tool call), restated at the end of the system
  message by tool_honesty_reminder() with the turn's real tool names.
- Engine: skipped-tool guard. When a native-tool model answers before any
  tool has run and the plan names a callable tool as a concrete call, the
  answer is dropped and the plan steps are direct-executed, then the model
  answers from the results. Only literal, schema-valid steps run (regex
  fast path, no LLM repair); otherwise the held-back answer is delivered.
- Planner: the AVAILABLE TOOLS lines now carry argument names
  (planner_tool_catalog), so concrete steps use the tool's real keys.
- Eval evals/test_tool_skip_confabulation.py; on qwen2.5:7b, 3 runs each,
  available-tool cases went from 0/12 to 9/12 calling the tool.
- M0 kit: tools_fast / tools_recommended stages (run_m0_tools.bat) rerun
  tool calling before and after the fix on the real models, loading the
  production system_prompt.py and planner.py.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-10 15:05:40 +09:00

185 lines
7.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
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's answer stands
# and no second chat call is spent.
reply, invoked, seen = _run(
mock_config, db, dialogue_memory, plan=["setBroadcast duration='5 minutes'"],
chat_replies=[_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 len(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); the model's answer stands.
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("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")