drydock-cli 2.9.81__tar.gz → 2.9.87__tar.gz

{drydock_cli-2.9.81 → drydock_cli-2.9.87}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.9.81
+Version: 2.9.87
 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.81 → drydock_cli-2.9.87}/drydock/core/agent_loop.py

@@ -1652,6 +1652,43 @@ class AgentLoop:
                     and not last_message.tool_calls
                 )
 
+                # 2026-06-06 v2.9.82: text-loop guard for TUI mode.
+                # Operator: "harness talking to itself". When the model
+                # emits 3+ consecutive assistant text messages without
+                # any tool call (typically in a reasoning loop), break
+                # the session and surface a clear message rather than
+                # silently calling the LLM forever. Programmatic mode
+                # has its own premature-exit logic below; this is the
+                # TUI-mode safety net.
+                if not should_break_loop:
+                    # Reset counter on any productive turn (tool call OR
+                    # message that didn't break loop because it had tool_calls)
+                    self._consecutive_empty_turns = 0
+                else:
+                    streak = getattr(self, "_consecutive_empty_turns", 0)
+                    # Count consecutive text-only assistant turns by walking
+                    # backward through history.
+                    text_only_streak = 0
+                    for m in reversed(self.messages):
+                        if m.role != Role.assistant:
+                            break
+                        if m.tool_calls:
+                            break
+                        text_only_streak += 1
+                    self._consecutive_empty_turns = text_only_streak
+                    if text_only_streak >= 3:
+                        # Force-break SILENTLY. The operator does not want
+                        # to see drydock's own messages in the TUI — only
+                        # the model's actual work. Log the event for
+                        # post-hoc investigation; don't inject anything.
+                        logger.warning(
+                            "[TEXT-LOOP-GUARD] %d consecutive text-only "
+                            "assistant turns — silently force-ending session "
+                            "(no UI marker per operator preference)",
+                            text_only_streak,
+                        )
+                        # should_break_loop already True; falls through.
+
                 # 2026-06-02: programmatic-mode premature-exit fix.
                 # Observed in tbench probe v2938: pypi-server trial
                 # made 1 tool call (read_file), got the result, emitted
@@ -2698,17 +2735,21 @@ class AgentLoop:
                     recent_paths.append(p)
         if not recent_paths:
             return None
-        # If exactly one unique path in recent window → safe to infer
+        # 2026-06-06 (v2.9.82): operator hitting the missing-path advisory
+        # repeatedly because recent reads had 5 different files — the old
+        # logic refused to guess. Switched to ALWAYS picking the most
+        # recent path. The PREFLIGHT injects a result that names the
+        # inferred path, so the model can correct on the next turn if
+        # wrong. Net: model never sees a "missing path" error, the write
+        # either lands on the right file or the model immediately writes
+        # again to the correct file.
         unique = list(dict.fromkeys(recent_paths))
         if len(unique) == 1:
             return unique[0]
-        # If multiple, prefer the most recent unique one but only if it
-        # was touched 2+ times recently (signal of "this is the working
-        # file"). Otherwise refuse to guess.
-        last_path = recent_paths[-1]
-        if recent_paths.count(last_path) >= 2:
-            return last_path
-        return None
+        # Multiple unique paths — return the most recently touched one.
+        # If multiple files were touched the same number of times,
+        # recent_paths[-1] is the latest write/read.
+        return recent_paths[-1]
 
     def _maybe_perform_loop_surgery(self, tool_call: ResolvedToolCall) -> None:
         """Detect tool-call loops and rewrite history to break them.
@@ -5344,6 +5385,68 @@ class AgentLoop:
             )
             if extra_sampling:
                 complete_kwargs["extra_sampling"] = extra_sampling
+
+            # 2026-06-06 PRD §5.3.5 Phase 2: grammar-constrained sampling
+            # for forced-tool turns. When tool_choice locks the next call
+            # to a specific tool, compile that tool's Pydantic args schema
+            # to GBNF and pass via the `grammar` field. The sampler then
+            # physically prevents invalid JSON (no broken escapes, no
+            # unescaped quotes, no raw control chars). Strips the `tools`
+            # field so the output is bare JSON args, not OpenAI tool_call
+            # envelope; we wrap the raw JSON into a synthetic tool_call
+            # below (search for "GRAMMAR_FORCED_TOOL").
+            _grammar_forced_tool: str | None = None
+            _grammar_union_engaged: bool = False
+            try:
+                from drydock.core.llm.grammar.policy import (
+                    select_grammar, apply_grammar,
+                )
+                # First, check for forced-single-tool case.
+                _grammar_gbnf, _grammar_forced_tool = select_grammar(
+                    tool_choice=tool_choice,
+                    tool_manager=self.tool_manager,
+                )
+                if _grammar_gbnf and _grammar_forced_tool:
+                    apply_grammar(
+                        complete_kwargs=complete_kwargs,
+                        grammar_gbnf=_grammar_gbnf,
+                        forced_tool_name=_grammar_forced_tool,
+                        extra_sampling=complete_kwargs.get("extra_sampling"),
+                    )
+                else:
+                    # tool_choice is auto/None: try union grammar over
+                    # all available tools. Model picks which tool inside
+                    # the grammar; we wrap the {name,arguments} envelope
+                    # into a synthetic tool_call after the call.
+                    from drydock.core.llm.grammar.policy_union import (
+                        select_union_grammar,
+                    )
+                    union_gbnf = select_union_grammar(
+                        tool_choice=tool_choice,
+                        available_tools=available_tools,
+                        tool_manager=self.tool_manager,
+                    )
+                    if union_gbnf:
+                        merged = dict(complete_kwargs.get("extra_sampling") or {})
+                        merged["grammar"] = union_gbnf
+                        complete_kwargs["extra_sampling"] = merged
+                        complete_kwargs.pop("tools", None)
+                        complete_kwargs.pop("tool_choice", None)
+                        cur_max = complete_kwargs.get("max_tokens") or 0
+                        if cur_max < 16000:
+                            complete_kwargs["max_tokens"] = 16000
+                        _grammar_union_engaged = True
+                        logger.info(
+                            "[GRAMMAR] engaged union grammar for "
+                            "auto-mode (%d chars)", len(union_gbnf),
+                        )
+            except Exception as _ge:
+                logger.warning(
+                    "[GRAMMAR] policy raised %s — falling through to "
+                    "unconstrained generation", _ge,
+                )
+                _grammar_forced_tool = None
+                _grammar_union_engaged = False
             if steering_logit_bias:
                 # Merge into extra_sampling so vLLM/Mistral backends pick it up
                 # via SamplingParams. Backends that don't understand logit_bias
@@ -5375,6 +5478,52 @@ class AgentLoop:
             processed_message = self.format_handler.process_api_response_message(
                 result.message
             )
+
+            # GRAMMAR: synthesize a tool_call from the bare JSON output
+            # produced under constrained sampling.
+            #
+            # FORCED case: output is just args, e.g. `{"path":...,"content":...}`
+            # UNION case: output is the envelope `{"name":"<tool>","arguments":{...}}`
+            if (_grammar_forced_tool or _grammar_union_engaged) and not processed_message.tool_calls:
+                raw_content = (processed_message.content or "").strip()
+                if raw_content.startswith("{"):
+                    try:
+                        from drydock.core.types import ToolCall, FunctionCall
+                        import json as _json_synth
+                        import uuid as _uuid_synth
+                        parsed = _json_synth.loads(raw_content)
+                        if _grammar_union_engaged:
+                            # Envelope shape — pull name + arguments.
+                            picked_name = parsed.get("name")
+                            picked_args = parsed.get("arguments", {})
+                            args_str = _json_synth.dumps(picked_args)
+                            tool_label = picked_name
+                        else:
+                            picked_name = _grammar_forced_tool
+                            args_str = raw_content
+                            tool_label = _grammar_forced_tool
+
+                        if isinstance(picked_name, str) and picked_name:
+                            synthetic_tc = ToolCall(
+                                id=f"grammar-{_uuid_synth.uuid4().hex[:16]}",
+                                function=FunctionCall(
+                                    name=picked_name,
+                                    arguments=args_str,
+                                ),
+                                type="function",
+                            )
+                            processed_message.tool_calls = [synthetic_tc]
+                            processed_message.content = ""
+                            logger.info(
+                                "[GRAMMAR] wrapped raw JSON output into "
+                                "synthetic tool_call for %s", tool_label,
+                            )
+                    except Exception as _se:
+                        logger.warning(
+                            "[GRAMMAR] failed to wrap raw output as "
+                            "tool_call: %s — leaving as text", _se,
+                        )
+
             self.messages.append(processed_message)
             return LLMChunk(message=processed_message, usage=result.usage)
 

{drydock_cli-2.9.81 → drydock_cli-2.9.87}/drydock/core/llm/backend/generic.py

@@ -139,6 +139,15 @@ class OpenAIAdapter(APIAdapter):
                 if v is not None:
                     payload[k] = v
 
+        # 2026-06-06 PRD §5.3.5: grammar-constrained sampling.
+        # When a `grammar` (GBNF string) is supplied via extra_sampling,
+        # llama.cpp's sampler masks logits to physically prevent invalid
+        # JSON during generation. Eliminates the "missing closing quote"
+        # failure mode that 80 commits of client-side patches couldn't fix.
+        # The grammar is generated from each tool's Pydantic args schema
+        # via drydock.core.llm.grammar.pydantic_to_gbnf().
+        # No-op when extra_sampling doesn't include "grammar".
+
         return payload
 
     def build_headers(self, api_key: str | None = None) -> dict[str, str]:

drydock_cli-2.9.87/drydock/core/llm/grammar/__init__.py

@@ -0,0 +1,59 @@
+"""GBNF grammar generation for constrained tool-call generation.
+
+Background (2026-06-06 PRD §5.3.5): the model's tool_call arguments are
+JSON serialized token-by-token via freeform sampling. Q3 quantization noise
+causes ~5-25% of long generations to produce structurally invalid JSON.
+Engine-level constrained decoding (GBNF on llama.cpp) physically prevents
+the model from emitting invalid JSON during sampling.
+
+This module provides:
+  - `pydantic_to_gbnf(model)`: compile a Pydantic BaseModel to a GBNF
+    grammar string suitable for llama.cpp's `grammar` request field.
+  - `tools_to_union_gbnf(tools)`: build a union grammar that lets the
+    model pick one of N tool calls, each constrained to its schema.
+
+The actual JSON-Schema → GBNF compiler is `_llamacpp_converter.py`, a
+verbatim copy of llama.cpp's `examples/json_schema_to_grammar.py`
+(Apache 2.0). Keep that file in sync with upstream when llama.cpp
+ships grammar bug fixes.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from drydock.core.llm.grammar._llamacpp_converter import SchemaConverter
+
+
+def pydantic_to_gbnf(model_cls: Any) -> str:
+    """Compile a Pydantic BaseModel class to a GBNF grammar string.
+
+    The grammar matches valid JSON objects conforming to the model's
+    schema. Strings get the proper char-class that excludes unescaped
+    control chars and requires valid backslash escapes — exactly the
+    constraint that fixes the "missing closing quote" failure mode.
+    """
+    schema = model_cls.model_json_schema()
+    conv = SchemaConverter(
+        prop_order={},
+        allow_fetch=False,
+        dotall=False,
+        raw_pattern=False,
+    )
+    conv.visit(schema, "")
+    return conv.format_grammar()
+
+
+def json_schema_to_gbnf(schema: dict[str, Any]) -> str:
+    """Compile a JSON Schema dict directly to a GBNF grammar string."""
+    conv = SchemaConverter(
+        prop_order={},
+        allow_fetch=False,
+        dotall=False,
+        raw_pattern=False,
+    )
+    conv.visit(schema, "")
+    return conv.format_grammar()
+
+
+__all__ = ["pydantic_to_gbnf", "json_schema_to_gbnf"]