ct-toolkit 0.3.2__tar.gz → 0.3.4__tar.gz

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/PKG-INFO

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

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/__init__.py

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

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/core/wrapper.py

@@ -24,7 +24,7 @@ import hashlib
 import os
 from dataclasses import dataclass, field
 from pathlib import Path
-from typing import Any, Iterator
+from typing import Any, Iterator, Optional, Callable, Dict
 import any_llm
 from any_llm import AnyLLM
 import glob
@@ -69,6 +69,8 @@ class WrapperConfig:
     elasticity_growth_rate: float | None = None
     risk_profile: RiskProfile | None = None
 
+    strict_embedding: bool = False   # Raise error if embedding API fails
+
 
 @dataclass
 class CTResponse:
@@ -192,7 +194,7 @@ class TheseusWrapper:
                     if file_path.is_file():
                         self._integrity_monitor.register_file(file_path)
 
-        except (ImportError, ModuleNotFoundError):
+        except Exception:
             # Fallback for older Python or different environments
             package_root = Path(__file__).parent.parent
             # This is less ideal as it might find non-package files, but it's a
@@ -309,6 +311,7 @@ class TheseusWrapper:
             embedding_client=emb_client,
             embedding_model=self._config.embedding_model,
             project_root=self._project_root,
+            strict_embedding=self._config.strict_embedding,
         )
 
     def _init_divergence_engine(self) -> Any:

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/divergence/l3_icm.py

@@ -19,6 +19,8 @@ from dataclasses import dataclass, field
 from pathlib import Path
 from typing import Any
 
+import any_llm
+
 from ct_toolkit.utils.logger import get_logger
 
 logger = get_logger(__name__)
@@ -117,7 +119,7 @@ class BehaviorClassifier:
     ]
 
     COMPLY_SIGNALS = [
-        "sure", "of course", "here's",
+        "sure", "of course",
         "certainly", "happy to",
     ]
 
@@ -288,38 +290,47 @@ class ICMRunner:
     def _call_model(self, prompt: str) -> str:
         system = self._kernel.get_system_prompt_injection()
 
-        if self._provider == "openai":
-            resp = self._client.chat.completions.create(
-                model=self._model,
-                messages=[
-                    {"role": "system", "content": system},
-                    {"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."},
-                ],
-                max_tokens=512,
-                temperature=0.0,
-            )
-            return resp.choices[0].message.content or ""
-
-        elif self._provider == "anthropic":
-            resp = self._client.messages.create(
-                model=self._model,
-                max_tokens=512,
-                system=system,
-                messages=[{"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."}],
-            )
-            return resp.content[0].text if resp.content else ""
-
-        elif self._provider == "ollama":
-            resp = self._client.chat(
-                model=self._model,
-                messages=[
-                    {"role": "system", "content": system},
-                    {"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."},
-                ],
-            )
-            return resp.message.content or ""
-
-        raise ValueError(f"Unsupported provider: {self._provider}")
+        full_model = self._model
+        if ":" not in self._model:
+            full_model = f"{self._provider}:{self._model}"
+
+        any_llm_kwargs = {
+            "model": full_model,
+            "messages": [
+                {"role": "system", "content": system},
+                {"role": "user", "content": f"{prompt}\n\nPlease provide your reasoning step-by-step wrapped in <think></think> tags before your final response."},
+            ],
+            "max_tokens": 512,
+            "temperature": 0.0,
+        }
+
+        # 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)
+        if hasattr(self._client, "api_key") and self._client.api_key:
+            any_llm_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
+            if isinstance(resp, dict):
+                if "choices" in resp and resp["choices"]:
+                    return resp["choices"][0].get("message", {}).get("content", "")
+                if "message" in resp:
+                    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}")
+            raise
 
     # ── Probe Loading ──────────────────────────────────────────────────────────
 

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/endorsement/reflective.py

@@ -36,6 +36,7 @@ class EndorsementDecision(str, Enum):
     APPROVED = "approved"
     REJECTED = "rejected"
     PENDING  = "pending"
+    FAILED   = "failed"
 
 
 @dataclass
@@ -273,20 +274,7 @@ class ReflectiveEndorsement:
         # Stage 2: Send to approval channel
         decision, actual_operator_id, rationale = self._approval_channel(conflict)
 
-        # Stage 3: Sign EndorsementRecord
-        record = EndorsementRecord(
-            id=str(uuid.uuid4()),
-            timestamp=time.time(),
-            conflict_id=conflict.id,
-            rule_text=rule_text,
-            commitment_id=conflict.conflicting_commitment_id,
-            decision=decision,
-            operator_id=actual_operator_id or operator_id,
-            rationale=rationale,
-            kernel_name=self._kernel.name,
-        )
-
-        # Stage 4: Apply decision
+        # Stage 3: Apply decision
         if decision == EndorsementDecision.APPROVED:
             applied = self._apply_override(
                 commitment_id=conflict.conflicting_commitment_id,
@@ -296,22 +284,37 @@ class ReflectiveEndorsement:
                 logger.info(
                     f"Override approved and applied | "
                     f"commitment={conflict.conflicting_commitment_id} | "
-                    f"operator={record.operator_id}"
+                    f"operator={actual_operator_id or operator_id}"
                 )
             else:
+                decision = EndorsementDecision.FAILED
+                rationale = "System failed to apply approved rule to kernel (commitment not found)"
                 logger.warning(
-                    f"Override APPROVED in log but NOT applied to kernel "
+                    f"Override APPROVED by operator but failed to apply to kernel "
                     f"(commitment not found) | "
                     f"commitment={conflict.conflicting_commitment_id} | "
-                    f"operator={record.operator_id}"
+                    f"operator={actual_operator_id or operator_id}"
                 )
         else:
             logger.info(
                 f"Override rejected | "
                 f"commitment={conflict.conflicting_commitment_id} | "
-                f"operator={record.operator_id}"
+                f"operator={actual_operator_id or operator_id}"
             )
 
+        # Stage 4: Sign EndorsementRecord
+        record = EndorsementRecord(
+            id=str(uuid.uuid4()),
+            timestamp=time.time(),
+            conflict_id=conflict.id,
+            rule_text=rule_text,
+            commitment_id=conflict.conflicting_commitment_id,
+            decision=decision,
+            operator_id=actual_operator_id or operator_id,
+            rationale=rationale,
+            kernel_name=self._kernel.name,
+        )
+
         # Write to log in either case
         self._write_to_log(record)
         self._pending_records.append(record)

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/identity/embedding.py

@@ -44,6 +44,7 @@ class IdentityEmbeddingLayer:
         embedding_client: Any = None,  # Provider client for real embeddings
         embedding_model: str = "text-embedding-3-small",
         project_root: Path | None = None,
+        strict_embedding: bool = False,
     ) -> None:
         self._template = template
         self._embedding_client = embedding_client
@@ -52,6 +53,7 @@ class IdentityEmbeddingLayer:
         self._template_keywords: list[str] = []
         self._reference_text: str = ""          # stored for lazy computation
         self._project_root = project_root
+        self._strict_embedding = strict_embedding
         self._embedding_method: str = "uninitialized"
         self._load_template()
 
@@ -165,6 +167,8 @@ class IdentityEmbeddingLayer:
                 else:
                     logger.debug("Embedding client does not support .embeddings API. Falling back.")
             except Exception as e:
+                if self._strict_embedding:
+                    raise RuntimeError(f"Embedding API failed: {e}") from e
                 logger.error(f"Embedding API failed: {e}. Falling back to local method.")
         if not self._template_keywords:
             # Fallback: character n-gram hash vector

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit/provenance/log.py

@@ -85,7 +85,7 @@ class ProvenanceLog:
         self._vault_type = vault_type
         self._vault_path = Path(vault_path)
         self._hmac_key = hmac_key or self._load_or_generate_key()
-        self._lock = threading.Lock()
+        self._lock = threading.RLock()
         self._conn = self._init_db()
         logger.info(f"ProvenanceLog initialized | vault={vault_path}")
 
@@ -134,7 +134,8 @@ class ProvenanceLog:
 
         Returns: True (valid) | raises ChainIntegrityError
         """
-        entries = self._load_all_entries(include_rolled_back=False)
+        with self._lock:
+            entries = self._load_all_entries(include_rolled_back=False)
         if not entries:
             return True
 
@@ -157,14 +158,16 @@ class ProvenanceLog:
 
     def get_entries(self, limit: int = 100, include_rolled_back: bool = False) -> list[ProvenanceEntry]:
         """Returns the last N entries."""
-        return self._load_all_entries(limit=limit, include_rolled_back=include_rolled_back)
+        with self._lock:
+            return self._load_all_entries(limit=limit, include_rolled_back=include_rolled_back)
 
     def get_entry(self, entry_id: str) -> ProvenanceEntry | None:
-        cursor = self._conn.execute(
-            "SELECT * FROM provenance WHERE id = ?", (entry_id,)
-        )
-        row = cursor.fetchone()
-        return self._row_to_entry(row) if row else None
+        with self._lock:
+            cursor = self._conn.execute(
+                "SELECT * FROM provenance WHERE id = ?", (entry_id,)
+            )
+            row = cursor.fetchone()
+            return self._row_to_entry(row) if row else None
 
     def get_interaction_count(
         self, template: str, kernel_name: str, model: str

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/ct_toolkit.egg-info/PKG-INFO

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

{ct_toolkit-0.3.2 → ct_toolkit-0.3.4}/pyproject.toml

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