agenticdome-python-sdk 1.2.2__py3-none-any.whl → 1.2.3__py3-none-any.whl

{agenticdome_python_sdk-1.2.2.dist-info → agenticdome_python_sdk-1.2.3.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.2
+Version: 1.2.3
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License: Proprietary
@@ -27,36 +27,40 @@ License-File: LICENSE
 Requires-Dist: requests>=2.31.0
 Requires-Dist: urllib3>=2.0.0
 Provides-Extra: crewai
-Requires-Dist: crewai==1.15.5; extra == "crewai"
+Requires-Dist: crewai<=1.15.6,>=1.15.5; extra == "crewai"
 Provides-Extra: redis
 Requires-Dist: redis>=4.5.0; extra == "redis"
 Provides-Extra: pop
 Requires-Dist: cryptography>=42.0.0; extra == "pop"
 Provides-Extra: pydanticai
-Requires-Dist: pydantic-ai==2.16.0; extra == "pydanticai"
+Requires-Dist: pydantic-ai<=2.18.0,>=2.16.0; extra == "pydanticai"
 Requires-Dist: anyio>=4.0.0; extra == "pydanticai"
 Provides-Extra: pydantic
-Requires-Dist: pydantic-ai==2.16.0; extra == "pydantic"
+Requires-Dist: pydantic-ai<=2.18.0,>=2.16.0; extra == "pydantic"
 Requires-Dist: anyio>=4.0.0; extra == "pydantic"
 Provides-Extra: langgraph
 Requires-Dist: langgraph==1.2.9; extra == "langgraph"
-Requires-Dist: langchain-core==1.5.0; extra == "langgraph"
+Requires-Dist: langchain-core<=1.5.1,>=1.5.0; extra == "langgraph"
 Requires-Dist: langchain-openai==1.3.5; extra == "langgraph"
 Requires-Dist: anyio>=4.0.0; extra == "langgraph"
 Provides-Extra: microsoft
+Provides-Extra: autogen
+Requires-Dist: autogen-agentchat==0.7.5; extra == "autogen"
+Provides-Extra: microsoft-autogen
+Requires-Dist: autogen-agentchat==0.7.5; extra == "microsoft-autogen"
 Provides-Extra: foundry
 Requires-Dist: azure-ai-projects==2.3.0; extra == "foundry"
 Requires-Dist: azure-identity==1.25.3; extra == "foundry"
 Provides-Extra: agno
-Requires-Dist: agno==2.8.0; extra == "agno"
+Requires-Dist: agno<=2.8.3,>=2.8.0; extra == "agno"
 Provides-Extra: openai-agents
 Requires-Dist: openai-agents==0.18.3; extra == "openai-agents"
 Provides-Extra: mcp
 Requires-Dist: mcp<=1.28.1,>=1.26.0; extra == "mcp"
 Provides-Extra: bedrock
-Requires-Dist: boto3==1.43.54; extra == "bedrock"
+Requires-Dist: boto3<=1.43.56,>=1.43.54; extra == "bedrock"
 Provides-Extra: aws-bedrock
-Requires-Dist: boto3==1.43.54; extra == "aws-bedrock"
+Requires-Dist: boto3<=1.43.56,>=1.43.54; extra == "aws-bedrock"
 Provides-Extra: llamaindex
 Requires-Dist: llama-index==0.14.23; extra == "llamaindex"
 Provides-Extra: llama-index
@@ -66,29 +70,30 @@ Requires-Dist: google-adk==2.5.0; extra == "google-adk"
 Provides-Extra: adk
 Requires-Dist: google-adk==2.5.0; extra == "adk"
 Provides-Extra: claude
-Requires-Dist: claude-agent-sdk==0.2.126; extra == "claude"
+Requires-Dist: claude-agent-sdk<=0.2.128,>=0.2.126; extra == "claude"
 Provides-Extra: claude-agent-sdk
-Requires-Dist: claude-agent-sdk==0.2.126; extra == "claude-agent-sdk"
+Requires-Dist: claude-agent-sdk<=0.2.128,>=0.2.126; extra == "claude-agent-sdk"
 Provides-Extra: smolagents
 Requires-Dist: smolagents==1.26.0; extra == "smolagents"
 Provides-Extra: all
-Requires-Dist: crewai==1.15.5; extra == "all"
+Requires-Dist: crewai<=1.15.6,>=1.15.5; extra == "all"
 Requires-Dist: redis>=4.5.0; extra == "all"
 Requires-Dist: cryptography>=42.0.0; extra == "all"
-Requires-Dist: pydantic-ai==2.16.0; extra == "all"
+Requires-Dist: pydantic-ai<=2.18.0,>=2.16.0; extra == "all"
 Requires-Dist: anyio>=4.0.0; extra == "all"
 Requires-Dist: langgraph==1.2.9; extra == "all"
-Requires-Dist: langchain-core==1.5.0; extra == "all"
+Requires-Dist: langchain-core<=1.5.1,>=1.5.0; extra == "all"
 Requires-Dist: langchain-openai==1.3.5; extra == "all"
-Requires-Dist: agno==2.8.0; extra == "all"
+Requires-Dist: autogen-agentchat==0.7.5; extra == "all"
+Requires-Dist: agno<=2.8.3,>=2.8.0; extra == "all"
 Requires-Dist: azure-ai-projects==2.3.0; extra == "all"
 Requires-Dist: azure-identity==1.25.3; extra == "all"
 Requires-Dist: openai-agents==0.18.3; extra == "all"
 Requires-Dist: mcp<=1.28.1,>=1.26.0; extra == "all"
-Requires-Dist: boto3==1.43.54; extra == "all"
+Requires-Dist: boto3<=1.43.56,>=1.43.54; extra == "all"
 Requires-Dist: llama-index==0.14.23; extra == "all"
 Requires-Dist: google-adk==2.5.0; extra == "all"
-Requires-Dist: claude-agent-sdk==0.2.126; extra == "all"
+Requires-Dist: claude-agent-sdk<=0.2.128,>=0.2.126; extra == "all"
 Requires-Dist: smolagents==1.26.0; extra == "all"
 Provides-Extra: dev
 Requires-Dist: pytest>=8.0.0; extra == "dev"
@@ -109,7 +114,7 @@ Dynamic: license-file
 
 `agenticdome-python-sdk` is the official Python SDK and middleware package for [AgenticDome](https://agenticdome.io). It enforces deterministic security controls at every boundary your agents cross — prompt ingress, tool execution, agent-to-agent handoffs, and output egress — backed by the AgenticDome central policy plane.
 
-**One security pattern, fourteen runtimes:** CrewAI · PydanticAI · LangGraph/LangChain · Microsoft Agent Framework · Microsoft AI Foundry · OpenAI Agents SDK · Claude Agent SDK · Hugging Face smolagents · Agno · Google ADK · LlamaIndex · AWS Bedrock · MCP hosts/gateways · custom Python.
+**One security pattern, fifteen runtimes:** CrewAI · PydanticAI · LangGraph/LangChain · Microsoft Agent Framework · Microsoft AutoGen · Microsoft AI Foundry · OpenAI Agents SDK · Claude Agent SDK · Hugging Face smolagents · Agno · Google ADK · LlamaIndex · AWS Bedrock · MCP hosts/gateways · custom Python.
 
 ```python
 # The 30-second version: block a prompt-injected refund before it executes.
@@ -131,7 +136,7 @@ result = crew.kickoff()          # hostile prompts, unsafe tools, and rogue
 5. [Configuration](#configuration)
 6. [Choosing Your Integration Point](#choosing-your-integration-point)
 7. [Framework Integrations](#framework-integrations)
-   - [CrewAI](#crewai) · [PydanticAI](#pydanticai) · [LangGraph](#langgraph) · [Microsoft Agent Framework](#microsoft-agent-framework) · [Microsoft AI Foundry](#microsoft-ai-foundry) · [OpenAI Agents SDK](#openai-agents-sdk) · [Agno](#agno) · [Google ADK](#google-adk) · [LlamaIndex](#llamaindex) · [AWS Bedrock](#aws-bedrock) · [MCP Host / Gateway](#mcp-host--gateway)
+   - [CrewAI](#crewai) · [PydanticAI](#pydanticai) · [LangGraph](#langgraph) · [Microsoft Agent Framework](#microsoft-agent-framework) · [Microsoft AutoGen](#microsoft-autogen) · [Microsoft AI Foundry](#microsoft-ai-foundry) · [OpenAI Agents SDK](#openai-agents-sdk) · [Agno](#agno) · [Google ADK](#google-adk) · [LlamaIndex](#llamaindex) · [AWS Bedrock](#aws-bedrock) · [MCP Host / Gateway](#mcp-host--gateway)
 8. [Core SDK Client (Custom Runtimes)](#core-sdk-client-custom-runtimes)
 9. [Production Deployment](#production-deployment)
 10. [Package Build and Verification](#package-build-and-verification)
@@ -276,6 +281,8 @@ result = crew.kickoff()
 
 ```bash
 python examples/attack_demo.py --framework crewai --scenario refund_hijack
+python examples/attack_demo.py --framework claude --scenario metadata_exfil
+python examples/attack_demo.py --framework smolagents --scenario generated_code_exfil
 ```
 
 ---
@@ -294,6 +301,7 @@ pip install agenticdome-python-sdk
 | PydanticAI | `pip install "agenticdome-python-sdk[pydanticai]"` |
 | LangGraph / LangChain | `pip install "agenticdome-python-sdk[langgraph]"` |
 | Microsoft Agent Framework | `pip install "agenticdome-python-sdk[microsoft]"` |
+| Microsoft AutoGen AgentChat / Core (Python 3.10+) | `pip install "agenticdome-python-sdk[autogen]"` |
 | Microsoft AI Foundry | `pip install "agenticdome-python-sdk[foundry]"` |
 | OpenAI Agents SDK | `pip install "agenticdome-python-sdk[openai-agents]"` |
 | Anthropic Claude Agent SDK | `pip install "agenticdome-python-sdk[claude]"` |
@@ -309,6 +317,12 @@ pip install agenticdome-python-sdk
 
 Some adapters are dependency-light at import time: Google ADK, LlamaIndex, Bedrock, MCP, and Microsoft helpers can wrap local boundaries without forcing one exact runtime stack. Install the framework packages your application actually uses.
 
+### Framework-version compatibility
+
+AgenticDome supports framework versions only inside the range certified by the SDK Harness. When an upstream framework release appears, **Upgrade & Certify** keeps the existing certified version as the compatibility floor, tests the new release as the ceiling, and publishes an inclusive dependency range such as `framework>=floor,<=ceiling` only when both endpoints pass the adapter and firewall release gates. Multi-package integrations such as LangGraph/LangChain are also retested at their complete certified floor set.
+
+This means upgrading support for the latest framework does not silently drop customers on the previously certified version. Versions below the displayed certified floor are not claimed as supported until they are tested. Customers managing framework dependencies themselves may install the core SDK without an extra, but their framework version must still be inside the certified range for a production support claim.
+
 ---
 
 ## Configuration
@@ -406,7 +420,7 @@ export AGENTICDOME_PRODUCTION_MODE="false"            # production hardening (st
 <details>
 <summary><strong>Full configuration reference — per-adapter variables</strong></summary>
 
-Every framework adapter exposes the same family of local hardening controls, prefixed per adapter: `AGENTICDOME_CREWAI_*`, `AGENTICDOME_PYDANTICAI_*`, `AGENTICDOME_LANGGRAPH_*`, `AGENTICDOME_MSAF_*` (Microsoft Agent Framework), `AGENTICDOME_FOUNDRY_*`, `AGENTICDOME_OPENAI_AGENTS_*`, `AGENTICDOME_CLAUDE_*`, `AGENTICDOME_SMOLAGENTS_*`, `AGENTICDOME_AGNO_*`, `AGENTICDOME_BEDROCK_*`, `AGENTICDOME_GOOGLE_ADK_*`, and `AGENTICDOME_MCP_*`.
+Every framework adapter exposes the same family of local hardening controls, prefixed per adapter: `AGENTICDOME_CREWAI_*`, `AGENTICDOME_PYDANTICAI_*`, `AGENTICDOME_LANGGRAPH_*`, `AGENTICDOME_MSAF_*` (Microsoft Agent Framework), `AGENTICDOME_AUTOGEN_*`, `AGENTICDOME_FOUNDRY_*`, `AGENTICDOME_OPENAI_AGENTS_*`, `AGENTICDOME_CLAUDE_*`, `AGENTICDOME_SMOLAGENTS_*`, `AGENTICDOME_AGNO_*`, `AGENTICDOME_BEDROCK_*`, `AGENTICDOME_GOOGLE_ADK_*`, and `AGENTICDOME_MCP_*`.
 
 **Common per-adapter pattern** (substitute the prefix for your adapter):
 
@@ -484,6 +498,7 @@ One table, one decision. Find your runtime, apply the required code action, and
 | [PydanticAI](#pydanticai) | `agenticdome_sdk.pydantic` | Module where each `Agent(...)` and tool is constructed | `CyberSecFirewall(...)` + `create_hooks()`, `install_native_hooks(agent)`, or `attach_to_agent(agent)` | `@firewall.secure_tool(...)` with optional `tool_schema` validation |
 | [LangGraph](#langgraph) | `agenticdome_sdk.langgraph` | Module where `StateGraph` or LangChain `create_agent()` is assembled | Add `input_node()` / `transition_node()` / `graph_transition_node()` / `output_node()`, or `as_langchain_middleware()` | `wrap_agent_node()`, `wrap_tool_node()`, `security_route()` for blocked edges |
 | [Microsoft Agent Framework](#microsoft-agent-framework) | `agenticdome_sdk.microsoft_agent_framework` | Module where agents, workflows, tools, or middleware are declared | `create_middleware()`, `install_on_agent()`, or `run_agent_securely()` | `@firewall.secure_tool`, `wrap_tool_handler`, `secure_delegated_tool`, `wrap_delegated_tool_handler` |
+| [Microsoft AutoGen](#microsoft-autogen) | `agenticdome_sdk.autogen` | AgentChat teams/Core runtimes; legacy 0.2 ConversableAgent loops | `wrap_team()`, `create_intervention_handler()`, `create_termination_condition()`, `attach_agentchat_agent()`, or `attach_conversable_agent()` | Core `FunctionCall` authorization plus inherited `wrap_tool_handler()` / `secure_tool()` |
 | [Microsoft AI Foundry](#microsoft-ai-foundry) | `agenticdome_sdk.microsoft_ai_foundry` | Module handling Foundry runs, function calls, or client construction | `create_middleware()`, `install_on_client()`, or `run_secure()` | `wrap_tool_executor()`, `@firewall.secure_tool(...)`, `before_tool_call()`, delegation verifiers |
 | [OpenAI Agents SDK](#openai-agents-sdk) | `agenticdome_sdk.openai_agents` | Module where `Agent`, `Runner.run(...)`, `@function_tool`, guardrails, or handoffs are declared | `run_agent_securely()`, `run_agent_stream_securely()`, `create_input_guardrail()`, `create_output_guardrail()` | `wrap_tool_handler()`, `wrap_delegated_tool_handler()`, `@firewall.secure_tool(...)`, handoff verifiers |
 | [Claude Agent SDK](#claude-agent-sdk) | `agenticdome_sdk.claude` | Module constructing `ClaudeAgentOptions`, `ClaudeSDKClient`, SDK MCP tools, or `query()` | `install_on_options()` plus `run_client_securely()`, or `secure_query()` | Native `PreToolUse`/`PostToolUse` hooks, `wrap_tool_handler()`, and `secure_sdk_tool()` |
@@ -1013,6 +1028,108 @@ from agenticdome_sdk.microsoft_agent_framework import (
 
 ---
 
+### Microsoft AutoGen
+
+AutoGen is Microsoft's open-source conversational multi-agent framework and is now community-managed in maintenance mode; Microsoft Agent Framework is the recommended successor for new systems. AgenticDome supports current AutoGen AgentChat/Core applications and existing legacy `ConversableAgent` deployments so teams can migrate without losing runtime enforcement.
+
+```bash
+# AutoGen AgentChat requires Python 3.10+.
+pip install "agenticdome-python-sdk[autogen]"
+```
+
+**Protect a current AgentChat team** — the wrapper screens the initial task, every streamed team event, and final messages while retaining the underlying Team API:
+
+```python
+from autogen_agentchat.teams import RoundRobinGroupChat
+from agenticdome_sdk.autogen import AgenticDomeAutoGenFirewall
+
+firewall = AgenticDomeAutoGenFirewall()
+team = RoundRobinGroupChat([planner, researcher, payments_specialist], max_turns=12)
+secure_team = firewall.wrap_team(
+    team,
+    session_id="sess_prod_01J4X",
+    agent_id="customer_operations_team",
+    policy_context={"request_purpose": "customer_support"},
+)
+
+result = await secure_team.run(task=user_prompt)
+```
+
+**Authorize AutoGen Core tool traffic at the runtime boundary** — current AutoGen sends `FunctionCall` messages to tool agents, so the intervention handler is a stronger boundary than patching an individual assistant:
+
+```python
+from autogen_core import SingleThreadedAgentRuntime
+
+handler = firewall.create_intervention_handler(
+    session_id="sess_prod_01J4X",
+    agent_id="autogen_planner",
+)
+runtime = SingleThreadedAgentRuntime(intervention_handlers=[handler])
+```
+
+**Freeze a group chat on behavioral drift** — compose the AgenticDome condition with AutoGen's normal termination conditions:
+
+```python
+agenticdome_stop = firewall.create_termination_condition(
+    session_id="sess_prod_01J4X",
+    agent_id="customer_operations_team",
+)
+team = RoundRobinGroupChat(
+    [planner, researcher, payments_specialist],
+    termination_condition=agenticdome_stop | normal_stop,
+    max_turns=12,
+)
+```
+
+Family 2 policy receives a bounded rolling conversation window digest, participant lineage, semantic-deviation evaluation request, and tool-call frequency. A blocked cross-agent message or excessive tool rate freezes the local session, reports a trust incident, and advances revocation state for the emitting agent before an external action can run.
+
+**Existing AutoGen 0.2 deployments** — attach to the legacy `ConversableAgent.send()`, `receive()`, `a_send()`, and `a_receive()` lifecycles:
+
+Keep the customer's already-certified legacy AutoGen dependency in place and install the dependency-light base SDK (do not use the `[autogen]` extra, because that extra deliberately installs the current AgentChat release):
+
+```bash
+pip install agenticdome-python-sdk
+```
+
+```python
+assistant = firewall.attach_conversable_agent(
+    assistant,
+    session_id="sess_prod_01J4X",
+    agent_id="legacy_autogen_assistant",
+)
+user_proxy = firewall.attach_conversable_agent(
+    user_proxy,
+    session_id="sess_prod_01J4X",
+    agent_id="legacy_autogen_user_proxy",
+)
+```
+
+Wrap side-effecting local tools as well; conversation screening does not replace authorization at the execution boundary:
+
+```python
+secure_refund = firewall.wrap_tool_handler(
+    tool_name="payments.refund.create",
+    tool_platform="payments",
+    handler=raw_refund,
+    session_id="sess_prod_01J4X",
+    agent_id="payments_specialist",
+)
+```
+
+```bash
+export AGENTICDOME_PLATFORM="autogen"
+export AGENTICDOME_PRODUCTION_MODE="true"
+export AGENTICDOME_REQUIRE_STABLE_SESSION_ID_IN_PROD="true"
+export AGENTICDOME_AUTOGEN_CONVERSATION_WINDOW="12"
+export AGENTICDOME_AUTOGEN_MAX_TOOL_CALLS_PER_WINDOW="8"
+export AGENTICDOME_AUTOGEN_FREEZE_ON_BLOCK="true"
+export AGENTICDOME_AUTOGEN_REVOKE_ON_FREEZE="true"
+```
+
+Official references: [AutoGen project status and migration guidance](https://github.com/microsoft/autogen) · [AgentChat teams](https://microsoft.github.io/autogen/stable/reference/python/autogen_agentchat.teams.html) · [Core intervention handlers](https://microsoft.github.io/autogen/dev/user-guide/core-user-guide/cookbook/tool-use-with-intervention.html) · [Legacy 0.2 conversational agents](https://microsoft.github.io/autogen/0.2/docs/Use-Cases/agent_chat/)
+
+---
+
 ### Microsoft AI Foundry
 
 For services that call Foundry agents, handle function-call requests from Foundry, execute local function tools, or use `FoundryChatClient` with local tools.
@@ -2366,7 +2483,7 @@ source .venv/bin/activate
 
 python -m pip install --upgrade pip setuptools wheel
 python -m pip install -e ".[dev]"
-python -m pip install -e ".[crewai,pydanticai,langgraph,microsoft,foundry,agno,openai-agents,mcp,bedrock,google-adk,llamaindex,redis]"
+python -m pip install -e ".[crewai,pydanticai,langgraph,microsoft,autogen,foundry,agno,openai-agents,claude,smolagents,mcp,bedrock,google-adk,llamaindex,redis]"
 
 python -m pytest -q
 rm -rf build dist *.egg-info agenticdome_sdk.egg-info agenticdome_python_sdk.egg-info
@@ -2389,10 +2506,12 @@ python -m pytest -q tests/test_langgraph_integration.py
 | :--- | :--- | :--- |
 | Core SDK client | `python -m pytest -q tests/test_client.py` | Request validation, headers, guardrail calls, A2A/MCP JSON-RPC calls, Mesh DLP, HTTP errors, JSON handling |
 | Package contract | `python -m pytest -q tests/test_packaging_contract.py` | `pyproject.toml` metadata, legacy `setup.py` shim, public exports, manifest hygiene, ignored build artifacts, documented extras |
+| Attack demos | `python -m pytest -q tests/test_attack_demo.py` | Offline vulnerable-vs-protected CLI coverage, including AutoGen, Claude Agent SDK, and Hugging Face smolagents |
 | CrewAI | `python -m pytest -q tests/test_crewai_integration.py` | Prompt/tool hooks, handoff token injection, specialist verification, output redaction, schema checks, rate limits, retries, streaming DLP |
 | PydanticAI | `python -m pytest -q tests/test_pydanticai_integration.py` | Agent hooks, secure tools, sanitized arguments, token-store fallback, production session enforcement, rate limits, retries, streaming output |
 | LangGraph / LangChain | `python -m pytest -q tests/test_langgraph_integration.py` | Graph input, transition, tool, retrieval, middleware, security routing, token consumption, output DLP, streaming events |
 | Microsoft Agent Framework | `python -m pytest -q tests/test_microsoft_agent_framework_integration.py` | Tool/run boundaries, delegated tool verification, middleware install helpers, identity context, Copilot enforcement hooks, streaming output |
+| Microsoft AutoGen | `python -m pytest -q tests/test_autogen_integration.py` | Current AgentChat team/Core interception, legacy send/receive hooks, rolling Family 2 context, session freeze, trust incident and revocation escalation |
 | Microsoft AI Foundry | `python -m pytest -q tests/test_microsoft_ai_foundry_integration.py` | Prompt threat contracts, local tool executors, run boundaries, bearer/API-key configuration, delegated execution, circuit breaker, stream DLP |
 | OpenAI Agents SDK | `python -m pytest -q tests/test_openai_agents_integration.py` | Runner wrappers, guardrail helpers, function-tool wrappers, handoff/delegated tools, HMAC token storage, schema checks, retries, streaming output |
 | Claude Agent SDK | `python -m pytest -q tests/test_claude_integration.py` | Native prompt/tool hooks, tool-output replacement, secure query responses, decision-token binding and one-time consumption |
@@ -2417,7 +2536,7 @@ python -m twine check dist/*
 **Full offline release gate** across all supported Python integrations:
 
 ```bash
-python -m pip install -e ".[dev,crewai,pydanticai,langgraph,microsoft,foundry,agno,openai-agents,mcp,bedrock,google-adk,llamaindex,redis]"
+python -m pip install -e ".[dev,crewai,pydanticai,langgraph,microsoft,autogen,foundry,agno,openai-agents,claude,smolagents,mcp,bedrock,google-adk,llamaindex,redis]"
 python -m pytest -q
 rm -rf build dist *.egg-info agenticdome_sdk.egg-info agenticdome_python_sdk.egg-info
 python -m build

{agenticdome_python_sdk-1.2.2.dist-info → agenticdome_python_sdk-1.2.3.dist-info}/RECORD

@@ -1,7 +1,8 @@
-agenticdome_python_sdk-1.2.2.dist-info/licenses/LICENSE,sha256=lqAH8G9tU2WPK9fzrnM_QMd4XUrh9fsmPqKE_hniKpM,718
+agenticdome_python_sdk-1.2.3.dist-info/licenses/LICENSE,sha256=lqAH8G9tU2WPK9fzrnM_QMd4XUrh9fsmPqKE_hniKpM,718
 agenticdome_sdk/__init__.py,sha256=6eOHJkY_Ir51dRKTktObXS40PjUsHrWMEQ2V3N0ItN4,576
 agenticdome_sdk/_framework_firewall.py,sha256=XJaKgDlVFfZJXVg1vL8jQOZDH05g8P9GQseh8J22p4M,27860
 agenticdome_sdk/agno.py,sha256=3gbc5URNTAHyNVAaAH882CpQpMecTv0R6S0CNMDOgos,60686
+agenticdome_sdk/autogen.py,sha256=0NAqCxk9zTyRZX7LnqqdT9cSzjbAJjQVgz6aq9QWy0Q,29015
 agenticdome_sdk/aws_bedrock.py,sha256=Z1Rcbps7VgvETmq_wrUbIvg6lJxsoe7YJEPZYkBKr80,69498
 agenticdome_sdk/claude.py,sha256=LEmfIAXOkZlbE_XISDHagze2JiDlRUA_j776ntP4QwM,17454
 agenticdome_sdk/client.py,sha256=rRFqW5zXVDYGqDrchy3D-HxRaDINttcgYu8VRQXnceU,48658
@@ -18,7 +19,7 @@ agenticdome_sdk/proof.py,sha256=ECKc14xSE0V1HHmcpZjfVz8-Q2H_fooah3BfdblFV8M,2878
 agenticdome_sdk/pydantic.py,sha256=7R6X0JgPIMLcWO682wcpN0X8dSMVEiwvVc4ydUN111s,54882
 agenticdome_sdk/scenarios.py,sha256=QROC_JWKwub5AdpP9pLXdJCpotEACkF-qgKAnDAo8XA,7882
 agenticdome_sdk/smolagents.py,sha256=j51nHazdFvA2DNRv6mibKKcEkZvw__xg6bjPUrhMKuk,19092
-agenticdome_python_sdk-1.2.2.dist-info/METADATA,sha256=QedjcKiYV6j_QfvUgcM8CkuwMMsppEPCQ8xNKixBQFY,121809
-agenticdome_python_sdk-1.2.2.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
-agenticdome_python_sdk-1.2.2.dist-info/top_level.txt,sha256=LZbbjXco5mqDrGwlTJpIKI5Sp6R_njzHHjExxAs9c3s,16
-agenticdome_python_sdk-1.2.2.dist-info/RECORD,,
+agenticdome_python_sdk-1.2.3.dist-info/METADATA,sha256=RthBXIsCPHzc1iYbENsoCbtmZfZO7xg71Gw-BDqEJRg,128670
+agenticdome_python_sdk-1.2.3.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+agenticdome_python_sdk-1.2.3.dist-info/top_level.txt,sha256=LZbbjXco5mqDrGwlTJpIKI5Sp6R_njzHHjExxAs9c3s,16
+agenticdome_python_sdk-1.2.3.dist-info/RECORD,,

agenticdome_sdk/autogen.py

@@ -0,0 +1,709 @@
+from __future__ import annotations
+
+import copy
+import hashlib
+import inspect
+import json
+import logging
+import os
+from collections import defaultdict, deque
+from dataclasses import dataclass
+from threading import Lock
+from types import MethodType
+from typing import Any, AsyncIterator, Callable, Deque, Dict, Iterable, List, Optional
+
+from ._framework_firewall import DecisionTokenStore, FrameworkFirewallBase, FrameworkFirewallConfig
+from .client import AgentGuardClient
+
+
+logger = logging.getLogger("agenticdome.autogen")
+
+
+def _env(name: str, default: str = "") -> str:
+    return os.getenv(name, os.getenv(name.replace("AGENTICDOME", "AgenticDome"), default))
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    value = _env(name)
+    return default if value == "" else value.strip().lower() in {"1", "true", "yes", "y", "on"}
+
+
+def _env_int(name: str, default: int) -> int:
+    try:
+        return int(_env(name, str(default)))
+    except (TypeError, ValueError):
+        return default
+
+
+def _env_float(name: str, default: float) -> float:
+    try:
+        return float(_env(name, str(default)))
+    except (TypeError, ValueError):
+        return default
+
+
+@dataclass(frozen=True)
+class FirewallConfig(FrameworkFirewallConfig):
+    platform: str = "autogen"
+    agent_id: str = "autogen_agent"
+    default_tool_platform: str = "autogen"
+    redis_key_prefix: str = "AgenticDome:autogen:handoff"
+    conversation_window_messages: int = 12
+    max_tool_calls_per_window: int = 8
+    freeze_on_policy_block: bool = True
+    revoke_agent_on_freeze: bool = True
+
+
+def load_config() -> FirewallConfig:
+    return FirewallConfig(
+        api_base=_env("AGENTICDOME_API_BASE").rstrip("/"),
+        api_key=_env("AGENTICDOME_API_KEY"),
+        tenant_id=_env("AGENTICDOME_TENANT_ID"),
+        platform=_env("AGENTICDOME_PLATFORM", "autogen"),
+        agent_id=_env("AGENTICDOME_AUTOGEN_AGENT_ID", "autogen_agent"),
+        default_tool_platform=_env("AGENTICDOME_DEFAULT_TOOL_PLATFORM", "autogen"),
+        timeout_s=_env_int("AGENTICDOME_TIMEOUT_S", 20),
+        fail_closed=_env_bool("AGENTICDOME_FAIL_CLOSED", True),
+        production_mode=_env_bool("AGENTICDOME_PRODUCTION_MODE", False),
+        require_explicit_session_id=_env_bool("AGENTICDOME_REQUIRE_SESSION_ID", False),
+        require_stable_session_id_in_prod=_env_bool("AGENTICDOME_REQUIRE_STABLE_SESSION_ID_IN_PROD", True),
+        redact_pii=_env_bool("AGENTICDOME_REDACT_PII", True),
+        redact_secrets=_env_bool("AGENTICDOME_REDACT_SECRETS", True),
+        block_on_sensitive_output=_env_bool("AGENTICDOME_BLOCK_ON_SENSITIVE_OUTPUT", False),
+        handoff_token_ttl_s=_env_int("AGENTICDOME_HANDOFF_TOKEN_TTL_S", 900),
+        redis_url=_env("AGENTICDOME_REDIS_URL").strip(),
+        redis_key_prefix=_env("AGENTICDOME_REDIS_KEY_PREFIX", "AgenticDome:autogen:handoff"),
+        token_hmac_secret=_env("AGENTICDOME_TOKEN_HMAC_SECRET"),
+        max_input_chars=_env_int("AGENTICDOME_AUTOGEN_MAX_INPUT_CHARS", 50_000),
+        max_output_chars=_env_int("AGENTICDOME_AUTOGEN_MAX_OUTPUT_CHARS", 100_000),
+        max_tool_arg_chars=_env_int("AGENTICDOME_AUTOGEN_MAX_TOOL_ARG_CHARS", 20_000),
+        streaming_buffer_chars=_env_int("AGENTICDOME_AUTOGEN_STREAMING_BUFFER_CHARS", 4_000),
+        rate_limit_per_minute=_env_int("AGENTICDOME_AUTOGEN_RATE_LIMIT_PER_MINUTE", 0),
+        retry_attempts=_env_int("AGENTICDOME_AUTOGEN_RETRY_ATTEMPTS", 2),
+        retry_backoff_s=_env_float("AGENTICDOME_AUTOGEN_RETRY_BACKOFF_S", 0.25),
+        circuit_breaker_failures=_env_int("AGENTICDOME_AUTOGEN_CIRCUIT_BREAKER_FAILURES", 5),
+        circuit_breaker_reset_s=_env_int("AGENTICDOME_AUTOGEN_CIRCUIT_BREAKER_RESET_S", 60),
+        audit_logging=_env_bool("AGENTICDOME_AUTOGEN_AUDIT_LOGGING", True),
+        otel_enabled=_env_bool("AGENTICDOME_AUTOGEN_OTEL_ENABLED", True),
+        emergency_block_tools=_env("AGENTICDOME_AUTOGEN_EMERGENCY_BLOCK_TOOLS"),
+        emergency_block_agents=_env("AGENTICDOME_AUTOGEN_EMERGENCY_BLOCK_AGENTS"),
+        strict_delegated_execution=_env_bool("AGENTICDOME_AUTOGEN_STRICT_DELEGATED_EXECUTION", True),
+        scan_code_expressions=_env_bool("AGENTICDOME_AUTOGEN_SCAN_CODE", True),
+        report_incidents=_env_bool("AGENTICDOME_REPORT_INCIDENTS", True),
+        blocked_incident_severity=_env("AGENTICDOME_BLOCKED_INCIDENT_SEVERITY", "high"),
+        conversation_window_messages=_env_int("AGENTICDOME_AUTOGEN_CONVERSATION_WINDOW", 12),
+        max_tool_calls_per_window=_env_int("AGENTICDOME_AUTOGEN_MAX_TOOL_CALLS_PER_WINDOW", 8),
+        freeze_on_policy_block=_env_bool("AGENTICDOME_AUTOGEN_FREEZE_ON_BLOCK", True),
+        revoke_agent_on_freeze=_env_bool("AGENTICDOME_AUTOGEN_REVOKE_ON_FREEZE", True),
+    )
+
+
+class AutoGenFirewallError(RuntimeError):
+    """Base error for the Microsoft AutoGen adapter."""
+
+
+class AutoGenFirewallDenied(AutoGenFirewallError):
+    """Raised when an AutoGen message, tool, handoff, or team run is denied."""
+
+
+class AutoGenFirewallConfigurationError(AutoGenFirewallError):
+    """Raised when AgenticDome runtime configuration is incomplete."""
+
+
+ToolBlocked = AutoGenFirewallDenied
+FirewallMisconfigured = AutoGenFirewallConfigurationError
+
+
+def _agent_name(value: Any, fallback: str) -> str:
+    if value is None:
+        return fallback
+    for key in ("name", "id", "agent_id", "type"):
+        candidate = value.get(key) if isinstance(value, dict) else getattr(value, key, None)
+        if candidate:
+            return str(candidate)
+    return fallback
+
+
+def _content(value: Any) -> str:
+    if value is None:
+        return ""
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict):
+        for key in ("content", "text", "message", "task", "arguments"):
+            if key in value and value[key] is not None:
+                return _content(value[key])
+        return json.dumps(value, sort_keys=True, default=str)
+    if isinstance(value, (list, tuple)):
+        return "\n".join(filter(None, (_content(item) for item in value)))
+    for key in ("content", "text", "message", "task", "arguments"):
+        candidate = getattr(value, key, None)
+        if candidate is not None:
+            return _content(candidate)
+    return str(value)
+
+
+def _replace_content(value: Any, content: str) -> Any:
+    if isinstance(value, str):
+        return content
+    if isinstance(value, dict):
+        updated = dict(value)
+        key = next((item for item in ("content", "text", "message", "task") if item in updated), "content")
+        updated[key] = content
+        return updated
+    model_copy = getattr(value, "model_copy", None)
+    if callable(model_copy) and hasattr(value, "content"):
+        try:
+            return model_copy(update={"content": content})
+        except Exception:
+            pass
+    if hasattr(value, "content"):
+        try:
+            updated = copy.copy(value)
+            setattr(updated, "content", content)
+            return updated
+        except Exception:
+            pass
+    return value
+
+
+class SecureAutoGenTeam:
+    """Dependency-light proxy for current AutoGen AgentChat Team.run/run_stream."""
+
+    def __init__(
+        self,
+        team: Any,
+        firewall: "AgenticDomeAutoGenFirewall",
+        *,
+        session_id: str,
+        agent_id: str,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> None:
+        self._team = team
+        self._firewall = firewall
+        self._session_id = session_id
+        self._agent_id = agent_id
+        self._policy_context = dict(policy_context or {})
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self._team, name)
+
+    async def run(self, *args: Any, **kwargs: Any) -> Any:
+        task = kwargs.get("task", args[0] if args else None)
+        if task is not None:
+            secured = await self._firewall.ainspect_message(
+                task,
+                session_id=self._session_id,
+                sender_agent_id="user",
+                recipient_agent_id=self._agent_id,
+                direction="team_input",
+                policy_context=self._policy_context,
+            )
+            if "task" in kwargs:
+                kwargs["task"] = secured
+            elif args:
+                args = (secured, *args[1:])
+        result = await self._team.run(*args, **kwargs)
+        return await self._firewall.areview_team_result(
+            result,
+            session_id=self._session_id,
+            agent_id=self._agent_id,
+            policy_context=self._policy_context,
+        )
+
+    async def run_stream(self, *args: Any, **kwargs: Any) -> AsyncIterator[Any]:
+        task = kwargs.get("task", args[0] if args else None)
+        if task is not None:
+            secured = await self._firewall.ainspect_message(
+                task,
+                session_id=self._session_id,
+                sender_agent_id="user",
+                recipient_agent_id=self._agent_id,
+                direction="team_input",
+                policy_context=self._policy_context,
+            )
+            if "task" in kwargs:
+                kwargs["task"] = secured
+            elif args:
+                args = (secured, *args[1:])
+        async for event in self._team.run_stream(*args, **kwargs):
+            yield await self._firewall.ainspect_message(
+                event,
+                session_id=self._session_id,
+                sender_agent_id=_agent_name(event, self._agent_id),
+                recipient_agent_id="team_output",
+                direction="team_stream",
+                policy_context=self._policy_context,
+                sanitize=True,
+            )
+
+
+class AgenticDomeAutoGenFirewall(FrameworkFirewallBase):
+    """Native policy boundaries for AutoGen AgentChat/Core and legacy ConversableAgent."""
+
+    def __init__(
+        self,
+        config: Optional[FirewallConfig] = None,
+        *,
+        client: Optional[AgentGuardClient] = None,
+        token_store: Optional[DecisionTokenStore] = None,
+    ) -> None:
+        resolved = config or load_config()
+        super().__init__(
+            resolved,
+            client=client,
+            token_store=token_store,
+            denied_error=AutoGenFirewallDenied,
+            configuration_error=AutoGenFirewallConfigurationError,
+            label="Microsoft AutoGen",
+            logger=logger,
+        )
+        self.config: FirewallConfig = resolved
+        self._conversation_lock = Lock()
+        self._conversation_windows: Dict[str, Deque[Dict[str, Any]]] = defaultdict(
+            lambda: deque(maxlen=max(1, self.config.conversation_window_messages))
+        )
+        self._frozen_sessions: Dict[str, str] = {}
+
+    authorize_direct_tool_call = FrameworkFirewallBase.authorize_tool_call
+
+    def is_session_frozen(self, session_id: str) -> bool:
+        with self._conversation_lock:
+            return session_id in self._frozen_sessions
+
+    def frozen_reason(self, session_id: str) -> Optional[str]:
+        with self._conversation_lock:
+            return self._frozen_sessions.get(session_id)
+
+    def unfreeze_session(self, session_id: str) -> None:
+        with self._conversation_lock:
+            self._frozen_sessions.pop(session_id, None)
+            self._conversation_windows.pop(session_id, None)
+
+    def freeze_session(self, session_id: str, *, agent_id: str, reason: str) -> None:
+        with self._conversation_lock:
+            self._frozen_sessions[session_id] = reason
+        self._audit("conversation_frozen", session_id=session_id, agent_id=agent_id, reason=reason)
+        if self.config.report_incidents and hasattr(self.client, "report_incident"):
+            try:
+                self._client_call_sync(
+                    self.client.report_incident,
+                    agent_id=agent_id,
+                    incident_type="autogen_conversation_policy_block",
+                    severity=self.config.blocked_incident_severity,
+                    details=reason,
+                    platform=self.config.platform,
+                )
+            except Exception as exc:
+                logger.warning("AutoGen incident reporting failed after enforcement: %s", exc)
+        if self.config.revoke_agent_on_freeze and hasattr(self.client, "revoke_decision_token"):
+            try:
+                self._client_call_sync(
+                    self.client.revoke_decision_token,
+                    agent_id=agent_id,
+                    reason=f"AutoGen session {session_id} frozen: {reason}",
+                )
+            except Exception as exc:
+                logger.warning("AutoGen revocation-epoch advance failed after enforcement: %s", exc)
+
+    @staticmethod
+    def _is_tool_event(message: Any) -> bool:
+        name = type(message).__name__.lower()
+        if any(marker in name for marker in ("functioncall", "toolcall", "codeexecution")):
+            return True
+        if isinstance(message, dict):
+            return bool(message.get("tool_name") or message.get("function_call") or message.get("tool_calls"))
+        return bool(getattr(message, "name", None) and getattr(message, "arguments", None) is not None)
+
+    def _record_event(
+        self,
+        *,
+        session_id: str,
+        sender_agent_id: str,
+        recipient_agent_id: str,
+        direction: str,
+        text: str,
+        tool_event: bool,
+    ) -> Dict[str, Any]:
+        event = {
+            "sender": sender_agent_id,
+            "recipient": recipient_agent_id,
+            "direction": direction,
+            "text": text,
+            "tool_event": tool_event,
+        }
+        with self._conversation_lock:
+            window = self._conversation_windows[session_id]
+            window.append(event)
+            snapshot = list(window)
+        tool_calls = sum(1 for item in snapshot if item["tool_event"])
+        digest = hashlib.sha256(
+            json.dumps(snapshot, sort_keys=True, separators=(",", ":"), default=str).encode()
+        ).hexdigest()
+        return {
+            "family": 2,
+            "family_name": "multi_agent_behavioral_trust",
+            "conversation_window_size": len(snapshot),
+            "conversation_window_limit": max(1, self.config.conversation_window_messages),
+            "tool_calls_in_window": tool_calls,
+            "tool_call_limit": max(0, self.config.max_tool_calls_per_window),
+            "conversation_digest": digest,
+            "conversation_participants": sorted(
+                {item["sender"] for item in snapshot} | {item["recipient"] for item in snapshot}
+            ),
+        }
+
+    def inspect_message(
+        self,
+        message: Any,
+        *,
+        session_id: str,
+        sender_agent_id: str,
+        recipient_agent_id: str,
+        direction: str,
+        policy_context: Optional[Dict[str, Any]] = None,
+        sanitize: bool = True,
+    ) -> Any:
+        if self.is_session_frozen(session_id):
+            raise AutoGenFirewallDenied(
+                f"AgenticDome froze AutoGen session {session_id}: {self.frozen_reason(session_id)}"
+            )
+        text = _content(message)
+        metrics = self._record_event(
+            session_id=session_id,
+            sender_agent_id=sender_agent_id,
+            recipient_agent_id=recipient_agent_id,
+            direction=direction,
+            text=text,
+            tool_event=self._is_tool_event(message),
+        )
+        context = {
+            **dict(policy_context or {}),
+            **metrics,
+            "source_agent_id": sender_agent_id,
+            "target_agent_id": recipient_agent_id,
+            "conversation_direction": direction,
+            "semantic_deviation_evaluation": "server_side",
+        }
+        if metrics["tool_call_limit"] and metrics["tool_calls_in_window"] > metrics["tool_call_limit"]:
+            reason = "AutoGen tool-call frequency exceeded the certified rolling-window limit."
+            self.freeze_session(session_id, agent_id=sender_agent_id, reason=reason)
+            raise AutoGenFirewallDenied(reason)
+        try:
+            self.screen_input(
+                session_id=session_id,
+                agent_id=recipient_agent_id,
+                text=text,
+                policy_context=context,
+            )
+            if not sanitize or text == "":
+                return message
+            reviewed = self.sanitize_output(
+                session_id=session_id,
+                agent_id=sender_agent_id,
+                text=text,
+                policy_context=context,
+            )
+            return _replace_content(message, reviewed)
+        except AutoGenFirewallDenied as exc:
+            if self.config.freeze_on_policy_block:
+                self.freeze_session(session_id, agent_id=sender_agent_id, reason=str(exc))
+            raise
+
+    async def ainspect_message(self, message: Any, **kwargs: Any) -> Any:
+        # AgentGuardClient is intentionally synchronous. Keeping one enforcement
+        # path here avoids ordering races between consecutive AutoGen team events.
+        return self.inspect_message(message, **kwargs)
+
+    def wrap_team(
+        self,
+        team: Any,
+        *,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> SecureAutoGenTeam:
+        sid = self.session_id(session_id, team)
+        aid = agent_id or _agent_name(team, self.config.agent_id)
+        return SecureAutoGenTeam(team, self, session_id=sid, agent_id=aid, policy_context=policy_context)
+
+    async def areview_team_result(
+        self,
+        result: Any,
+        *,
+        session_id: str,
+        agent_id: str,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        messages = getattr(result, "messages", None)
+        if not isinstance(messages, list):
+            return await self.ainspect_message(
+                result,
+                session_id=session_id,
+                sender_agent_id=agent_id,
+                recipient_agent_id="application",
+                direction="team_output",
+                policy_context=policy_context,
+                sanitize=True,
+            )
+        secured = []
+        for message in messages:
+            secured.append(
+                await self.ainspect_message(
+                    message,
+                    session_id=session_id,
+                    sender_agent_id=_agent_name(message, agent_id),
+                    recipient_agent_id="application",
+                    direction="team_output",
+                    policy_context=policy_context,
+                    sanitize=True,
+                )
+            )
+        try:
+            updated = copy.copy(result)
+            updated.messages = secured
+            return updated
+        except Exception:
+            return result
+
+    def _attach_method(
+        self,
+        agent: Any,
+        method_name: str,
+        *,
+        session_id: str,
+        agent_id: str,
+        direction: str,
+        policy_context: Optional[Dict[str, Any]],
+    ) -> bool:
+        original = getattr(agent, method_name, None)
+        if not callable(original):
+            return False
+        marker = f"_agenticdome_original_{method_name}"
+        if hasattr(agent, marker):
+            return False
+        setattr(agent, marker, original)
+        is_async = inspect.iscoroutinefunction(original)
+
+        async def async_wrapper(_agent: Any, message: Any, *args: Any, **kwargs: Any) -> Any:
+            peer = args[0] if args else kwargs.get("recipient") or kwargs.get("sender")
+            peer_id = _agent_name(peer, "autogen_peer")
+            sender, recipient = (agent_id, peer_id) if direction == "send" else (peer_id, agent_id)
+            secured = await self.ainspect_message(
+                message,
+                session_id=session_id,
+                sender_agent_id=sender,
+                recipient_agent_id=recipient,
+                direction=f"legacy_{direction}",
+                policy_context=policy_context,
+                sanitize=True,
+            )
+            return await original(secured, *args, **kwargs)
+
+        def sync_wrapper(_agent: Any, message: Any, *args: Any, **kwargs: Any) -> Any:
+            peer = args[0] if args else kwargs.get("recipient") or kwargs.get("sender")
+            peer_id = _agent_name(peer, "autogen_peer")
+            sender, recipient = (agent_id, peer_id) if direction == "send" else (peer_id, agent_id)
+            secured = self.inspect_message(
+                message,
+                session_id=session_id,
+                sender_agent_id=sender,
+                recipient_agent_id=recipient,
+                direction=f"legacy_{direction}",
+                policy_context=policy_context,
+                sanitize=True,
+            )
+            return original(secured, *args, **kwargs)
+
+        setattr(agent, method_name, MethodType(async_wrapper if is_async else sync_wrapper, agent))
+        return True
+
+    def attach_conversable_agent(
+        self,
+        agent: Any,
+        *,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Attach to legacy AutoGen 0.2 ConversableAgent send/receive lifecycles."""
+        sid = self.session_id(session_id, agent)
+        aid = agent_id or _agent_name(agent, self.config.agent_id)
+        for name, direction in (("send", "send"), ("receive", "receive"), ("a_send", "send"), ("a_receive", "receive")):
+            self._attach_method(
+                agent,
+                name,
+                session_id=sid,
+                agent_id=aid,
+                direction=direction,
+                policy_context=policy_context,
+            )
+        return agent
+
+    def attach_agentchat_agent(
+        self,
+        agent: Any,
+        *,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Attach to current AutoGen BaseChatAgent.on_messages/on_messages_stream."""
+        sid = self.session_id(session_id, agent)
+        aid = agent_id or _agent_name(agent, self.config.agent_id)
+        original = getattr(agent, "on_messages", None)
+        if callable(original) and not hasattr(agent, "_agenticdome_original_on_messages"):
+            setattr(agent, "_agenticdome_original_on_messages", original)
+
+            async def on_messages(_agent: Any, messages: Iterable[Any], *args: Any, **kwargs: Any) -> Any:
+                secured = []
+                for message in messages:
+                    secured.append(
+                        await self.ainspect_message(
+                            message,
+                            session_id=sid,
+                            sender_agent_id=_agent_name(message, "autogen_peer"),
+                            recipient_agent_id=aid,
+                            direction="agentchat_receive",
+                            policy_context=policy_context,
+                            sanitize=True,
+                        )
+                    )
+                response = await original(secured, *args, **kwargs)
+                chat_message = getattr(response, "chat_message", None)
+                if chat_message is not None:
+                    reviewed = await self.ainspect_message(
+                        chat_message,
+                        session_id=sid,
+                        sender_agent_id=aid,
+                        recipient_agent_id="autogen_team",
+                        direction="agentchat_send",
+                        policy_context=policy_context,
+                        sanitize=True,
+                    )
+                    try:
+                        updated = copy.copy(response)
+                        updated.chat_message = reviewed
+                        return updated
+                    except Exception:
+                        pass
+                return response
+
+            setattr(agent, "on_messages", MethodType(on_messages, agent))
+        return agent
+
+    def create_intervention_handler(
+        self,
+        *,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Create an AutoGen Core intervention handler for messages and FunctionCall tools."""
+        try:
+            from autogen_core import DefaultInterventionHandler, DropMessage, FunctionCall
+        except ImportError as exc:
+            raise ImportError(
+                "AutoGen integration requires Python 3.10+ and: pip install 'agenticdome-python-sdk[autogen]'"
+            ) from exc
+
+        firewall = self
+        sid = self.session_id(session_id)
+        aid = agent_id or self.config.agent_id
+
+        class AgenticDomeInterventionHandler(DefaultInterventionHandler):
+            async def on_send(self, message: Any, *, message_context: Any, recipient: Any) -> Any:
+                sender = _agent_name(getattr(message_context, "sender", None), aid)
+                recipient_id = _agent_name(recipient, "autogen_recipient")
+                try:
+                    if isinstance(message, FunctionCall):
+                        args = firewall.normalize_args(getattr(message, "arguments", {}))
+                        # Keep Core message ordering deterministic. The SDK client is
+                        # synchronous, and dispatching this boundary to the loop's
+                        # default executor can outlive short-lived AutoGen runtimes.
+                        decision = firewall.authorize_tool_call(
+                            session_id=sid,
+                            agent_id=sender,
+                            source_agent_id=sender,
+                            tool_name=str(getattr(message, "name", "autogen.tool")),
+                            tool_args=args,
+                            tool_platform="autogen_core",
+                            text=f"[Microsoft AutoGen] {sender} requests a tool execution",
+                            policy_context={**dict(policy_context or {}), "recipient_agent_id": recipient_id},
+                        )
+                        clean = firewall.sanitized_args(decision, args)
+                        if clean != args:
+                            try:
+                                return message.model_copy(update={"arguments": json.dumps(clean)})
+                            except Exception:
+                                pass
+                    return await firewall.ainspect_message(
+                        message,
+                        session_id=sid,
+                        sender_agent_id=sender,
+                        recipient_agent_id=recipient_id,
+                        direction="core_send",
+                        policy_context=policy_context,
+                        sanitize=True,
+                    )
+                except AutoGenFirewallDenied:
+                    return DropMessage
+
+        return AgenticDomeInterventionHandler()
+
+    def create_termination_condition(
+        self,
+        *,
+        session_id: Optional[str] = None,
+        agent_id: Optional[str] = None,
+        policy_context: Optional[Dict[str, Any]] = None,
+    ) -> Any:
+        """Create a composable AgentChat termination condition that freezes on policy denial."""
+        try:
+            from autogen_agentchat.base import TerminationCondition
+            from autogen_agentchat.messages import StopMessage
+        except ImportError as exc:
+            raise ImportError(
+                "AutoGen integration requires Python 3.10+ and: pip install 'agenticdome-python-sdk[autogen]'"
+            ) from exc
+
+        firewall = self
+        sid = self.session_id(session_id)
+        aid = agent_id or self.config.agent_id
+
+        class AgenticDomeTermination(TerminationCondition):
+            @property
+            def terminated(self) -> bool:
+                return firewall.is_session_frozen(sid)
+
+            async def __call__(self, messages: Iterable[Any]) -> Optional[Any]:
+                try:
+                    for message in messages:
+                        await firewall.ainspect_message(
+                            message,
+                            session_id=sid,
+                            sender_agent_id=_agent_name(message, aid),
+                            recipient_agent_id="autogen_team",
+                            direction="termination_check",
+                            policy_context=policy_context,
+                            sanitize=False,
+                        )
+                except AutoGenFirewallDenied as exc:
+                    return StopMessage(content=str(exc), source="AgenticDome")
+                return None
+
+            async def reset(self) -> None:
+                firewall.unfreeze_session(sid)
+
+        return AgenticDomeTermination()
+
+
+__all__ = [
+    "AgenticDomeAutoGenFirewall",
+    "AutoGenFirewallConfigurationError",
+    "AutoGenFirewallDenied",
+    "AutoGenFirewallError",
+    "FirewallConfig",
+    "SecureAutoGenTeam",
+    "load_config",
+]