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>
185 lines
7.8 KiB
Python
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")
|