crprotocol 4.3.0__tar.gz → 4.3.1__tar.gz

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

@@ -11,6 +11,26 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 
 ## [Unreleased]
 
+## [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.1}/PKG-INFO

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

crprotocol-4.3.1/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.1/crp/integrations/app_discovery.py

@@ -0,0 +1,194 @@
+# Copyright © 2025-2026 Constantinos Vidiniotis. All rights reserved.
+# Licensed under Elastic License 2.0 — see LICENSE.md for details.
+"""Discover an existing application's tools and context strategy.
+
+This module introspects common LLM frameworks *without* hard-depending on them.
+Every import of an external package is guarded so CRP still works when the
+framework is not installed.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from crp.core.app_profile import (
+    ApplicationProfile,
+    ContextStrategy,
+    FrameworkKind,
+    ProviderKind,
+    ToolInfo,
+)
+from crp.core.context_source import ContextSource, SourceKind
+
+
+def _langchain_tools(obj: Any) -> list[ToolInfo]:
+    """Extract ToolInfo objects from a LangChain tool list or agent executor."""
+    tools: list[ToolInfo] = []
+    if obj is None:
+        return tools
+
+    items: list[Any] = []
+    if isinstance(obj, (list, tuple)):
+        items = list(obj)
+    elif hasattr(obj, "tools") and isinstance(getattr(obj, "tools"), (list, tuple)):
+        items = list(getattr(obj, "tools"))
+
+    for item in items:
+        if item is None:
+            continue
+        name = ""
+        description = ""
+        params: dict[str, Any] = {}
+
+        if isinstance(item, dict):
+            name = item.get("name", "")
+            description = item.get("description", "")
+            params = item.get("parameters", item.get("args_schema", {}))
+        else:
+            name = getattr(item, "name", "") or getattr(item, "__name__", "")
+            description = getattr(item, "description", "") or getattr(item, "__doc__", "")
+            schema = getattr(item, "args_schema", None)
+            if schema is not None:
+                try:
+                    params = schema.schema() if hasattr(schema, "schema") else dict(schema)
+                except Exception:
+                    params = {}
+
+        if name:
+            tools.append(ToolInfo(
+                name=name,
+                description=str(description)[:500],
+                parameters=params if isinstance(params, dict) else {},
+                source="langchain",
+            ))
+    return tools
+
+
+def _llamaindex_tools(obj: Any) -> list[ToolInfo]:
+    """Extract ToolInfo objects from a LlamaIndex QueryEngine or tool list."""
+    tools: list[ToolInfo] = []
+    if obj is None:
+        return tools
+
+    items: list[Any] = []
+    if isinstance(obj, (list, tuple)):
+        items = list(obj)
+    elif hasattr(obj, "get_tools"):
+        try:
+            items = list(obj.get_tools())
+        except Exception:
+            pass
+
+    for item in items:
+        if item is None:
+            continue
+        name = ""
+        description = ""
+        params: dict[str, Any] = {}
+
+        if isinstance(item, dict):
+            name = item.get("name", "")
+            description = item.get("description", "")
+            params = item.get("parameters", {})
+        else:
+            name = getattr(item, "metadata", {}).get("name", "") if hasattr(item, "metadata") else ""
+            if not name:
+                name = getattr(item, "__class__", type(item)).__name__
+            description = getattr(item, "metadata", {}).get("description", "")
+
+        if name:
+            tools.append(ToolInfo(
+                name=name,
+                description=str(description)[:500],
+                parameters=params,
+                source="llamaindex",
+            ))
+    return tools
+
+
+def profile_from_langchain(
+    llm: Any | None = None,
+    tools: Any | None = None,
+    chain: Any | None = None,
+) -> ApplicationProfile:
+    """Build an :class:`ApplicationProfile` from a LangChain setup.
+
+    Args:
+        llm: A LangChain LLM/chat-model instance (used for provider hints).
+        tools: A list of LangChain tools or an agent/executor with ``.tools``.
+        chain: A LangChain chain (used for framework detection).
+    """
+    profile = ApplicationProfile(framework=FrameworkKind.LANGCHAIN)
+
+    # Provider hint from LLM class name / model kwargs
+    if llm is not None:
+        cls_name = getattr(llm, "__class__", type(llm)).__name__.lower()
+        if "openai" in cls_name:
+            profile.provider = ProviderKind.OPENAI
+        elif "anthropic" in cls_name:
+            profile.provider = ProviderKind.ANTHROPIC
+        elif "ollama" in cls_name:
+            profile.provider = ProviderKind.OLLAMA
+        elif "llama" in cls_name:
+            profile.provider = ProviderKind.LLAMA_CPP
+
+        model = getattr(llm, "model", "") or getattr(llm, "model_name", "")
+        if isinstance(model, str):
+            profile.provider_model = model
+
+    profile.tools = _langchain_tools(tools)
+    return profile
+
+
+def profile_from_llamaindex(
+    query_engine: Any | None = None,
+    tools: Any | None = None,
+) -> ApplicationProfile:
+    """Build an :class:`ApplicationProfile` from a LlamaIndex setup."""
+    profile = ApplicationProfile(framework=FrameworkKind.LLAMAINDEX)
+    profile.tools = _llamaindex_tools(tools)
+
+    if query_engine is not None:
+        # Best-effort: mark RAG if a query engine is present.
+        profile.context_strategy = ContextStrategy.RAG
+        profile.rag_sources.append(ContextSource(
+            kind=SourceKind.RAG_RETRIEVAL,
+            name=getattr(query_engine, "__class__", type(query_engine)).__name__,
+            origin="DECLARED",
+        ))
+
+    return profile
+
+
+def profile_from_openai_tools(
+    tools: list[dict[str, Any]],
+    model: str = "",
+) -> ApplicationProfile:
+    """Build an :class:`ApplicationProfile` from an OpenAI-style tool list."""
+    profile = ApplicationProfile(
+        framework=FrameworkKind.OPENAI,
+        provider=ProviderKind.OPENAI,
+        provider_model=model,
+    )
+    for tool in tools:
+        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", {}),
+            source="openai",
+        ))
+    return profile
+
+
+def profile_from_mcp_servers(
+    servers: list[str] | list[dict[str, Any]],
+) -> ApplicationProfile:
+    """Build an :class:`ApplicationProfile` from a list of MCP server refs."""
+    profile = ApplicationProfile()
+    for srv in servers or []:
+        if isinstance(srv, str):
+            profile.mcp_servers.append(srv)
+        elif isinstance(srv, dict):
+            profile.mcp_servers.append(srv.get("name", srv.get("url", str(srv))))
+    return profile