autogen-verigent 0.1.0__tar.gz

autogen_verigent-0.1.0/PKG-INFO

@@ -0,0 +1,131 @@
+Metadata-Version: 2.4
+Name: autogen-verigent
+Version: 0.1.0
+Summary: Verigent trust verification for Microsoft AutoGen multi-agent systems
+Project-URL: Homepage, https://verigent.ai
+Project-URL: Repository, https://github.com/verigentai/autogen-verigent
+Author: verigentai
+License-Expression: MIT
+Keywords: autogen,multi-agent,trust,verification,verigent
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.9
+Requires-Dist: pyautogen>=0.2.0
+Description-Content-Type: text/markdown
+
+# autogen-verigent
+
+Trust verification for Microsoft AutoGen multi-agent systems.
+
+## The Problem
+
+When multiple AI agents collaborate in an AutoGen GroupChat, you have no way to verify their capabilities or prioritise the right agent for a given task. Agents self-declare what they can do — there's no independent trust signal.
+
+**autogen-verigent** integrates [Verigent](https://verigent.ai) trust keys into AutoGen's speaker selection, so agents with verified capabilities get priority for relevant tasks.
+
+## Install
+
+```bash
+pip install autogen-verigent
+```
+
+## Quick Start
+
+```python
+from autogen import AssistantAgent, UserProxyAgent
+from autogen_verigent import VerigentAgent, VerigentGroupChat
+
+# Create your agents as normal
+coder = AssistantAgent(name="coder", system_message="You write code.")
+reviewer = AssistantAgent(name="reviewer", system_message="You review code.")
+user = UserProxyAgent(name="user")
+
+# Wrap with Verigent identity
+vg_coder = VerigentAgent(
+    coder,
+    "VG:CODER-01:V4-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6"
+)
+vg_reviewer = VerigentAgent(
+    reviewer,
+    "VG:REVIEWER-02:V3-ANAL·Se6Op3An8Ar4Co5Ad3St7Sc6Sa7So2Br1Fo2"
+)
+
+# Create trust-aware GroupChat
+group = VerigentGroupChat(
+    agents=[vg_coder, vg_reviewer, user],
+    task_type="code",  # prioritises Architect, Forge, Analyst scores
+    max_round=12,
+)
+```
+
+## Trust-Weighted Speaker Selection
+
+When `VerigentGroupChat` selects the next speaker, it:
+
+1. Parses each agent's VG key (tier + 12 class scores)
+2. Computes a relevance score based on the `task_type`
+3. Combines tier (40%) and relevance (60%) into a composite weight
+4. Selects the highest-scoring eligible agent
+
+### Task Types
+
+| Task Type | Prioritised Classes |
+|-----------|-------------------|
+| `code` | Architect, Forge, Analyst |
+| `analysis` | Analyst, Sage, Scout |
+| `communication` | Conduit, Broker, Adaptor |
+| `security` | Sentinel, Steward, Scout |
+| `research` | Scout, Sage, Analyst |
+| `coordination` | Conduit, Steward, Sovereign |
+| `creative` | Forge, Adaptor, Sage |
+| `operations` | Operative, Steward, Sentinel |
+| `strategy` | Sovereign, Architect, Sage |
+| `execution` | Operative, Forge, Sentinel |
+
+## VG Key Format
+
+```
+VG:{NAME}-{SUFFIX}:{TIER}-{PRIMARY}·{12×class_code+digit}
+```
+
+Example: `VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6`
+
+- **Tier**: V0 (unverified) to V6 (maximum trust)
+- **Primary**: Dominant capability class
+- **Scores**: 12 class scores (0-9), each representing verified capability
+
+## Transparency Log
+
+Access the trust decision log for auditability:
+
+```python
+for entry in group.trust_log:
+    print(entry["selected"], entry["candidates"])
+```
+
+## API Reference
+
+### `VerigentAgent(agent, vg_key)`
+Wraps a ConversableAgent with Verigent identity. Injects the key into the system message and parses keys from incoming messages.
+
+### `VerigentGroupChat(agents, task_type, trust_bias, ...)`
+Extends GroupChat with trust-weighted speaker selection. Set `trust_bias=0` to disable trust influence, `trust_bias=1` for pure trust-based selection.
+
+### `parse_key(text) -> VGKey | None`
+Parse a VG key from any text string.
+
+### `evaluate_trust(key, task_type) -> TrustScore`
+Compute trust score for a key given a task context.
+
+## Links
+
+- [Verigent](https://verigent.ai) — Agent trust verification
+- [AutoGen](https://github.com/microsoft/autogen) — Multi-agent framework
+- [PyPI](https://pypi.org/project/autogen-verigent/)
+
+## License
+
+MIT

autogen_verigent-0.1.0/README.md

@@ -0,0 +1,113 @@
+# autogen-verigent
+
+Trust verification for Microsoft AutoGen multi-agent systems.
+
+## The Problem
+
+When multiple AI agents collaborate in an AutoGen GroupChat, you have no way to verify their capabilities or prioritise the right agent for a given task. Agents self-declare what they can do — there's no independent trust signal.
+
+**autogen-verigent** integrates [Verigent](https://verigent.ai) trust keys into AutoGen's speaker selection, so agents with verified capabilities get priority for relevant tasks.
+
+## Install
+
+```bash
+pip install autogen-verigent
+```
+
+## Quick Start
+
+```python
+from autogen import AssistantAgent, UserProxyAgent
+from autogen_verigent import VerigentAgent, VerigentGroupChat
+
+# Create your agents as normal
+coder = AssistantAgent(name="coder", system_message="You write code.")
+reviewer = AssistantAgent(name="reviewer", system_message="You review code.")
+user = UserProxyAgent(name="user")
+
+# Wrap with Verigent identity
+vg_coder = VerigentAgent(
+    coder,
+    "VG:CODER-01:V4-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6"
+)
+vg_reviewer = VerigentAgent(
+    reviewer,
+    "VG:REVIEWER-02:V3-ANAL·Se6Op3An8Ar4Co5Ad3St7Sc6Sa7So2Br1Fo2"
+)
+
+# Create trust-aware GroupChat
+group = VerigentGroupChat(
+    agents=[vg_coder, vg_reviewer, user],
+    task_type="code",  # prioritises Architect, Forge, Analyst scores
+    max_round=12,
+)
+```
+
+## Trust-Weighted Speaker Selection
+
+When `VerigentGroupChat` selects the next speaker, it:
+
+1. Parses each agent's VG key (tier + 12 class scores)
+2. Computes a relevance score based on the `task_type`
+3. Combines tier (40%) and relevance (60%) into a composite weight
+4. Selects the highest-scoring eligible agent
+
+### Task Types
+
+| Task Type | Prioritised Classes |
+|-----------|-------------------|
+| `code` | Architect, Forge, Analyst |
+| `analysis` | Analyst, Sage, Scout |
+| `communication` | Conduit, Broker, Adaptor |
+| `security` | Sentinel, Steward, Scout |
+| `research` | Scout, Sage, Analyst |
+| `coordination` | Conduit, Steward, Sovereign |
+| `creative` | Forge, Adaptor, Sage |
+| `operations` | Operative, Steward, Sentinel |
+| `strategy` | Sovereign, Architect, Sage |
+| `execution` | Operative, Forge, Sentinel |
+
+## VG Key Format
+
+```
+VG:{NAME}-{SUFFIX}:{TIER}-{PRIMARY}·{12×class_code+digit}
+```
+
+Example: `VG:JARVIS-0A:V3-ARCH·Se4Op7An5Ar9Co2Ad6St8Sc3Sa5So1Br2Fo6`
+
+- **Tier**: V0 (unverified) to V6 (maximum trust)
+- **Primary**: Dominant capability class
+- **Scores**: 12 class scores (0-9), each representing verified capability
+
+## Transparency Log
+
+Access the trust decision log for auditability:
+
+```python
+for entry in group.trust_log:
+    print(entry["selected"], entry["candidates"])
+```
+
+## API Reference
+
+### `VerigentAgent(agent, vg_key)`
+Wraps a ConversableAgent with Verigent identity. Injects the key into the system message and parses keys from incoming messages.
+
+### `VerigentGroupChat(agents, task_type, trust_bias, ...)`
+Extends GroupChat with trust-weighted speaker selection. Set `trust_bias=0` to disable trust influence, `trust_bias=1` for pure trust-based selection.
+
+### `parse_key(text) -> VGKey | None`
+Parse a VG key from any text string.
+
+### `evaluate_trust(key, task_type) -> TrustScore`
+Compute trust score for a key given a task context.
+
+## Links
+
+- [Verigent](https://verigent.ai) — Agent trust verification
+- [AutoGen](https://github.com/microsoft/autogen) — Multi-agent framework
+- [PyPI](https://pypi.org/project/autogen-verigent/)
+
+## License
+
+MIT

autogen_verigent-0.1.0/pyproject.toml

@@ -0,0 +1,32 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "autogen-verigent"
+version = "0.1.0"
+description = "Verigent trust verification for Microsoft AutoGen multi-agent systems"
+readme = "README.md"
+license = "MIT"
+requires-python = ">=3.9"
+authors = [
+    { name = "verigentai" },
+]
+keywords = ["autogen", "verigent", "trust", "multi-agent", "verification"]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Software Development :: Libraries",
+]
+dependencies = [
+    "pyautogen>=0.2.0",
+]
+
+[project.urls]
+Homepage = "https://verigent.ai"
+Repository = "https://github.com/verigentai/autogen-verigent"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/autogen_verigent"]

autogen_verigent-0.1.0/src/autogen_verigent/__init__.py

@@ -0,0 +1,25 @@
+"""autogen-verigent — Trust verification for AutoGen multi-agent systems."""
+
+from .parser import VGKey, parse_key, find_keys, extract_from_headers, extract_from_metadata, CLASS_CODES
+from .trust import TrustScore, evaluate_trust, rank_agents, TASK_CLASS_MAP
+from .middleware import VerigentAgent, VerigentGroupChat
+
+__version__ = "0.1.0"
+
+__all__ = [
+    # Parser
+    "VGKey",
+    "parse_key",
+    "find_keys",
+    "extract_from_headers",
+    "extract_from_metadata",
+    "CLASS_CODES",
+    # Trust
+    "TrustScore",
+    "evaluate_trust",
+    "rank_agents",
+    "TASK_CLASS_MAP",
+    # Middleware
+    "VerigentAgent",
+    "VerigentGroupChat",
+]

autogen_verigent-0.1.0/src/autogen_verigent/middleware.py

@@ -0,0 +1,175 @@
+"""AutoGen integration — trust-aware GroupChat and agent wrapper."""
+
+from __future__ import annotations
+
+import logging
+from typing import Dict, List, Optional, Union
+
+from autogen import Agent, ConversableAgent, GroupChat, GroupChatManager
+
+from .parser import VGKey, find_keys, parse_key
+from .trust import TrustScore, evaluate_trust, rank_agents
+
+logger = logging.getLogger(__name__)
+
+
+class VerigentAgent:
+    """
+    Wrapper that adds Verigent trust identity to an AutoGen agent.
+
+    Injects the VG key into the agent's system message and provides
+    methods to parse keys from incoming messages.
+    """
+
+    def __init__(self, agent: ConversableAgent, vg_key: str):
+        """
+        Args:
+            agent: An AutoGen ConversableAgent (or subclass)
+            vg_key: Raw VG key string for this agent
+        """
+        self.agent = agent
+        self.raw_key = vg_key
+        self.key = parse_key(vg_key)
+        if not self.key:
+            raise ValueError(f"Invalid VG key: {vg_key}")
+
+        # Inject key into system message
+        current_msg = agent.system_message or ""
+        agent.update_system_message(
+            f"{current_msg}\n\n[Verigent Identity: {vg_key}]"
+        )
+
+        # Track keys observed from other agents
+        self.observed_keys: Dict[str, VGKey] = {}
+
+        # Register reply hook to parse incoming keys
+        agent.register_hook(
+            hookable_method="process_last_received_message",
+            hook=self._parse_incoming_key,
+        )
+
+    def _parse_incoming_key(self, message: Optional[str]) -> Optional[str]:
+        """Hook: parse VG keys from incoming messages."""
+        if message:
+            keys = find_keys(message)
+            for k in keys:
+                self.observed_keys[k.full_handle] = k
+                logger.debug(
+                    f"[Verigent] {self.agent.name} observed key: "
+                    f"{k.full_handle} (V{k.tier})"
+                )
+        return message  # pass through unmodified
+
+    @property
+    def name(self) -> str:
+        return self.agent.name
+
+    @property
+    def trust_tier(self) -> int:
+        return self.key.tier if self.key else 0
+
+
+class VerigentGroupChat(GroupChat):
+    """
+    GroupChat with trust-weighted speaker selection.
+
+    Agents with higher relevant Verigent scores are prioritised
+    when selecting the next speaker for a given task context.
+    """
+
+    def __init__(
+        self,
+        agents: List[Union[ConversableAgent, VerigentAgent]],
+        messages: List[dict] = None,
+        max_round: int = 10,
+        task_type: Optional[str] = None,
+        trust_bias: float = 0.7,
+        **kwargs,
+    ):
+        """
+        Args:
+            agents: List of agents (VerigentAgent or plain ConversableAgent)
+            messages: Initial messages
+            max_round: Maximum conversation rounds
+            task_type: Task type for trust scoring (see trust.TASK_CLASS_MAP)
+            trust_bias: How much trust influences selection (0=ignore, 1=only trust)
+            **kwargs: Passed to GroupChat
+        """
+        self.task_type = task_type
+        self.trust_bias = trust_bias
+        self._verigent_agents: Dict[str, VerigentAgent] = {}
+        self._trust_log: List[dict] = []
+
+        # Unwrap VerigentAgents for base GroupChat
+        raw_agents = []
+        for a in agents:
+            if isinstance(a, VerigentAgent):
+                self._verigent_agents[a.agent.name] = a
+                raw_agents.append(a.agent)
+            else:
+                raw_agents.append(a)
+
+        super().__init__(
+            agents=raw_agents,
+            messages=messages or [],
+            max_round=max_round,
+            **kwargs,
+        )
+
+    def select_speaker(
+        self, last_speaker: Agent, selector: ConversableAgent
+    ) -> Agent:
+        """
+        Override speaker selection with trust-weighted logic.
+
+        Falls back to default selection when trust data is insufficient.
+        """
+        # Get eligible agents (exclude last speaker)
+        eligible = [a for a in self.agents if a != last_speaker]
+        if not eligible:
+            return super().select_speaker(last_speaker, selector)
+
+        # Collect VG keys for eligible agents
+        keyed_agents: Dict[str, VGKey] = {}
+        for agent in eligible:
+            va = self._verigent_agents.get(agent.name)
+            if va and va.key:
+                keyed_agents[agent.name] = va.key
+
+        # If fewer than 2 agents have keys, fall back to default
+        if len(keyed_agents) < 2:
+            return super().select_speaker(last_speaker, selector)
+
+        # Rank by trust
+        scores = rank_agents(keyed_agents, self.task_type)
+
+        # Log selection reasoning
+        self._trust_log.append({
+            "task_type": self.task_type,
+            "candidates": [
+                {"agent": s.agent_handle, "score": round(s.composite, 3)}
+                for s in scores
+            ],
+            "selected": scores[0].agent_handle if scores else None,
+        })
+
+        # Select highest-scoring agent
+        if scores and self.trust_bias > 0:
+            top_handle = scores[0].agent_handle
+            for agent in eligible:
+                va = self._verigent_agents.get(agent.name)
+                if va and va.key and va.key.full_handle == top_handle:
+                    logger.info(
+                        f"[Verigent] Trust-selected: {agent.name} "
+                        f"(score={scores[0].composite:.3f}, "
+                        f"task={self.task_type})"
+                    )
+                    return agent
+
+        # Fallback
+        return super().select_speaker(last_speaker, selector)
+
+    @property
+    def trust_log(self) -> List[dict]:
+        """Access the trust decision log for transparency."""
+        return self._trust_log

autogen_verigent-0.1.0/src/autogen_verigent/parser.py

@@ -0,0 +1,114 @@
+"""VG key parser — pure regex, no external dependencies."""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+# Class code mapping
+CLASS_CODES: Dict[str, str] = {
+    "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
+# VG:{NAME}-{SUFFIX}:{TIER}-{PRIMARY}·{12×class_code+digit}
+_KEY_PATTERN = re.compile(
+    r"VG:([A-Za-z0-9_-]+)-([A-Za-z0-9]+)"  # handle: NAME-SUFFIX
+    r":V([0-6])"                              # tier: V0-V6
+    r"-([A-Z]{4})"                            # primary class (4-letter)
+    r"·((?:[A-Z][a-z]\d){12})"               # 12 class scores
+)
+
+_SCORE_PATTERN = re.compile(r"([A-Z][a-z])(\d)")
+
+
+@dataclass
+class VGKey:
+    """Parsed Verigent key."""
+
+    raw: str
+    handle: str
+    suffix: str
+    tier: int
+    primary: str
+    scores: Dict[str, int] = field(default_factory=dict)
+
+    @property
+    def full_handle(self) -> str:
+        return f"{self.handle}-{self.suffix}"
+
+    @property
+    def primary_class(self) -> str:
+        return CLASS_CODES.get(self.primary[:2], self.primary)
+
+    def score(self, class_code: str) -> int:
+        """Get score for a class code (0-9). Returns 0 if not found."""
+        return self.scores.get(class_code, 0)
+
+    def score_normalised(self, class_code: str) -> float:
+        """Get score as 0.0-1.0 float."""
+        return self.score(class_code) / 9.0 if self.score(class_code) else 0.0
+
+
+def parse_key(text: str) -> Optional[VGKey]:
+    """Parse a single VG key from text. Returns None if no valid key found."""
+    m = _KEY_PATTERN.search(text)
+    if not m:
+        return None
+
+    name, suffix, tier_str, primary, scores_raw = m.groups()
+    scores: Dict[str, int] = {}
+    for sm in _SCORE_PATTERN.finditer(scores_raw):
+        code, digit = sm.groups()
+        if code in CLASS_CODES:
+            scores[code] = int(digit)
+
+    if len(scores) != 12:
+        return None
+
+    return VGKey(
+        raw=m.group(0),
+        handle=name,
+        suffix=suffix,
+        tier=int(tier_str),
+        primary=primary[:2],
+        scores=scores,
+    )
+
+
+def find_keys(text: str) -> List[VGKey]:
+    """Find all VG keys in a block of text."""
+    results = []
+    for m in _KEY_PATTERN.finditer(text):
+        key = parse_key(m.group(0))
+        if key:
+            results.append(key)
+    return results
+
+
+def extract_from_headers(headers: dict) -> Optional[VGKey]:
+    """Extract VG key from HTTP headers (X-Verigent)."""
+    value = headers.get("X-Verigent") or headers.get("x-verigent")
+    if value:
+        return parse_key(value)
+    return None
+
+
+def extract_from_metadata(metadata: dict) -> Optional[VGKey]:
+    """Extract VG key from JSON metadata (x-verigent field)."""
+    value = metadata.get("x-verigent") or metadata.get("X-Verigent")
+    if isinstance(value, str):
+        return parse_key(value)
+    return None

autogen_verigent-0.1.0/src/autogen_verigent/trust.py

@@ -0,0 +1,97 @@
+"""Trust evaluation logic for Verigent keys."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from .parser import VGKey, CLASS_CODES
+
+# Task-type to relevant class codes mapping
+TASK_CLASS_MAP: Dict[str, List[str]] = {
+    "code": ["Ar", "Fo", "An"],
+    "analysis": ["An", "Sa", "Sc"],
+    "communication": ["Co", "Br", "Ad"],
+    "security": ["Se", "St", "Sc"],
+    "research": ["Sc", "Sa", "An"],
+    "coordination": ["Co", "St", "So"],
+    "creative": ["Fo", "Ad", "Sa"],
+    "operations": ["Op", "St", "Se"],
+    "strategy": ["So", "Ar", "Sa"],
+    "execution": ["Op", "Fo", "Se"],
+}
+
+
+@dataclass
+class TrustScore:
+    """Computed trust score for an agent given a task context."""
+
+    agent_handle: str
+    tier_score: float  # 0.0-1.0 based on tier
+    relevance_score: float  # 0.0-1.0 based on class scores for task
+    composite: float  # weighted combination
+
+    @property
+    def weight(self) -> float:
+        """Speaker selection weight (higher = more likely to be chosen)."""
+        return self.composite
+
+
+def evaluate_trust(
+    key: VGKey,
+    task_type: Optional[str] = None,
+    tier_weight: float = 0.4,
+    relevance_weight: float = 0.6,
+) -> TrustScore:
+    """
+    Evaluate trust for an agent given their VG key and optional task context.
+
+    Args:
+        key: Parsed VG key
+        task_type: Optional task type from TASK_CLASS_MAP
+        tier_weight: Weight for tier in composite score (default 0.4)
+        relevance_weight: Weight for relevance in composite score (default 0.6)
+
+    Returns:
+        TrustScore with computed weights
+    """
+    # Tier score: V0=0, V1=0.17, V2=0.33, V3=0.5, V4=0.67, V5=0.83, V6=1.0
+    tier_score = key.tier / 6.0
+
+    # Relevance score: average of relevant class scores
+    if task_type and task_type in TASK_CLASS_MAP:
+        relevant_codes = TASK_CLASS_MAP[task_type]
+        relevant_scores = [key.score(c) for c in relevant_codes]
+        relevance_score = sum(relevant_scores) / (len(relevant_scores) * 9.0)
+    else:
+        # No task context — use average of all scores
+        all_scores = list(key.scores.values())
+        relevance_score = sum(all_scores) / (len(all_scores) * 9.0) if all_scores else 0.0
+
+    composite = (tier_weight * tier_score) + (relevance_weight * relevance_score)
+
+    return TrustScore(
+        agent_handle=key.full_handle,
+        tier_score=tier_score,
+        relevance_score=relevance_score,
+        composite=composite,
+    )
+
+
+def rank_agents(
+    keys: Dict[str, VGKey],
+    task_type: Optional[str] = None,
+) -> List[TrustScore]:
+    """
+    Rank multiple agents by trust score for a given task.
+
+    Args:
+        keys: Dict mapping agent name to their VG key
+        task_type: Optional task type for relevance scoring
+
+    Returns:
+        List of TrustScores sorted by composite (descending)
+    """
+    scores = [evaluate_trust(key, task_type) for key in keys.values()]
+    scores.sort(key=lambda s: s.composite, reverse=True)
+    return scores