crprotocol 4.2.0__tar.gz → 4.2.1__tar.gz

{crprotocol-4.2.0 → crprotocol-4.2.1}/CHANGELOG.md

@@ -11,6 +11,22 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [4.2.1] - 2026-06-28
+
+### Fixed
+- `dispatch_with_tools()` now continues on `finish_reason="length"` instead of
+  returning truncated output. Each continuation window extracts facts and feeds
+  them back into the `ContinuationManager` so info-flow and gap signals stay
+  alive across tool-mediated windows.
+- `dispatch_with_tools()` continuation metrics now report the real continuation
+  window count, recomputed output tokens, and adjusted quality tier.
+
+### Changed
+- crp-comply legacy `_continue_window()` no longer appends the entire
+  accumulated message history to every continuation window. It now builds a
+  fresh bounded window (system prompt + compact task reference + prior output +
+  continuation directive), preventing context explosion on small local models.
+
 ## [4.2.0] - 2026-06-28
 
 ### Added

{crprotocol-4.2.0 → crprotocol-4.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crprotocol
-Version: 4.2.0
+Version: 4.2.1
 Summary: Context Relay Protocol — unbounded context, unbounded generation, amplified reasoning for LLMs
 Project-URL: Homepage, https://crprotocol.io
 Project-URL: Documentation, https://crprotocol.io

{crprotocol-4.2.0 → crprotocol-4.2.1}/crp/_version.py

@@ -2,4 +2,4 @@
 # Licensed under Elastic License 2.0 — see LICENSE.md for details.
 """CRP — Context Relay Protocol SDK."""
 
-__version__ = "4.2.0"
+__version__ = "4.2.1"

{crprotocol-4.2.0 → crprotocol-4.2.1}/crp/core/dispatch_router.py

@@ -2337,15 +2337,84 @@ class DispatchMixin:
             finish_reason = reason
             break
 
+        # ---------- Output continuation for tool-mediated dispatch ----------
+        # If the final generation hit the token wall, continue across additional
+        # windows just like plain dispatch().  Tool rounds are complete; these
+        # windows only extend the answer.
+        from crp.continuation.manager import ContinuationManager
+        cont_mgr = ContinuationManager(self._continuation_config)
+        _cont_facts = self._extraction.extract(output, source_window_id=window_id).facts
+        cont_state = cont_mgr.process_window(
+            task_intent=task_input,
+            output=output,
+            finish_reason=finish_reason,
+            output_tokens=self._provider.count_tokens(output),
+            facts=_cont_facts,
+            window_id=window_id,
+        )
+        _cont_window_count = 0
+        _last_output = output
+        _cont_deadline = time.monotonic() + int(self._config.get("dispatch_timeout", 3600))
+        while not cont_state.finished:
+            if time.monotonic() > _cont_deadline:
+                cont_state.termination_reason = "wall_time_deadline"
+                break
+            _cont_window_count += 1
+            if _cont_window_count > int(self._config.get("max_continuations", 50)):
+                cont_state.termination_reason = "max_continuations"
+                break
+
+            cont_env = cont_mgr.build_continuation_envelope(
+                task_intent=task_input,
+                gap_result=cont_state.gap_result,
+                structural_state=self._warm_store.structural_state.to_dict(),
+                last_output=_last_output,
+            )
+            cont_messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": task_input},
+                {"role": "assistant", "content": output},
+                {"role": "user", "content": f"[CONTINUATION]\n{cont_env}"},
+            ]
+            _t0 = time.monotonic_ns()
+            try:
+                cont_text, cont_reason = self._provider.generate_chat(
+                    cont_messages, max_tokens=g,
+                )
+                self._circuit_breaker.record_success()
+            except Exception as exc:
+                self._circuit_breaker.record_failure()
+                logger.error("Provider error (tool continuation): %s", exc)
+                break
+            _total_llm_ms += (time.monotonic_ns() - _t0) / 1_000_000
+
+            cont_wid = f"{window_id}-cont-{_cont_window_count}"
+            cont_facts = self._extraction.extract(cont_text, source_window_id=cont_wid).facts
+            _last_output = cont_text
+            output = f"{output}\n\n{cont_text}"
+            finish_reason = cont_reason
+            cont_state = cont_mgr.process_window(
+                task_intent=task_input,
+                output=cont_text,
+                finish_reason=cont_reason,
+                output_tokens=self._provider.count_tokens(cont_text),
+                facts=cont_facts,
+                window_id=cont_wid,
+            )
+
+        if _cont_window_count > 0 and cont_state.stitched_output:
+            output = cont_state.stitched_output
+            finish_reason = "stop"
+
         node.finish_reason = finish_reason
         node.raw_output_id = str(uuid.uuid4())
         node.advance(WindowState.COMPLETED)
 
         logger.info(
             "Tool-mediated dispatch done: finish=%s, tool_rounds=%d, "
-            "tool_tokens=%d, output_chars=%d, llm_ms=%.0f",
-            finish_reason, total_tool_rounds, total_tool_tokens,
-            len(output), _total_llm_ms,
+            "cont_windows=%d, tool_tokens=%d, output_chars=%d, llm_ms=%.0f",
+            finish_reason, total_tool_rounds, _cont_window_count,
+            total_tool_tokens, len(output), _total_llm_ms,
         )
 
         # ---------- Extract facts from output ----------
@@ -2387,6 +2456,8 @@ class DispatchMixin:
         e_tokens = total_tool_tokens  # Context served via tools, not envelope
         input_tokens = s_tokens + t_tokens + e_tokens
         self._total_input_tokens += input_tokens
+        # Recompute output tokens after any continuation windows.
+        output_tokens = self._provider.count_tokens(output)
         self._total_output_tokens += output_tokens
         self._rbac.record_dispatch(tokens_used=output_tokens)
 
@@ -2409,8 +2480,8 @@ class DispatchMixin:
             wall_time_ms=int(_total_llm_ms),
             finish_reason=finish_reason,
             facts_extracted=extraction.total_facts,
-            continuation_triggered=False,
-            continuation_index=0,
+            continuation_triggered=_cont_window_count > 0,
+            continuation_index=_cont_window_count,
             envelope_latency_ms=0.0,
             extraction_latency_ms=0.0,
             extraction_stage_used=",".join(str(s) for s in getattr(extraction, "stages_run", [])),
@@ -2439,7 +2510,7 @@ class DispatchMixin:
 
         quality_tier = _classify_quality_tier(
             facts_extracted=extraction.total_facts,
-            continuation_windows=0,
+            continuation_windows=_cont_window_count,
             saturation=0.0,
             finish_reason=finish_reason,
             output_tokens=output_tokens,

{crprotocol-4.2.0 → crprotocol-4.2.1}/tests/test_smoke.py

@@ -8,7 +8,7 @@ from __future__ import annotations
 def test_version() -> None:
     from crp import __version__
 
-    assert __version__ == "4.2.0"
+    assert __version__ == "4.2.1"
 
 
 def test_imports() -> None:

{crprotocol-4.2.0 → crprotocol-4.2.1}/tests/test_tool_relay.py

@@ -547,6 +547,74 @@ class TestDispatchWithToolsMocked:
         assert report.quality_tier is not None
         assert isinstance(report.telemetry, dict)
 
+    def test_tool_dispatch_continues_on_length(self):
+        """If the final answer hits length, continuation windows extend it."""
+        from crp.core.orchestrator import CRPOrchestrator
+        from crp.providers.base import LLMProvider
+
+        tool_calls = [{
+            "id": "call_1",
+            "type": "function",
+            "function": {
+                "name": "crp_retrieve_context",
+                "arguments": {"query": "data"},
+            },
+        }]
+        raw_msg = {
+            "role": "assistant",
+            "content": None,
+            "tool_calls": [{
+                "id": "call_1",
+                "type": "function",
+                "function": {"name": "crp_retrieve_context", "arguments": '{"query":"data"}'},
+            }],
+        }
+
+        chat_idx = [0]
+        continuation_replies = [
+            "Part one of the answer. ",
+            "Part two of the answer. ",
+            "Part three of the answer.",
+        ]
+
+        class ContinuationToolProvider(LLMProvider):
+            def __init__(self):
+                self.tool_done = False
+
+            def generate_chat(self, messages, **kwargs):
+                idx = min(chat_idx[0], len(continuation_replies) - 1)
+                chat_idx[0] += 1
+                # First two windows hit length, final stops.
+                fr = "length" if chat_idx[0] < len(continuation_replies) else "stop"
+                return continuation_replies[idx], fr
+
+            def count_tokens(self, text):
+                return max(1, len(text) // 4)
+
+            def context_window_size(self):
+                return 32000
+
+            def supports_tools(self):
+                return True
+
+            def generate_chat_with_tools(self, messages, tools, **kwargs):
+                if not self.tool_done:
+                    self.tool_done = True
+                    return ("", "tool_calls", tool_calls, raw_msg)
+                # Final answer truncated; return a fact-bearing output.
+                return ("Part one covers cloud threats. ", "length", None, None)
+
+        provider = ContinuationToolProvider()
+        orch = CRPOrchestrator(provider=provider)
+        output, report = orch.dispatch_with_tools(
+            "You are helpful",
+            "Write a detailed three-part report about cloud security. "
+            "Include part 1: threats, part 2: controls, part 3: compliance.",
+        )
+        assert "Part one" in output
+        assert "Part three" in output
+        assert report.telemetry.get("continuation_index", 0) >= 2
+
 
 # ── WindowMetrics tool fields tests ───────────────────────────────────