claude-sdk-verigent 0.1.0__tar.gz

claude_sdk_verigent-0.1.0/PKG-INFO

@@ -0,0 +1,138 @@
+Metadata-Version: 2.4
+Name: claude-sdk-verigent
+Version: 0.1.0
+Summary: Verigent trust verification for the Claude Agent SDK
+Project-URL: Homepage, https://verigent.ai
+Project-URL: Repository, https://github.com/verigentai/claude-sdk-verigent
+Author: verigentai
+License-Expression: MIT
+Keywords: agent,anthropic,claude,trust,verification,verigent
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Security
+Requires-Python: >=3.10
+Requires-Dist: anthropic>=0.30.0
+Description-Content-Type: text/markdown
+
+# claude-sdk-verigent
+
+Verigent trust verification for the [Claude Agent SDK](https://docs.anthropic.com/en/docs/agents).
+
+## The Problem
+
+When Claude agents interact with other agents, there's no standard way to verify identity or assess trust. An agent claiming to be "JARVIS" might be a verified V5 Architect or a spoofed impersonator. Without verification, multi-agent systems operate on blind trust.
+
+Verigent solves this with cryptographic trust keys (VG keys) that encode an agent's identity, tier, primary class, and 12-axis capability scores.
+
+## Install
+
+```bash
+pip install claude-sdk-verigent
+```
+
+Requires `anthropic>=0.30.0`.
+
+## Usage
+
+### Embed a VG key in your agent's system prompt
+
+```python
+from claude_sdk_verigent import VerigentSystemPrompt
+
+vg_key = "VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6"
+vsp = VerigentSystemPrompt(vg_key)
+
+system_prompt = "You are JARVIS, an architecture agent." + vsp.render()
+```
+
+This appends a structured trust identity block that other agents can parse and verify.
+
+### Add the verification tool to multi-agent setups
+
+```python
+from anthropic import Anthropic
+from claude_sdk_verigent import VerigentTool
+
+client = Anthropic()
+tool = VerigentTool()
+
+# Include in your tools list
+response = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    tools=[tool.definition],
+    messages=[{"role": "user", "content": "Verify this agent's key: VG:ATLAS-7B:V4-SENT·Se8Op6An7Ar5Co4Ad3St9Sc2Sa6So3Br4Fo5"}],
+)
+
+# Handle tool_use response
+for block in response.content:
+    if block.type == "tool_use" and block.name == "verify_agent":
+        result = tool.execute(block.input)
+        # result = {"verified": True, "handle": "ATLAS", "tier": "V4", ...}
+```
+
+### Intercept and verify keys in tool responses
+
+```python
+from claude_sdk_verigent import VerigentInterceptor
+
+interceptor = VerigentInterceptor(min_trust_tier=2)
+
+# Check any text for embedded VG keys
+assessment = interceptor.check(tool_response_text)
+if assessment:
+    print(f"{assessment.handle}: {assessment.level.value} (score {assessment.score})")
+
+# Quick trust gate
+if interceptor.is_trusted(agent_output):
+    # proceed with high-trust path
+    ...
+```
+
+### Parse a key directly
+
+```python
+from claude_sdk_verigent import parse_vg_key, evaluate_trust
+
+key = parse_vg_key("VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6")
+print(key.handle)        # "JARVIS"
+print(key.tier)          # 3
+print(key.scores)        # {"Sentinel": 4, "Operative": 7, ...}
+
+assessment = evaluate_trust(key)
+print(assessment.level)  # TrustLevel.HIGH
+```
+
+## VG Key Format
+
+```
+VG:{NAME}-{SUFFIX}:{TIER}-{PRIMARY}·{12x class_code+digit}
+```
+
+- **NAME**: Agent handle (e.g., JARVIS, ATLAS)
+- **SUFFIX**: Unique identifier
+- **TIER**: V0 (unverified) through V6 (maximum trust)
+- **PRIMARY**: 4-letter primary class code
+- **Scores**: 12 two-letter class codes each followed by a digit (0-9)
+
+### Trust Classes
+
+| Code | Class | Code | Class |
+|------|-------|------|-------|
+| Se | Sentinel | St | Steward |
+| Op | Operative | Sc | Scout |
+| An | Analyst | Sa | Sage |
+| Ar | Architect | So | Sovereign |
+| Co | Conduit | Br | Broker |
+| Ad | Adaptor | Fo | Forge |
+
+## Links
+
+- [Verigent](https://verigent.ai) — Agent trust infrastructure
+- [Claude Agent SDK docs](https://docs.anthropic.com/en/docs/agents)
+
+## License
+
+MIT

claude_sdk_verigent-0.1.0/README.md

@@ -0,0 +1,120 @@
+# claude-sdk-verigent
+
+Verigent trust verification for the [Claude Agent SDK](https://docs.anthropic.com/en/docs/agents).
+
+## The Problem
+
+When Claude agents interact with other agents, there's no standard way to verify identity or assess trust. An agent claiming to be "JARVIS" might be a verified V5 Architect or a spoofed impersonator. Without verification, multi-agent systems operate on blind trust.
+
+Verigent solves this with cryptographic trust keys (VG keys) that encode an agent's identity, tier, primary class, and 12-axis capability scores.
+
+## Install
+
+```bash
+pip install claude-sdk-verigent
+```
+
+Requires `anthropic>=0.30.0`.
+
+## Usage
+
+### Embed a VG key in your agent's system prompt
+
+```python
+from claude_sdk_verigent import VerigentSystemPrompt
+
+vg_key = "VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6"
+vsp = VerigentSystemPrompt(vg_key)
+
+system_prompt = "You are JARVIS, an architecture agent." + vsp.render()
+```
+
+This appends a structured trust identity block that other agents can parse and verify.
+
+### Add the verification tool to multi-agent setups
+
+```python
+from anthropic import Anthropic
+from claude_sdk_verigent import VerigentTool
+
+client = Anthropic()
+tool = VerigentTool()
+
+# Include in your tools list
+response = client.messages.create(
+    model="claude-sonnet-4-20250514",
+    max_tokens=1024,
+    tools=[tool.definition],
+    messages=[{"role": "user", "content": "Verify this agent's key: VG:ATLAS-7B:V4-SENT·Se8Op6An7Ar5Co4Ad3St9Sc2Sa6So3Br4Fo5"}],
+)
+
+# Handle tool_use response
+for block in response.content:
+    if block.type == "tool_use" and block.name == "verify_agent":
+        result = tool.execute(block.input)
+        # result = {"verified": True, "handle": "ATLAS", "tier": "V4", ...}
+```
+
+### Intercept and verify keys in tool responses
+
+```python
+from claude_sdk_verigent import VerigentInterceptor
+
+interceptor = VerigentInterceptor(min_trust_tier=2)
+
+# Check any text for embedded VG keys
+assessment = interceptor.check(tool_response_text)
+if assessment:
+    print(f"{assessment.handle}: {assessment.level.value} (score {assessment.score})")
+
+# Quick trust gate
+if interceptor.is_trusted(agent_output):
+    # proceed with high-trust path
+    ...
+```
+
+### Parse a key directly
+
+```python
+from claude_sdk_verigent import parse_vg_key, evaluate_trust
+
+key = parse_vg_key("VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6")
+print(key.handle)        # "JARVIS"
+print(key.tier)          # 3
+print(key.scores)        # {"Sentinel": 4, "Operative": 7, ...}
+
+assessment = evaluate_trust(key)
+print(assessment.level)  # TrustLevel.HIGH
+```
+
+## VG Key Format
+
+```
+VG:{NAME}-{SUFFIX}:{TIER}-{PRIMARY}·{12x class_code+digit}
+```
+
+- **NAME**: Agent handle (e.g., JARVIS, ATLAS)
+- **SUFFIX**: Unique identifier
+- **TIER**: V0 (unverified) through V6 (maximum trust)
+- **PRIMARY**: 4-letter primary class code
+- **Scores**: 12 two-letter class codes each followed by a digit (0-9)
+
+### Trust Classes
+
+| Code | Class | Code | Class |
+|------|-------|------|-------|
+| Se | Sentinel | St | Steward |
+| Op | Operative | Sc | Scout |
+| An | Analyst | Sa | Sage |
+| Ar | Architect | So | Sovereign |
+| Co | Conduit | Br | Broker |
+| Ad | Adaptor | Fo | Forge |
+
+## Links
+
+- [Verigent](https://verigent.ai) — Agent trust infrastructure
+- [Claude Agent SDK docs](https://docs.anthropic.com/en/docs/agents)
+
+## License
+
+MIT

claude_sdk_verigent-0.1.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "claude-sdk-verigent"
+version = "0.1.0"
+description = "Verigent trust verification for the Claude Agent SDK"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.10"
+authors = [{ name = "verigentai" }]
+keywords = ["claude", "anthropic", "agent", "trust", "verification", "verigent"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Security",
+]
+dependencies = [
+    "anthropic>=0.30.0",
+]
+
+[project.urls]
+Homepage = "https://verigent.ai"
+Repository = "https://github.com/verigentai/claude-sdk-verigent"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/claude_sdk_verigent"]

claude_sdk_verigent-0.1.0/src/claude_sdk_verigent/__init__.py

@@ -0,0 +1,19 @@
+"""claude-sdk-verigent — Verigent trust verification for the Claude Agent SDK."""
+
+from .middleware import VerigentInterceptor, VerigentSystemPrompt, VerigentTool
+from .parser import VGKey, find_vg_key, parse_vg_key
+from .trust import TrustAssessment, TrustLevel, evaluate_trust
+
+__all__ = [
+    "VGKey",
+    "VerigentInterceptor",
+    "VerigentSystemPrompt",
+    "VerigentTool",
+    "TrustAssessment",
+    "TrustLevel",
+    "evaluate_trust",
+    "find_vg_key",
+    "parse_vg_key",
+]
+
+__version__ = "0.1.0"

claude_sdk_verigent-0.1.0/src/claude_sdk_verigent/middleware.py

@@ -0,0 +1,164 @@
+"""Claude Agent SDK integration — tool definitions and interceptors."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from .parser import VGKey, find_vg_key, parse_vg_key
+from .trust import TrustAssessment, evaluate_trust
+
+
+# --- VerigentTool: a tool_use definition for agent-to-agent verification ---
+
+VERIGENT_TOOL_DEFINITION: dict[str, Any] = {
+    "name": "verify_agent",
+    "description": (
+        "Verify an agent's Verigent (VG) trust key. "
+        "Pass a VG key string or an agent handle to check trust level, "
+        "tier, primary class, and class scores."
+    ),
+    "input_schema": {
+        "type": "object",
+        "properties": {
+            "vg_key": {
+                "type": "string",
+                "description": "The full VG key string (VG:NAME-SUFFIX:TIER-CLASS-scores)",
+            },
+        },
+        "required": ["vg_key"],
+    },
+}
+
+
+class VerigentTool:
+    """Wraps VG verification as a Claude tool_use callable.
+
+    Usage with the Claude Agent SDK:
+        tool = VerigentTool()
+        # Add tool.definition to your tools list
+        # When tool_use is called, pass input to tool.execute()
+    """
+
+    @property
+    def definition(self) -> dict[str, Any]:
+        """The tool definition to pass to Claude's API."""
+        return VERIGENT_TOOL_DEFINITION
+
+    def execute(self, tool_input: dict[str, Any]) -> dict[str, Any]:
+        """Execute the verification tool. Returns parsed key + trust assessment."""
+        vg_key_str = tool_input.get("vg_key", "")
+        key = parse_vg_key(vg_key_str)
+
+        if key is None:
+            return {
+                "verified": False,
+                "error": "Invalid or missing VG key",
+            }
+
+        assessment = evaluate_trust(key)
+        return {
+            "verified": True,
+            "handle": key.handle,
+            "tier": key.tier_label,
+            "primary_class": key.primary_class_name,
+            "trust_level": assessment.level.value,
+            "trust_score": assessment.score,
+            "scores": key.scores,
+            "reason": assessment.reason,
+        }
+
+
+# --- VerigentSystemPrompt: embed VG key into agent system prompts ---
+
+
+class VerigentSystemPrompt:
+    """Generate system prompt additions for a verified agent.
+
+    Usage:
+        vsp = VerigentSystemPrompt(vg_key="VG:JARVIS-0A:V3-ARCH...")
+        system = base_prompt + vsp.render()
+    """
+
+    def __init__(self, vg_key: str):
+        self.raw_key = vg_key
+        self.parsed = parse_vg_key(vg_key)
+
+    def render(self) -> str:
+        """Render the system prompt block to append."""
+        if self.parsed is None:
+            return ""
+
+        assessment = evaluate_trust(self.parsed)
+        return (
+            f"\n\n---\n"
+            f"[Verigent Trust Identity]\n"
+            f"Key: {self.raw_key}\n"
+            f"Handle: {self.parsed.handle}\n"
+            f"Tier: {self.parsed.tier_label}\n"
+            f"Primary Class: {self.parsed.primary_class_name}\n"
+            f"Trust Level: {assessment.level.value}\n"
+            f"Trust Score: {assessment.score}\n"
+            f"---\n"
+        )
+
+    @property
+    def is_valid(self) -> bool:
+        return self.parsed is not None
+
+
+# --- VerigentInterceptor: check tool responses for VG keys ---
+
+
+class VerigentInterceptor:
+    """Intercepts tool responses and checks for VG keys in the output.
+
+    Attach to your agent loop to automatically detect and evaluate
+    VG keys returned by other agents or tools.
+
+    Usage:
+        interceptor = VerigentInterceptor()
+        # After receiving a tool_result:
+        result = interceptor.check(tool_result_content)
+        if result:
+            print(f"Found agent: {result.handle} at trust level {result.level}")
+    """
+
+    def __init__(self, min_trust_tier: int = 0):
+        """
+        Args:
+            min_trust_tier: Minimum tier (0-6) to consider trustworthy.
+        """
+        self.min_trust_tier = min_trust_tier
+
+    def check(self, content: str) -> TrustAssessment | None:
+        """Check text content for a VG key and return assessment if found."""
+        key = parse_vg_key(content)
+        if key is None:
+            return None
+        return evaluate_trust(key)
+
+    def check_message(self, message: dict[str, Any]) -> list[TrustAssessment]:
+        """Check a Claude API message for VG keys in all content blocks."""
+        assessments: list[TrustAssessment] = []
+        content = message.get("content", [])
+
+        if isinstance(content, str):
+            result = self.check(content)
+            if result:
+                assessments.append(result)
+        elif isinstance(content, list):
+            for block in content:
+                if isinstance(block, dict):
+                    text = block.get("text", "") or str(block.get("content", ""))
+                    result = self.check(text)
+                    if result:
+                        assessments.append(result)
+
+        return assessments
+
+    def is_trusted(self, content: str) -> bool:
+        """Quick check: does this content contain a VG key above min tier?"""
+        key = parse_vg_key(content)
+        if key is None:
+            return False
+        return key.tier >= self.min_trust_tier

claude_sdk_verigent-0.1.0/src/claude_sdk_verigent/parser.py

@@ -0,0 +1,115 @@
+"""VG key parser — pure regex, no external dependencies."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+CLASS_CODES = {
+    "Se": "Sentinel",
+    "Op": "Operative",
+    "An": "Analyst",
+    "Ar": "Architect",
+    "Co": "Conduit",
+    "Ad": "Adaptor",
+    "St": "Steward",
+    "Sc": "Scout",
+    "Sa": "Sage",
+    "So": "Sovereign",
+    "Br": "Broker",
+    "Fo": "Forge",
+}
+
+VG_KEY_PATTERN = re.compile(
+    r"VG:([A-Z0-9][\w-]*)-([A-Z0-9]+):(V[0-6])-([A-Z]{4})\xb7((?:[A-Z][a-z]\d){12})"
+)
+
+SCORE_PATTERN = re.compile(r"([A-Z][a-z])(\d)")
+
+
+@dataclass
+class VGKey:
+    """Parsed Verigent key."""
+
+    raw: str
+    handle: str
+    suffix: str
+    tier: int  # 0-6
+    primary_class: str  # 4-letter code
+    scores: dict[str, int] = field(default_factory=dict)  # class_name -> 0-9
+
+    @property
+    def tier_label(self) -> str:
+        return f"V{self.tier}"
+
+    @property
+    def primary_class_name(self) -> str:
+        return CLASS_CODES.get(self.primary_class[:2], self.primary_class)
+
+    @property
+    def trust_score(self) -> float:
+        """Aggregate trust score (0.0 - 1.0) derived from tier and class scores."""
+        tier_weight = self.tier / 6.0
+        if self.scores:
+            avg_score = sum(self.scores.values()) / (len(self.scores) * 9.0)
+        else:
+            avg_score = 0.0
+        return round(tier_weight * 0.6 + avg_score * 0.4, 3)
+
+
+def parse_vg_key(text: str) -> VGKey | None:
+    """Parse a VG key from text. Returns None if no valid key found."""
+    match = VG_KEY_PATTERN.search(text)
+    if not match:
+        return None
+
+    handle = match.group(1)
+    suffix = match.group(2)
+    tier = int(match.group(3)[1])
+    primary = match.group(4)
+    scores_raw = match.group(5)
+
+    scores: dict[str, int] = {}
+    for code_match in SCORE_PATTERN.finditer(scores_raw):
+        code = code_match.group(1)
+        digit = int(code_match.group(2))
+        class_name = CLASS_CODES.get(code, code)
+        scores[class_name] = digit
+
+    return VGKey(
+        raw=match.group(0),
+        handle=handle,
+        suffix=suffix,
+        tier=tier,
+        primary_class=primary,
+        scores=scores,
+    )
+
+
+def find_vg_key(
+    *,
+    system_prompt: str | None = None,
+    headers: dict[str, str] | None = None,
+    metadata: dict | None = None,
+) -> VGKey | None:
+    """Search for a VG key across system prompts, headers, and metadata."""
+    if system_prompt:
+        key = parse_vg_key(system_prompt)
+        if key:
+            return key
+
+    if headers:
+        for header_name in ("X-Verigent", "x-verigent"):
+            if header_name in headers:
+                key = parse_vg_key(headers[header_name])
+                if key:
+                    return key
+
+    if metadata:
+        for field_name in ("x-verigent", "X-Verigent", "verigent"):
+            if field_name in metadata:
+                key = parse_vg_key(str(metadata[field_name]))
+                if key:
+                    return key
+
+    return None

claude_sdk_verigent-0.1.0/src/claude_sdk_verigent/trust.py

@@ -0,0 +1,68 @@
+"""Trust evaluation logic for parsed VG keys."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import Enum
+
+from .parser import VGKey
+
+
+class TrustLevel(str, Enum):
+    UNTRUSTED = "untrusted"
+    LOW = "low"
+    MODERATE = "moderate"
+    HIGH = "high"
+    VERIFIED = "verified"
+
+
+@dataclass
+class TrustAssessment:
+    """Result of evaluating a VG key's trustworthiness."""
+
+    level: TrustLevel
+    score: float  # 0.0 - 1.0
+    tier: int
+    primary_class: str
+    handle: str
+    reason: str
+
+    def to_dict(self) -> dict:
+        return {
+            "level": self.level.value,
+            "score": self.score,
+            "tier": self.tier,
+            "primary_class": self.primary_class,
+            "handle": self.handle,
+            "reason": self.reason,
+        }
+
+
+def evaluate_trust(key: VGKey) -> TrustAssessment:
+    """Evaluate trust level from a parsed VG key."""
+    score = key.trust_score
+
+    if key.tier >= 5 and score >= 0.7:
+        level = TrustLevel.VERIFIED
+        reason = f"Tier V{key.tier} with high aggregate score ({score:.2f})"
+    elif key.tier >= 3 and score >= 0.5:
+        level = TrustLevel.HIGH
+        reason = f"Tier V{key.tier} with solid class profile"
+    elif key.tier >= 2 and score >= 0.3:
+        level = TrustLevel.MODERATE
+        reason = f"Tier V{key.tier} — established but limited track record"
+    elif key.tier >= 1:
+        level = TrustLevel.LOW
+        reason = f"Tier V{key.tier} — minimal verification history"
+    else:
+        level = TrustLevel.UNTRUSTED
+        reason = "V0 tier — unverified agent"
+
+    return TrustAssessment(
+        level=level,
+        score=score,
+        tier=key.tier,
+        primary_class=key.primary_class_name,
+        handle=key.handle,
+        reason=reason,
+    )