axonflow 1.0.0__tar.gz → 1.4.0__tar.gz

{axonflow-1.0.0 → axonflow-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: axonflow
-Version: 1.0.0
+Version: 1.4.0
 Summary: AxonFlow Python SDK - Enterprise AI Governance in 3 Lines of Code
 Author-email: AxonFlow <dev@getaxonflow.com>
 Maintainer-email: AxonFlow <dev@getaxonflow.com>
@@ -202,6 +202,38 @@ result = await client.query_connector(
 )
 ```
 
+### MCP Policy Features (v3.2.0)
+
+**Exfiltration Detection** - Prevent large-scale data extraction:
+
+```python
+# Query with exfiltration limits (default: 10K rows, 10MB)
+result = await client.query_connector(
+    user_token="user-jwt",
+    connector_name="postgres",
+    operation="query",
+    params={"sql": "SELECT * FROM customers"}
+)
+
+# Check exfiltration info
+if result.policy_info.exfiltration_check.exceeded:
+    print(f"Limit exceeded: {result.policy_info.exfiltration_check.limit_type}")
+
+# Configure: MCP_MAX_ROWS_PER_QUERY=1000, MCP_MAX_BYTES_PER_QUERY=5242880
+```
+
+**Dynamic Policy Evaluation** - Orchestrator-based rate limiting, budget controls:
+
+```python
+# Response includes dynamic policy info when enabled
+if result.policy_info.dynamic_policy_info.orchestrator_reachable:
+    print(f"Policies evaluated: {result.policy_info.dynamic_policy_info.policies_evaluated}")
+    for policy in result.policy_info.dynamic_policy_info.matched_policies:
+        print(f"  {policy.policy_name}: {policy.action}")
+
+# Enable: MCP_DYNAMIC_POLICIES_ENABLED=true
+```
+
 ### Multi-Agent Planning
 
 Generate and execute multi-agent plans:
@@ -227,9 +259,8 @@ from axonflow import AxonFlow, Mode, RetryConfig
 
 client = AxonFlow(
     endpoint="https://your-agent.axonflow.com",
-    client_id="your-client-id",
-    client_secret="your-client-secret",
-    license_key="optional-license-key",      # For enterprise features
+    client_id="your-client-id",               # Required for enterprise features
+    client_secret="your-client-secret",       # Required for enterprise features
     mode=Mode.PRODUCTION,                     # or Mode.SANDBOX
     debug=True,                               # Enable debug logging
     timeout=60.0,                             # Request timeout in seconds
@@ -305,12 +336,102 @@ ruff format .
 mypy axonflow
 ```
 
+## Examples
+
+Complete working examples for all features are available in the [examples folder](https://github.com/getaxonflow/axonflow/tree/main/examples).
+
+### Community Features
+
+```python
+# PII Detection - Automatically detect sensitive data
+result = await client.get_policy_approved_context(
+    user_token="user-123",
+    query="My SSN is 123-45-6789"
+)
+# result.approved = True, result.requires_redaction = True (SSN detected)
+
+# SQL Injection Detection - Block malicious queries
+result = await client.get_policy_approved_context(
+    user_token="user-123",
+    query="SELECT * FROM users; DROP TABLE users;"
+)
+# result.approved = False, result.block_reason = "SQL injection detected"
+
+# Static Policies - List and manage built-in policies
+policies = await client.list_policies()
+# Returns: [Policy(name="pii-detection", enabled=True), ...]
+
+# Dynamic Policies - Create runtime policies
+await client.create_dynamic_policy(
+    name="block-competitor-queries",
+    conditions={"contains": ["competitor", "pricing"]},
+    action="block"
+)
+
+# MCP Connectors - Query external data sources
+resp = await client.query_connector(
+    user_token="user-123",
+    connector_name="postgres-db",
+    operation="query",
+    params={"sql": "SELECT name FROM customers"}
+)
+
+# Multi-Agent Planning - Orchestrate complex workflows
+plan = await client.generate_plan(
+    query="Research AI governance regulations",
+    domain="legal"
+)
+result = await client.execute_plan(plan.plan_id)
+
+# Audit Logging - Track all LLM interactions
+await client.audit_llm_call(
+    context_id=ctx.context_id,
+    response_summary="AI response summary",
+    provider="openai",
+    model="gpt-4",
+    token_usage=TokenUsage(prompt_tokens=100, completion_tokens=200, total_tokens=300),
+    latency_ms=450
+)
+```
+
+### Enterprise Features
+
+These features require an AxonFlow Enterprise license:
+
+```python
+# Code Governance - Automated PR reviews with AI
+pr_result = await client.review_pull_request(
+    repo_owner="your-org",
+    repo_name="your-repo",
+    pr_number=123,
+    check_types=["security", "style", "performance"]
+)
+
+# Cost Controls - Budget management for LLM usage
+budget = await client.get_budget("team-engineering")
+# Returns: Budget(limit=1000.00, used=234.56, remaining=765.44)
+
+# MCP Policy Enforcement - Automatic PII redaction in connector responses
+resp = await client.query_connector("user", "postgres", "SELECT * FROM customers", {})
+# resp.policy_info.redacted = True
+# resp.policy_info.redacted_fields = ["ssn", "credit_card"]
+```
+
+For enterprise features, contact [sales@getaxonflow.com](mailto:sales@getaxonflow.com).
+
 ## Documentation
 
 - [Getting Started](https://docs.getaxonflow.com/sdk/python-getting-started)
 - [Gateway Mode Guide](https://docs.getaxonflow.com/sdk/gateway-mode)
-- [Examples](https://github.com/getaxonflow/axonflow/tree/main/examples)
+
+## Support
+
+- **Documentation**: https://docs.getaxonflow.com
+- **Issues**: https://github.com/getaxonflow/axonflow-sdk-python/issues
+- **Email**: dev@getaxonflow.com
 
 ## License
 
 MIT - See [LICENSE](LICENSE) for details.
+
+<img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=fbda6e64-1812-428b-b135-ed2b548ce50d" />

{axonflow-1.0.0 → axonflow-1.4.0}/README.md

@@ -143,6 +143,38 @@ result = await client.query_connector(
 )
 ```
 
+### MCP Policy Features (v3.2.0)
+
+**Exfiltration Detection** - Prevent large-scale data extraction:
+
+```python
+# Query with exfiltration limits (default: 10K rows, 10MB)
+result = await client.query_connector(
+    user_token="user-jwt",
+    connector_name="postgres",
+    operation="query",
+    params={"sql": "SELECT * FROM customers"}
+)
+
+# Check exfiltration info
+if result.policy_info.exfiltration_check.exceeded:
+    print(f"Limit exceeded: {result.policy_info.exfiltration_check.limit_type}")
+
+# Configure: MCP_MAX_ROWS_PER_QUERY=1000, MCP_MAX_BYTES_PER_QUERY=5242880
+```
+
+**Dynamic Policy Evaluation** - Orchestrator-based rate limiting, budget controls:
+
+```python
+# Response includes dynamic policy info when enabled
+if result.policy_info.dynamic_policy_info.orchestrator_reachable:
+    print(f"Policies evaluated: {result.policy_info.dynamic_policy_info.policies_evaluated}")
+    for policy in result.policy_info.dynamic_policy_info.matched_policies:
+        print(f"  {policy.policy_name}: {policy.action}")
+
+# Enable: MCP_DYNAMIC_POLICIES_ENABLED=true
+```
+
 ### Multi-Agent Planning
 
 Generate and execute multi-agent plans:
@@ -168,9 +200,8 @@ from axonflow import AxonFlow, Mode, RetryConfig
 
 client = AxonFlow(
     endpoint="https://your-agent.axonflow.com",
-    client_id="your-client-id",
-    client_secret="your-client-secret",
-    license_key="optional-license-key",      # For enterprise features
+    client_id="your-client-id",               # Required for enterprise features
+    client_secret="your-client-secret",       # Required for enterprise features
     mode=Mode.PRODUCTION,                     # or Mode.SANDBOX
     debug=True,                               # Enable debug logging
     timeout=60.0,                             # Request timeout in seconds
@@ -246,12 +277,102 @@ ruff format .
 mypy axonflow
 ```
 
+## Examples
+
+Complete working examples for all features are available in the [examples folder](https://github.com/getaxonflow/axonflow/tree/main/examples).
+
+### Community Features
+
+```python
+# PII Detection - Automatically detect sensitive data
+result = await client.get_policy_approved_context(
+    user_token="user-123",
+    query="My SSN is 123-45-6789"
+)
+# result.approved = True, result.requires_redaction = True (SSN detected)
+
+# SQL Injection Detection - Block malicious queries
+result = await client.get_policy_approved_context(
+    user_token="user-123",
+    query="SELECT * FROM users; DROP TABLE users;"
+)
+# result.approved = False, result.block_reason = "SQL injection detected"
+
+# Static Policies - List and manage built-in policies
+policies = await client.list_policies()
+# Returns: [Policy(name="pii-detection", enabled=True), ...]
+
+# Dynamic Policies - Create runtime policies
+await client.create_dynamic_policy(
+    name="block-competitor-queries",
+    conditions={"contains": ["competitor", "pricing"]},
+    action="block"
+)
+
+# MCP Connectors - Query external data sources
+resp = await client.query_connector(
+    user_token="user-123",
+    connector_name="postgres-db",
+    operation="query",
+    params={"sql": "SELECT name FROM customers"}
+)
+
+# Multi-Agent Planning - Orchestrate complex workflows
+plan = await client.generate_plan(
+    query="Research AI governance regulations",
+    domain="legal"
+)
+result = await client.execute_plan(plan.plan_id)
+
+# Audit Logging - Track all LLM interactions
+await client.audit_llm_call(
+    context_id=ctx.context_id,
+    response_summary="AI response summary",
+    provider="openai",
+    model="gpt-4",
+    token_usage=TokenUsage(prompt_tokens=100, completion_tokens=200, total_tokens=300),
+    latency_ms=450
+)
+```
+
+### Enterprise Features
+
+These features require an AxonFlow Enterprise license:
+
+```python
+# Code Governance - Automated PR reviews with AI
+pr_result = await client.review_pull_request(
+    repo_owner="your-org",
+    repo_name="your-repo",
+    pr_number=123,
+    check_types=["security", "style", "performance"]
+)
+
+# Cost Controls - Budget management for LLM usage
+budget = await client.get_budget("team-engineering")
+# Returns: Budget(limit=1000.00, used=234.56, remaining=765.44)
+
+# MCP Policy Enforcement - Automatic PII redaction in connector responses
+resp = await client.query_connector("user", "postgres", "SELECT * FROM customers", {})
+# resp.policy_info.redacted = True
+# resp.policy_info.redacted_fields = ["ssn", "credit_card"]
+```
+
+For enterprise features, contact [sales@getaxonflow.com](mailto:sales@getaxonflow.com).
+
 ## Documentation
 
 - [Getting Started](https://docs.getaxonflow.com/sdk/python-getting-started)
 - [Gateway Mode Guide](https://docs.getaxonflow.com/sdk/gateway-mode)
-- [Examples](https://github.com/getaxonflow/axonflow/tree/main/examples)
+
+## Support
+
+- **Documentation**: https://docs.getaxonflow.com
+- **Issues**: https://github.com/getaxonflow/axonflow-sdk-python/issues
+- **Email**: dev@getaxonflow.com
 
 ## License
 
 MIT - See [LICENSE](LICENSE) for details.
+
+<img referrerpolicy="no-referrer-when-downgrade" src="https://static.scarf.sh/a.png?x-pxid=fbda6e64-1812-428b-b135-ed2b548ce50d" />

{axonflow-1.0.0 → axonflow-1.4.0}/axonflow/__init__.py

@@ -128,7 +128,7 @@ from axonflow.types import (
     UsageSummary,
 )
 
-__version__ = "0.6.0"
+__version__ = "1.2.0"
 __all__ = [
     # Main client
     "AxonFlow",

{axonflow-1.0.0 → axonflow-1.4.0}/axonflow/client.py

@@ -24,6 +24,7 @@ Example:
 from __future__ import annotations
 
 import asyncio
+import base64
 import concurrent.futures
 import contextlib
 import hashlib
@@ -63,6 +64,7 @@ from axonflow.exceptions import (
     AuthenticationError,
     AxonFlowError,
     ConnectionError,
+    ConnectorError,
     PolicyViolationError,
     TimeoutError,
 )
@@ -102,6 +104,7 @@ from axonflow.types import (
     ConnectorHealthStatus,
     ConnectorInstallRequest,
     ConnectorMetadata,
+    ConnectorPolicyInfo,
     ConnectorResponse,
     CreateBudgetRequest,
     ExecutionDetail,
@@ -182,7 +185,6 @@ class AxonFlow:
         client_id: str | None = None,
         client_secret: str | None = None,
         *,
-        license_key: str | None = None,
         mode: Mode | str = Mode.PRODUCTION,
         debug: bool = False,
         timeout: float = 60.0,
@@ -199,7 +201,6 @@ class AxonFlow:
             endpoint: AxonFlow endpoint URL. Can also be set via AXONFLOW_AGENT_URL env var.
             client_id: Client ID (optional for community/self-hosted mode)
             client_secret: Client secret (optional for community/self-hosted mode)
-            license_key: Optional license key for organization-level auth
             mode: Operation mode (production or sandbox)
             debug: Enable debug logging
             timeout: Request timeout in seconds
@@ -230,7 +231,6 @@ class AxonFlow:
             endpoint=resolved_endpoint.rstrip("/"),
             client_id=client_id,
             client_secret=client_secret,
-            license_key=license_key,
             mode=mode,
             debug=debug,
             timeout=timeout,
@@ -247,14 +247,16 @@ class AxonFlow:
         headers: dict[str, str] = {
             "Content-Type": "application/json",
         }
-        # Add authentication headers only when credentials are provided
-        # For community/self-hosted mode, these can be omitted
-        if client_secret:
-            headers["X-Client-Secret"] = client_secret
+        # Add authentication and tenant headers
+        # client_id is always required for policy APIs (sets X-Tenant-ID)
+        # client_secret is optional for community mode but required for enterprise
         if client_id:
             headers["X-Tenant-ID"] = client_id  # client_id is used as tenant ID for policy APIs
-        if license_key:
-            headers["X-License-Key"] = license_key
+            # OAuth2-style: Authorization: Basic base64(clientId:clientSecret)
+            if client_secret:
+                credentials = f"{client_id}:{client_secret}"
+                encoded = base64.b64encode(credentials.encode()).decode()
+                headers["Authorization"] = f"Basic {encoded}"
 
         # Initialize HTTP client
         self._http_client = httpx.AsyncClient(
@@ -298,27 +300,28 @@ class AxonFlow:
     def _has_credentials(self) -> bool:
         """Check if credentials are configured.
 
-        Returns True if either a license key or client secret is set.
-        These credentials are optional for community/self-hosted deployments,
-        but required for enterprise features like Gateway Mode.
+        Returns True if client_id is set.
+        client_secret is optional for community mode but required for enterprise.
         """
-        return bool(self._config.client_secret or self._config.license_key)
+        return bool(self._config.client_id)
 
     def _require_credentials(self, feature: str) -> None:
         """Require credentials for enterprise features.
 
-        Raises AuthenticationError if no credentials are configured.
+        Raises AuthenticationError if client_id is not configured.
+        Note: client_secret is optional for community mode.
 
         Args:
             feature: Name of the feature requiring credentials (for error message)
 
         Raises:
-            AuthenticationError: If no credentials are configured
+            AuthenticationError: If client_id is not configured
         """
         if not self._has_credentials():
             msg = (
-                f"{feature} requires credentials. "
-                "Set client_secret or license_key when creating the client."
+                f"{feature} requires client_id. "
+                "Set client_id when creating the client "
+                "(client_secret is optional for community mode)."
             )
             raise AuthenticationError(msg)
 
@@ -362,19 +365,20 @@ class AxonFlow:
         return SyncAxonFlow(cls(endpoint, client_id, client_secret, **kwargs))
 
     @classmethod
-    def sandbox(cls, api_key: str = "demo-key") -> AxonFlow:
+    def sandbox(cls, client_id: str = "demo-key", client_secret: str = "demo-key") -> AxonFlow:  # noqa: S107
         """Create a sandbox client for testing.
 
         Args:
-            api_key: Optional API key (defaults to demo-key)
+            client_id: Optional client ID (defaults to demo-key)
+            client_secret: Optional client secret (defaults to demo-key)
 
         Returns:
             Configured AxonFlow client for sandbox environment
         """
         return cls(
             endpoint="https://staging-eu.getaxonflow.com",
-            client_id=api_key,
-            client_secret=api_key,
+            client_id=client_id,
+            client_secret=client_secret,
             mode=Mode.SANDBOX,
             debug=True,
         )
@@ -543,7 +547,8 @@ class AxonFlow:
         """Execute a query through AxonFlow with policy enforcement.
 
         Args:
-            user_token: User authentication token
+            user_token: User authentication token. If empty, defaults to "anonymous"
+                for audit purposes (community mode).
             query: The query or prompt
             request_type: Type of request (chat, sql, mcp-query, multi-agent-plan)
             context: Optional additional context
@@ -556,6 +561,10 @@ class AxonFlow:
             AuthenticationError: If credentials are invalid
             TimeoutError: If request times out
         """
+        # Default to "anonymous" if user_token is empty (community mode)
+        if not user_token:
+            user_token = "anonymous"  # noqa: S105 - not a password, just a placeholder
+
         # Check cache
         if self._cache is not None:
             cache_key = self._get_cache_key(request_type, query, user_token)
@@ -743,6 +752,98 @@ class AxonFlow:
             },
         )
 
+    async def mcp_query(
+        self,
+        connector: str,
+        statement: str,
+        options: dict[str, Any] | None = None,
+    ) -> ConnectorResponse:
+        """Execute a query directly against the MCP connector endpoint.
+
+        This method calls the agent's /mcp/resources/query endpoint which provides:
+        - Request-phase policy evaluation (SQLi blocking, PII blocking)
+        - Response-phase policy evaluation (PII redaction)
+        - PolicyInfo metadata in responses
+
+        Args:
+            connector: Name of the MCP connector (e.g., "postgres")
+            statement: SQL statement or query to execute
+            options: Optional additional options for the query
+
+        Returns:
+            ConnectorResponse with data, redaction info, and policy_info
+
+        Raises:
+            ConnectorError: If the request is blocked by policy or fails
+
+        Example:
+            response = await client.mcp_query(
+                connector="postgres",
+                statement="SELECT * FROM customers LIMIT 10"
+            )
+            if response.redacted:
+                print(f"Redacted fields: {response.redacted_fields}")
+        """
+        if not connector:
+            msg = "connector name is required"
+            raise ConnectorError(msg, connector=None, operation="mcp_query")
+        if not statement:
+            msg = "statement is required"
+            raise ConnectorError(msg, connector=connector, operation="mcp_query")
+
+        url = f"{self._config.endpoint}/mcp/resources/query"
+        body = {
+            "connector": connector,
+            "statement": statement,
+            "options": options or {},
+        }
+
+        if self._config.debug:
+            self._logger.debug("MCP Query", connector=connector, statement=statement[:50])
+
+        response = await self._http_client.post(url, json=body)
+        response_data = response.json()
+
+        # Handle policy blocks (403 responses)
+        if not response.is_success:
+            error_msg = response_data.get("error", f"MCP query failed: {response.status_code}")
+            raise ConnectorError(error_msg, connector=connector, operation="mcp_query")
+
+        if self._config.debug:
+            self._logger.debug(
+                "MCP Query result",
+                connector=connector,
+                success=response_data.get("success"),
+                redacted=response_data.get("redacted"),
+            )
+
+        # Build policy_info if present
+        policy_info = None
+        if response_data.get("policy_info"):
+            policy_info = ConnectorPolicyInfo.model_validate(response_data["policy_info"])
+
+        return ConnectorResponse(
+            success=response_data.get("success", True),
+            data=response_data.get("data"),
+            error=response_data.get("error"),
+            meta=response_data.get("meta", {}),
+            redacted=response_data.get("redacted", False),
+            redacted_fields=response_data.get("redacted_fields", []),
+            policy_info=policy_info,
+        )
+
+    async def mcp_execute(
+        self,
+        connector: str,
+        statement: str,
+        options: dict[str, Any] | None = None,
+    ) -> ConnectorResponse:
+        """Execute a statement against an MCP connector (alias for mcp_query).
+
+        Same as mcp_query but follows the naming convention of other execute* methods.
+        """
+        return await self.mcp_query(connector, statement, options)
+
     async def generate_plan(
         self,
         query: str,
@@ -886,7 +987,7 @@ class AxonFlow:
         Returns:
             PlanExecutionResponse with current status
         """
-        response = await self._request("GET", f"/api/plans/{plan_id}")
+        response = await self._request("GET", f"/api/v1/plan/{plan_id}")
         return PlanExecutionResponse.model_validate(response)
 
     # =========================================================================
@@ -907,7 +1008,7 @@ class AxonFlow:
 
         Note:
             This is an enterprise feature that requires credentials.
-            Set client_secret or license_key when creating the client.
+            Set client_id and client_secret when creating the client.
 
         Args:
             user_token: JWT token for the user making the request
@@ -1036,7 +1137,7 @@ class AxonFlow:
 
         Note:
             This is an enterprise feature that requires credentials.
-            Set client_secret or license_key when creating the client.
+            Set client_id and client_secret when creating the client.
 
         Args:
             context_id: Context ID from get_policy_approved_context()
@@ -1731,7 +1832,7 @@ class AxonFlow:
             self._logger.debug("Toggling dynamic policy", policy_id=policy_id, enabled=enabled)
 
         response = await self._orchestrator_request(
-            "PATCH",
+            "PUT",
             f"/api/v1/dynamic-policies/{policy_id}",
             json_data={"enabled": enabled},
         )
@@ -1992,6 +2093,29 @@ class AxonFlow:
         response = await self._portal_request("POST", f"/api/v1/code-governance/prs/{pr_id}/sync")
         return PRRecord.model_validate(response)
 
+    async def close_pr(self, pr_id: str, delete_branch: bool = True) -> PRRecord:
+        """Close a PR without merging and optionally delete the branch.
+
+        This is an enterprise feature for cleaning up test/demo PRs.
+        Supports all Git providers: GitHub, GitLab, Bitbucket.
+
+        Args:
+            pr_id: PR record ID
+            delete_branch: Whether to delete the source branch (default: True)
+
+        Returns:
+            Closed PR record
+        """
+        if self._config.debug:
+            self._logger.debug("Closing PR", pr_id=pr_id, delete_branch=delete_branch)
+
+        path = f"/api/v1/code-governance/prs/{pr_id}"
+        if delete_branch:
+            path += "?delete_branch=true"
+
+        response = await self._portal_request("DELETE", path)
+        return PRRecord.model_validate(response)
+
     # =========================================================================
     # Code Governance Metrics and Export
     # =========================================================================
@@ -2796,7 +2920,10 @@ class SyncAxonFlow:
         request_type: str,
         context: dict[str, Any] | None = None,
     ) -> ClientResponse:
-        """Execute a query through AxonFlow."""
+        """Execute a query through AxonFlow.
+
+        If user_token is empty, defaults to "anonymous" for audit purposes.
+        """
         return self._run_sync(
             self._async_client.execute_query(user_token, query, request_type, context)
         )
@@ -2833,6 +2960,30 @@ class SyncAxonFlow:
             self._async_client.query_connector(user_token, connector_name, operation, params)
         )
 
+    def mcp_query(
+        self,
+        connector: str,
+        statement: str,
+        options: dict[str, Any] | None = None,
+    ) -> ConnectorResponse:
+        """Execute a query directly against the MCP connector endpoint.
+
+        This method calls the agent's /mcp/resources/query endpoint which provides:
+        - Request-phase policy evaluation (SQLi blocking, PII blocking)
+        - Response-phase policy evaluation (PII redaction)
+        - PolicyInfo metadata in responses
+        """
+        return self._run_sync(self._async_client.mcp_query(connector, statement, options))
+
+    def mcp_execute(
+        self,
+        connector: str,
+        statement: str,
+        options: dict[str, Any] | None = None,
+    ) -> ConnectorResponse:
+        """Execute a statement against an MCP connector (alias for mcp_query)."""
+        return self._run_sync(self._async_client.mcp_execute(connector, statement, options))
+
     def generate_plan(
         self,
         query: str,
@@ -3084,6 +3235,10 @@ class SyncAxonFlow:
         """Sync PR status with the Git provider."""
         return self._run_sync(self._async_client.sync_pr_status(pr_id))
 
+    def close_pr(self, pr_id: str, delete_branch: bool = True) -> PRRecord:
+        """Close a PR without merging and optionally delete the branch."""
+        return self._run_sync(self._async_client.close_pr(pr_id, delete_branch))
+
     def get_code_governance_metrics(self) -> CodeGovernanceMetrics:
         """Get aggregated code governance metrics."""
         return self._run_sync(self._async_client.get_code_governance_metrics())