adapt-agent 0.2.0__py3-none-any.whl

adapt_agent/adapters/base.py

@@ -0,0 +1,79 @@
+"""Base adapter interface for framework integrations."""
+
+from abc import ABC, abstractmethod
+from typing import Any
+
+from adapt_agent.core.types import Agent, AgentState
+
+
+class BaseAdapter(ABC):
+    """Base class for framework adapters.
+
+    Adapters provide integration with different LLM agent frameworks,
+    converting framework-specific APIs to ADAPT-Agent's unified interface.
+    """
+
+    def __init__(self, config: dict[str, Any] | None = None):
+        """Initialize the adapter.
+
+        Args:
+            config: Optional configuration dictionary
+        """
+        self.config = config or {}
+
+    @abstractmethod
+    def wrap_agent(self, agent: Any) -> Agent:
+        """Wrap a framework-specific agent with ADAPT-Agent capabilities.
+
+        Args:
+            agent: Framework-specific agent instance
+
+        Returns:
+            Wrapped agent implementing the Agent protocol
+        """
+        pass
+
+    @abstractmethod
+    def extract_state(self, agent: Any) -> AgentState:
+        """Extract the current state from a framework-specific agent.
+
+        Args:
+            agent: Framework-specific agent instance
+
+        Returns:
+            AgentState representing the current state
+        """
+        pass
+
+    @abstractmethod
+    def inject_middleware(self, agent: Any, middleware: Any) -> Any:
+        """Inject ADAPT-Agent middleware into a framework-specific agent.
+
+        Args:
+            agent: Framework-specific agent instance
+            middleware: Middleware to inject
+
+        Returns:
+            Modified agent with middleware
+        """
+        pass
+
+    def validate_agent(self, agent: Any) -> bool:
+        """Validate that an agent is compatible with this adapter.
+
+        Args:
+            agent: Agent to validate
+
+        Returns:
+            True if compatible, False otherwise
+        """
+        # Default implementation - should be overridden
+        return True
+
+    def get_framework_name(self) -> str:
+        """Get the name of the framework this adapter supports.
+
+        Returns:
+            Framework name
+        """
+        return self.__class__.__name__.replace("Adapter", "")

adapt_agent/adapters/claude_agent/__init__.py

@@ -0,0 +1,49 @@
+"""Claude Agent SDK adapter for ADAPT-Agent.
+
+The `Claude Agent SDK <https://github.com/anthropics/claude-agent-sdk-python>`_
+exposes ``query(prompt=..., options=...)``, an async generator that yields
+message objects (``AssistantMessage`` with ``TextBlock`` content, terminated by
+a ``ResultMessage``).
+
+This adapter wraps the ``query`` function (or any callable accepting a
+``prompt`` keyword) and applies ADAPT-Agent's governance pipeline. The async
+stream is drained to a list of messages, so ``execute`` stays synchronous and
+the firewall can scan every text block in the response. Importing this module
+never imports ``claude_agent_sdk``.
+
+Example
+-------
+>>> from claude_agent_sdk import query             # doctest: +SKIP
+>>> from adapt_agent.adapters import ClaudeAgentSDKAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = ClaudeAgentSDKAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(query)            # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}]})  # doctest: +SKIP
+"""
+
+from typing import Any
+
+from adapt_agent.adapters._governed import GovernedAdapter, Runner, _extract_prompt
+
+
+class ClaudeAgentSDKAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with the Claude Agent SDK.
+
+    Wrap the SDK's ``query`` function (or any callable accepting a ``prompt``
+    keyword). The async message stream is drained synchronously. See
+    :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the full
+    constructor signature.
+    """
+
+    framework_name = "Claude Agent SDK"
+    run_method_names = ("query", "run")
+    operation = "claude_agent.query"
+
+    def _prepare_input(self, payload: dict[str, Any]) -> Any:
+        return _extract_prompt(payload)
+
+    def _call_runner(self, runner: Runner, payload: dict[str, Any]) -> Any:
+        return runner(prompt=self._prepare_input(payload))
+
+
+__all__ = ["ClaudeAgentSDKAdapter"]

adapt_agent/adapters/crewai/__init__.py

@@ -0,0 +1,71 @@
+"""CrewAI adapter for ADAPT-Agent.
+
+`CrewAI <https://docs.crewai.com>`_ orchestrates a ``Crew`` of agents that you
+run with ``crew.kickoff(inputs=...)`` (sync) or ``crew.kickoff_async(...)``. The
+result is a ``CrewOutput`` whose final text is on ``.raw``.
+
+This adapter wraps a ``Crew`` (or anything exposing a callable ``kickoff`` /
+``kickoff_async`` / ``run``) and applies ADAPT-Agent's governance pipeline. The
+payload's ``context`` (its non-``messages`` keys) is forwarded to ``kickoff`` as
+the ``inputs`` mapping of template variables when the runner accepts it.
+Importing this module never imports ``crewai``.
+
+Example
+-------
+>>> from crewai import Crew                      # doctest: +SKIP
+>>> crew = Crew(agents=[...], tasks=[...])        # doctest: +SKIP
+>>> from adapt_agent.adapters import CrewAIAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = CrewAIAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(crew)            # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}], "topic": "AI"})  # doctest: +SKIP
+"""
+
+import inspect
+from typing import Any
+
+from adapt_agent.adapters._governed import GovernedAdapter, Runner
+
+
+class CrewAIAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with CrewAI crews.
+
+    Wrap a ``Crew`` (or any object exposing a callable ``kickoff`` /
+    ``kickoff_async`` / ``run``). See
+    :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the full
+    constructor signature.
+    """
+
+    framework_name = "CrewAI"
+    run_method_names = ("kickoff", "kickoff_async", "run")
+    operation = "crewai.kickoff"
+
+    def _prepare_input(self, payload: dict[str, Any]) -> Any:
+        # CrewAI's ``inputs`` are template variables, not a chat transcript.
+        return {k: v for k, v in payload.items() if k != "messages"}
+
+    def _call_runner(self, runner: Runner, payload: dict[str, Any]) -> Any:
+        inputs = self._prepare_input(payload)
+        # Prefer the idiomatic ``kickoff(inputs=...)`` call when supported.
+        if self._accepts_kwarg(runner, "inputs"):
+            return runner(inputs=inputs)
+        return runner(inputs)
+
+    @staticmethod
+    def _accepts_kwarg(runner: Runner, name: str) -> bool:
+        try:
+            signature = inspect.signature(runner)
+        except (TypeError, ValueError):
+            return False
+        for param in signature.parameters.values():
+            if param.kind is inspect.Parameter.VAR_KEYWORD:
+                return True
+            if param.name == name and param.kind in (
+                inspect.Parameter.POSITIONAL_OR_KEYWORD,
+                inspect.Parameter.KEYWORD_ONLY,
+            ):
+                return True
+        return False
+
+
+__all__ = ["CrewAIAdapter"]

adapt_agent/adapters/google_adk/__init__.py

@@ -0,0 +1,50 @@
+"""Google ADK adapter for ADAPT-Agent.
+
+The `Google Agent Development Kit <https://google.github.io/adk-docs>`_ runs an
+agent through a ``Runner``: ``runner.run_async(user_id=..., session_id=...,
+new_message=...)`` (an async generator of ``Event`` objects) or the sync
+``runner.run(...)``. There is no single result object -- you iterate events and
+take the one where ``event.is_final_response()`` is true.
+
+Because an ADK run needs a session plus ``user_id`` / ``session_id`` /
+``new_message`` arguments, the idiomatic wrap target here is a **callable** you
+provide that performs the run and returns (or yields) the events. The adapter
+drains async/sync generators automatically and screens the text inside each
+event's ``content.parts``. Importing this module never imports ``google.adk``.
+
+Example
+-------
+>>> from google.adk.runners import InMemoryRunner   # doctest: +SKIP
+>>> from google.genai import types                  # doctest: +SKIP
+>>> runner = InMemoryRunner(agent=my_agent)          # doctest: +SKIP
+>>> def run(payload):                                # doctest: +SKIP
+...     msg = types.Content(role="user", parts=[types.Part(text=payload["prompt"])])
+...     return runner.run(user_id="u", session_id="s", new_message=msg)
+>>> from adapt_agent.adapters import GoogleADKAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = GoogleADKAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(run)                # doctest: +SKIP
+>>> guarded.execute({"prompt": "hi"})                # doctest: +SKIP
+"""
+
+from adapt_agent.adapters._governed import GovernedAdapter
+
+
+class GoogleADKAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with Google ADK agents.
+
+    Wrap a callable ``run(payload) -> events`` that drives an ADK ``Runner`` (the
+    events may be a sync generator, an async generator, or a list). The full
+    payload dict is passed through to your callable. See
+    :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the full
+    constructor signature.
+    """
+
+    framework_name = "Google ADK"
+    # An ADK run requires session/user arguments, so binding to a bare
+    # ``runner.run`` would mismatch its signature; wrap a callable instead.
+    run_method_names = ()
+    operation = "google_adk.run"
+
+
+__all__ = ["GoogleADKAdapter"]

adapt_agent/adapters/langgraph/__init__.py

@@ -0,0 +1,45 @@
+"""LangGraph adapter for ADAPT-Agent.
+
+This adapter wraps a compiled LangGraph graph (or any object exposing an
+``invoke`` method) with ADAPT-Agent's security and governance primitives:
+a :class:`~adapt_agent.security.Firewall`, an
+:class:`~adapt_agent.adversarial.AdversarialDefense`, a
+:class:`~adapt_agent.core.PolicyEnforcer`, an
+:class:`~adapt_agent.observability.AgentObserver` and a
+:class:`~adapt_agent.core.Middleware` pipeline.
+
+The adapter is intentionally *structural*: it integrates with anything that
+looks like a compiled LangGraph graph (a callable ``invoke(state) -> state``)
+rather than importing LangGraph at module load time. The optional ``langgraph``
+dependency is only needed at runtime to build the graph you pass in; importing
+this module never imports ``langgraph``.
+
+Example
+-------
+>>> from adapt_agent.adapters import LangGraphAdapter
+>>> from adapt_agent.security import Firewall
+>>> fw = Firewall(max_content_length=10_000)
+>>> fw.add_blocked_pattern(r"(?i)ignore previous instructions")
+>>> adapter = LangGraphAdapter(firewall=fw)
+>>> guarded = adapter.wrap_agent(compiled_graph)   # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}]})  # doctest: +SKIP
+"""
+
+from adapt_agent.adapters._governed import GovernedAdapter, _extract_texts
+
+
+class LangGraphAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with LangGraph agents.
+
+    Wrap a **compiled** LangGraph graph -- or any object exposing a callable
+    ``invoke(state) -> state``. See :class:`~adapt_agent.adapters._governed.GovernedAdapter`
+    for the full constructor signature; every security control is optional and
+    keyword-only.
+    """
+
+    framework_name = "LangGraph"
+    run_method_names = ("invoke",)
+    operation = "langgraph.invoke"
+
+
+__all__ = ["LangGraphAdapter", "_extract_texts"]

adapt_agent/adapters/microsoft_agent_framework/__init__.py

@@ -0,0 +1,47 @@
+"""Microsoft Agent Framework adapter for ADAPT-Agent.
+
+`Microsoft Agent Framework <https://github.com/microsoft/agent-framework>`_ is
+Microsoft's unified successor to Semantic Kernel and AutoGen. Its primary
+runnable object is a ``ChatAgent`` (also exported as ``Agent``), whose
+``run(prompt)`` coroutine returns an ``AgentRunResponse`` carrying the final
+text on ``.text``.
+
+This adapter wraps a ``ChatAgent`` (or anything exposing a callable ``run`` /
+``run_sync``) and applies ADAPT-Agent's governance pipeline. ``run`` is async;
+the wrapper resolves the coroutine transparently, so ``execute`` stays
+synchronous. Importing this module never imports ``agent_framework``.
+
+Example
+-------
+>>> from agent_framework.openai import OpenAIChatClient        # doctest: +SKIP
+>>> agent = OpenAIChatClient().create_agent(instructions="...")  # doctest: +SKIP
+>>> from adapt_agent.adapters import MicrosoftAgentFrameworkAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = MicrosoftAgentFrameworkAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(agent)                          # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}]})  # doctest: +SKIP
+"""
+
+from typing import Any
+
+from adapt_agent.adapters._governed import GovernedAdapter, _extract_prompt
+
+
+class MicrosoftAgentFrameworkAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with Microsoft Agent Framework agents.
+
+    Wrap a ``ChatAgent`` (or any object exposing a callable ``run`` / ``run_sync``).
+    The agent is run from a prompt string derived from the payload's latest user
+    message. See :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the
+    full constructor signature.
+    """
+
+    framework_name = "Microsoft Agent Framework"
+    run_method_names = ("run", "run_sync")
+    operation = "agent_framework.run"
+
+    def _prepare_input(self, payload: dict[str, Any]) -> Any:
+        return _extract_prompt(payload)
+
+
+__all__ = ["MicrosoftAgentFrameworkAdapter"]

adapt_agent/adapters/openai_agents/__init__.py

@@ -0,0 +1,65 @@
+"""OpenAI Agents SDK adapter for ADAPT-Agent.
+
+The `OpenAI Agents SDK <https://openai.github.io/openai-agents-python>`_ runs an
+``Agent`` through the ``Runner`` class: ``Runner.run_sync(agent, input)`` (sync)
+or ``await Runner.run(agent, input)`` (async). The result is a ``RunResult``
+whose final text is on ``.final_output``.
+
+You can wrap an OpenAI ``Agent`` directly -- the adapter lazily imports
+``agents.Runner`` at execution time and drives it for you -- or wrap any plain
+callable ``run(input) -> result`` if you want full control over the run
+configuration. Importing this module never imports ``agents``.
+
+Example
+-------
+>>> from agents import Agent                       # doctest: +SKIP
+>>> agent = Agent(name="Assistant", instructions="...")  # doctest: +SKIP
+>>> from adapt_agent.adapters import OpenAIAgentsAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = OpenAIAgentsAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(agent)            # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}]})  # doctest: +SKIP
+"""
+
+from typing import Any, Optional
+
+from adapt_agent.adapters._governed import GovernedAdapter, Runner, _extract_prompt
+from adapt_agent.exceptions import MissingDependencyError
+
+
+class OpenAIAgentsAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with the OpenAI Agents SDK.
+
+    Wrap an OpenAI ``Agent`` (driven via a lazily-imported ``Runner``) or any
+    plain callable ``run(input) -> result``. See
+    :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the full
+    constructor signature.
+    """
+
+    framework_name = "OpenAI Agents"
+    run_method_names = ("run_sync", "run")
+    operation = "openai_agents.run"
+
+    def _resolve_runner(self, agent: Any) -> Runner | None:
+        # An object exposing run_sync/run (e.g. a custom runner) or a plain
+        # callable is used as-is.
+        runner = super()._resolve_runner(agent)
+        if runner is not None:
+            return runner
+        # Otherwise treat ``agent`` as an OpenAI Agent and drive it through the
+        # SDK's Runner, imported lazily so importing this module stays cheap.
+        return lambda prompt: self._run_with_sdk(agent, prompt)
+
+    @staticmethod
+    def _run_with_sdk(agent: Any, prompt: Any) -> Any:
+        try:
+            from agents import Runner
+        except ImportError as exc:  # pragma: no cover - exercised only without the dep
+            raise MissingDependencyError("openai-agents", "openai-agents") from exc
+        return Runner.run_sync(agent, prompt)
+
+    def _prepare_input(self, payload: dict[str, Any]) -> Any:
+        return _extract_prompt(payload)
+
+
+__all__ = ["OpenAIAgentsAdapter"]

adapt_agent/adapters/pydantic_ai/__init__.py

@@ -0,0 +1,45 @@
+"""Pydantic AI adapter for ADAPT-Agent.
+
+`Pydantic AI <https://ai.pydantic.dev>`_ centres on an ``Agent`` whose
+``run_sync(prompt)`` (sync) and ``run(prompt)`` (async) methods return an
+``AgentRunResult`` carrying the final output on ``.output``.
+
+This adapter wraps a Pydantic AI ``Agent`` (or anything exposing a callable
+``run_sync`` / ``run``) and applies ADAPT-Agent's governance pipeline. Importing
+this module never imports ``pydantic_ai``.
+
+Example
+-------
+>>> from pydantic_ai import Agent                       # doctest: +SKIP
+>>> agent = Agent("openai:gpt-4o", system_prompt="...")  # doctest: +SKIP
+>>> from adapt_agent.adapters import PydanticAIAdapter
+>>> from adapt_agent.security import Firewall
+>>> adapter = PydanticAIAdapter(firewall=Firewall())
+>>> guarded = adapter.wrap_agent(agent)                  # doctest: +SKIP
+>>> guarded.execute({"messages": [{"role": "user", "content": "hi"}]})  # doctest: +SKIP
+"""
+
+from typing import Any
+
+from adapt_agent.adapters._governed import GovernedAdapter, _extract_prompt
+
+
+class PydanticAIAdapter(GovernedAdapter):
+    """Adapter for integrating ADAPT-Agent with Pydantic AI agents.
+
+    Wrap a Pydantic AI ``Agent`` (or any object exposing a callable
+    ``run_sync`` / ``run``). The agent is run from a prompt string derived from
+    the payload's latest user message. See
+    :class:`~adapt_agent.adapters._governed.GovernedAdapter` for the full
+    constructor signature.
+    """
+
+    framework_name = "Pydantic AI"
+    run_method_names = ("run_sync", "run")
+    operation = "pydantic_ai.run"
+
+    def _prepare_input(self, payload: dict[str, Any]) -> Any:
+        return _extract_prompt(payload)
+
+
+__all__ = ["PydanticAIAdapter"]