fix: address CodeRabbit review on dedup reminder and test

Bound the canonical arguments echoed in the strong dedup reminder to a 256-char preview so large-payload tools (WriteFile, MultiEdit) don't re-inject their whole body into context on every repeat; exact identity is still carried by the args_hash dedup telemetry.

Rewrite test_begin_end_step to assert observable behaviour (handle()/end_step()/dedup_triggered) instead of poking private _current_step_* internals.

Author: elkaix

src/pythinker_code/soul/toolset.py

@@ -228,13 +228,23 @@ def type_check(pythinker_toolset: PythinkerToolset):
 
 
 def _make_reminder_text_2(tool_name: str, repeat_count: int, canonical_args: str) -> str:
+    # Echo only a bounded preview of the arguments: large-payload tools
+    # (WriteFile, MultiEdit) would otherwise re-inject the whole body into
+    # context on every repeat — defeating the reminder by inflating tokens.
+    # Exact identity is preserved by the args_hash in the dedup telemetry.
+    args_limit = 256
+    if len(canonical_args) > args_limit:
+        dropped = len(canonical_args) - args_limit
+        args_preview = f"{canonical_args[:args_limit]}... [truncated {dropped} chars]"
+    else:
+        args_preview = canonical_args
     return (
         "\n\n<system-reminder>\n"
         "You have repeatedly called the same tool with identical parameters many times.\n"
         "Repeated tool call detected:\n"
         f"- tool: {tool_name}\n"
         f"- repeated_times: {repeat_count}\n"
-        f"- arguments: {canonical_args}\n"
+        f"- arguments: {args_preview}\n"
         "The previous repeated calls did not make progress. Do not call this exact same tool "
         "with the exact same arguments again.\n"
         "Carefully inspect the latest tool result and choose a different next action, "

tests/core/test_toolset.py

@@ -449,22 +449,17 @@ async def test_non_duplicate_allowed():
     assert ts.end_step() == [("ToolA", '{"value":"y"}')]
 
 
-def test_begin_end_step():
-    """begin_step and end_step should correctly manage deduplication state."""
+async def test_begin_end_step():
+    """begin_step seeds the prior step's calls; end_step captures this step's."""
     ts = _make_toolset()
 
     ts.begin_step([("ToolA", "{}")])
-    assert ts._previous_step_calls == [("ToolA", "{}")]
-    assert ts._current_step_calls == []
-    assert ts._current_step_tasks == {}
     assert ts.dedup_triggered is False
 
-    ts._current_step_calls.append(("ToolB", "{}"))
+    # A fresh (non-duplicate) call this step is captured by end_step() and does
+    # not trip cross-step dedup, since only ToolA was seen previously.
+    await ts.handle(ToolCall(id="b1", function=ToolCall.FunctionBody(name="ToolB", arguments="{}")))
     assert ts.end_step() == [("ToolB", "{}")]
-
-    # After end_step, internal lists are not cleared by end_step itself;
-    # the caller (PythinkerSoul) is expected to call begin_step again for the next step.
-    # But dedup_triggered should still reflect the last step's state.
     assert ts.dedup_triggered is False