crprotocol 4.3.0__tar.gz → 4.3.2__tar.gz

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

@@ -11,6 +11,47 @@ 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
+- **Native tool calling for local runtimes.** `OllamaAdapter` and
+  `LlamaCppAdapter` now implement `generate_chat_with_tools()` with
+  OpenAI-compatible tool schemas, so `dispatch_with_tools()` works against
+  Ollama, llama.cpp server, and LM Studio (via OpenAI-compatible discovery).
+- **Application capability contract.** New `crp.core.app_profile` module with
+  `ApplicationProfile`, `FrameworkKind`, `ProviderKind`, `ContextStrategy`,
+  `ToolInfo`, and `build_profile_from_messages()` so applications can declare
+  or be discovered: framework, provider, context window, tool registry,
+  MCP servers, RAG sources, and context-management strategy.
+- **Framework discovery helpers** in `crp.integrations.app_discovery`:
+  `profile_from_langchain()`, `profile_from_llamaindex()`,
+  `profile_from_openai_tools()`, `profile_from_mcp_servers()`.
+- **Discovery-to-provider bridge.** `DetectedModel.to_provider()` returns a
+  ready-to-use CRP adapter (`OllamaAdapter`, `LlamaCppAdapter`, or
+  `OpenAIAdapter` for LM Studio / OpenAI-compatible servers) from a discovery
+  report.
+
 ## [4.3.0] - 2026-06-28
 
 ### Added

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: crprotocol
-Version: 4.3.0
+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.0 → crprotocol-4.3.2}/crp/__init__.py

@@ -125,6 +125,12 @@ def __getattr__(name: str):
         "SafetyControlPlane": "crp.security.control_plane",
         "Checkpoint": "crp.security.checkpoint",
         "SafetyManifest": "crp.security.safety_manifest",
+        "ApplicationProfile": "crp.core.app_profile",
+        "FrameworkKind": "crp.core.app_profile",
+        "ProviderKind": "crp.core.app_profile",
+        "ContextStrategy": "crp.core.app_profile",
+        "ToolInfo": "crp.core.app_profile",
+        "build_profile_from_messages": "crp.core.app_profile",
     }
     if name in _ADVANCED:
         import importlib

{crprotocol-4.3.0 → 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.0"
+__version__ = "4.3.2"

crprotocol-4.3.2/crp/core/app_profile.py

@@ -0,0 +1,295 @@
+# Copyright © 2025-2026 Constantinos Vidiniotis. All rights reserved.
+# Licensed under Elastic License 2.0 — see LICENSE.md for details.
+"""Application capability contract and strategy discovery (CRP-SPEC-008 extension).
+
+Most applications already have their own context-management and tool-calling
+strategy before CRP is introduced: a LangChain chain with a set of tools, a
+LlamaIndex RAG pipeline, a custom sliding-window summariser, etc.  Rather than
+forcing the integrator to throw that away, :class:`ApplicationProfile` lets CRP
+*discover* or be *told* what the application already does, so CRP can:
+
+1. Avoid duplicating existing retrieval (don't build a second vector index if
+   the app already has one).
+2. Delegate tool execution to the application's own tool registry when possible.
+3. Choose a compatible relay strategy (push vs pull vs reflexive) based on the
+   app's actual provider and context budget.
+4. Record provenance accurately for audit (this fact came from the app's
+   existing RAG, not from CRP's warm store).
+
+The profile is intentionally a *contract*, not a config file.  It can be:
+
+* **Declared** by the integrator (authoritative).
+* **Derived** from a message list and an optional tool list (heuristic).
+* **Detected** from a framework object such as a LangChain ``BaseCallbackHandler``
+  or LlamaIndex ``QueryEngine`` (best-effort).
+"""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from crp.core.context_source import ContextManifest, ContextSource, SourceKind, SourceOrigin
+
+
+class FrameworkKind(str, Enum):
+    """Known application/framework integrations."""
+
+    UNKNOWN = "unknown"
+    LANGCHAIN = "langchain"
+    LLAMAINDEX = "llamaindex"
+    HAYSTACK = "haystack"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    CUSTOM = "custom"
+
+
+class ContextStrategy(str, Enum):
+    """How the application manages long conversation context."""
+
+    UNKNOWN = "unknown"
+    FULL_HISTORY = "full_history"          # Replays every turn verbatim
+    SLIDING_WINDOW = "sliding_window"      # Keeps last N turns
+    SUMMARIZATION = "summarization"        # Condenses old turns
+    RAG = "rag"                            # Retrieves relevant chunks
+    LONG_CONTEXT = "long_context"          # Relies on huge native context
+    HYBRID = "hybrid"                      # Mix of the above
+
+
+class ProviderKind(str, Enum):
+    """Broad provider families CRP knows how to govern."""
+
+    UNKNOWN = "unknown"
+    OPENAI = "openai"
+    ANTHROPIC = "anthropic"
+    OLLAMA = "ollama"
+    LLAMA_CPP = "llama_cpp"
+    LM_STUDIO = "lm_studio"
+    CUSTOM = "custom"
+
+
+@dataclass
+class ToolInfo:
+    """A tool the application already exposes."""
+
+    name: str
+    description: str = ""
+    parameters: dict[str, Any] = field(default_factory=dict)
+    source: str = "declared"   # "declared" | "derived" | "mcp" | "langchain" | ...
+
+
+@dataclass
+class ApplicationProfile:
+    """Capability contract for an existing application.
+
+    Fields are optional; missing fields mean "unknown / not provided" and CRP
+    falls back to its own defaults.
+    """
+
+    framework: FrameworkKind = FrameworkKind.UNKNOWN
+    provider: ProviderKind = ProviderKind.UNKNOWN
+    provider_model: str = ""
+    context_window: int | None = None
+    max_output_tokens: int | None = None
+    context_strategy: ContextStrategy = ContextStrategy.UNKNOWN
+    tools: list[ToolInfo] = field(default_factory=list)
+    mcp_servers: list[str] = field(default_factory=list)
+    rag_sources: list[ContextSource] = field(default_factory=list)
+    long_context_caching: bool = False
+    sliding_window_size: int | None = None
+    metadata: dict[str, Any] = field(default_factory=dict)
+
+    def supports_tools(self) -> bool:
+        """Return True if the profile indicates tool-calling is available."""
+        return len(self.tools) > 0 or len(self.mcp_servers) > 0
+
+    def to_manifest(self) -> ContextManifest:
+        """Convert the profile's RAG/sources into a :class:`ContextManifest`."""
+        manifest = ContextManifest()
+        for src in self.rag_sources:
+            manifest.add(src)
+        if self.context_strategy in {ContextStrategy.RAG, ContextStrategy.HYBRID}:
+            # Add a generic RAG placeholder if no explicit sources were given.
+            if not self.rag_sources:
+                manifest.add(ContextSource(
+                    kind=SourceKind.RAG_RETRIEVAL,
+                    source_id="application_rag",
+                    origin=SourceOrigin.DECLARED,
+                ))
+        for tool in self.tools:
+            manifest.add(ContextSource(
+                kind=SourceKind.FUNCTION_CALL,
+                source_id=tool.name,
+                description=tool.description,
+                origin=SourceOrigin.DECLARED,
+            ))
+        return manifest
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to a JSON-safe dict."""
+        return {
+            "framework": self.framework.value,
+            "provider": self.provider.value,
+            "provider_model": self.provider_model,
+            "context_window": self.context_window,
+            "max_output_tokens": self.max_output_tokens,
+            "context_strategy": self.context_strategy.value,
+            "tools": [
+                {
+                    "name": t.name,
+                    "description": t.description,
+                    "parameters": t.parameters,
+                    "source": t.source,
+                }
+                for t in self.tools
+            ],
+            "mcp_servers": list(self.mcp_servers),
+            "rag_sources": [s.to_dict() for s in self.rag_sources],
+            "long_context_caching": self.long_context_caching,
+            "sliding_window_size": self.sliding_window_size,
+            "metadata": dict(self.metadata),
+        }
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> "ApplicationProfile":
+        """Restore from a JSON-safe dict."""
+        return cls(
+            framework=FrameworkKind(data.get("framework", "unknown")),
+            provider=ProviderKind(data.get("provider", "unknown")),
+            provider_model=data.get("provider_model", ""),
+            context_window=data.get("context_window"),
+            max_output_tokens=data.get("max_output_tokens"),
+            context_strategy=ContextStrategy(data.get("context_strategy", "unknown")),
+            tools=[
+                ToolInfo(
+                    name=t["name"],
+                    description=t.get("description", ""),
+                    parameters=t.get("parameters", {}),
+                    source=t.get("source", "declared"),
+                )
+                for t in data.get("tools", [])
+            ],
+            mcp_servers=list(data.get("mcp_servers", [])),
+            rag_sources=[
+                ContextSource.from_dict(s) for s in data.get("rag_sources", [])
+            ],
+            long_context_caching=bool(data.get("long_context_caching", False)),
+            sliding_window_size=data.get("sliding_window_size"),
+            metadata=dict(data.get("metadata", {})),
+        )
+
+
+def detect_framework(messages: list[dict[str, Any]]) -> FrameworkKind:
+    """Heuristically detect the framework from message content/structure."""
+    if not messages:
+        return FrameworkKind.UNKNOWN
+
+    # Look for framework-specific metadata in message dicts.
+    for m in messages:
+        if not isinstance(m, dict):
+            continue
+        meta = m.get("metadata") or m.get("additional_kwargs") or {}
+        if isinstance(meta, dict):
+            keys = " ".join(str(k).lower() for k in meta.keys())
+            if "langchain" in keys or "lc_serializable" in keys:
+                return FrameworkKind.LANGCHAIN
+            if "llamaindex" in keys or "index_id" in keys:
+                return FrameworkKind.LLAMAINDEX
+
+    # Tool-call message shapes
+    has_tool_calls = any(
+        isinstance(m.get("tool_calls"), list) or m.get("role") in {"tool", "function"}
+        for m in messages
+    )
+    if has_tool_calls:
+        # OpenAI/Anthropic native shapes are most common
+        return FrameworkKind.OPENAI
+
+    return FrameworkKind.UNKNOWN
+
+
+def detect_context_strategy(messages: list[dict[str, Any]]) -> ContextStrategy:
+    """Heuristically detect how the app manages context.
+
+    This is best-effort: we look at message-count patterns, presence of
+    summarising system prompts, and explicit metadata.
+    """
+    if not messages:
+        return ContextStrategy.UNKNOWN
+
+    # Explicit metadata wins.
+    for m in messages:
+        meta = m.get("metadata") or m.get("additional_kwargs") or {}
+        if isinstance(meta, dict):
+            strategy = str(meta.get("context_strategy", "")).lower()
+            if strategy:
+                try:
+                    return ContextStrategy(strategy)
+                except ValueError:
+                    pass
+
+    system = " ".join(
+        str(m.get("content", "")).lower() for m in messages if m.get("role") == "system"
+    )
+    if ("summary" in system or "summarize" in system) and "conversation" in system:
+        return ContextStrategy.SUMMARIZATION
+    if "last" in system and ("messages" in system or "turns" in system):
+        return ContextStrategy.SLIDING_WINDOW
+    if len(messages) > 20:
+        # Very long verbatim history often means full replay or long-context.
+        return ContextStrategy.FULL_HISTORY
+
+    return ContextStrategy.UNKNOWN
+
+
+def build_profile_from_messages(
+    messages: list[dict[str, Any]],
+    *,
+    tools: list[dict[str, Any]] | None = None,
+    provider: ProviderKind | None = None,
+    context_window: int | None = None,
+) -> ApplicationProfile:
+    """Derive an application profile from observed messages and tools.
+
+    The derived profile is *observed*, not authoritative.  Use it for
+    negotiation and audit, but prefer an explicitly declared profile when
+    accuracy matters.
+    """
+    profile = ApplicationProfile(
+        framework=detect_framework(messages),
+        context_strategy=detect_context_strategy(messages),
+        provider=provider or ProviderKind.UNKNOWN,
+        context_window=context_window,
+    )
+
+    for tool in tools or []:
+        if isinstance(tool, ToolInfo):
+            profile.tools.append(tool)
+            continue
+        if isinstance(tool, dict):
+            func = tool.get("function", {}) or tool
+            profile.tools.append(ToolInfo(
+                name=func.get("name", tool.get("name", "unknown")),
+                description=func.get("description", ""),
+                parameters=func.get("parameters", func.get("arguments", {})),
+                source="derived",
+            ))
+
+    # Detect RAG evidence in messages (e.g. retrieved chunks, sources).
+    for m in messages:
+        meta = m.get("metadata") or {}
+        if isinstance(meta, dict):
+            sources = meta.get("sources") or meta.get("retrieved_chunks") or []
+            if sources:
+                profile.context_strategy = ContextStrategy.RAG
+                for src in sources:
+                    if isinstance(src, dict):
+                        profile.rag_sources.append(ContextSource(
+                            kind=SourceKind.RAG_RETRIEVAL,
+                            source_id=src.get("name", "retrieved_source"),
+                            metadata={"snippet": str(src.get("content", ""))[:200]},
+                            origin=SourceOrigin.OBSERVED,
+                        ))
+
+    return profile

{crprotocol-4.3.0 → 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.0 → 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)
     # ------------------------------------------------------------------