ct-toolkit 0.3.5__tar.gz → 0.3.7__tar.gz

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ct-toolkit
-Version: 0.3.5
+Version: 0.3.7
 Summary: Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems
 Author: Hakan Damar
 License: Apache-2.0
@@ -9,7 +9,7 @@ Requires-Python: >=3.11
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: instructor>=1.3.0
-Requires-Dist: any-llm-sdk[all]>=1.0.0
+Requires-Dist: litellm>=1.40.0
 Requires-Dist: numpy>=1.26.0
 Requires-Dist: pyyaml>=6.0
 Requires-Dist: pydantic>=2.5.0
@@ -20,6 +20,8 @@ Requires-Dist: rich>=13.0.0
 Requires-Dist: jinja2>=3.1.0
 Requires-Dist: pyasn1>=0.6.3
 Requires-Dist: typer[all]>=0.12.0
+Requires-Dist: fastapi>=0.110.0
+Requires-Dist: uvicorn>=0.29.0
 Provides-Extra: ollama
 Requires-Dist: ollama>=0.2.0; extra == "ollama"
 Provides-Extra: langchain
@@ -65,6 +67,7 @@ For full API reference, architecture details, examples, and integration guides,
 
 In complex agentic workflows, LLMs tend to "drift" from their original instructions. CT Toolkit provides the mathematical and cryptographic guardrails to ensure your agents remain aligned with their core constitution, even across deep hierarchies.
 
+- **Passive Context Compression Detection**: Automatically detects silent provider-side history compression (e.g., OpenAI/Anthropic) via history shrinkage heuristics.
 - **Constitutional Kernels**: Axiomatic identity anchors.
 - **Standalone Auditor CLI**: Rapidly audit any LLM endpoint for identity drift without writing code.
 - **Autonomous Self-Correction**: Active L2->L1 feedback loop that retries and corrects divergent responses before they reach the user.
@@ -81,10 +84,13 @@ pip install ct-toolkit
 ```
 
 ```python
-from ct_toolkit import TheseusWrapper
+from ct_toolkit import TheseusWrapper, WrapperConfig
+
+# Protect against silent provider context compression
+config = WrapperConfig(compression_passive_detection=True)
 
 # One-line injection for any LLM provider
-client = TheseusWrapper(provider="openai")
+client = TheseusWrapper(provider="openai", config=config)
 
 # Guardrails and drift analysis applied automatically
 response = client.chat("What are your core security axioms?")
@@ -112,9 +118,9 @@ ct-toolkit list-templates
 
 | Metric           | Status                                                  |
 | :--------------- | :------------------------------------------------------ |
-| **Tests**        | ✅ 237/240 passing (90% coverage)                       |
+| **Tests**        | ✅ 281/292 passing (95% coverage)                       |
 | **Last Phase**   | ✅ Phase 6: Auditor Mode (Complete)                     |
-| **Current Goal** | 🔶 Phase 7: Multi-Agent Synchronization (Planning)      |
+| **Current Goal** | 🔶 Phase 7: Multi-Agent Synchronization (Integration)   |
 
 For a detailed breakdown of the 8-phase roadmap, see [**PROJECT_STATUS.md**](docs/PROJECT_STATUS.md).
 

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/README.md

@@ -24,6 +24,7 @@ For full API reference, architecture details, examples, and integration guides,
 
 In complex agentic workflows, LLMs tend to "drift" from their original instructions. CT Toolkit provides the mathematical and cryptographic guardrails to ensure your agents remain aligned with their core constitution, even across deep hierarchies.
 
+- **Passive Context Compression Detection**: Automatically detects silent provider-side history compression (e.g., OpenAI/Anthropic) via history shrinkage heuristics.
 - **Constitutional Kernels**: Axiomatic identity anchors.
 - **Standalone Auditor CLI**: Rapidly audit any LLM endpoint for identity drift without writing code.
 - **Autonomous Self-Correction**: Active L2->L1 feedback loop that retries and corrects divergent responses before they reach the user.
@@ -40,10 +41,13 @@ pip install ct-toolkit
 ```
 
 ```python
-from ct_toolkit import TheseusWrapper
+from ct_toolkit import TheseusWrapper, WrapperConfig
+
+# Protect against silent provider context compression
+config = WrapperConfig(compression_passive_detection=True)
 
 # One-line injection for any LLM provider
-client = TheseusWrapper(provider="openai")
+client = TheseusWrapper(provider="openai", config=config)
 
 # Guardrails and drift analysis applied automatically
 response = client.chat("What are your core security axioms?")
@@ -71,9 +75,9 @@ ct-toolkit list-templates
 
 | Metric           | Status                                                  |
 | :--------------- | :------------------------------------------------------ |
-| **Tests**        | ✅ 237/240 passing (90% coverage)                       |
+| **Tests**        | ✅ 281/292 passing (95% coverage)                       |
 | **Last Phase**   | ✅ Phase 6: Auditor Mode (Complete)                     |
-| **Current Goal** | 🔶 Phase 7: Multi-Agent Synchronization (Planning)      |
+| **Current Goal** | 🔶 Phase 7: Multi-Agent Synchronization (Integration)   |
 
 For a detailed breakdown of the 8-phase roadmap, see [**PROJECT_STATUS.md**](docs/PROJECT_STATUS.md).
 

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/__init__.py

@@ -23,7 +23,7 @@ from ct_toolkit.core.exceptions import (
     ChainIntegrityError,
 )
 
-__version__ = "0.3.5"
+__version__ = "0.3.7"
 
 __all__ = [
     "TheseusWrapper",

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/cli.py

@@ -17,6 +17,7 @@ from rich.table import Table
 from ct_toolkit import TheseusWrapper, WrapperConfig, __version__
 from ct_toolkit.divergence.l3_icm import ICMRunner
 from ct_toolkit.core.kernel import ConstitutionalKernel
+from ct_toolkit.server import start_server
 
 app = typer.Typer(
     help="Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems.",
@@ -135,6 +136,37 @@ def audit(
     if not report.is_healthy:
         raise typer.Exit(code=1)
 
+@app.command()
+def serve(
+    host: str = typer.Option("127.0.0.1", "--host", help="Host to bind the server to."),
+    port: int = typer.Option(8001, "--port", help="Port to bind the server to."),
+    kernel: str = typer.Option("general", "--kernel", help="Name of the Constitutional Kernel to use."),
+    template: str = typer.Option("general", "--template", help="Name of the Identity Template to use."),
+    vault_path: str = typer.Option("./ct_provenance.db", "--vault", help="Path to the provenance log database."),
+    judge_provider: str = typer.Option("openai", "--judge-provider", help="LLM provider for the L2 judge."),
+    judge_model: Optional[str] = typer.Option(None, "--judge-model", help="Model ID for the L2 judge."),
+):
+    """Start the CT-Toolkit Guardrail Server for LiteLLM integration."""
+    console.print(f"Starting Guardrail Server...")
+    console.print(f"  - Kernel: [bold yellow]{kernel}[/bold yellow]")
+    console.print(f"  - Template: [bold green]{template}[/bold green]")
+    console.print(f"  - Bind: [bold cyan]{host}:{port}[/bold cyan]")
+    
+    try:
+        config = WrapperConfig(
+            kernel_name=kernel,
+            template=template,
+            vault_path=vault_path,
+            project_root=Path.cwd()
+        )
+        wrapper = TheseusWrapper(provider=judge_provider, config=config)
+        
+        # Start the uvicorn server
+        start_server(wrapper=wrapper, host=host, port=port)
+    except Exception as e:
+        console.print(f"[bold red]Failed to start server:[/bold red] {e}")
+        raise typer.Exit(code=1)
+
 @app.command()
 def list_kernels():
     """List available Constitutional Kernels."""

ct_toolkit-0.3.5/ct_toolkit/middleware/deepagents.py → ct_toolkit-0.3.7/ct_toolkit/core/compression_guard.py

@@ -1,20 +1,18 @@
 """
-ct_toolkit.middleware.deepagents
+ct_toolkit.core.compression_guard
 ---------------------------------
-Specialized integration for LangChain Deep Agents (deepagents).
-
-This module provides helpers to wrap Deep Agents with CT Toolkit's
-identity-continuity guardrails, specifically ensuring that when a
-Deep Agent spawns sub-agents, they inherit the mother agent's
-Constitutional Kernel.
+Provider-agnostic compression drift detector.
+Works with OpenAI compaction, Anthropic compaction, LangChain memory,
+or any framework that silently shortens context.
 """
 from __future__ import annotations
 
-from typing import Any, Dict, List, Optional, Union, Callable
-from ct_toolkit.core.wrapper import TheseusWrapper, WrapperConfig
-from ct_toolkit.middleware.langchain import TheseusChatModel
+from typing import Any, Dict, List, TYPE_CHECKING
 from ct_toolkit.utils.logger import get_logger
 
+if TYPE_CHECKING:
+    from ct_toolkit.core.wrapper import TheseusWrapper
+
 logger = get_logger(__name__)
 
 class ContextCompressionGuard:
@@ -27,7 +25,7 @@ class ContextCompressionGuard:
 
     def analyze_summary_drift(
         self, 
-        original_messages: List[Dict[str, str]], 
+        original_messages: List[Dict[str, str]] | str, 
         summary_text: str
     ) -> Dict[str, Any]:
         """
@@ -37,9 +35,12 @@ class ContextCompressionGuard:
         Returns:
             Dict containing similarity score and drift status.
         """
-        # 1. Flatten original messages into a single identity string
-        original_text = " ".join([m.get("content", "") for m in original_messages])
-        
+        # 1. Flatten original messages into a single identity string if it's a list
+        if isinstance(original_messages, list):
+            original_text = " ".join([m.get("content", "") for m in original_messages])
+        else:
+            original_text = original_messages
+            
         # 2. Compute embeddings via identity layer
         original_emb = self.wrapper._identity_layer._compute_vector(original_text)
         summary_emb = self.wrapper._identity_layer._compute_vector(summary_text)
@@ -49,7 +50,6 @@ class ContextCompressionGuard:
         similarity = IdentityEmbeddingLayer.calculate_similarity(original_emb, summary_emb)
         
         # 4. Identity Safety Floor (Internal protection against manipulated thresholds)
-        # Even if the user sets threshold to 0.4, 0.6 is still risky for LLM identity.
         drift_detected = similarity < self.threshold
         is_critical = similarity < 0.70  # A hard floor for identity integrity
         
@@ -88,48 +88,11 @@ class ContextCompressionGuard:
 
         return result
 
-def wrap_deep_agent_factory(
-    create_deep_agent_fn: Callable,
-    wrapper: Optional[TheseusWrapper] = None,
-    wrapper_config: Optional[WrapperConfig] = None,
-    compression_threshold: float = 0.85,
-) -> Callable:
-    """
-    Wraps the LangChain `create_deep_agent` function to automatically
-    inject Theseus guardrails, enable hierarchical kernel propagation,
-    and monitor context compression drift.
-    """
-    _wrapper = wrapper or TheseusWrapper(config=wrapper_config)
-    guard = ContextCompressionGuard(_wrapper, threshold=compression_threshold)
-
-    def wrapped_create_deep_agent(*args: Any, **kwargs: Any) -> Any:
-        # 1. Inject TheseusChatModel
-        model = kwargs.get("model")
-        if isinstance(model, str) or model is None:
-            kwargs["model"] = TheseusChatModel(
-                wrapper=_wrapper,
-                model=model if isinstance(model, str) else "gpt-4o-mini"
-            )
-
-        # 2. Inject ContextCompressionGuard into the middleware stack if possible
-        # Since deepagents middleware is internal, we use the helper to signal it
-        # In a real integration, we'd wrap the SummarizationMiddleware.
-        
-        return create_deep_agent_fn(*args, **kwargs)
-
-    return wrapped_create_deep_agent
-
-class DeepAgentTheseusHelper:
-    """
-    Helper for programmatic integration with Deep Agents.
-    """
-    @staticmethod
-    def prepare_config(wrapper: TheseusWrapper) -> Dict[str, Any]:
-        """Returns configuration for Deep Agents that includes identity constraints."""
-        return {
-            "callbacks": [], # We could add TheseusLangChainCallback here
-            "metadata": {
-                "ct_kernel": wrapper.kernel.name,
-                "ct_identity_protection": True
-            }
-        }
+    def on_passive_detection(self, original: List[Dict[str, str]], compressed: List[Dict[str, str]]) -> Dict[str, Any]:
+        """
+        Triggered when TheseusWrapper detects a significant history shrinkage.
+        """
+        logger.info("CT Toolkit | Passive compression detection triggered.")
+        original_text = " ".join(m.get("content", "") for m in original)
+        compressed_text = " ".join(m.get("content", "") for m in compressed)
+        return self.analyze_summary_drift(original_text, compressed_text)

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/core/wrapper.py

@@ -25,15 +25,14 @@ import os
 from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any, Iterator, Optional, Callable, Dict
-import any_llm
-from any_llm import AnyLLM
-import glob
+import litellm
 
 from ct_toolkit.core.kernel import ConstitutionalKernel
 from ct_toolkit.core.compatibility import CompatibilityLayer, CompatibilityResult
 from ct_toolkit.core.exceptions import CTToolkitError, MissingClientError
 from ct_toolkit.core.integrity import IntegrityMonitor
 from ct_toolkit.divergence.scheduler import RiskProfile
+from ct_toolkit.core.compression_guard import ContextCompressionGuard
 from ct_toolkit.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -71,6 +70,10 @@ class WrapperConfig:
 
     strict_embedding: bool = False   # Raise error if embedding API fails
 
+    # -- Context Compression Guard --
+    compression_threshold: float = 0.85
+    compression_passive_detection: bool = True
+
 
 @dataclass
 class CTResponse:
@@ -92,7 +95,7 @@ class TheseusWrapper:
     Identity-continuity proxy wrapping the LLM API client.
 
     Supported providers: openai (default), anthropic, ollama, google, etc.
-    (Any provider supported by any-llm-sdk)
+    (Any provider supported by LiteLLM)
 
     Usage:
         from ct_toolkit import TheseusWrapper
@@ -128,7 +131,7 @@ class TheseusWrapper:
                     Optional if 'provider' is specified.
             config:  Optional WrapperConfig instance.
             provider: Provider name (e.g. "openai", "anthropic", "ollama", "google", "cohere").
-                      If provided, 'any-llm' will be used to initialize the client internally.
+                      If provided, LiteLLM will be used to initialize the client internally.
             project_root: Path to the user's project root directory. Used to find a custom 'config/' folder.
                           Defaults to the current working directory.
         """
@@ -165,6 +168,13 @@ class TheseusWrapper:
         self._divergence_engine = self._init_divergence_engine()
         self._last_model: str = "unknown"
 
+        # ── Context Compression Guard ──
+        self._compression_guard = ContextCompressionGuard(
+            self, 
+            threshold=self._config.compression_threshold
+        )
+        self._shadow_history: Optional[List[Dict[str, str]]] = None
+
         # ── Integrity Monitoring ──
         self._integrity_monitor = IntegrityMonitor()
         self._register_monitored_files()
@@ -231,7 +241,7 @@ class TheseusWrapper:
             return client.lower()
 
         try:
-            # Check for any_llm wrapper
+            # Check for LiteLLM specific attributes if any
             if hasattr(client, "provider") and isinstance(client.provider, str):
                 return client.provider
 
@@ -489,9 +499,21 @@ class TheseusWrapper:
         model: str | None,
         **kwargs: Any,
     ) -> Any:
-        """Uses any_llm for unified provider calling."""
-        # Convert messages to any_llm format if necessary
-        # any_llm.completion handles different formats internally
+        """Uses LiteLLM for unified provider calling."""
+        # --- Passive Context Compression Detection ---
+        if self._config.compression_passive_detection and self._shadow_history:
+            # Simple heuristic: message count dropped significantly
+            # We use 0.7 as a threshold (30% drop)
+            if len(messages) < len(self._shadow_history) * 0.7:
+                self._compression_guard.on_passive_detection(
+                    original=self._shadow_history,
+                    compressed=messages
+                )
+
+        # Update shadow history for next call
+        self._shadow_history = list(messages)
+        
+        # LiteLLM handles different message formats internally
         
         # Set default models per provider if not specified
         if not model:
@@ -500,32 +522,29 @@ class TheseusWrapper:
             elif self._provider == "ollama": model = "llama3"
             else: model = "gpt-4o-mini"
 
-        # any_llm expects "provider:model" format
+        # LiteLLM expects "provider/model" format for non-default providers
+        # Usually OpenAI models don't need a prefix.
         full_model = model
-        if ":" not in model:
-            full_model = f"{self._provider}:{model}"
-
-        # Prepare any_llm call
-        any_llm_kwargs = {
-            "model": full_model,
-            "messages": messages,
-            **kwargs
-        }
+        if ":" in model:
+             # If it has the legacy format "provider:model", convert it
+             full_model = model.replace(":", "/", 1)
+        elif self._provider not in ("openai", "unknown"):
+             full_model = f"{self._provider}/{model}"
 
         # Extract connection info from client if possible
         if hasattr(self._client, "base_url") and self._client.base_url:
-            any_llm_kwargs["api_base"] = str(self._client.base_url)
+            kwargs["api_base"] = str(self._client.base_url)
         if hasattr(self._client, "api_key") and self._client.api_key:
-            any_llm_kwargs["api_key"] = self._client.api_key
+            kwargs["api_key"] = self._client.api_key
 
         # Transfer common client configurations if available
-        if hasattr(self._client, "timeout") and "timeout" not in any_llm_kwargs:
-            any_llm_kwargs["timeout"] = self._client.timeout
+        if hasattr(self._client, "timeout") and "timeout" not in kwargs:
+            kwargs["timeout"] = self._client.timeout
 
         try:
-            return any_llm.completion(**any_llm_kwargs)
+            return litellm.completion(model=full_model, messages=messages, **kwargs)
         except Exception as e:
-            logger.error(f"any_llm call failed: {e}")
+            logger.error(f"litellm call failed: {e}")
             raise
 
     # ── Helper Methods ──────────────────────────────────────────────────────
@@ -579,25 +598,33 @@ class TheseusWrapper:
         return messages
 
     def _extract_content(self, raw: Any) -> str:
-        # Handle dict responses (e.g. from some mockers or raw APIs)
+        # Handle dict responses
         if isinstance(raw, dict):
             if "choices" in raw and isinstance(raw["choices"], list) and raw["choices"]:
-                # OpenAI dict format
                 return raw["choices"][0].get("message", {}).get("content", "") or ""
             if "message" in raw:
-                # Ollama dict format
+                # Ollama dictate format
                 return raw["message"].get("content", "") or ""
             return str(raw)
 
-        # OpenAI
-        if hasattr(raw, "choices"):
-            return raw.choices[0].message.content or ""
-        # Anthropic
-        if hasattr(raw, "content") and isinstance(raw.content, list):
-            return raw.content[0].text if raw.content else ""
-        # Ollama
-        if hasattr(raw, "message"):
-            return raw.message.content or ""
+        # LiteLLM ModelResponse (Standardized for all providers)
+        try:
+            if hasattr(raw, "choices") and raw.choices:
+                choice = raw.choices[0]
+                if hasattr(choice, "message") and choice.message:
+                    return choice.message.content or ""
+                # Some older/alternative formats
+                if hasattr(choice, "text"):
+                    return choice.text or ""
+        except Exception:
+            pass
+            
+        # Fallback raw extraction for edge cases
+        if hasattr(raw, "content") and isinstance(raw.content, list): # Anthropic style
+             return raw.content[0].text if raw.content else ""
+        if hasattr(raw, "message"): # Ollama generic style
+             return getattr(raw.message, "content", "") or ""
+             
         return str(raw)
 
     def _extract_model(self, raw: Any, fallback: str | None) -> str:

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/divergence/l3_icm.py

@@ -19,7 +19,7 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
-import any_llm
+import litellm
 
 from ct_toolkit.utils.logger import get_logger
 
@@ -290,11 +290,14 @@ class ICMRunner:
     def _call_model(self, prompt: str) -> str:
         system = self._kernel.get_system_prompt_injection()
 
+        # LiteLLM format
         full_model = self._model
-        if ":" not in self._model:
-            full_model = f"{self._provider}:{self._model}"
+        if ":" in self._model:
+            full_model = self._model.replace(":", "/", 1)
+        elif self._provider not in ("openai", "unknown"):
+            full_model = f"{self._provider}/{self._model}"
 
-        any_llm_kwargs = {
+        kwargs: dict[str, Any] = {
             "model": full_model,
             "messages": [
                 {"role": "system", "content": system},
@@ -306,13 +309,20 @@ class ICMRunner:
 
         # Extract connection info from client if possible
         if hasattr(self._client, "base_url") and self._client.base_url:
-            any_llm_kwargs["api_base"] = str(self._client.base_url)
+            kwargs["api_base"] = str(self._client.base_url)
         if hasattr(self._client, "api_key") and self._client.api_key:
-            any_llm_kwargs["api_key"] = self._client.api_key
+            kwargs["api_key"] = self._client.api_key
             
         try:
-            resp = any_llm.completion(**any_llm_kwargs)
-            # any_llm SDK standardizes responses but fallback handling preserves robustness
+            resp = litellm.completion(**kwargs)
+            
+            # Extract content from LiteLLM response
+            if hasattr(resp, "choices") and resp.choices:
+                choice = resp.choices[0]
+                if hasattr(choice, "message") and choice.message:
+                    return choice.message.content or ""
+            
+            # Fallback
             if isinstance(resp, dict):
                 if "choices" in resp and resp["choices"]:
                     return resp["choices"][0].get("message", {}).get("content", "")
@@ -320,16 +330,9 @@ class ICMRunner:
                     return resp["message"].get("content", "")
                 return str(resp)
 
-            if hasattr(resp, "choices"):
-                return resp.choices[0].message.content or ""
-            if hasattr(resp, "content") and isinstance(resp.content, list):
-                return resp.content[0].text if resp.content else ""
-            if hasattr(resp, "message"):
-                return resp.message.content or ""
-            
             return str(resp)
         except Exception as e:
-            logger.error(f"ICM probe any_llm call failed: {e}")
+            logger.error(f"ICM probe litellm call failed: {e}")
             raise
 
     # ── Probe Loading ──────────────────────────────────────────────────────────

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/identity/embedding.py

@@ -9,9 +9,7 @@ Step 3 MVP implementation:
   - Each response embedding is calculated
   - Cosine distance = 1 - cosine_similarity → divergence score
 """
-from __future__ import annotations
-
-import json
+import litellm
 import hashlib
 from pathlib import Path
 from typing import Any
@@ -155,17 +153,21 @@ class IdentityEmbeddingLayer:
         """
         if self._embedding_client is not None:
             try:
-                # Robust attribute check for OpenAI-compatible clients
-                embeddings_api = getattr(self._embedding_client, "embeddings", None)
-                if embeddings_api:
-                    response = embeddings_api.create(
-                        input=[text],
-                        model=self._embedding_model
-                    )
-                    embedding = response.data[0].embedding
-                    return np.array(embedding, dtype=np.float32)
-                else:
-                    logger.debug("Embedding client does not support .embeddings API. Falling back.")
+                # Prepare arguments for litellm.embedding
+                kwargs: dict[str, Any] = {
+                    "model": self._embedding_model,
+                    "input": [text]
+                }
+                
+                # Transfer client configuration if available
+                if hasattr(self._embedding_client, "base_url") and self._embedding_client.base_url:
+                    kwargs["api_base"] = str(self._embedding_client.base_url)
+                if hasattr(self._embedding_client, "api_key") and self._embedding_client.api_key:
+                    kwargs["api_key"] = self._embedding_client.api_key
+                    
+                response = litellm.embedding(**kwargs)
+                embedding = response.data[0]["embedding"]
+                return np.array(embedding, dtype=np.float32)
             except Exception as e:
                 if self._strict_embedding:
                     raise RuntimeError(f"Embedding API failed: {e}") from e

{ct_toolkit-0.3.5 → ct_toolkit-0.3.7}/ct_toolkit/middleware/crewai.py

@@ -92,6 +92,8 @@ class TheseusCrewMiddleware:
                 parent_kernel=manager_wrapper.kernel,
                 vault_path=manager_wrapper._config.vault_path,
                 template=manager_wrapper._config.template,
+                compression_threshold=manager_wrapper._config.compression_threshold,
+                compression_passive_detection=manager_wrapper._config.compression_passive_detection,
             )
             agent.llm = TheseusChatModel(
                 provider=manager_wrapper._provider,
@@ -134,6 +136,8 @@ class TheseusCrewMiddleware:
             parent_kernel=manager_wrapper.kernel,
             vault_path=manager_wrapper._config.vault_path,
             template=manager_wrapper._config.template,
+            compression_threshold=manager_wrapper._config.compression_threshold,
+            compression_passive_detection=manager_wrapper._config.compression_passive_detection,
         )
         agent.llm = TheseusChatModel(
             provider=manager_wrapper._provider,

ct_toolkit-0.3.7/ct_toolkit/middleware/deepagents.py

@@ -0,0 +1,67 @@
+"""
+ct_toolkit.middleware.deepagents
+---------------------------------
+Specialized integration for LangChain Deep Agents (deepagents).
+
+This module provides helpers to wrap Deep Agents with CT Toolkit's
+identity-continuity guardrails, specifically ensuring that when a
+Deep Agent spawns sub-agents, they inherit the mother agent's
+Constitutional Kernel.
+"""
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional, Union, Callable
+from ct_toolkit.core.wrapper import TheseusWrapper, WrapperConfig
+from ct_toolkit.core.compression_guard import ContextCompressionGuard
+from ct_toolkit.middleware.langchain import TheseusChatModel
+from ct_toolkit.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
+
+
+def wrap_deep_agent_factory(
+    create_deep_agent_fn: Callable,
+    wrapper: Optional[TheseusWrapper] = None,
+    wrapper_config: Optional[WrapperConfig] = None,
+    compression_threshold: float = 0.85,
+) -> Callable:
+    """
+    Wraps the LangChain `create_deep_agent` function to automatically
+    inject Theseus guardrails, enable hierarchical kernel propagation,
+    and monitor context compression drift.
+    """
+    _wrapper = wrapper or TheseusWrapper(config=wrapper_config)
+    guard = ContextCompressionGuard(_wrapper, threshold=compression_threshold)
+
+    def wrapped_create_deep_agent(*args: Any, **kwargs: Any) -> Any:
+        # 1. Inject TheseusChatModel
+        model = kwargs.get("model")
+        if isinstance(model, str) or model is None:
+            kwargs["model"] = TheseusChatModel(
+                wrapper=_wrapper,
+                model=model if isinstance(model, str) else "gpt-4o-mini"
+            )
+
+        # 2. Inject ContextCompressionGuard into the middleware stack if possible
+        # Since deepagents middleware is internal, we use the helper to signal it
+        # In a real integration, we'd wrap the SummarizationMiddleware.
+        
+        return create_deep_agent_fn(*args, **kwargs)
+
+    return wrapped_create_deep_agent
+
+class DeepAgentTheseusHelper:
+    """
+    Helper for programmatic integration with Deep Agents.
+    """
+    @staticmethod
+    def prepare_config(wrapper: TheseusWrapper) -> Dict[str, Any]:
+        """Returns configuration for Deep Agents that includes identity constraints."""
+        return {
+            "callbacks": [], # We could add TheseusLangChainCallback here
+            "metadata": {
+                "ct_kernel": wrapper.kernel.name,
+                "ct_identity_protection": True
+            }
+        }