agentrust-py 0.0.6__tar.gz → 0.0.8__tar.gz

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentrust-py
-Version: 0.0.6
+Version: 0.0.8
 Summary: AgentTrust Edge — Full Governance Platform. Policy Engine + MAD Classifier + HITL + Kill Switch.
 Project-URL: Homepage, https://agentrust.io
 Project-URL: Documentation, https://docs.agentrust.io
@@ -23,6 +23,10 @@ Requires-Python: >=3.10
 Requires-Dist: httpx<1.0.0,>=0.27.0
 Requires-Dist: pydantic<3.0.0,>=2.0.0
 Requires-Dist: pyyaml<7.0,>=6.0.3
+Provides-Extra: ag2
+Requires-Dist: ag2<1.0,>=0.9; extra == 'ag2'
+Provides-Extra: autogen
+Requires-Dist: autogen-agentchat<1.0,>=0.4; extra == 'autogen'
 Provides-Extra: autoload
 Provides-Extra: crewai
 Requires-Dist: crewai<2.0,>=1.0; extra == 'crewai'

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/agentrust_sdk/__init__.py

@@ -38,7 +38,14 @@ from .client import (
 from .config import SDK_CONFIG
 from .hooks import auto_instrument, auto_wrap
 from .adapters.mcp import mcp_tool_guard, MCPServerGuard
-from .adapters.autogen import AgentTrustReplyHook, AgentTrustGroupChatMonitor
+from .adapters.autogen import (
+    AgentTrustGroupChatMonitor,
+    AgentTrustReplyHook,
+    governed_function,
+    governed_functions,
+    governed_tool as governed_autogen_tool,
+    governed_tools as governed_autogen_tools,
+)
 from .adapters.claude_agents import ClaudeAgentGuard
 from .adapters.openai_agents import agent_guard as openai_agent_guard, OpenAIAgentsGuard, SwarmGuard
 from .adapters.crewai import AgentTrustCallback
@@ -87,6 +94,8 @@ from .webhooks import (
 __all__ = [
     # Primary API
     "harness",
+    "governed_function",
+    "governed_functions",
     # Embedded gateway (zero-dep plug-and-play)
     "embed_gateway",
     "EmbeddedGateway",
@@ -147,4 +156,4 @@ __all__ = [
     "validate",
 ]
 
-__version__ = "0.0.6"
+__version__ = "0.0.8"

agentrust_py-0.0.8/agentrust_sdk/adapters/autogen.py

@@ -0,0 +1,457 @@
+"""
+AutoGen adapter — AgentTrust governance for Microsoft AutoGen agents.
+
+Architecture doc (two-pager): "Connects to … AutoGen agents."
+
+Supports both AutoGen v0.2 (pyautogen) and AutoGen v0.4 (autogen-agentchat):
+
+Pattern 0 — governed_function (AG2 / pyautogen 0.2 tools):
+  Wrap each tool before register_function so every call is pre-checked,
+  held for approval when needed, run, post-checked and audited. A refusal
+  is returned as the tool result, so the chat keeps going.
+
+Pattern 0b — governed_tool (AutoGen 0.4+ / autogen-agentchat tools):
+  Wrap each FunctionTool (or plain function) before giving it to an
+  AssistantAgent. Same checks as governed_function.
+
+Pattern 1 — AgentTrustReplyHook (v0.2 + v0.4):
+  Attach to any ConversableAgent / AssistantAgent to validate every reply
+  before it is sent.
+
+Pattern 2 — AgentTrustGroupChatMonitor (v0.2 GroupChat):
+  Wraps a GroupChat's speaker-selection to validate messages between agents.
+
+Usage::
+
+    from autogen import AssistantAgent
+    from agentrust_sdk.adapters.autogen import AgentTrustReplyHook
+
+    hook = AgentTrustReplyHook(agent_id="research-team")
+    assistant = AssistantAgent("researcher", llm_config={...})
+    hook.attach(assistant)
+
+Requires Team tier.
+"""
+from __future__ import annotations
+
+import functools
+import inspect
+import logging
+import time
+from typing import Any, Callable, Sequence
+
+from ..tiers import Capability
+from ._core import Allowed, Governor, OnBlock, Refused, check_adapter_tier
+
+logger = logging.getLogger(__name__)
+
+_FRAMEWORK = "ag2"
+_FRAMEWORK_V04 = "autogen"
+
+
+def governed_function(
+    fn: Callable[..., Any],
+    *,
+    agent_id: str,
+    name: str | None = None,
+    on_block: OnBlock = "refuse",
+    review_timeout_s: float = 300.0,
+    user: str = "ag2",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> Callable[..., Any]:
+    """Wrap an AG2 tool function so AgentTrust governs every call.
+
+    The result keeps the name, docstring and signature of *fn*, so AG2 builds
+    the same tool schema from it. Pass it to ``register_function`` or
+    ``register_for_llm``. Async functions stay async.
+    """
+    check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+    gov = governor or Governor(
+        agent_id,
+        framework=_FRAMEWORK,
+        on_block=on_block,
+        review_timeout_s=review_timeout_s,
+        user=user,
+        base_url=base_url,
+        api_key=api_key,
+    )
+    tool_name = name or fn.__name__
+    signature = inspect.signature(fn)
+
+    def call_args(args: tuple, kwargs: dict) -> dict[str, Any]:
+        bound = signature.bind(*args, **kwargs)
+        bound.apply_defaults()
+        return dict(bound.arguments)
+
+    def unwrap(outcome: Allowed | Refused) -> Any:
+        # The refusal text is the tool result the agent reads next.
+        return outcome.message if isinstance(outcome, Refused) else outcome.result
+
+    if inspect.iscoroutinefunction(fn):
+
+        @functools.wraps(fn)
+        async def governed(*args: Any, **kwargs: Any) -> Any:
+            params = call_args(args, kwargs)
+            outcome = await gov.aguard_tool(
+                tool_name, params, lambda: fn(*args, **kwargs), input=_describe_call(tool_name, params),
+            )
+            return unwrap(outcome)
+
+    else:
+
+        @functools.wraps(fn)
+        def governed(*args: Any, **kwargs: Any) -> Any:
+            params = call_args(args, kwargs)
+            outcome = gov.guard_tool(
+                tool_name, params, lambda: fn(*args, **kwargs), input=_describe_call(tool_name, params),
+            )
+            return unwrap(outcome)
+
+    return governed
+
+
+def governed_functions(
+    fns: Sequence[Callable[..., Any]],
+    *,
+    agent_id: str,
+    on_block: OnBlock = "refuse",
+    review_timeout_s: float = 300.0,
+    user: str = "ag2",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> list[Callable[..., Any]]:
+    """Wrap each function with :func:`governed_function`, sharing one Governor."""
+    check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+    gov = governor or Governor(
+        agent_id,
+        framework=_FRAMEWORK,
+        on_block=on_block,
+        review_timeout_s=review_timeout_s,
+        user=user,
+        base_url=base_url,
+        api_key=api_key,
+    )
+    return [governed_function(fn, agent_id=agent_id, governor=gov) for fn in fns]
+
+
+def _governor(
+    agent_id: str, framework: str, on_block: OnBlock, review_timeout_s: float,
+    user: str, base_url: str | None, api_key: str | None,
+) -> Governor:
+    return Governor(
+        agent_id, framework=framework, on_block=on_block, review_timeout_s=review_timeout_s,
+        user=user, base_url=base_url, api_key=api_key,
+    )
+
+
+def governed_tool(
+    tool: Any,
+    *,
+    agent_id: str,
+    on_block: OnBlock = "refuse",
+    review_timeout_s: float = 300.0,
+    user: str = "autogen",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> Any:
+    """Wrap an AutoGen 0.4+ tool so AgentTrust governs every call.
+
+    Accepts a ``BaseTool`` such as ``FunctionTool``, or a plain function (its
+    docstring becomes the description). The result has the same name,
+    description and argument schema, so the model sees the same tool. Pass it
+    in ``AssistantAgent(tools=[...])``. A refused call reaches the agent as the
+    tool result.
+    """
+    check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+    gov = governor or _governor(
+        agent_id, _FRAMEWORK_V04, on_block, review_timeout_s, user, base_url, api_key,
+    )
+    return _governed_tool_class().wrap(_as_tool(tool), gov)
+
+
+def governed_tools(
+    tools: Sequence[Any],
+    *,
+    agent_id: str,
+    on_block: OnBlock = "refuse",
+    review_timeout_s: float = 300.0,
+    user: str = "autogen",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> list[Any]:
+    """Wrap each AutoGen 0.4+ tool with :func:`governed_tool`, sharing one Governor."""
+    check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+    gov = governor or _governor(
+        agent_id, _FRAMEWORK_V04, on_block, review_timeout_s, user, base_url, api_key,
+    )
+    return [governed_tool(t, agent_id=agent_id, governor=gov) for t in tools]
+
+
+def _as_tool(tool: Any) -> Any:
+    from autogen_core.tools import BaseTool, FunctionTool
+
+    if isinstance(tool, BaseTool):
+        return tool
+    return FunctionTool(tool, description=inspect.getdoc(tool) or tool.__name__)
+
+
+@functools.lru_cache(maxsize=None)
+def _governed_tool_class() -> type:
+    """Build GovernedTool on first use, so autogen-core stays optional."""
+    from autogen_core import CancellationToken
+    from autogen_core.tools import BaseTool
+
+    class GovernedTool(BaseTool):
+        """A tool whose every call goes through an AgentTrust Governor."""
+
+        def __init__(self, inner: Any, governor: Governor) -> None:
+            super().__init__(
+                inner.args_type(), inner.return_type(), inner.name, inner.description,
+                strict=getattr(inner, "_strict", False),
+            )
+            self._inner = inner
+            self._governor = governor
+
+        @classmethod
+        def wrap(cls, inner: Any, governor: Governor) -> "GovernedTool":
+            return cls(inner, governor)
+
+        async def run(self, args: Any, cancellation_token: CancellationToken) -> Any:
+            params = args.model_dump()
+            outcome = await self._governor.aguard_tool(
+                self.name, params, lambda: self._inner.run(args, cancellation_token),
+                input=_describe_call(self.name, params),
+            )
+            # The refusal text is the tool result the agent reads next.
+            return outcome.message if isinstance(outcome, Refused) else outcome.result
+
+    return GovernedTool
+
+
+def _describe_call(name: str, args: dict[str, Any]) -> str:
+    """The proposed call as the pre-check's request input."""
+    return f"tool call {name}({', '.join(f'{k}={v!r}' for k, v in args.items())})"
+
+
+def _validate_sync(
+    agent_id: str,
+    base_url: str,
+    api_key: str | None,
+    user: str,
+    input_text: str,
+    output: dict,
+    framework: str,
+    block_on_block: bool,
+) -> None:
+    from agentrust_sdk.client import AgentTrustClient, GatewayUnavailableError
+    from agentrust_sdk.config import SDK_CONFIG
+    from agentrust_sdk.decorator import _check_decision, BlockedError
+
+    try:
+        with AgentTrustClient(base_url=base_url, api_key=api_key) as client:
+            resp = client.validate(
+                agent_id=agent_id,
+                user=user,
+                input=input_text,
+                output=output,
+                framework=framework,
+            )
+        _check_decision(resp, block_on_block, False)
+    except (BlockedError, GatewayUnavailableError):
+        raise
+    except Exception as exc:
+        if SDK_CONFIG.failure_mode == "closed":
+            raise
+        logger.warning("[AgentTrust] AutoGen validate failed (non-fatal): %s", exc)
+
+
+async def _avalidate(
+    agent_id: str,
+    base_url: str,
+    api_key: str | None,
+    user: str,
+    input_text: str,
+    output: dict,
+    framework: str,
+    block_on_block: bool,
+) -> None:
+    """Async counterpart of :func:`_validate_sync`, safe to await in an event loop."""
+    from agentrust_sdk.client import AsyncAgentTrustClient, GatewayUnavailableError
+    from agentrust_sdk.config import SDK_CONFIG
+    from agentrust_sdk.decorator import _check_decision, BlockedError
+
+    try:
+        async with AsyncAgentTrustClient(base_url=base_url, api_key=api_key) as client:
+            resp = await client.validate(
+                agent_id=agent_id,
+                user=user,
+                input=input_text,
+                output=output,
+                framework=framework,
+            )
+        _check_decision(resp, block_on_block, False)
+    except (BlockedError, GatewayUnavailableError):
+        raise
+    except Exception as exc:
+        if SDK_CONFIG.failure_mode == "closed":
+            raise
+        logger.warning("[AgentTrust] AutoGen validate failed (non-fatal): %s", exc)
+
+
+class AgentTrustReplyHook:
+    """
+    Reply hook that validates every AutoGen agent reply via AgentTrust.
+
+    Compatible with AutoGen v0.2 (pyautogen) reply_func mechanism and
+    AutoGen v0.4 (autogen-agentchat) message hook pattern.
+
+    Usage (v0.2)::
+
+        hook = AgentTrustReplyHook(agent_id="my-autogen")
+        assistant = AssistantAgent("researcher", llm_config={...})
+        hook.attach(assistant)
+
+    Usage (v0.4)::
+
+        hook = AgentTrustReplyHook(agent_id="my-autogen")
+        agent = AssistantAgent("researcher", model_client=..., tools=[...])
+        hook.attach_v4(agent)
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        *,
+        base_url: str = "http://localhost:8000",
+        api_key: str | None = None,
+        user: str = "autogen",
+        block_on_block: bool = True,
+        framework: str = "AutoGen",
+    ) -> None:
+        check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+        self._agent_id = agent_id
+        self._base_url = base_url
+        self._api_key = api_key
+        self._user = user
+        self._block_on_block = block_on_block
+        self._framework = framework
+
+    # ------------------------------------------------------------------
+    # AutoGen v0.2
+    # ------------------------------------------------------------------
+
+    def _check_outgoing(
+        self, sender: Any = None, message: Any = None, recipient: Any = None, silent: bool = False,
+    ) -> Any:
+        """AG2 ``process_message_before_send`` hook: check the agent's own reply."""
+        content = message.get("content") if isinstance(message, dict) else message
+        if not isinstance(content, str) or not content:
+            return message
+
+        t0 = time.perf_counter()
+        _validate_sync(
+            self._agent_id, self._base_url, self._api_key, self._user,
+            content[:500], {"content": content[:4000], "role": "assistant"},
+            self._framework, self._block_on_block,
+        )
+        logger.debug(
+            "[AgentTrust] AutoGen reply validated in %.1f ms", (time.perf_counter() - t0) * 1000
+        )
+        return message
+
+    def attach(self, agent: Any) -> None:
+        """Attach to an AG2 / AutoGen v0.2 ConversableAgent.
+
+        Checks every message the agent sends, before it leaves the agent.
+        """
+        if not hasattr(agent, "register_hook"):
+            raise TypeError(
+                f"Expected a ConversableAgent with register_hook(), got {type(agent).__name__}"
+            )
+        agent.register_hook("process_message_before_send", self._check_outgoing)
+        logger.info(
+            "[AgentTrust] AutoGen reply hook attached to agent '%s'", getattr(agent, "name", "?")
+        )
+
+    # ------------------------------------------------------------------
+    # AutoGen v0.4
+    # ------------------------------------------------------------------
+
+    def attach_v4(self, agent: Any) -> None:
+        """Attach to an AutoGen v0.4 BaseChatAgent via on_messages hook."""
+        original_on_messages = agent.on_messages
+
+        async def _wrapped_on_messages(messages: Any, cancellation_token: Any = None) -> Any:
+            result = await original_on_messages(messages, cancellation_token)
+            # result is a Response object with a .chat_message attribute
+            content = ""
+            if hasattr(result, "chat_message") and result.chat_message:
+                content = getattr(result.chat_message, "content", "") or ""
+            output = {"content": content[:4000]}
+            await _avalidate(
+                self._agent_id, self._base_url, self._api_key,
+                self._user, content[:500], output, self._framework, self._block_on_block,
+            )
+            return result
+
+        agent.on_messages = _wrapped_on_messages
+        logger.info(
+            "[AgentTrust] AutoGen v0.4 hook attached to agent '%s'",
+            getattr(agent, "name", "?"),
+        )
+
+
+class AgentTrustGroupChatMonitor:
+    """
+    Monitors AutoGen GroupChat messages and validates each speaker's reply.
+
+    Usage::
+
+        from autogen import GroupChat, GroupChatManager
+        from agentrust_sdk.adapters.autogen import AgentTrustGroupChatMonitor
+
+        monitor = AgentTrustGroupChatMonitor(agent_id="planning-crew")
+        groupchat = GroupChat(agents=[...], messages=[])
+        manager = GroupChatManager(groupchat=groupchat)
+        monitor.attach(groupchat)
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        *,
+        base_url: str = "http://localhost:8000",
+        api_key: str | None = None,
+        user: str = "autogen-group",
+        block_on_block: bool = False,  # Default False — group chats tolerate review
+        framework: str = "AutoGen",
+    ) -> None:
+        check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
+        self._agent_id = agent_id
+        self._base_url = base_url
+        self._api_key = api_key
+        self._user = user
+        self._block_on_block = block_on_block
+        self._framework = framework
+
+    def attach(self, groupchat: Any) -> None:
+        """Patch groupchat.append to intercept every new message."""
+        original_append = groupchat.append
+
+        def _governed_append(message: dict, speaker: Any) -> None:
+            content = message.get("content", "") or ""
+            _validate_sync(
+                self._agent_id, self._base_url, self._api_key,
+                self._user, content[:500],
+                {"content": content[:4000], "speaker": getattr(speaker, "name", str(speaker))},
+                self._framework, self._block_on_block,
+            )
+            original_append(message, speaker)
+
+        groupchat.append = _governed_append
+        logger.info("[AgentTrust] AutoGen GroupChatMonitor attached")

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/agentrust_sdk/config.py

@@ -47,7 +47,7 @@ from pathlib import Path
 logger = logging.getLogger(__name__)
 
 _VALID_FAILURE_MODES = frozenset({"open", "closed", "queue"})
-_SDK_VERSION = "0.0.6"
+_SDK_VERSION = "0.0.8"
 _MIN_GATEWAY_VERSION = "0.0.1a1"
 
 

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/agentrust_sdk/decorator.py

@@ -329,6 +329,17 @@ def _check_decision(resp: Any, block_on_block: bool, block_on_review: bool) -> N
         raise BlockedError(outcome, resp.decision.reason, resp.envelope_id)
 
 
+def _ag2_installed() -> bool:
+    """AG2 installs the ``autogen`` module under the distribution name ``ag2``."""
+    from importlib.metadata import PackageNotFoundError, version
+
+    try:
+        version("ag2")
+    except PackageNotFoundError:
+        return False
+    return True
+
+
 def _detect_framework() -> str:
     """Best-effort framework detection from installed packages."""
     try:
@@ -341,7 +352,7 @@ def _detect_framework() -> str:
             ("llama_index", "LlamaIndex"),
         ]:
             if importlib.util.find_spec(name):
-                return label
+                return "AG2" if name == "autogen" and _ag2_installed() else label
     except Exception:
         pass
     return "REST"

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/agentrust_sdk/manifest.py

@@ -50,7 +50,7 @@ class CertifyManifest(BaseModel):
     display_name: str = ""
     framework: str = Field(
         default="rest",
-        pattern=r"^(langchain|langgraph|crewai|autogen|openai-agents|mcp|rest)$",
+        pattern=r"^(langchain|langgraph|crewai|autogen|ag2|openai-agents|mcp|rest)$",
     )
     language: str = Field(default="python", pattern=r"^(python|typescript|rest)$")
     model: ModelDeclaration = Field(default_factory=ModelDeclaration)

{agentrust_py-0.0.6 → agentrust_py-0.0.8}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentrust-py"
-version = "0.0.6"
+version = "0.0.8"
 description = "AgentTrust Edge — Full Governance Platform. Policy Engine + MAD Classifier + HITL + Kill Switch."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -41,6 +41,10 @@ llm = [
 # Framework adapters (optional, tier-gated)
 langgraph = ["langgraph>=0.2.0,<2.0.0"]
 crewai    = ["crewai>=1.0,<2.0"]
+# AG2 0.x keeps the ConversableAgent API (module `autogen`); 1.x is a new API
+ag2       = ["ag2>=0.9,<1.0"]
+# Microsoft AutoGen 0.4+ (module autogen_agentchat)
+autogen   = ["autogen-agentchat>=0.4,<1.0"]
 openai    = ["openai>=2.41.1,<3.0.0"]
 langchain = ["langchain>=0.2.0,<1.0.0"]
 # Retry/backoff (recommended for production)

agentrust_py-0.0.8/tests/adapters/_ag2.py

@@ -0,0 +1,57 @@
+"""A scripted chat model for real AG2 agents, shared by the AG2 binding tests."""
+from __future__ import annotations
+
+import json
+from types import SimpleNamespace as NS
+from typing import Any
+
+
+def tool_call(name: str, args: dict[str, Any]) -> tuple[str, dict[str, Any]]:
+    """The reply in which the agent calls a tool."""
+    return name, args
+
+
+def final(text: str = "done DONE") -> str:
+    return text
+
+
+class ScriptedModel:
+    """Stands in for ``OpenAIWrapper.create``: replays *replies* in order."""
+
+    def __init__(self, *replies):
+        self.replies = list(replies)
+        self.prompts: list[str] = []
+
+    def create(self, wrapper, **params):
+        self.prompts.append(json.dumps(params.get("messages", []), default=str))
+        reply = self.replies.pop(0)
+        if isinstance(reply, str):
+            message = {"role": "assistant", "content": reply}
+            msg = NS(content=reply, tool_calls=None, function_call=None, role="assistant")
+        else:
+            name, args = reply
+            call = {"id": "call-1", "type": "function",
+                    "function": {"name": name, "arguments": json.dumps(args)}}
+            message = {"role": "assistant", "content": None, "tool_calls": [call]}
+            msg = NS(content=None, tool_calls=[call], function_call=None, role="assistant")
+        msg.model_dump = lambda: message
+        return NS(
+            choices=[NS(message=msg, finish_reason="stop")], model="scripted", cost=0, id="r",
+            usage=NS(prompt_tokens=0, completion_tokens=0, total_tokens=0),
+        )
+
+    @staticmethod
+    def extract(response):
+        msg = response.choices[0].message
+        return [msg.model_dump()] if msg.tool_calls else [msg.content]
+
+
+def install(monkeypatch, *replies) -> ScriptedModel:
+    from autogen.oai.client import OpenAIWrapper
+
+    model = ScriptedModel(*replies)
+    monkeypatch.setattr(OpenAIWrapper, "create", lambda self, **kw: model.create(self, **kw))
+    monkeypatch.setattr(
+        OpenAIWrapper, "extract_text_or_completion_object", classmethod(lambda cls, r: model.extract(r)),
+    )
+    return model