drydock-cli 2.9.107__tar.gz → 2.9.110__tar.gz

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.107
+Version: 2.9.110
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/drydock/core/agent_loop.py

@@ -825,7 +825,20 @@ class AgentLoop:
                 )
                 self.telemetry_client.send_auto_compact_triggered()
 
-                summary = await self.compact()
+                try:
+                    summary = await self.compact()
+                except Exception as _compact_err:
+                    # compact() failed (e.g. 400 from model server during
+                    # compaction request). Log and continue — the session
+                    # can keep running with its current context rather than
+                    # crashing. The context is not reduced, so it may hit
+                    # limits sooner, but that is recoverable; a crash is not.
+                    import logging as _logging
+                    _logging.getLogger(__name__).warning(
+                        "compact() failed, continuing without compaction: %s",
+                        _compact_err,
+                    )
+                    summary = ""
 
                 yield CompactEndEvent(
                     tool_call_id=tool_call_id,
@@ -3242,65 +3255,66 @@ class AgentLoop:
                     )
                 return
 
-        # 2026-06-07 Pre-flight: prune duplicate write_file history (v2.9.104).
-        # User session 2026-06-06 v2.9.95 batch `sam-cell-seg` trial:
-        # 22 identical writes to `/app/conversation_summary.smd` with the
-        # same sha8=d3bedbf3 content. The existing write_file dedup is
-        # advisory-only (per feedback_no_tool_errors_for_loop_detection.md)
-        # and Gemma 4 ignores the advisory. Same architectural fix as the
-        # consecutive-task preflight: drop the old duplicate calls from
-        # history so the model's next turn sees a cleaner context, with
-        # only the most recent attempt visible. Tool itself stays advisory.
-        if tool_call.tool_name == "write_file":
-            try:
-                cur_path = (
-                    tool_call.args_dict.get("path")
-                    or tool_call.args_dict.get("file_path")
-                    or ""
+        # 2026-06-07 Pre-flight: prune duplicate tool-call history
+        # (v2.9.104 write_file-specific; v2.9.108 generalized to any tool).
+        # Multiple user-observed loops where Gemma 4 emits the EXACT same
+        # tool name + args 5+ times in a row, each producing the same
+        # no-op result, ignoring the advisory:
+        #   2026-06-06 v2.9.95 sam-cell-seg: 22 writes to same path, same
+        #     content (sha8=d3bedbf3).
+        #   2026-06-06 v2.9.95 distribution-search: 3 identical
+        #     solve(p1:Real, p2:Real, conclusion:True, objective:"") calls
+        #     ending the trial.
+        # Tool-level dedup is advisory-only by design (per memory file
+        # feedback_no_tool_errors_for_loop_detection.md) and the model
+        # ignores advisories.
+        #
+        # Architectural fix: at preflight, if the current call is the
+        # 5th+ identical (same name + same args) call in history, prune
+        # the older N-1 duplicates (and their tool-result siblings) so
+        # the model's next turn sees a clean context. Exact-args match
+        # only — partial overlap doesn't count, since e.g. read_file
+        # with different offsets is legitimate progress.
+        try:
+            cur_name = tool_call.tool_name
+            cur_args_json = json.dumps(
+                tool_call.args_dict, sort_keys=True, default=str
+            )
+            dup_indices: list[int] = []
+            for i, m in enumerate(self.messages):
+                if m.role != Role.assistant or not m.tool_calls:
+                    continue
+                for tc in m.tool_calls:
+                    if tc.function.name != cur_name:
+                        continue
+                    try:
+                        a = json.loads(tc.function.arguments or "{}")
+                    except Exception:
+                        continue
+                    if json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                        dup_indices.append(i)
+                        break
+            dup_count = len(dup_indices)
+            if dup_count >= 5 and len(dup_indices) > 1:
+                to_drop = set()
+                for idx in dup_indices[:-1]:
+                    to_drop.add(idx)
+                    if idx + 1 < len(self.messages):
+                        next_m = self.messages[idx + 1]
+                        if next_m.role == Role.tool:
+                            to_drop.add(idx + 1)
+                kept = [
+                    m for i, m in enumerate(self.messages)
+                    if i not in to_drop
+                ]
+                self.messages.reset(kept)
+                logger.warning(
+                    "[PREFLIGHT-DUP] pruned %d duplicate %s calls "
+                    "(%d identical attempts in history)",
+                    len(to_drop), cur_name, dup_count,
                 )
-                cur_content = tool_call.args_dict.get("content", "")
-                if cur_path and isinstance(cur_content, str):
-                    dup_count = 0
-                    dup_indices: list[int] = []
-                    for i, m in enumerate(self.messages):
-                        if m.role != Role.assistant or not m.tool_calls:
-                            continue
-                        for tc in m.tool_calls:
-                            if tc.function.name != "write_file":
-                                continue
-                            try:
-                                a = json.loads(tc.function.arguments or "{}")
-                            except Exception:
-                                continue
-                            ap = a.get("path") or a.get("file_path") or ""
-                            ac = a.get("content", "")
-                            if ap == cur_path and ac == cur_content:
-                                dup_count += 1
-                                dup_indices.append(i)
-                                break
-                    if dup_count >= 5 and len(dup_indices) > 1:
-                        # Drop all but the most recent prior duplicate.
-                        # Also drop the tool result that immediately follows.
-                        to_drop = set()
-                        for idx in dup_indices[:-1]:
-                            to_drop.add(idx)
-                            if idx + 1 < len(self.messages):
-                                next_m = self.messages[idx + 1]
-                                if next_m.role == Role.tool:
-                                    to_drop.add(idx + 1)
-                        kept = [
-                            m for i, m in enumerate(self.messages)
-                            if i not in to_drop
-                        ]
-                        self.messages.reset(kept)
-                        logger.warning(
-                            "[PREFLIGHT-WRITE-DUP] pruned %d duplicate "
-                            "write_file calls to %r (%d identical "
-                            "attempts in history)",
-                            len(to_drop), cur_path, dup_count,
-                        )
-            except Exception as _e:
-                logger.debug("[PREFLIGHT-WRITE-DUP] failed: %s", _e)
+        except Exception as _e:
+            logger.debug("[PREFLIGHT-DUP] failed: %s", _e)
 
         # 2026-06-05 Pre-flight path validation. Operator: "why can't tool
         # calls check the right pathing BEFORE doing it?" Right answer.

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.9.107"
+version = "2.9.110"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via llama.cpp"
 readme = "README.md"
 requires-python = ">=3.12"

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/tests/test_agent_auto_compact.py

@@ -125,3 +125,24 @@ async def test_compact_replaces_messages_with_summary() -> None:
     assert agent.messages[0].role == Role.system
     assert agent.messages[-1].role == Role.assistant
     assert agent.messages[-1].content == "<final>"
+
+
+@pytest.mark.asyncio
+async def test_compact_failure_does_not_crash_session() -> None:
+    """If compact() raises (e.g. 400 from model server), session continues."""
+    from unittest.mock import AsyncMock, patch
+
+    backend = FakeBackend([
+        [mock_llm_chunk(content="<final>")],
+    ])
+    cfg = build_test_drydock_config(models=make_test_models(auto_compact_threshold=1))
+    agent = build_test_agent_loop(config=cfg, backend=backend)
+    agent.stats.context_tokens = 2
+
+    with patch.object(agent, "compact", new=AsyncMock(side_effect=RuntimeError("400 Bad Request"))):
+        events = [ev async for ev in agent.act("Hello")]
+
+    # Session should yield CompactStart + CompactEnd + AssistantEvent (no crash)
+    assert any(isinstance(ev, CompactStartEvent) for ev in events)
+    assert any(isinstance(ev, CompactEndEvent) for ev in events)
+    assert any(isinstance(ev, AssistantEvent) for ev in events)

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/tests/test_loop_regressions_2026_06_06.py

@@ -127,11 +127,13 @@ class TestConsecutiveWriteDuplicatePreflight:
         text = open(
             "/data3/drydock/drydock/core/agent_loop.py"
         ).read()
-        assert "PREFLIGHT-WRITE-DUP" in text, (
-            "consecutive-write preflight was removed from agent_loop.py"
+        # v2.9.108 generalized the marker from PREFLIGHT-WRITE-DUP to
+        # PREFLIGHT-DUP (covers any tool with 5+ identical-args calls).
+        assert "PREFLIGHT-DUP" in text, (
+            "duplicate-call preflight was removed from agent_loop.py"
         )
         assert "dup_count >= 5" in text, (
-            "duplicate-write threshold changed; update test"
+            "duplicate-call threshold changed; update test"
         )
 
     def test_preflight_prunes_history_to_most_recent_attempt(self):
@@ -300,3 +302,133 @@ class TestUnionGrammarDefaultOff:
         gbnf = build_union_gbnf([("write_file", WriteFileArgs)])
         assert gbnf is not None
         assert "write_file" in gbnf or "root" in gbnf
+
+
+class TestGeneralizedDuplicatePreflight:
+    """v2.9.108: the preflight handles ANY tool with 5+ identical-args
+    calls, not just write_file. Verifies the v2.9.95 distribution-search
+    pattern (3 identical `solve` calls at end of trial) would be
+    pruned."""
+
+    def test_solve_loop_pattern_prunes(self):
+        import json as _json
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import (
+            FunctionCall,
+            LLMMessage,
+            MessageList,
+            Role,
+            ToolCall,
+        )
+
+        msgs = MessageList()
+        # 6 identical solve calls — same args, same conclusion.
+        solve_args = _json.dumps({
+            "op": "solve",
+            "variables": "p1: Real, p2: Real",
+            "conclusion": "True",
+            "objective": "",
+        })
+        for i in range(6):
+            msgs.append(LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[ToolCall(
+                    id=f"solve_{i}",
+                    function=FunctionCall(name="solve", arguments=solve_args),
+                )],
+            ))
+            msgs.append(LLMMessage(
+                role=Role.tool,
+                content="sat",
+                tool_call_id=f"solve_{i}",
+            ))
+
+        al = object.__new__(AgentLoop)
+        al.messages = msgs
+
+        # Reproduce the inline generic preflight
+        cur_name = "solve"
+        cur_args_dict = _json.loads(solve_args)
+        cur_args_json = _json.dumps(cur_args_dict, sort_keys=True, default=str)
+        dup_indices = []
+        for i, m in enumerate(al.messages):
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != cur_name:
+                    continue
+                try:
+                    a = _json.loads(tc.function.arguments or "{}")
+                except Exception:
+                    continue
+                if _json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                    dup_indices.append(i)
+                    break
+
+        assert len(dup_indices) == 6
+        to_drop = set()
+        for idx in dup_indices[:-1]:
+            to_drop.add(idx)
+            if idx + 1 < len(al.messages):
+                if al.messages[idx + 1].role == Role.tool:
+                    to_drop.add(idx + 1)
+        kept = [m for i, m in enumerate(al.messages) if i not in to_drop]
+        al.messages.reset(kept)
+        # 5 older duplicates + their tool results = 10 dropped, 2 remain
+        assert len(al.messages) == 2
+
+    def test_different_args_NOT_pruned(self):
+        """read_file with different offsets — legitimate progress, NOT a dup."""
+        import json as _json
+        from drydock.core.agent_loop import AgentLoop
+        from drydock.core.types import (
+            FunctionCall,
+            LLMMessage,
+            MessageList,
+            Role,
+            ToolCall,
+        )
+
+        msgs = MessageList()
+        for i in range(8):
+            args = _json.dumps({"path": "/app/foo.py", "offset": i * 100})
+            msgs.append(LLMMessage(
+                role=Role.assistant,
+                content="",
+                tool_calls=[ToolCall(
+                    id=f"read_{i}",
+                    function=FunctionCall(name="read_file", arguments=args),
+                )],
+            ))
+            msgs.append(LLMMessage(
+                role=Role.tool,
+                content=f"contents at offset {i*100}",
+                tool_call_id=f"read_{i}",
+            ))
+
+        al = object.__new__(AgentLoop)
+        al.messages = msgs
+
+        # Now check what the preflight would do for "the 9th read_file
+        # call with offset=900". cur_args_json differs from all prior 8
+        # calls (each had a different offset).
+        cur_args_json = _json.dumps(
+            {"path": "/app/foo.py", "offset": 900}, sort_keys=True
+        )
+        dup_indices = []
+        for i, m in enumerate(al.messages):
+            if m.role != Role.assistant or not m.tool_calls:
+                continue
+            for tc in m.tool_calls:
+                if tc.function.name != "read_file":
+                    continue
+                try:
+                    a = _json.loads(tc.function.arguments or "{}")
+                except Exception:
+                    continue
+                if _json.dumps(a, sort_keys=True, default=str) == cur_args_json:
+                    dup_indices.append(i)
+                    break
+        # No duplicates of {offset:900} in history — preflight stays inert
+        assert dup_indices == []

{drydock_cli-2.9.107 → drydock_cli-2.9.110}/uv.lock

@@ -326,7 +326,7 @@ wheels = [
 
 [[package]]
 name = "drydock-cli"
-version = "2.9.105"
+version = "2.9.109"
 source = { editable = "." }
 dependencies = [
     { name = "agent-client-protocol" },