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

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

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

@@ -1677,31 +1677,17 @@ class AgentLoop:
                         text_only_streak += 1
                     self._consecutive_empty_turns = text_only_streak
                     if text_only_streak >= 3:
-                        # Force-break: model is stuck in a reasoning loop.
-                        # Make this visible to the user via assistant event.
+                        # 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 — force-ending session",
+                            "assistant turns — silently force-ending session "
+                            "(no UI marker per operator preference)",
                             text_only_streak,
                         )
-                        try:
-                            # Append a marker so the TUI shows the user
-                            # what happened, not just a silent stop.
-                            self.messages.append(LLMMessage(
-                                role=Role.assistant,
-                                content=(
-                                    f"⚠ Drydock stopped: model emitted "
-                                    f"{text_only_streak} consecutive "
-                                    "text-only responses with no tool call. "
-                                    "This usually means a reasoning loop. "
-                                    "Type a new prompt to continue, or /clear "
-                                    "to reset context."
-                                ),
-                            ))
-                        except Exception:
-                            pass
-                        # should_break_loop already True; just continue
-                        # to the break path.
+                        # should_break_loop already True; falls through.
 
                 # 2026-06-02: programmatic-mode premature-exit fix.
                 # Observed in tbench probe v2938: pypi-server trial
@@ -5399,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
@@ -5430,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.83 → 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"]