agenticdome-python-sdk 1.2.13__tar.gz → 1.2.14__tar.gz

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.13
+Version: 1.2.14
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/agenticdome_python_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: agenticdome-python-sdk
-Version: 1.2.13
+Version: 1.2.14
 Summary: Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement.
 Author: AgenticDome
 License-Expression: Apache-2.0

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/agno.md

@@ -14,18 +14,43 @@ agenticdome-demo --framework agno --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime, and make sure simulation is not inherited by
+the production process:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+This factory receives the application-owned model and CRM operation explicitly,
+defines the secured tool before registration, then attaches hooks before the
+agent's first run:
+
 ```python
+from typing import Any, Callable, Tuple
+
+from agno.agent import Agent
 from agenticdome_sdk.agno import AgenticDomeAgnoFirewall
 
-firewall = AgenticDomeAgnoFirewall()
-agent = firewall.attach_firewall(agent)
+def build_secured_agent(
+    *,
+    model: Any,
+    crm_lookup: Callable[[str], Any],
+) -> Tuple[Any, AgenticDomeAgnoFirewall]:
+    firewall = AgenticDomeAgnoFirewall()
+
+    @firewall.secure_tool(
+        tool_name="crm.customer.read",
+        tool_platform="crm",
+    )
+    def read_customer(agent_context: Any, customer_id: str) -> Any:
+        return crm_lookup(customer_id)
 
-@firewall.secure_tool(
-    tool_name="crm.customer.read",
-    tool_platform="crm",
-)
-def read_customer(agent, customer_id: str):
-    return crm.read_customer(customer_id)
+    agent = Agent(name="support-agent", model=model, tools=[read_customer])
+    firewall.attach_firewall(agent)
+    return agent, firewall
 ```
 
 Use `create_hook_bundle()`, `create_middleware()` or `create_plugin()` when the

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/autogen.md

@@ -14,16 +14,31 @@ agenticdome-demo --framework autogen --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned team and task into an async boundary rather than
+copying a top-level `await` statement:
+
 ```python
+from typing import Any
+
 from agenticdome_sdk.autogen import AgenticDomeAutoGenFirewall
 
-firewall = AgenticDomeAutoGenFirewall()
-secure_team = firewall.wrap_team(
-    team,
-    session_id="stable-session-id",
-    agent_id="operations-team",
-)
-result = await secure_team.run(task=user_prompt)
+async def run_secured_team(*, team: Any, user_prompt: str) -> Any:
+    firewall = AgenticDomeAutoGenFirewall()
+    secure_team = firewall.wrap_team(
+        team,
+        session_id="stable-session-id",
+        agent_id="operations-team",
+    )
+    return await secure_team.run(task=user_prompt)
 ```
 
 For AutoGen Core, install `create_intervention_handler(...)` when constructing

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/aws-bedrock.md

@@ -14,20 +14,37 @@ agenticdome-demo --framework bedrock --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Create the application-owned boto3 client in your AWS bootstrap, then pass it
+and the real request into this async boundary:
+
 ```python
-import boto3
-from agenticdome_sdk.aws_bedrock import AgenticDomeAWSBedrockFirewall
+from typing import Any, Dict, List
 
-bedrock = boto3.client("bedrock-runtime", region_name="us-east-1")
-firewall = AgenticDomeAWSBedrockFirewall()
+from agenticdome_sdk.aws_bedrock import AgenticDomeAWSBedrockFirewall
 
-response = await firewall.converse_securely(
-    bedrock_runtime_client=bedrock,
-    model_id=model_id,
-    messages=messages,
-    agent_id="support-agent",
-    session_id="stable-session-id",
-)
+async def converse_with_policy(
+    *,
+    bedrock_runtime_client: Any,
+    model_id: str,
+    messages: List[Dict[str, Any]],
+) -> Any:
+    firewall = AgenticDomeAWSBedrockFirewall()
+    return await firewall.converse_securely(
+        bedrock_runtime_client=bedrock_runtime_client,
+        model_id=model_id,
+        messages=messages,
+        agent_id="support-agent",
+        session_id="stable-session-id",
+    )
 ```
 
 Use the corresponding secure methods for streaming, `InvokeModel` and Bedrock

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/claude-agent-sdk.md

@@ -14,19 +14,39 @@ agenticdome-demo --framework claude --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned options and message consumer explicitly. Keeping
+the async iterator inside a function makes the example valid Python:
+
 ```python
+from typing import Any, Callable
+
 from agenticdome_sdk.claude import AgenticDomeClaudeFirewall
 
-firewall = AgenticDomeClaudeFirewall()
-options = firewall.install_on_options(options)
+async def run_secured_query(
+    *,
+    options: Any,
+    user_prompt: str,
+    consume: Callable[[Any], None],
+) -> None:
+    firewall = AgenticDomeClaudeFirewall()
+    secured_options = firewall.install_on_options(options)
 
-async for message in firewall.secure_query(
-    prompt=user_prompt,
-    options=options,
-    session_id="stable-session-id",
-    agent_id="support-agent",
-):
-    consume(message)
+    async for message in firewall.secure_query(
+        prompt=user_prompt,
+        options=secured_options,
+        session_id="stable-session-id",
+        agent_id="support-agent",
+    ):
+        consume(message)
 ```
 
 Use `run_client_securely(...)` for a constructed SDK client and

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/crewai.md

@@ -18,15 +18,26 @@ contacting a sidecar or executing either demonstration tool.
 ## Attach in production
 
 Configure the assigned runtime sidecar URL, Runtime/SDK key and matching tenant
-ID, then import the adapter in application bootstrap **before** constructing
-agents or crews:
+ID, and make sure simulation is not inherited by the production process:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Then import the adapter in application bootstrap **before** constructing the
+application-owned agents or crews:
 
 ```python
 import agenticdome_sdk.crewai  # registers the process-wide hooks
 
-from crewai import Agent, Crew, Task
+from crewai import Crew
 
-# Construct agents, tasks and crews only after the security hooks are loaded.
+def build_secured_crew(*, agents: list, tasks: list) -> Crew:
+    # Agents and tasks are constructed by the application after hooks load.
+    return Crew(agents=agents, tasks=tasks)
 ```
 
 For explicit lifecycle control, instantiate `AgenticDomeCrewAIFirewall` and

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/custom-python.md

@@ -14,32 +14,48 @@ agenticdome-demo --framework custom-python --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first. The executor remains application-owned:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
 ```python
+from typing import Any, Callable, Dict
+
 from agenticdome_sdk import AgentGuardClient
 
-client = AgentGuardClient()
-decision = client.guardrail_validate(
-    text="Support agent requests a customer lookup.",
-    agent_id="support-agent",
-    session_id="stable-session-id",
-    direction="outbound",
-    platform="python",
-    tool_name="crm.customer.read",
-    tool_args={"customer_id": customer_id},
-)
-
-if decision.get("verdict") == "BLOCKED":
-    raise PermissionError(decision.get("reason", "Action blocked"))
-
-# Execute only after the decision and use sanitized arguments when returned.
-raw_output = execute_customer_lookup(customer_id)
-safe_output = client.mesh_validate(
-    agent_id="support-agent",
-    session_id="stable-session-id",
-    direction="output",
-    platform="python",
-    text=str(raw_output),
-)
+def secured_customer_lookup(
+    *,
+    customer_id: str,
+    execute_customer_lookup: Callable[[str], Any],
+) -> Dict[str, Any]:
+    client = AgentGuardClient()
+    decision = client.guardrail_validate(
+        text="Support agent requests a customer lookup.",
+        agent_id="support-agent",
+        session_id="stable-session-id",
+        direction="outbound",
+        platform="python",
+        tool_name="crm.customer.read",
+        tool_args={"customer_id": customer_id},
+    )
+
+    if decision.get("verdict") == "BLOCKED":
+        raise PermissionError(decision.get("reason", "Action blocked"))
+
+    effective_args = decision.get("sanitized_tool_args") or {"customer_id": customer_id}
+    raw_output = execute_customer_lookup(str(effective_args["customer_id"]))
+    return client.mesh_validate(
+        agent_id="support-agent",
+        session_id="stable-session-id",
+        direction="output",
+        platform="python",
+        text=str(raw_output),
+    )
 ```
 
 Use the A2A authorization and verification methods when a manager delegates a

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/google-adk.md

@@ -14,17 +14,32 @@ agenticdome-demo --framework google-adk --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned model into the same factory that constructs every
+protected ADK agent:
+
 ```python
+from typing import Any
+
 from google.adk.agents import LlmAgent
 from agenticdome_sdk.google_adk import AgenticDomeGoogleADKFirewall
 
-firewall = AgenticDomeGoogleADKFirewall()
-agent = LlmAgent(
-    name="support-agent",
-    model="gemini-2.5-flash",
-    instruction="Help support users safely.",
-    **firewall.build_callback_kwargs(),
-)
+def build_secured_agent(*, model: Any) -> LlmAgent:
+    firewall = AgenticDomeGoogleADKFirewall()
+    return LlmAgent(
+        name="support-agent",
+        model=model,
+        instruction="Help support users safely.",
+        **firewall.build_callback_kwargs(),
+    )
 ```
 
 Use `install_on_agent(...)` for an existing agent, `create_plugin()` for

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/langgraph.md

@@ -14,20 +14,42 @@ agenticdome-demo --framework langgraph --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned agent and tool nodes into the graph factory; do not
+leave raw execution nodes reachable through another edge:
+
 ```python
+from typing import Any, Callable
+
 from langgraph.graph import START, StateGraph
 from agenticdome_sdk.langgraph import AgentState, AgenticDomeLangGraphFirewall
 
-firewall = AgenticDomeLangGraphFirewall()
-graph = StateGraph(AgentState)
-graph.add_node("input_security", firewall.input_node(agent_id="support"))
-graph.add_node("agent", agent_node)
-graph.add_node("tool_security", firewall.transition_node(agent_id="support"))
-graph.add_node("tools", tool_node)
-graph.add_node("output_security", firewall.output_node(agent_id="support"))
-graph.add_edge(START, "input_security")
-# Connect input_security -> agent -> tool_security -> tools -> output_security.
-compiled = graph.compile()
+def build_secured_graph(
+    *,
+    agent_node: Callable[[AgentState], Any],
+    tool_node: Callable[[AgentState], Any],
+) -> Any:
+    firewall = AgenticDomeLangGraphFirewall()
+    graph = StateGraph(AgentState)
+    graph.add_node("input_security", firewall.input_node(agent_id="support"))
+    graph.add_node("agent", agent_node)
+    graph.add_node("tool_security", firewall.transition_node(agent_id="support"))
+    graph.add_node("tools", tool_node)
+    graph.add_node("output_security", firewall.output_node(agent_id="support"))
+    graph.add_edge(START, "input_security")
+    graph.add_edge("input_security", "agent")
+    graph.add_edge("agent", "tool_security")
+    graph.add_edge("tool_security", "tools")
+    graph.add_edge("tools", "output_security")
+    return graph.compile()
 ```
 
 Alternatively use `wrap_agent_node()`, `wrap_tool_node()`, or

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/llamaindex.md

@@ -14,23 +14,42 @@ agenticdome-demo --framework llamaindex --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned lookup function and query engine into the assembly
+function instead of relying on undeclared example globals:
+
 ```python
+from typing import Any, Callable, Tuple
+
 from agenticdome_sdk.llamaindex import AgenticDomeLlamaIndexFirewall
 
-firewall = AgenticDomeLlamaIndexFirewall()
-secure_lookup = firewall.to_function_tool(
-    lookup_customer,
-    tool_name="crm.customer.read",
-    tool_platform="crm",
-    agent_id="support-agent",
-    session_id="stable-session-id",
-)
-
-secure_query_engine = firewall.wrap_query_engine(
-    query_engine,
-    agent_id="support-agent",
-    session_id="stable-session-id",
-)
+def build_secured_rag(
+    *,
+    lookup_customer: Callable[..., Any],
+    query_engine: Any,
+) -> Tuple[Any, Any]:
+    firewall = AgenticDomeLlamaIndexFirewall()
+    secure_lookup = firewall.to_function_tool(
+        lookup_customer,
+        tool_name="crm.customer.read",
+        tool_platform="crm",
+        agent_id="support-agent",
+        session_id="stable-session-id",
+    )
+    secure_query_engine = firewall.wrap_query_engine(
+        query_engine,
+        agent_id="support-agent",
+        session_id="stable-session-id",
+    )
+    return secure_lookup, secure_query_engine
 ```
 
 Also wrap retrievers or install the node postprocessor before retrieved text is

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/microsoft-agent-framework.md

@@ -16,17 +16,36 @@ Install the Microsoft packages used by your application separately.
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned agent and real tool handler into the assembly
+function, then register only the returned secured handler:
+
 ```python
-from agenticdome_sdk.microsoft_agent_framework import AgenticDomeMicrosoftAgentFirewall
+from typing import Any, Callable, Tuple
 
-firewall = AgenticDomeMicrosoftAgentFirewall()
-agent = firewall.install_on_agent(agent)
+from agenticdome_sdk.microsoft_agent_framework import AgenticDomeMicrosoftAgentFirewall
 
-secure_lookup = firewall.wrap_tool_handler(
-    tool_name="crm.customer.read",
-    tool_platform="crm",
-    handler=raw_lookup,
-)
+def secure_agent_and_tool(
+    *,
+    agent: Any,
+    raw_lookup: Callable[..., Any],
+) -> Tuple[Any, Callable[..., Any]]:
+    firewall = AgenticDomeMicrosoftAgentFirewall()
+    secured_agent = firewall.install_on_agent(agent)
+    secure_lookup = firewall.wrap_tool_handler(
+        tool_name="crm.customer.read",
+        tool_platform="crm",
+        handler=raw_lookup,
+    )
+    return secured_agent, secure_lookup
 ```
 
 Applications that own invocation should call `run_agent_securely(...)`. Use

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/microsoft-ai-foundry.md

@@ -14,17 +14,36 @@ agenticdome-demo --framework foundry --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned Foundry client and executor into the assembly
+function, then publish only the secured executor to the dispatch table:
+
 ```python
-from agenticdome_sdk.microsoft_ai_foundry import AgenticDomeMicrosoftAIFoundryFirewall
+from typing import Any, Callable, Tuple
 
-firewall = AgenticDomeMicrosoftAIFoundryFirewall()
-client = firewall.install_on_client(client)
+from agenticdome_sdk.microsoft_ai_foundry import AgenticDomeMicrosoftAIFoundryFirewall
 
-secure_executor = firewall.wrap_tool_executor(
-    tool_name="payments.refund.create",
-    tool_platform="payments",
-    handler=raw_refund_executor,
-)
+def secure_foundry_client(
+    *,
+    client: Any,
+    raw_refund_executor: Callable[..., Any],
+) -> Tuple[Any, Callable[..., Any]]:
+    firewall = AgenticDomeMicrosoftAIFoundryFirewall()
+    secured_client = firewall.install_on_client(client)
+    secure_executor = firewall.wrap_tool_executor(
+        tool_name="payments.refund.create",
+        tool_platform="payments",
+        handler=raw_refund_executor,
+    )
+    return secured_client, secure_executor
 ```
 
 Call `run_secure(...)` when the application controls the complete run. Register

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/openai-agents.md

@@ -14,22 +14,43 @@ agenticdome-demo --framework openai-agents --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned runner, agent and raw handler into an async boundary.
+Register only `secure_lookup` with the framework's function-tool mechanism:
+
 ```python
+from typing import Any, Callable, Tuple
+
 from agenticdome_sdk.openai_agents import AgenticDomeOpenAIAgentsFirewall
 
-firewall = AgenticDomeOpenAIAgentsFirewall()
-secure_lookup = firewall.wrap_tool_handler(
-    tool_name="crm.customer.read",
-    tool_platform="crm",
-    handler=raw_lookup,
-)
-
-result = await firewall.run_agent_securely(
-    runner=Runner,
-    agent=agent,
-    input_text=user_prompt,
-    session_id="stable-session-id",
-)
+async def run_secured_agent(
+    *,
+    runner: Any,
+    agent: Any,
+    user_prompt: str,
+    raw_lookup: Callable[..., Any],
+) -> Tuple[Any, Callable[..., Any]]:
+    firewall = AgenticDomeOpenAIAgentsFirewall()
+    secure_lookup = firewall.wrap_tool_handler(
+        tool_name="crm.customer.read",
+        tool_platform="crm",
+        handler=raw_lookup,
+    )
+    result = await firewall.run_agent_securely(
+        runner=runner,
+        agent=agent,
+        input_text=user_prompt,
+        session_id="stable-session-id",
+    )
+    return result, secure_lookup
 ```
 
 Register `secure_lookup` with `@function_tool`; do not register `raw_lookup`.

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/pydanticai.md

@@ -14,19 +14,40 @@ agenticdome-demo --framework pydanticai --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned agent and CRM coroutine into the same factory that
+registers tools; no undeclared globals are required:
+
 ```python
+from typing import Any, Awaitable, Callable
+
 from agenticdome_sdk.pydantic import CyberSecFirewall
 
-firewall = CyberSecFirewall()
-firewall.install_native_hooks(agent)
+def attach_secured_tools(
+    *,
+    agent: Any,
+    crm_lookup: Callable[[str], Awaitable[Any]],
+) -> CyberSecFirewall:
+    firewall = CyberSecFirewall()
+    firewall.install_native_hooks(agent)
+
+    @agent.tool
+    @firewall.secure_tool(
+        tool_name="crm.customer.read",
+        tool_platform="crm",
+    )
+    async def read_customer(ctx: Any, customer_id: str) -> Any:
+        return await crm_lookup(customer_id)
 
-@agent.tool
-@firewall.secure_tool(
-    tool_name="crm.customer.read",
-    tool_platform="crm",
-)
-async def read_customer(ctx, customer_id: str):
-    return await crm.read_customer(customer_id)
+    return firewall
 ```
 
 Create the firewall after configuring the assigned sidecar URL, Runtime/SDK

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/docs/frameworks/smolagents.md

@@ -14,18 +14,31 @@ agenticdome-demo --framework smolagents --scenario both
 
 ## Attach in production
 
+Configure the assigned runtime first:
+
+```bash
+unset AGENTICDOME_MODE
+export AGENTICDOME_API_BASE="https://your-assigned-sidecar.example.com"
+export AGENTICDOME_API_KEY="your-runtime-sdk-key"
+export AGENTICDOME_TENANT_ID="your-tenant-id"
+```
+
+Pass the application-owned agent and prompt into the execution boundary:
+
 ```python
-from agenticdome_sdk.smolagents import AgenticDomeSmolagentsFirewall
+from typing import Any
 
-firewall = AgenticDomeSmolagentsFirewall()
-agent = firewall.attach_firewall(agent, session_id="stable-session-id")
+from agenticdome_sdk.smolagents import AgenticDomeSmolagentsFirewall
 
-result = firewall.run_agent_securely(
-    agent,
-    user_prompt,
-    session_id="stable-session-id",
-    agent_id="support-agent",
-)
+def run_secured_agent(*, agent: Any, user_prompt: str) -> Any:
+    firewall = AgenticDomeSmolagentsFirewall()
+    secured_agent = firewall.attach_firewall(agent, session_id="stable-session-id")
+    return firewall.run_agent_securely(
+        secured_agent,
+        user_prompt,
+        session_id="stable-session-id",
+        agent_id="support-agent",
+    )
 ```
 
 Wrap sensitive native tools with `wrap_tool(...)`. Use

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "agenticdome-python-sdk"
-version = "1.2.13"
+version = "1.2.14"
 description = "Official Python SDK for AgenticDome security guardrails, DLP, tool authorization, and multi-agent delegation enforcement."
 readme = "README.md"
 requires-python = ">=3.9"

{agenticdome_python_sdk-1.2.13 → agenticdome_python_sdk-1.2.14}/tests/test_framework_guides.py

@@ -2,10 +2,15 @@
 
 from __future__ import annotations
 
+import ast
 import importlib
 import re
+import subprocess
+import sys
 from pathlib import Path
 
+import pytest
+
 
 SDK_ROOT = Path(__file__).resolve().parents[1]
 GUIDE_ROOT = SDK_ROOT / "docs" / "frameworks"
@@ -72,6 +77,14 @@ GUIDES = {
 }
 
 
+def _production_python(guide: Path) -> str:
+    text = guide.read_text(encoding="utf-8")
+    section = text.split("## Attach in production", 1)[1].split("## Launch checks", 1)[0]
+    blocks = re.findall(r"```python\n(.*?)```", section, flags=re.DOTALL)
+    assert blocks, f"{guide.name}: missing production Python block"
+    return "\n\n".join(blocks)
+
+
 def test_every_supported_non_mcp_integration_has_a_launch_guide() -> None:
     index = (GUIDE_ROOT / "README.md").read_text(encoding="utf-8")
     for filename in GUIDES:
@@ -95,6 +108,34 @@ def test_documented_attachment_methods_exist_on_public_adapter_classes() -> None
             assert method in guide, f"{filename}: public method {method} is not documented"
 
 
+@pytest.mark.parametrize("filename", sorted(GUIDES))
+def test_production_snippets_compile_without_undefined_names_or_top_level_await(filename: str, tmp_path: Path) -> None:
+    source = _production_python(GUIDE_ROOT / filename)
+    tree = ast.parse(source, filename=filename)
+    compile(tree, filename, "exec")
+    assert not any(isinstance(node, (ast.Await, ast.AsyncFor)) for node in tree.body), (
+        f"{filename}: await/async-for must be inside an async integration function"
+    )
+
+    snippet = tmp_path / filename.replace(".md", ".py")
+    snippet.write_text(source, encoding="utf-8")
+    lint = subprocess.run(
+        [sys.executable, "-m", "ruff", "check", "--select", "F821", "--output-format", "concise", str(snippet)],
+        capture_output=True,
+        text=True,
+        check=False,
+    )
+    assert lint.returncode == 0, f"{filename}: production snippet has undefined names\n{lint.stdout}{lint.stderr}"
+
+
+@pytest.mark.parametrize("filename", sorted(GUIDES))
+def test_each_framework_guide_is_self_contained_about_live_runtime_configuration(filename: str) -> None:
+    text = (GUIDE_ROOT / filename).read_text(encoding="utf-8")
+    for variable in ("AGENTICDOME_API_BASE", "AGENTICDOME_API_KEY", "AGENTICDOME_TENANT_ID"):
+        assert variable in text, f"{filename}: missing {variable} production configuration"
+    assert "application-owned" in text.lower(), f"{filename}: application-owned inputs are not explained"
+
+
 def test_local_markdown_links_in_launch_documentation_resolve() -> None:
     documents = [
         *GUIDE_ROOT.glob("*.md"),