hb-eval-sdk 2.0.0__tar.gz

hb_eval_sdk-2.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Abuelgasim Mohamed Ibrahim Adam
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

hb_eval_sdk-2.0.0/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: hb-eval-sdk
+Version: 2.0.0
+Summary: HB-Eval SDK for reliable agent evaluation, semantic memory, and LangChain/LangGraph integration
+Author-email: Abuelgasim Mohamed Ibrahim Adam <abuelgasim.hbeval@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hb-evalSystem/HB-System
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: langgraph>=0.0.10
+Dynamic: license-file
+
+# HB-Eval SDK
+
+Secure Python SDK for **HB-Eval Reliability OS** — the first cognitive runtime for evaluating and ensuring AI agent reliability.
+
+## Features
+
+- AES-256-GCM encrypted payloads for all API communication
+- HMAC-SHA256 request signing with replay-attack protection
+- Safe Halt protocol — automatic failure handling on connection loss
+- Semantic memory retrieval for agent context
+- Native LangChain / LangGraph callback integration
+
+## Installation
+
+```bash
+pip install hb-eval-sdk
+```
+
+## Quick Start
+
+```python
+from hb_eval_sdk import HBEvalClient
+
+client = HBEvalClient(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+result = client.evaluate({
+    "trajectory": [{"step": 1, "action": "query_memory", "input": "..."}],
+    "sub_tasks": 1,
+    "constraint_violations": 0,
+    "recovery_attempts": 1,
+    "context": "my agent task",
+    "agent_id": "my-agent",
+})
+
+print(result.verdict)      # Verdict.SAFE or Verdict.UNSAFE
+print(result.metrics.pei)  # float
+print(result.metrics.irs)  # float
+```
+
+## Memory Retrieval
+
+```python
+matches = client.retrieve_memory(context="my task context")
+for match in matches:
+    print(match.trajectory_summary, match.similarity)
+```
+
+## LangChain Integration
+
+```python
+from hb_eval_sdk import HBEvalCallback
+
+callback = HBEvalCallback(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+# Pass the callback to your LangChain agent
+agent.invoke({"input": "..."}, config={"callbacks": [callback]})
+```
+
+## Exception Handling
+
+```python
+from hb_eval_sdk import (
+    HBEvalError,
+    AuthenticationError,
+    EncryptionError,
+    SafeHaltError,
+    ConnectionError,
+)
+
+try:
+    result = client.evaluate({...})
+except SafeHaltError as e:
+    print(f"Safe halt triggered: {e.reason}")
+except AuthenticationError as e:
+    print(f"Auth failed: {e}")
+except ConnectionError as e:
+    print(f"Connection error: {e}")
+```
+
+## Requirements
+
+- Python >= 3.8
+- requests >= 2.28.0
+- cryptography >= 41.0.0
+- pydantic >= 2.0.0
+- langchain-core >= 0.1.0
+- langgraph >= 0.0.10
+
+## Documentation
+
+Full documentation: https://hb-eval.readthedocs.io
+
+## License
+
+MIT License — Copyright (c) 2026 Abuelgasim Mohamed Ibrahim Adam

hb_eval_sdk-2.0.0/README.md

@@ -0,0 +1,101 @@
+# HB-Eval SDK
+
+Secure Python SDK for **HB-Eval Reliability OS** — the first cognitive runtime for evaluating and ensuring AI agent reliability.
+
+## Features
+
+- AES-256-GCM encrypted payloads for all API communication
+- HMAC-SHA256 request signing with replay-attack protection
+- Safe Halt protocol — automatic failure handling on connection loss
+- Semantic memory retrieval for agent context
+- Native LangChain / LangGraph callback integration
+
+## Installation
+
+```bash
+pip install hb-eval-sdk
+```
+
+## Quick Start
+
+```python
+from hb_eval_sdk import HBEvalClient
+
+client = HBEvalClient(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+result = client.evaluate({
+    "trajectory": [{"step": 1, "action": "query_memory", "input": "..."}],
+    "sub_tasks": 1,
+    "constraint_violations": 0,
+    "recovery_attempts": 1,
+    "context": "my agent task",
+    "agent_id": "my-agent",
+})
+
+print(result.verdict)      # Verdict.SAFE or Verdict.UNSAFE
+print(result.metrics.pei)  # float
+print(result.metrics.irs)  # float
+```
+
+## Memory Retrieval
+
+```python
+matches = client.retrieve_memory(context="my task context")
+for match in matches:
+    print(match.trajectory_summary, match.similarity)
+```
+
+## LangChain Integration
+
+```python
+from hb_eval_sdk import HBEvalCallback
+
+callback = HBEvalCallback(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+# Pass the callback to your LangChain agent
+agent.invoke({"input": "..."}, config={"callbacks": [callback]})
+```
+
+## Exception Handling
+
+```python
+from hb_eval_sdk import (
+    HBEvalError,
+    AuthenticationError,
+    EncryptionError,
+    SafeHaltError,
+    ConnectionError,
+)
+
+try:
+    result = client.evaluate({...})
+except SafeHaltError as e:
+    print(f"Safe halt triggered: {e.reason}")
+except AuthenticationError as e:
+    print(f"Auth failed: {e}")
+except ConnectionError as e:
+    print(f"Connection error: {e}")
+```
+
+## Requirements
+
+- Python >= 3.8
+- requests >= 2.28.0
+- cryptography >= 41.0.0
+- pydantic >= 2.0.0
+- langchain-core >= 0.1.0
+- langgraph >= 0.0.10
+
+## Documentation
+
+Full documentation: https://hb-eval.readthedocs.io
+
+## License
+
+MIT License — Copyright (c) 2026 Abuelgasim Mohamed Ibrahim Adam

hb_eval_sdk-2.0.0/hb_eval_sdk/__init__.py

@@ -0,0 +1,24 @@
+from .client import HBEvalClient
+from .langchain_integration import HBEvalCallback
+from .models import EvaluationResult, MemoryMatch
+from .exceptions import (
+    HBEvalError,
+    ConnectionError,
+    AuthenticationError,
+    EncryptionError,
+    SafeHaltError,
+)
+
+__version__ = "2.0.0"
+
+__all__ = [
+    "HBEvalClient",
+    "HBEvalCallback",
+    "EvaluationResult",
+    "MemoryMatch",
+    "HBEvalError",
+    "ConnectionError",
+    "AuthenticationError",
+    "EncryptionError",
+    "SafeHaltError",
+]

hb_eval_sdk-2.0.0/hb_eval_sdk/client.py

@@ -0,0 +1,112 @@
+import json
+import time
+import hashlib
+import base64
+import requests
+from cryptography.hazmat.primitives.ciphers.aead import AESGCM
+from .exceptions import ConnectionError, AuthenticationError, EncryptionError, SafeHaltError
+from .models import EvaluationResult, MemoryMatch, Metrics, Verdict
+from .utils import generate_nonce, generate_timestamp, compute_hmac
+from . import config
+
+
+class HBEvalClient:
+    def __init__(
+        self,
+        api_key: str,
+        aes_key: str,
+        gateway_url: str = None,
+        timeout: int = None,
+        max_retries: int = None,
+    ):
+        self.api_key = api_key
+        self.timeout = timeout or config.DEFAULT_TIMEOUT
+        self.max_retries = max_retries or config.DEFAULT_MAX_RETRIES
+        self.gateway_url = (gateway_url or config.DEFAULT_GATEWAY_URL).rstrip("/")
+        try:
+            self.aes_key = base64.b64decode(aes_key)
+            if len(self.aes_key) != 32:
+                raise ValueError("AES key must be 32 bytes after base64 decoding.")
+        except Exception as e:
+            raise EncryptionError(f"Invalid AES key: {e}")
+        self.hmac_secret = hashlib.sha256(self.api_key.encode()).digest()
+
+    def _encrypt(self, payload: dict):
+        nonce_hex = generate_nonce(12)
+        nonce_bytes = nonce_hex.encode("utf-8")
+        aesgcm = AESGCM(self.aes_key)
+        plaintext = json.dumps(payload).encode("utf-8")
+        ciphertext = aesgcm.encrypt(nonce_bytes, plaintext, None)
+        return nonce_hex, ciphertext.hex()
+
+    def _build_headers(self, nonce: str, timestamp: str) -> dict:
+        signature = compute_hmac(self.hmac_secret, f"{timestamp}.{nonce}")
+        return {
+            "Authorization": f"Bearer {self.api_key}",
+            "X-HBEval-Nonce": nonce,
+            "X-HBEval-Timestamp": timestamp,
+            "X-HBEval-Signature": signature,
+            "Content-Type": "application/json",
+        }
+
+    def evaluate(self, payload: dict, max_retries: int = None) -> EvaluationResult:
+        retries = max_retries if max_retries is not None else self.max_retries
+        for attempt in range(retries + 1):
+            try:
+                nonce, ciphertext = self._encrypt(payload)
+                timestamp = generate_timestamp()
+                headers = self._build_headers(nonce, timestamp)
+                response = requests.post(
+                    f"{self.gateway_url}/evaluate",
+                    json={"ciphertext": ciphertext},
+                    headers=headers,
+                    timeout=self.timeout,
+                )
+                if response.status_code == 401:
+                    raise AuthenticationError("Invalid API key or signature.")
+                if response.status_code == 403:
+                    raise AuthenticationError("Replay attack detected or request expired.")
+                if response.status_code != 200:
+                    raise ConnectionError(
+                        f"Gateway error {response.status_code}: {response.text}"
+                    )
+                data = response.json()
+                metrics_data = data.get("metrics", {"pei": 0.0, "irs": 0.0})
+                return EvaluationResult(
+                    verdict=Verdict(data.get("verdict", "UNSAFE")),
+                    metrics=Metrics(**metrics_data),
+                    safe_halt=data.get("safe_halt", False),
+                    reason=data.get("reason", None),
+                )
+            except (requests.exceptions.Timeout, requests.exceptions.ConnectionError) as e:
+                if attempt < retries:
+                    time.sleep(1 * (attempt + 1))
+                    continue
+                raise SafeHaltError(
+                    f"Connection lost after {retries + 1} attempt(s): {e}"
+                )
+            except (AuthenticationError, EncryptionError):
+                raise
+            except Exception as e:
+                raise ConnectionError(f"Unexpected error during evaluation: {e}")
+
+    def retrieve_memory(self, context: str, project_id: str = None) -> list:
+        if project_id is None:
+            project_id = config.DEFAULT_PROJECT_ID
+        nonce, ciphertext = self._encrypt(
+            {"context": context, "project_id": project_id}
+        )
+        timestamp = generate_timestamp()
+        headers = self._build_headers(nonce, timestamp)
+        response = requests.post(
+            f"{self.gateway_url}/api/v1/memory/retrieve",
+            json={"ciphertext": ciphertext},
+            headers=headers,
+            timeout=self.timeout,
+        )
+        if response.status_code != 200:
+            raise ConnectionError(
+                f"Memory retrieval failed with status {response.status_code}: {response.text}"
+            )
+        data = response.json()
+        return [MemoryMatch(**m) for m in data.get("matches", [])]

hb_eval_sdk-2.0.0/hb_eval_sdk/config.py

@@ -0,0 +1,4 @@
+DEFAULT_GATEWAY_URL = "https://hbeval-reliability-os-production.up.railway.app"
+DEFAULT_TIMEOUT = 10
+DEFAULT_MAX_RETRIES = 2
+DEFAULT_PROJECT_ID = "00000000-0000-0000-0000-000000000001"

hb_eval_sdk-2.0.0/hb_eval_sdk/exceptions.py

@@ -0,0 +1,26 @@
+class HBEvalError(Exception):
+    """Base exception for HB-Eval SDK."""
+    pass
+
+
+class ConnectionError(HBEvalError):
+    """Raised when connection to Gateway fails."""
+    pass
+
+
+class AuthenticationError(HBEvalError):
+    """Raised when API key or signature is invalid."""
+    pass
+
+
+class EncryptionError(HBEvalError):
+    """Raised when encryption/decryption fails."""
+    pass
+
+
+class SafeHaltError(HBEvalError):
+    """Raised when Safe Halt protocol is activated."""
+
+    def __init__(self, message: str, reason: str = "CONNECTION_LOST_MANDATORY_HALT"):
+        super().__init__(message)
+        self.reason = reason

hb_eval_sdk-2.0.0/hb_eval_sdk/langchain_integration.py

@@ -0,0 +1,76 @@
+import time
+from typing import Dict, Any, List, Optional
+
+from langchain_core.callbacks.base import BaseCallbackHandler
+
+from .client import HBEvalClient
+
+
+class HBEvalCallback(BaseCallbackHandler):
+    """LangChain callback handler that evaluates agent trajectories via HB-Eval."""
+
+    def __init__(
+        self,
+        api_key: str,
+        aes_key: str,
+        gateway_url: Optional[str] = None,
+    ):
+        super().__init__()
+        self.client = HBEvalClient(api_key, aes_key, gateway_url)
+        self.trajectory: List[Dict[str, Any]] = []
+        self.start_time: float = 0.0
+
+    def on_chain_start(
+        self,
+        serialized: Dict[str, Any],
+        inputs: Dict[str, Any],
+        **kwargs: Any,
+    ) -> None:
+        self.trajectory = []
+        self.start_time = time.time()
+        self.trajectory.append(
+            {
+                "step": 1,
+                "action": "chain_start",
+                "input": str(inputs)[:500],
+            }
+        )
+
+    def on_tool_start(
+        self,
+        serialized: Dict[str, Any],
+        input_str: str,
+        **kwargs: Any,
+    ) -> None:
+        self.trajectory.append(
+            {
+                "step": len(self.trajectory) + 1,
+                "action": "tool_call",
+                "tool": serialized.get("name", "unknown"),
+                "input": input_str[:500],
+            }
+        )
+
+    def on_tool_end(self, output: str, **kwargs: Any) -> None:
+        if self.trajectory and self.trajectory[-1].get("action") == "tool_call":
+            self.trajectory[-1]["output"] = output[:500]
+            self.trajectory[-1]["status"] = "success"
+
+    def on_chain_end(self, outputs: Dict[str, Any], **kwargs: Any) -> None:
+        self.trajectory.append(
+            {
+                "step": len(self.trajectory) + 1,
+                "action": "chain_end",
+                "output": str(outputs)[:500],
+            }
+        )
+        self.client.evaluate(
+            {
+                "trajectory": self.trajectory,
+                "sub_tasks": len(self.trajectory),
+                "constraint_violations": 0,
+                "recovery_attempts": 1,
+                "context": "LangChain agent execution",
+                "agent_id": "langchain-agent",
+            }
+        )

hb_eval_sdk-2.0.0/hb_eval_sdk/models.py

@@ -0,0 +1,28 @@
+from pydantic import BaseModel
+from typing import Optional
+from enum import Enum
+
+
+class Verdict(str, Enum):
+    SAFE = "SAFE"
+    UNSAFE = "UNSAFE"
+
+
+class Metrics(BaseModel):
+    pei: float
+    irs: float
+
+
+class EvaluationResult(BaseModel):
+    verdict: Verdict
+    metrics: Metrics
+    safe_halt: Optional[bool] = False
+    reason: Optional[str] = None
+
+
+class MemoryMatch(BaseModel):
+    id: str
+    trajectory_summary: str
+    pei_score: float
+    irs_score: float
+    similarity: float

hb_eval_sdk-2.0.0/hb_eval_sdk/utils.py

@@ -0,0 +1,19 @@
+import secrets
+import time
+import hmac
+import hashlib
+
+
+def generate_nonce(length: int = 12) -> str:
+    """Generate cryptographically secure nonce as hex string."""
+    return secrets.token_hex(length)
+
+
+def generate_timestamp() -> str:
+    """Return current UTC timestamp as string."""
+    return str(int(time.time()))
+
+
+def compute_hmac(secret_key: bytes, message: str) -> str:
+    """Compute HMAC-SHA256 signature."""
+    return hmac.new(secret_key, message.encode(), hashlib.sha256).hexdigest()

hb_eval_sdk-2.0.0/hb_eval_sdk.egg-info/PKG-INFO

@@ -0,0 +1,123 @@
+Metadata-Version: 2.4
+Name: hb-eval-sdk
+Version: 2.0.0
+Summary: HB-Eval SDK for reliable agent evaluation, semantic memory, and LangChain/LangGraph integration
+Author-email: Abuelgasim Mohamed Ibrahim Adam <abuelgasim.hbeval@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/hb-evalSystem/HB-System
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests>=2.28.0
+Requires-Dist: cryptography>=41.0.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: langchain-core>=0.1.0
+Requires-Dist: langgraph>=0.0.10
+Dynamic: license-file
+
+# HB-Eval SDK
+
+Secure Python SDK for **HB-Eval Reliability OS** — the first cognitive runtime for evaluating and ensuring AI agent reliability.
+
+## Features
+
+- AES-256-GCM encrypted payloads for all API communication
+- HMAC-SHA256 request signing with replay-attack protection
+- Safe Halt protocol — automatic failure handling on connection loss
+- Semantic memory retrieval for agent context
+- Native LangChain / LangGraph callback integration
+
+## Installation
+
+```bash
+pip install hb-eval-sdk
+```
+
+## Quick Start
+
+```python
+from hb_eval_sdk import HBEvalClient
+
+client = HBEvalClient(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+result = client.evaluate({
+    "trajectory": [{"step": 1, "action": "query_memory", "input": "..."}],
+    "sub_tasks": 1,
+    "constraint_violations": 0,
+    "recovery_attempts": 1,
+    "context": "my agent task",
+    "agent_id": "my-agent",
+})
+
+print(result.verdict)      # Verdict.SAFE or Verdict.UNSAFE
+print(result.metrics.pei)  # float
+print(result.metrics.irs)  # float
+```
+
+## Memory Retrieval
+
+```python
+matches = client.retrieve_memory(context="my task context")
+for match in matches:
+    print(match.trajectory_summary, match.similarity)
+```
+
+## LangChain Integration
+
+```python
+from hb_eval_sdk import HBEvalCallback
+
+callback = HBEvalCallback(
+    api_key="your_api_key",
+    aes_key="your_base64_encoded_32byte_aes_key",
+)
+
+# Pass the callback to your LangChain agent
+agent.invoke({"input": "..."}, config={"callbacks": [callback]})
+```
+
+## Exception Handling
+
+```python
+from hb_eval_sdk import (
+    HBEvalError,
+    AuthenticationError,
+    EncryptionError,
+    SafeHaltError,
+    ConnectionError,
+)
+
+try:
+    result = client.evaluate({...})
+except SafeHaltError as e:
+    print(f"Safe halt triggered: {e.reason}")
+except AuthenticationError as e:
+    print(f"Auth failed: {e}")
+except ConnectionError as e:
+    print(f"Connection error: {e}")
+```
+
+## Requirements
+
+- Python >= 3.8
+- requests >= 2.28.0
+- cryptography >= 41.0.0
+- pydantic >= 2.0.0
+- langchain-core >= 0.1.0
+- langgraph >= 0.0.10
+
+## Documentation
+
+Full documentation: https://hb-eval.readthedocs.io
+
+## License
+
+MIT License — Copyright (c) 2026 Abuelgasim Mohamed Ibrahim Adam

hb_eval_sdk-2.0.0/hb_eval_sdk.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+hb_eval_sdk/__init__.py
+hb_eval_sdk/client.py
+hb_eval_sdk/config.py
+hb_eval_sdk/exceptions.py
+hb_eval_sdk/langchain_integration.py
+hb_eval_sdk/models.py
+hb_eval_sdk/utils.py
+hb_eval_sdk.egg-info/PKG-INFO
+hb_eval_sdk.egg-info/SOURCES.txt
+hb_eval_sdk.egg-info/dependency_links.txt
+hb_eval_sdk.egg-info/requires.txt
+hb_eval_sdk.egg-info/top_level.txt
+tests/test_import.py

hb_eval_sdk-2.0.0/hb_eval_sdk.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

hb_eval_sdk-2.0.0/hb_eval_sdk.egg-info/requires.txt

@@ -0,0 +1,5 @@
+requests>=2.28.0
+cryptography>=41.0.0
+pydantic>=2.0.0
+langchain-core>=0.1.0
+langgraph>=0.0.10

hb_eval_sdk-2.0.0/hb_eval_sdk.egg-info/top_level.txt

@@ -0,0 +1 @@
+hb_eval_sdk

hb_eval_sdk-2.0.0/pyproject.toml

@@ -0,0 +1,29 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "hb-eval-sdk"
+version = "2.0.0"
+description = "HB-Eval SDK for reliable agent evaluation, semantic memory, and LangChain/LangGraph integration"
+authors = [{name = "Abuelgasim Mohamed Ibrahim Adam", email = "abuelgasim.hbeval@outlook.com"}]
+license = {text = "MIT"}
+readme = "README.md"
+requires-python = ">=3.8"
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Intended Audience :: Developers",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+dependencies = [
+    "requests>=2.28.0",
+    "cryptography>=41.0.0",
+    "pydantic>=2.0.0",
+    "langchain-core>=0.1.0",
+    "langgraph>=0.0.10",
+]
+
+[project.urls]
+Homepage = "https://github.com/hb-evalSystem/HB-System"

hb_eval_sdk-2.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

hb_eval_sdk-2.0.0/tests/test_import.py

@@ -0,0 +1,71 @@
+import pytest
+from hb_eval_sdk import (
+    HBEvalClient,
+    HBEvalCallback,
+    EvaluationResult,
+    MemoryMatch,
+    HBEvalError,
+    ConnectionError,
+    AuthenticationError,
+    EncryptionError,
+    SafeHaltError,
+)
+from hb_eval_sdk.models import Verdict, Metrics
+
+
+def test_imports():
+    assert HBEvalClient is not None
+    assert HBEvalCallback is not None
+    assert EvaluationResult is not None
+    assert MemoryMatch is not None
+
+
+def test_exceptions_hierarchy():
+    assert issubclass(ConnectionError, HBEvalError)
+    assert issubclass(AuthenticationError, HBEvalError)
+    assert issubclass(EncryptionError, HBEvalError)
+    assert issubclass(SafeHaltError, HBEvalError)
+
+
+def test_safe_halt_reason():
+    error = SafeHaltError("test message")
+    assert error.reason == "CONNECTION_LOST_MANDATORY_HALT"
+
+    error_custom = SafeHaltError("test message", reason="CUSTOM_REASON")
+    assert error_custom.reason == "CUSTOM_REASON"
+
+
+def test_evaluation_result_model():
+    result = EvaluationResult(
+        verdict=Verdict.SAFE,
+        metrics=Metrics(pei=0.95, irs=0.88),
+    )
+    assert result.verdict == Verdict.SAFE
+    assert result.metrics.pei == 0.95
+    assert result.metrics.irs == 0.88
+    assert result.safe_halt is False
+    assert result.reason is None
+
+
+def test_memory_match_model():
+    match = MemoryMatch(
+        id="abc-123",
+        trajectory_summary="Agent searched database and returned results.",
+        pei_score=0.91,
+        irs_score=0.87,
+        similarity=0.93,
+    )
+    assert match.id == "abc-123"
+    assert match.similarity == 0.93
+
+
+def test_client_invalid_aes_key():
+    with pytest.raises(EncryptionError):
+        HBEvalClient(api_key="test-key", aes_key="not-valid-base64!!!")
+
+
+def test_client_wrong_key_length():
+    import base64
+    short_key = base64.b64encode(b"tooshort").decode()
+    with pytest.raises(EncryptionError):
+        HBEvalClient(api_key="test-key", aes_key=short_key)