ct-toolkit 0.2.8__tar.gz → 0.3.0__tar.gz

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ct-toolkit
-Version: 0.2.8
+Version: 0.3.0
 Summary: Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems
 Author: Hakan Damar
 License: Apache-2.0

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/core/kernel.py

@@ -73,12 +73,15 @@ class ConstitutionalKernel:
         else:
             with open(path, "r", encoding="utf-8") as f:
                 data = yaml.safe_load(f)
+        
+        if not isinstance(data, dict):
+            data = {}
 
         anchors = [AxiomaticAnchor(**a) for a in data.get("axiomatic_anchors", [])]
         commitments = [PlasticCommitment(**c) for c in data.get("plastic_commitments", [])]
 
         profile = KernelProfile(
-            name=data["name"],
+            name=data.get("name", "custom_kernel"),
             version=data.get("version", "1.0.0"),
             description=data.get("description", ""),
             axiomatic_anchors=anchors,

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/core/wrapper.py

@@ -304,6 +304,7 @@ class TheseusWrapper:
             template=self._config.template,
             embedding_client=emb_client,
             embedding_model=self._config.embedding_model,
+            project_root=self._project_root,
         )
 
     def _init_divergence_engine(self) -> Any:
@@ -335,6 +336,7 @@ class TheseusWrapper:
             l3_threshold=self._config.divergence_l3_threshold,
             enterprise_mode=self._config.enterprise_mode,
             scheduler=scheduler,
+            project_root=self._project_root,
             provenance_log=self._provenance_log,
         )
 

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/divergence/engine.py

@@ -17,6 +17,7 @@ from __future__ import annotations
 import time
 from dataclasses import dataclass
 from enum import Enum
+from pathlib import Path
 from typing import Any
 
 from ct_toolkit.identity.embedding import IdentityEmbeddingLayer
@@ -116,6 +117,7 @@ class DivergenceEngine:
         enterprise_mode: bool = False,   # Run all tiers all the time
         scheduler: Any | None = None,    # ElasticityScheduler instance
         provenance_log: Any | None = None, 
+        project_root: Path | None = None,
     ) -> None:
         self._identity = identity_layer
         self._kernel = kernel
@@ -123,6 +125,7 @@ class DivergenceEngine:
         self._provider = provider
         self._judge_client = judge_client
         self._log = provenance_log
+        self._project_root = project_root
         
         # Base thresholds
         self._base_l1_threshold = l1_threshold
@@ -331,5 +334,6 @@ class DivergenceEngine:
             kernel=self._kernel,
             template=self._template,
             max_probes=max_probes,
+            project_root=self._project_root,
         )
         return runner.run()

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/divergence/l2_judge.py

@@ -139,15 +139,26 @@ class LLMJudge:
 
         try:
             # Call using instructor for structured data
-            data: JudgeResponse = self._instructor_client.chat.completions.create(
-                model=self._model,
-                response_model=JudgeResponse,
-                messages=[
-                    {"role": "system", "content": system_prompt},
-                    {"role": "user", "content": user_prompt},
-                ],
-                max_retries=2
-            )
+            if self._provider == "anthropic":
+                data: JudgeResponse = self._instructor_client.messages.create(
+                    model=self._model,
+                    response_model=JudgeResponse,
+                    system=system_prompt,
+                    messages=[
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    max_retries=2
+                )
+            else:
+                data: JudgeResponse = self._instructor_client.chat.completions.create(
+                    model=self._model,
+                    response_model=JudgeResponse,
+                    messages=[
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    max_retries=2
+                )
             
             result = JudgeResult(
                 verdict=data.verdict,

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/divergence/l3_icm.py

@@ -209,6 +209,7 @@ class ICMRunner:
         model: str | None = None,
         include_domain_probes: bool = True,
         max_probes: int | None = None,
+        project_root: Path | None = None,
     ) -> None:
         self._client = client
         self._provider = provider
@@ -216,6 +217,7 @@ class ICMRunner:
         self._template = template
         self._model = model or self._default_model(provider)
         self._include_domain = include_domain_probes
+        self._project_root = project_root
         self._max_probes = max_probes
 
     @staticmethod
@@ -332,13 +334,22 @@ class ICMRunner:
 
         # Domain probes — based on template
         if self._include_domain:
-            domain_path = (
-                self.PROBES_DIR / "domain_probes" / f"{self._template}_probes.json"
-            )
-            if domain_path.exists():
-                with open(domain_path, encoding="utf-8") as f:
-                    probes.extend(json.load(f))
-                logger.info(f"Domain probes loaded: {self._template}")
+            # Check user config first
+            domain_loaded = False
+            if self._project_root:
+                user_probe_path = self._project_root / "config" / f"{self._template}_probes.json"
+                if user_probe_path.exists():
+                    with open(user_probe_path, encoding="utf-8") as f:
+                        probes.extend(json.load(f))
+                    logger.info(f"Custom domain probes loaded: {user_probe_path}")
+                    domain_loaded = True
+
+            if not domain_loaded:
+                domain_path = self.PROBES_DIR / "domain_probes" / f"{self._template}_probes.json"
+                if domain_path.exists():
+                    with open(domain_path, encoding="utf-8") as f:
+                        probes.extend(json.load(f))
+                    logger.info(f"Domain probes loaded: {self._template}")
 
         if not probes:
             logger.warning("Probe file not found. Empty battery.")

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit/identity/embedding.py

@@ -43,6 +43,7 @@ class IdentityEmbeddingLayer:
         template: str = "general",
         embedding_client: Any = None,  # Provider client for real embeddings
         embedding_model: str = "text-embedding-3-small",
+        project_root: Path | None = None,
     ) -> None:
         self._template = template
         self._embedding_client = embedding_client
@@ -50,6 +51,7 @@ class IdentityEmbeddingLayer:
         self._reference_vector: np.ndarray | None = None
         self._template_keywords: list[str] = []
         self._reference_text: str = ""          # stored for lazy computation
+        self._project_root = project_root
         self._embedding_method: str = "uninitialized"
         self._load_template()
 
@@ -58,34 +60,48 @@ class IdentityEmbeddingLayer:
     def _load_template(self) -> None:
         import os
         import yaml
-        from importlib.resources import files
+        
+        data = None
         
         # Sanitize template name to prevent path traversal
         safe_template = os.path.basename(self._template)
         
+        # 1. Check user config first if project_root is provided
+        if self._project_root:
+            # Check for both "name.yaml" and "name_identity.yaml"
+            for fname in [f"{safe_template}.yaml", f"{safe_template}_identity.yaml"]:
+                user_path = self._project_root / "config" / fname
+                if user_path.exists():
+                    logger.debug(f"Loading identity template from user config: {user_path}")
+                    with open(user_path, "r", encoding="utf-8") as f:
+                        data = yaml.safe_load(f)
+                    break
+        
         # Load built-in template using importlib.resources
-        try:
-            template_resource = files("ct_toolkit.identity.templates").joinpath(f"{safe_template}.yaml")
-            if template_resource.is_file():
-                with template_resource.open("r", encoding="utf-8") as f:
-                    data = yaml.safe_load(f)
-            else:
-                raise FileNotFoundError(f"Template resource not found: {template_resource}")
-        except (ImportError, FileNotFoundError):
-            # Fallback for development or older environments
-            template_path = (
-                Path(__file__).parent
-                / "templates"
-                / f"{safe_template}.yaml"
-            )
-            if not template_path.exists():
-                logger.warning(
-                    f"Template '{self._template}' not found, using 'general'."
+        if data is None:
+            try:
+                from importlib.resources import files
+                template_resource = files("ct_toolkit.identity.templates").joinpath(f"{safe_template}.yaml")
+                if template_resource.is_file():
+                    with template_resource.open("r", encoding="utf-8") as f:
+                        data = yaml.safe_load(f)
+                else:
+                    raise FileNotFoundError(f"Template resource not found: {template_resource}")
+            except (ImportError, FileNotFoundError):
+                # Fallback for development or older environments
+                template_path = (
+                    Path(__file__).parent
+                    / "templates"
+                    / f"{safe_template}.yaml"
                 )
-                template_path = Path(__file__).parent / "templates" / "general.yaml"
-            
-            with open(template_path, "r", encoding="utf-8") as f:
-                data = yaml.safe_load(f)
+                if not template_path.exists():
+                    logger.warning(
+                        f"Template '{self._template}' not found, using 'general'."
+                    )
+                    template_path = Path(__file__).parent / "templates" / "general.yaml"
+                
+                with open(template_path, "r", encoding="utf-8") as f:
+                    data = yaml.safe_load(f)
 
         self._template_keywords = data.get("identity_keywords", [])
         self._reference_text = data.get("reference_text", " ".join(self._template_keywords))

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/ct_toolkit.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ct-toolkit
-Version: 0.2.8
+Version: 0.3.0
 Summary: Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems
 Author: Hakan Damar
 License: Apache-2.0

{ct_toolkit-0.2.8 → ct_toolkit-0.3.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ct-toolkit"
-version = "0.2.8"
+version = "0.3.0"
 description = "Computational Theseus Toolkit — Identity Continuity Guardrails for Agentic Systems"
 readme = "README.md"
 requires-python = ">=3.11"