agentrust-py 0.0.5__tar.gz → 0.0.7__tar.gz

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/CHANGELOG.md

@@ -7,6 +7,22 @@ Versioning: [Semantic Versioning](https://semver.org/spec/v2.0.0.html)
 
 ---
 
+## [0.0.6] - 2026-10-26
+
+### Added
+- **CrewAI tool calls are checked before they run.** `governed_tools(tools, agent_id=...)` (`agentrust_sdk.adapters.crewai`) wraps the tools given to a CrewAI `Agent`: each call is pre-checked (tool trust, kill switch, trust chain), held for a person when the decision is `escalate`, then post-checked. A refused call reaches the agent as the tool's result (`Blocked by AgentTrust: ...`), so the crew finishes. Proven against real CrewAI by the same C1–C10 conformance suite as LangGraph.
+- `guardrail(agent_id=...)` for `Task(guardrail=...)`: a blocked task output returns `(False, "Blocked by AgentTrust: ...")`, so CrewAI asks the agent for a new answer instead of ending the crew.
+- `examples/crewai_quickstart.py`, the calculator crew governed by AgentTrust.
+
+### Changed
+- **`agentrust-py[crewai]` now needs CrewAI 1.x** (`crewai>=1.0,<2.0`). CrewAI 0.x is no longer supported.
+- **`AgentTrustCallback`:** the gateway URL defaults to `AGENTRUST_GATEWAY_URL` instead of a hardcoded `http://localhost:8000`; with `AGENTRUST_FAILURE_MODE=closed` an unreachable gateway now raises `GatewayUnavailableError` instead of passing the output through. Its constructor arguments and its behaviour in open mode are unchanged.
+
+### Fixed
+- **Console agent keys (`at_live_...`) were refused by the SDK's client-side tier check** with `<framework> adapter requires Team tier`, a paying Team customer's included, so a connection needed `AGENTRUST_ENV=development`. Only a JWT key states its tier, so only a JWT key is checked on the client; for any other key the gateway, which knows the owner's plan, decides. Affects `governed_tools` for LangGraph and the CrewAI adapter.
+
+---
+
 ## [0.0.5] - 2026-10-26
 
 ### Added

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: agentrust-py
-Version: 0.0.5
+Version: 0.0.7
 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,10 +23,13 @@ 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: autoload
 Provides-Extra: crewai
-Requires-Dist: crewai<1.0.0,>=0.80.0; extra == 'crewai'
+Requires-Dist: crewai<2.0,>=1.0; extra == 'crewai'
 Provides-Extra: dev
+Requires-Dist: crewai<2.0,>=1.0; extra == 'dev'
 Requires-Dist: fastapi>=0.137.1; extra == 'dev'
 Requires-Dist: httpx<1.0.0,>=0.27.0; extra == 'dev'
 Requires-Dist: langgraph<2.0.0,>=0.2.0; extra == 'dev'

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/agentrust_sdk/__init__.py

@@ -38,7 +38,12 @@ 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,
+)
 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 +92,8 @@ from .webhooks import (
 __all__ = [
     # Primary API
     "harness",
+    "governed_function",
+    "governed_functions",
     # Embedded gateway (zero-dep plug-and-play)
     "embed_gateway",
     "EmbeddedGateway",
@@ -147,4 +154,4 @@ __all__ = [
     "validate",
 ]
 
-__version__ = "0.0.5"
+__version__ = "0.0.7"

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/agentrust_sdk/adapters/_core.py

@@ -28,7 +28,7 @@ import logging
 import os
 import time
 from contextvars import ContextVar
-from dataclasses import dataclass
+from dataclasses import dataclass, replace
 from typing import Any, Awaitable, Callable, Literal
 
 from .. import client as _client
@@ -71,6 +71,8 @@ class Refused:
     envelope_id: str | None = None
     reason_code: str | None = None
     outcome: str = "block"
+    # The gateway answer behind a refused output check, when there is one.
+    response: ValidateResponse | None = None
 
 
 def _real_envelope(envelope_id: str | None) -> str | None:
@@ -80,12 +82,14 @@ def _real_envelope(envelope_id: str | None) -> str | None:
 def check_adapter_tier(capability: Capability, api_key: str | None = None) -> None:
     """Raise RuntimeError when *api_key*'s tier does not include *capability*.
 
-    Skipped in development/demo/test environments, without a key, and for
-    keys that are not AgentTrust ``at_`` keys (e.g. an embedded gateway token).
+    Only a JWT key states its tier, so only a JWT key is checked here. An
+    opaque key, such as a console agent key (``at_live_...``), carries no
+    tier: the gateway knows the owner's plan and decides. Also skipped in
+    development/demo/test environments and without a key.
     """
     env = os.environ.get("AGENTRUST_ENV", "production").lower()
     key = api_key or SDK_CONFIG.api_key
-    if env in ("development", "dev", "demo", "test") or not key or not key.startswith("at_"):
+    if env in ("development", "dev", "demo", "test") or not key or key.count(".") != 2:
         return
     from ..auth import resolve_key
 
@@ -281,10 +285,10 @@ class Governor:
 
     def _output_verdict(self, resp: ValidateResponse) -> Allowed | Refused:
         if resp.decision.outcome == "block":
-            return self._refused(
+            return replace(self._refused(
                 resp.decision.reason, _real_envelope(resp.envelope_id), resp.decision.reason_code,
                 outcome="block", raise_blocked=False,
-            )
+            ), response=resp)
         return Allowed(resp, _real_envelope(resp.envelope_id))
 
     def _hold(self, client: Any, pre: ValidateResponse) -> Refused | None:

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/agentrust_sdk/adapters/autogen.py

@@ -5,6 +5,11 @@ 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 1 — AgentTrustReplyHook (v0.2 + v0.4):
   Attach to any ConversableAgent / AssistantAgent to validate every reply
   before it is sent.
@@ -25,19 +30,111 @@ Requires Team tier.
 """
 from __future__ import annotations
 
+import functools
+import inspect
 import logging
 import time
-from typing import Any, Callable
+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"
+
+
+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:
 
-def _check_tier(api_key: str | None = None) -> None:
-    from agentrust_sdk.auth import resolve_key
-    from agentrust_sdk.tiers import Capability, is_allowed
-    info = resolve_key(api_key)
-    if not is_allowed(Capability.CREWAI_ADAPTER, info.tier):
-        raise RuntimeError("[AgentTrust] AutoGen adapter requires Team tier or higher.")
+        @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 _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(
@@ -50,7 +147,8 @@ def _validate_sync(
     framework: str,
     block_on_block: bool,
 ) -> None:
-    from agentrust_sdk.client import AgentTrustClient
+    from agentrust_sdk.client import AgentTrustClient, GatewayUnavailableError
+    from agentrust_sdk.config import SDK_CONFIG
     from agentrust_sdk.decorator import _check_decision, BlockedError
 
     try:
@@ -63,9 +161,11 @@ def _validate_sync(
                 framework=framework,
             )
         _check_decision(resp, block_on_block, False)
-    except BlockedError:
+    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)
 
 
@@ -99,7 +199,7 @@ class AgentTrustReplyHook:
         block_on_block: bool = True,
         framework: str = "AutoGen",
     ) -> None:
-        _check_tier(api_key)
+        check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
         self._agent_id = agent_id
         self._base_url = base_url
         self._api_key = api_key
@@ -111,47 +211,35 @@ class AgentTrustReplyHook:
     # AutoGen v0.2
     # ------------------------------------------------------------------
 
-    def _reply_func(
-        self,
-        recipient: Any,
-        messages: list[dict] | None = None,
-        sender: Any = None,
-        config: Any = None,
-    ) -> tuple[bool, str | None]:
-        """AutoGen v0.2 reply function — registered via register_reply()."""
-        if not messages:
-            return False, None
-
-        last = messages[-1]
-        content = last.get("content", "") or ""
-        role = last.get("role", "assistant")
-
-        if role not in ("assistant", "user"):
-            return False, None
+    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()
-        output = {"content": content[:4000], "role": role}
         _validate_sync(
-            self._agent_id, self._base_url, self._api_key,
-            self._user, content[:500], output, self._framework, self._block_on_block,
+            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 False, None  # False = don't override reply; None = no replacement content
+        return message
 
     def attach(self, agent: Any) -> None:
-        """Attach to an AutoGen v0.2 ConversableAgent / AssistantAgent."""
-        if not hasattr(agent, "register_reply"):
+        """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_reply(), got {type(agent).__name__}"
+                f"Expected a ConversableAgent with register_hook(), got {type(agent).__name__}"
             )
-        agent.register_reply(
-            trigger=[],
-            reply_func=self._reply_func,
-            position=0,
-            name="agentrust_reply_hook",
-        )
+        agent.register_hook("process_message_before_send", self._check_outgoing)
         logger.info(
             "[AgentTrust] AutoGen reply hook attached to agent '%s'", getattr(agent, "name", "?")
         )
@@ -209,7 +297,7 @@ class AgentTrustGroupChatMonitor:
         block_on_block: bool = False,  # Default False — group chats tolerate review
         framework: str = "AutoGen",
     ) -> None:
-        _check_tier(api_key)
+        check_adapter_tier(Capability.AUTOGEN_ADAPTER, api_key)
         self._agent_id = agent_id
         self._base_url = base_url
         self._api_key = api_key

agentrust_py-0.0.7/agentrust_sdk/adapters/crewai.py

@@ -0,0 +1,237 @@
+"""
+CrewAI adapter.
+
+- ``governed_tools(tools, agent_id=...)`` wraps each tool so every call is
+  pre-checked before it runs (tool trust, kill switch, review holds,
+  fail-closed) and its result post-checked. A refused call reaches the agent
+  as the tool's result text, so the crew keeps running.
+- ``AgentTrustCallback`` validates a task's output after the task finished.
+
+Requires Team tier. Gated at construction time.
+"""
+from __future__ import annotations
+
+import asyncio
+import inspect
+import logging
+from functools import lru_cache
+from typing import Any, Callable, Sequence
+
+from ._core import Allowed, Governor, OnBlock, Refused, check_adapter_tier
+from ..client import GatewayUnavailableError
+from ..tiers import Capability
+
+logger = logging.getLogger(__name__)
+
+_FRAMEWORK = "CrewAI"
+
+
+def governed_tools(
+    tools: Sequence[Any],
+    *,
+    agent_id: str,
+    on_block: OnBlock = "refuse",
+    review_timeout_s: float = 300.0,
+    user: str = "crewai",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> list[Any]:
+    """Wrap CrewAI tools so AgentTrust governs every call.
+
+    Accepts ``BaseTool`` instances (subclasses and the ``@tool`` decorator)
+    and plain functions with a docstring. Each wrapped tool keeps its name,
+    description and argument schema, so the agent sees the same definition as
+    before. Pass the result as the ``Agent``'s ``tools=``.
+    """
+    check_adapter_tier(Capability.CREWAI_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,
+    )
+    from crewai.tools import BaseTool, tool as as_tool
+
+    wrapper = _governed_tool_class()
+    return [
+        wrapper.wrap(t if isinstance(t, BaseTool) else as_tool(t), gov)
+        for t in tools
+    ]
+
+
+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 _never_cache(*_: Any, **__: Any) -> bool:
+    # A cached call skips ``_run``, so it would skip the pre-check too.
+    return False
+
+
+def _runs_async(tool: Any) -> bool:
+    """True when the tool has a real ``_arun`` rather than the base stub."""
+    func = getattr(tool, "func", None)
+    if func is not None:
+        return inspect.iscoroutinefunction(func)
+    from crewai.tools import BaseTool
+
+    return type(tool)._arun is not BaseTool._arun
+
+
+@lru_cache(maxsize=None)
+def _governed_tool_class() -> type:
+    """Build GovernedTool on first use, so crewai stays optional."""
+    from crewai.tools import BaseTool
+
+    class GovernedTool(BaseTool):
+        """A tool whose every call goes through an AgentTrust Governor."""
+
+        inner: Any
+        governor: Any
+
+        @classmethod
+        def wrap(cls, inner: BaseTool, governor: Governor) -> "GovernedTool":
+            return cls(
+                name=inner.name,
+                description=inner.description,
+                args_schema=inner.args_schema,
+                result_as_answer=inner.result_as_answer,
+                cache_function=_never_cache,
+                inner=inner,
+                governor=governor,
+            )
+
+        def _run(self, *args: Any, **kwargs: Any) -> Any:
+            outcome = self.governor.guard_tool(
+                self.name, kwargs,
+                lambda: self.inner.run(**kwargs),
+                input=_describe_call(self.name, kwargs),
+            )
+            return self._unwrap(outcome)
+
+        async def _arun(self, *args: Any, **kwargs: Any) -> Any:
+            async def call() -> Any:
+                if _runs_async(self.inner):
+                    return await self.inner.arun(**kwargs)
+                return await asyncio.to_thread(lambda: self.inner.run(**kwargs))
+
+            outcome = await self.governor.aguard_tool(
+                self.name, kwargs, call, input=_describe_call(self.name, kwargs),
+            )
+            return self._unwrap(outcome)
+
+        @staticmethod
+        def _unwrap(outcome: Allowed | Refused) -> Any:
+            # The refusal text is the observation the agent reads next.
+            return outcome.message if isinstance(outcome, Refused) else outcome.result
+
+    return GovernedTool
+
+
+def _task_payload(output: Any) -> dict[str, Any]:
+    """A task's output as the dict /validate expects."""
+    raw = getattr(output, "raw", output)
+    return raw if isinstance(raw, dict) else {"result": str(raw)}
+
+
+def guardrail(
+    *,
+    agent_id: str,
+    user: str = "crewai",
+    base_url: str | None = None,
+    api_key: str | None = None,
+    governor: Governor | None = None,
+) -> Callable[[Any], tuple[bool, Any]]:
+    """A ``Task(guardrail=...)`` that checks the task's output with AgentTrust.
+
+    Approved output passes through. A blocked output returns
+    ``(False, "Blocked by AgentTrust: ...")``, so CrewAI hands the refusal to
+    the agent and asks it to try again. In closed mode a gateway outage raises
+    ``GatewayUnavailableError``.
+    """
+    check_adapter_tier(Capability.CREWAI_ADAPTER, api_key)
+    gov = governor or Governor(
+        agent_id, framework=_FRAMEWORK, user=user, base_url=base_url, api_key=api_key,
+    )
+
+    # No return annotation: CrewAI checks it at runtime and rejects the string
+    # form that ``from __future__ import annotations`` produces.
+    def check(output):
+        verdict = gov.check_output(input="crewai-task", output=_task_payload(output))
+        if isinstance(verdict, Refused):
+            return False, verdict.message
+        return True, output
+
+    return check
+
+
+class AgentTrustCallback:
+    """
+    CrewAI task callback that validates output via AgentTrust.
+
+    Requires Team tier ($149/mo). Prefer ``guardrail()`` when a blocked output
+    should send the agent back to try again rather than raise.
+
+    Usage::
+
+        from crewai import Task
+        from agentrust_sdk.adapters.crewai import AgentTrustCallback
+
+        cb = AgentTrustCallback(agent_id="research-crew")
+        task = Task(description="...", callback=cb.on_task_complete)
+    """
+
+    def __init__(
+        self,
+        agent_id: str,
+        *,
+        base_url: str | None = None,
+        api_key: str | None = None,
+        user: str = "crewai",
+        block_on_block: bool = True,
+        block_on_review: bool = False,
+        framework: str = _FRAMEWORK,
+        governor: Governor | None = None,
+    ) -> None:
+        check_adapter_tier(Capability.CREWAI_ADAPTER, api_key)
+        self._agent_id = agent_id
+        self._block_on_block = block_on_block
+        self._block_on_review = block_on_review
+        self._governor = governor or Governor(
+            agent_id, framework=framework, user=user, base_url=base_url, api_key=api_key,
+        )
+        self._last_result: Any = None
+
+    def on_task_complete(self, output: Any) -> Any:
+        from agentrust_sdk.decorator import _check_decision
+
+        try:
+            verdict = self._governor.check_output(input="crewai-task", output=_task_payload(output))
+        except GatewayUnavailableError:
+            raise  # closed mode: the caller must stop
+        except Exception as exc:  # kept from before: an unexpected client error is not fatal
+            logger.warning("[AgentTrust] CrewAI callback failed (non-fatal): %s", exc)
+            return output
+        resp = verdict.response if isinstance(verdict, Refused) else verdict.result
+        self._last_result = resp
+        _check_decision(resp, self._block_on_block, self._block_on_review)
+        return output
+
+    def task_callback(self, fn: Callable) -> Callable:
+        import functools
+
+        @functools.wraps(fn)
+        def wrapper(output: Any) -> Any:
+            self.on_task_complete(output)
+            return fn(output)
+
+        return wrapper
+
+    @property
+    def last_result(self) -> Any:
+        return self._last_result

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/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.5"
+_SDK_VERSION = "0.0.7"
 _MIN_GATEWAY_VERSION = "0.0.1a1"
 
 

{agentrust_py-0.0.5 → agentrust_py-0.0.7}/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.5 → agentrust_py-0.0.7}/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.5 → agentrust_py-0.0.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "agentrust-py"
-version = "0.0.5"
+version = "0.0.7"
 description = "AgentTrust Edge — Full Governance Platform. Policy Engine + MAD Classifier + HITL + Kill Switch."
 readme = "README.md"
 license = { text = "Apache-2.0" }
@@ -40,7 +40,9 @@ llm = [
 ]
 # Framework adapters (optional, tier-gated)
 langgraph = ["langgraph>=0.2.0,<2.0.0"]
-crewai    = ["crewai>=0.80.0,<1.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"]
 openai    = ["openai>=2.41.1,<3.0.0"]
 langchain = ["langchain>=0.2.0,<1.0.0"]
 # Retry/backoff (recommended for production)
@@ -68,6 +70,7 @@ dev = [
     "uvicorn>=0.29.0",
     "httpx>=0.27.0,<1.0.0",
     "langgraph>=0.2.0,<2.0.0",
+    "crewai>=1.0,<2.0",
 ]
 
 [project.scripts]