crprotocol 4.3.1__tar.gz → 4.3.2__tar.gz

{crprotocol-4.3.1 → crprotocol-4.3.2}/CHANGELOG.md

@@ -11,6 +11,27 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [4.3.2] - 2026-06-26
+
+### Added
+- **ApplicationProfile wiring end-to-end.** `CRPOrchestrator` and `CRPClient`
+  now accept an `ApplicationProfile`, resolve providers and relay strategies
+  from the profile, and attest the application context manifest on every
+  dispatch.
+- **SDK provider-from-profile bridge.** `CRPClient` can instantiate
+  OpenAI/Anthropic/Ollama/llama.cpp/LM Studio adapters directly from a profile
+  so applications discovered by `build_profile_from_messages()` work without
+  manual provider setup.
+- **Strategy router.** `CRPOrchestrator.dispatch_with_strategy()` maps profile
+  `ContextStrategy` values (`rag`, `summarization`, `sliding_window`,
+  `long_context`, `hybrid`) to the correct CRP dispatch path (`push`,
+  `reflexive`, `progressive`, `stream_augmented`, `agentic`).
+
+### Fixed
+- `dispatch_router` now emits a `CRP-Application-Context-Manifest` attestation
+  header containing the resolved provider, model, and strategy when an
+  `ApplicationProfile` is present.
+
 ## [4.3.1] - 2026-06-28
 
 ### Added

{crprotocol-4.3.1 → crprotocol-4.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crprotocol
-Version: 4.3.1
+Version: 4.3.2
 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.3.1 → crprotocol-4.3.2}/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.3.1"
+__version__ = "4.3.2"

{crprotocol-4.3.1 → crprotocol-4.3.2}/crp/core/dispatch_router.py

@@ -16,10 +16,9 @@ import time
 import uuid
 from collections.abc import Generator
 from dataclasses import dataclass
-from typing import Any, TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 from crp.continuation.manager import ContinuationConfig, ContinuationManager
-
 from crp.core.errors import (
     ProviderError,
     RateLimitExceededError,
@@ -27,7 +26,6 @@ from crp.core.errors import (
 )
 from crp.core.session import QualityReport, SecurityFlags
 from crp.core.task_intent import TaskIntent
-from crp.security.audit_trail import ComplianceEventType
 from crp.core.window import (
     WindowMetrics,
     WindowNode,
@@ -35,6 +33,7 @@ from crp.core.window import (
     compute_envelope_budget,
     resolve_generation_reserve,
 )
+from crp.security.audit_trail import ComplianceEventType
 
 if TYPE_CHECKING:
     from crp.envelope.builder import EnvelopeResult
@@ -223,9 +222,10 @@ class DispatchMixin:
         from crp.envelope.builder import (
             EnvelopeResult,
             EnvelopeState,
+        )
+        from crp.envelope.builder import (
             construct as construct_envelope,
         )
-        from crp.extraction.types import Fact
 
         context_window = self._provider.context_window_size()
         s_tokens = self._provider.count_tokens(system_prompt)
@@ -242,11 +242,11 @@ class DispatchMixin:
         # CKF retriever callback for Phase 6 of envelope builder (GAP A fix)
         def ckf_retriever(query_text: str, budget_tokens: int) -> list[Fact]:
             """Execute CKF retriever and return the result.
-            
+
                 Args:
                     query_text (str): The query text value.
                     budget_tokens (int): The budget tokens value.
-            
+
                 Returns:
                     ``list[Fact]``.
             """
@@ -376,7 +376,6 @@ class DispatchMixin:
             A compact task reference that replaces the original ``task_input``.
         """
         from crp.continuation.input_planner import InputContinuationPlanner
-        from crp.extraction.types import Fact
 
         context_window = self._provider.context_window_size()
         planner = InputContinuationPlanner(count_tokens=self._provider.count_tokens)
@@ -837,11 +836,10 @@ class DispatchMixin:
                     "Auto-ingest triggered: task_input=%d tokens > available=%d",
                     t_tokens, available,
                 )
-                from crp.advanced.auto_ingest import auto_ingest, IngestFact
+                from crp.advanced.auto_ingest import IngestFact, auto_ingest
 
                 def _extract_fn(text: str, intent: str) -> list[IngestFact]:
                     """Adapter: run graduated extraction and return IngestFacts."""
-                    from crp.extraction.types import Fact
                     result = self._extraction.extract(
                         text, source_window_id="auto-ingest",
                     )
@@ -992,8 +990,20 @@ class DispatchMixin:
             "input_tokens": input_tokens,
         })
 
+        # ---------- Application-profile context attestation ----------
+        manifest = self._app_context_manifest()
+        observed_sources: Any | None = kwargs.pop("observed_sources", None)
+        if manifest is not None and observed_sources is None:
+            try:
+                observed_sources = manifest.sources
+            except Exception:
+                observed_sources = None
+
         # ---------- Assemble messages ----------
-        messages = assemble_messages(system_prompt, envelope, task_input)
+        messages = assemble_messages(
+            system_prompt, envelope, task_input,
+            manifest=manifest, observed_sources=observed_sources,
+        )
 
         # ---------- Dispatch to LLM ----------
         node.advance(WindowState.DISPATCHED)
@@ -1411,7 +1421,10 @@ class DispatchMixin:
             _cont_env_ms = (time.monotonic_ns() - _t_ce0) / 1_000_000
             _total_envelope_ms += _cont_env_ms
 
-            cont_messages = assemble_messages(system_prompt, cont_env_result.envelope_text, cont_task)
+            cont_messages = assemble_messages(
+                system_prompt, cont_env_result.envelope_text, cont_task,
+                manifest=manifest, observed_sources=observed_sources,
+            )
 
             # Dispatch continuation window
             cont_window_id = str(uuid.uuid4())
@@ -2269,7 +2282,7 @@ class DispatchMixin:
         output = ""
         finish_reason = "stop"
 
-        for round_idx in range(max_tool_rounds + 1):  # +1 for final generation
+        for _round_idx in range(max_tool_rounds + 1):  # +1 for final generation
             # Circuit breaker gate (§audit3: protect all dispatch variants)
             if not self._circuit_breaker.allow_request():
                 raise ProviderError(
@@ -3190,7 +3203,7 @@ class DispatchMixin:
         _total_llm_ms = 0.0
         finish_reason = "stop"
         accumulated_output = ""
-        embed_fn = self._embedding_fn if hasattr(self, "_embedding_fn") else None
+        self._embedding_fn if hasattr(self, "_embedding_fn") else None
 
         # Initial messages — no envelope, just system prompt + task
         current_messages: list[dict[str, str]] = [
@@ -3757,7 +3770,7 @@ class DispatchMixin:
                 max_continuations=int(self._config.get("max_continuations", 50)),
             )
             cont_mgr = ContinuationManager(cont_config)
-            task_intent = TaskIntent(task_input=task_input, system_prompt=system_prompt)
+            TaskIntent(task_input=task_input, system_prompt=system_prompt)
             init_facts = self._extraction.extract(
                 output, source_window_id=inner_report.window_id,
             ).facts
@@ -3906,7 +3919,7 @@ class DispatchMixin:
             if synthesis and synthesis.key_insights:
                 unused_insights = synthesis.key_insights[:3]
                 _synthesis_hints = (
-                    f"Available knowledge (may help fill gaps):\n"
+                    "Available knowledge (may help fill gaps):\n"
                     + "\n".join(f"- {i}" for i in unused_insights) + "\n"
                 )
             _continuation_note = ""
@@ -4164,7 +4177,7 @@ class DispatchMixin:
         # ---------- Advisory injection scan on full input (§7.5) ----------
         security_flags = self._scan_injection(large_input)
 
-        from crp.advanced.hierarchical import HierarchicalProcessor, HierarchicalConfig
+        from crp.advanced.hierarchical import HierarchicalProcessor
 
         processor = HierarchicalProcessor(
             dispatch_fn=lambda sys, task, **kw: self._provider.generate_chat(
@@ -4183,7 +4196,7 @@ class DispatchMixin:
 
         # Extract facts from all syntheses
         total_facts = 0
-        for i, synthesis in enumerate(syntheses):
+        for _i, synthesis in enumerate(syntheses):
             window_id = str(uuid.uuid4())
             self._warm_store.advance_window(window_id)
             ti = TaskIntent(task_input=intent_text, system_prompt=system_prompt)
@@ -4392,7 +4405,6 @@ class DispatchMixin:
         total_input_tokens = input_tokens
         total_output_tokens = 0
         total_llm_ms = 0.0
-        streaming_error: Exception | None = None
         max_continuations = int(self._config.get("max_continuations", 50))
         _cont_deadline = time.monotonic() + int(self._config.get("dispatch_timeout", 3600))
         last_output = ""
@@ -4411,7 +4423,6 @@ class DispatchMixin:
                 # Defensive: _stream_segment already yields error and returns,
                 # but yield from can propagate exceptions from the consumer.
                 logger.error("Streaming segment failed: %s", exc)
-                streaming_error = exc
                 finish_reason = "error"
                 output_segment = ""
 

{crprotocol-4.3.1 → crprotocol-4.3.2}/crp/core/orchestrator.py

@@ -29,8 +29,8 @@ import re
 import threading
 import time
 from collections import deque
+from collections.abc import Callable
 from concurrent.futures import ThreadPoolExecutor
-from dataclasses import dataclass
 
 # Deferred imports to avoid circular dependency chains.
 # These modules import from crp.core.task_intent (which is in crp.core),
@@ -38,6 +38,7 @@ from dataclasses import dataclass
 # We import them lazily at class init or first use instead.
 from typing import TYPE_CHECKING, Any
 
+from crp.core.app_profile import ApplicationProfile
 from crp.core.config import ConfigurationResolver, CRPConfig
 from crp.core.errors import (
     BudgetExhaustedError,
@@ -75,10 +76,8 @@ if TYPE_CHECKING:
     from crp.state.warm_store import WarmStateStore
 
 from crp.core.dispatch_router import (
-    ContinuationInfo,
     DispatchMixin,
     StreamEvent,
-    assemble_messages,
 )
 from crp.core.extraction_facade import ExtractionMixin, ExtractionResult
 
@@ -185,6 +184,7 @@ class CRPOrchestrator(DispatchMixin, ExtractionMixin):
         *,
         llm: LLMProvider | None = None,
         model: str | None = None,
+        app_profile: ApplicationProfile | None = None,
         **init_kwargs: Any,
     ) -> None:
         """Initialise the orchestrator and all subsystems."""
@@ -200,6 +200,7 @@ class CRPOrchestrator(DispatchMixin, ExtractionMixin):
             resolved_provider = _auto_detect_provider(model=model)
 
         self._provider = resolved_provider
+        self._app_profile = app_profile or ApplicationProfile()
 
         # Resolve configuration
         if config is not None:
@@ -495,6 +496,81 @@ class CRPOrchestrator(DispatchMixin, ExtractionMixin):
         # Register atexit handler for graceful shutdown (§audit H6)
         atexit.register(self._atexit_close)
 
+    # ------------------------------------------------------------------
+    # Application-profile helpers (SPEC-008 extension)
+    # ------------------------------------------------------------------
+
+    def _app_context_manifest(self) -> Any | None:
+        """Build a context manifest from the application profile if present."""
+        if self._app_profile is None:
+            return None
+        try:
+            manifest = self._app_profile.to_manifest()
+            return manifest if manifest.sources else None
+        except Exception as exc:
+            logger.debug("Failed to build app-profile manifest: %s", exc)
+            return None
+
+    def _select_relay_strategy(self, has_registered_tools: bool = False) -> str:
+        """Select a relay strategy based on the application capability contract.
+
+        Strategy strings:
+          - ``"push"``             — envelope-based dispatch (default)
+          - ``"tools"``            — pull-based tool-mediated dispatch
+          - ``"reflexive"``        — verify-then-refine
+          - ``"progressive"``      — index → detail on demand
+          - ``"stream_augmented"`` — real-time context injection
+          - ``"agentic"``          — LLM-in-the-loop cognitive engine
+        """
+        profile = self._app_profile
+        if profile is None:
+            return "push"
+
+        provider_supports_tools = self._provider.supports_tools()
+        if has_registered_tools and provider_supports_tools:
+            # Registered SDK tools run through the client's own tool loop.
+            return "tools"
+        if profile.supports_tools() and provider_supports_tools:
+            return "tools"
+
+        strategy = profile.context_strategy
+        if strategy.value == "rag":
+            return "push"
+        if strategy.value == "summarization":
+            return "reflexive"
+        if strategy.value == "sliding_window":
+            return "progressive"
+        if strategy.value == "long_context":
+            return "stream_augmented"
+        if strategy.value == "hybrid":
+            return "agentic"
+        return "push"
+
+    def dispatch_with_strategy(
+        self,
+        strategy: str,
+        system_prompt: str,
+        task_input: str,
+        **kwargs: Any,
+    ) -> tuple[str, QualityReport]:
+        """Route a dispatch to the named relay strategy.
+
+        Unknown strategies fall back to push-based dispatch with a warning.
+        """
+        _strategy_map: dict[str, Callable[..., tuple[str, QualityReport]]] = {
+            "push": self.dispatch,
+            "tools": self.dispatch_with_tools,
+            "reflexive": self.dispatch_reflexive,
+            "progressive": self.dispatch_progressive,
+            "stream_augmented": self.dispatch_stream_augmented,
+            "agentic": self.dispatch_agentic,
+        }
+        fn = _strategy_map.get(strategy)
+        if fn is None:
+            logger.warning("Unknown relay strategy '%s'; falling back to push", strategy)
+            fn = self.dispatch
+        return fn(system_prompt, task_input, **kwargs)
+
     # ------------------------------------------------------------------
     # L3 LLM-assisted requirement extraction (§5B.1)
     # ------------------------------------------------------------------

{crprotocol-4.3.1 → crprotocol-4.3.2}/crp/sdk/client.py

@@ -40,6 +40,11 @@ from typing import Any
 
 from crp._version import __version__
 from crp.config import CRPConfig as _UnifiedConfig
+from crp.core.app_profile import (
+    ApplicationProfile,
+    ProviderKind,
+    build_profile_from_messages,
+)
 from crp.core.config import _DEFAULTS as _CORE_DEFAULTS
 from crp.core.config import CRPConfig as _CoreConfig
 from crp.core.session import SessionHandle
@@ -181,6 +186,49 @@ class _ExhaustiveDispatcher:
         )
 
 
+def _provider_from_profile(profile: ApplicationProfile) -> LLMProvider | None:
+    """Create a provider adapter from an explicit application profile.
+
+    Returns ``None`` when the profile does not contain enough information to
+    instantiate a provider, letting the normal auto-detection path run.
+    """
+    if profile is None:
+        return None
+    import os
+
+    model = profile.provider_model or ""
+    metadata = profile.metadata or {}
+    base_url = metadata.get("base_url")
+    api_key = metadata.get("api_key")
+
+    if profile.provider is ProviderKind.OPENAI and model:
+        from crp.providers.openai import OpenAIAdapter
+        return OpenAIAdapter(
+            model=model,
+            api_key=api_key or os.environ.get("OPENAI_API_KEY") or "not-needed",
+        )
+    if profile.provider is ProviderKind.ANTHROPIC and model:
+        from crp.providers.anthropic import AnthropicAdapter
+        return AnthropicAdapter(
+            model=model,
+            api_key=api_key or os.environ.get("ANTHROPIC_API_KEY") or "not-needed",
+        )
+    if profile.provider is ProviderKind.OLLAMA and model:
+        from crp.providers.ollama import OllamaAdapter
+        return OllamaAdapter(model=model, base_url=base_url)
+    if profile.provider is ProviderKind.LLAMA_CPP:
+        from crp.providers.llamacpp import LlamaCppAdapter
+        return LlamaCppAdapter(server_url=base_url or "http://localhost:8080")
+    if profile.provider is ProviderKind.LM_STUDIO and model:
+        from crp.providers.openai import OpenAIAdapter
+        return OpenAIAdapter(
+            model=model,
+            base_url=base_url or "http://localhost:1234/v1",
+            api_key="not-needed",
+        )
+    return None
+
+
 # ── Tool decorator storage ─────────────────────────────────────────────────
 
 
@@ -215,6 +263,8 @@ class CRPClient:
         safety: Safety profile name ("balanced", "strict", etc.) or dict.
         depth: Default query depth ("auto", "quick", "standard", "thorough",
                "exhaustive").
+        app_profile: Optional application capability contract used to auto-select
+            provider, relay strategy, and context behaviour.
     """
 
     provider: LLMProvider | None = field(default=None)
@@ -223,6 +273,7 @@ class CRPClient:
     depth: str = field(default="auto")  # Level 2: quick | standard | thorough | exhaustive
     model: str | None = field(default=None)  # model identifier for auto-detection
     api_key: str | None = field(default=None)  # optional gateway/provider API key
+    app_profile: ApplicationProfile | None = field(default=None)
     _orchestrator: Any = field(default=None, repr=False)
     _session: SessionHandle | None = field(default=None, repr=False)
     _tools: _ToolRegistry = field(default_factory=_ToolRegistry, repr=False)
@@ -237,6 +288,7 @@ class CRPClient:
         model: str | None = None,
         api_key: str | None = None,
         input_continuation_mode: str | None = None,
+        app_profile: ApplicationProfile | None = None,
     ) -> None:
         """Manual __init__ to allow a ``safety`` property on a dataclass."""
         self.provider = provider
@@ -247,6 +299,7 @@ class CRPClient:
         self.depth = depth
         self.model = model
         self.api_key = api_key
+        self.app_profile = app_profile
         self._orchestrator = None
         self._session = None
         self._tools = _ToolRegistry()
@@ -276,21 +329,27 @@ class CRPClient:
             if self.provider is not None:
                 resolved_provider = self.provider
             else:
-                # Try orchestrator auto-detection; fall back to a silent provider
-                # so the client remains instantiable even with no LLM configured.
-                try:
-                    resolved_provider = _auto_detect_provider(model=self.model)
-                except ValueError:
-                    resolved_provider = CustomProvider(
-                        generate_fn=lambda msgs: ("", "stop"),
-                        count_tokens_fn=lambda t: len(t.split()),
-                        context_size=4096,
-                        name="sdk-fallback",
-                    )
+                # First try the explicit application profile; fall back to
+                # orchestrator auto-detection; finally a silent provider so the
+                # client remains instantiable even with no LLM configured.
+                resolved_provider = _provider_from_profile(self.app_profile)
+                if resolved_provider is None:
+                    try:
+                        resolved_provider = _auto_detect_provider(
+                            model=self.model or (self.app_profile.provider_model if self.app_profile else None),
+                        )
+                    except ValueError:
+                        resolved_provider = CustomProvider(
+                            generate_fn=lambda msgs: ("", "stop"),
+                            count_tokens_fn=lambda t: len(t.split()),
+                            context_size=4096,
+                            name="sdk-fallback",
+                        )
 
             self._orchestrator = CRPOrchestrator(
                 provider=resolved_provider,
                 config=core_config,
+                app_profile=self.app_profile,
             )
             self._apply_safety_profile()
         return self._orchestrator
@@ -620,6 +679,14 @@ class CRPClient:
             raise ValueError(f"Tool '{name}' not registered. Registered: {list(self._tools.tools.keys())}")
         return self._tools.tools[name](*args, **kwargs)
 
+    def derive_profile(
+        self,
+        messages: list[dict[str, Any]],
+        tools: list[dict[str, Any]] | None = None,
+    ) -> ApplicationProfile:
+        """Derive an application capability contract from observed messages."""
+        return build_profile_from_messages(messages, tools=tools)
+
     # ------------------------------------------------------------------
     # Session / visibility API (SPEC-038)
     # ------------------------------------------------------------------
@@ -876,7 +943,20 @@ class CRPClient:
         if self._tools.tools and orch._provider.supports_tools():
             return self._dispatch_with_tools(system, prompt, effective_depth, **kwargs)
 
+        # Profile-driven relay strategy selection (SPEC-008 extension).
+        strategy = orch._select_relay_strategy(has_registered_tools=bool(self._tools.tools))
         dispatch_kwargs = self._depth_kwargs(effective_depth, kwargs)
+        if strategy == "tools":
+            # Tool-mediated dispatch uses its own output-budget logic; only
+            # forward the explicit tool-round cap to avoid passing unknown
+            # provider parameters through.
+            return orch.dispatch_with_tools(
+                system, prompt,
+                max_tool_rounds=int(kwargs.get("max_tool_rounds", 10)),
+            )
+        if strategy != "push":
+            return orch.dispatch_with_strategy(strategy, system, prompt, **dispatch_kwargs)
+
         return orch.dispatch(
             system_prompt=system,
             task_input=prompt,