Python SDK Integration

from aim_sdk import secure

agent = secure("data-processor")

# Decorator automatically handles verification
@agent.perform_action("read_file", resource="/data/input.csv")
def process_csv_file(filepath):
    """This function is automatically verified before execution."""
    with open(filepath, 'r') as f:
        data = csv.reader(f)
        return list(data)

# Async support
@agent.perform_action("call_api", resource="https://api.example.com")
async def fetch_external_data(url):
    async with aiohttp.ClientSession() as session:
        async with session.get(url) as response:
            return await response.json()

# Context manager for manual verification
with agent.verify_action("write_database", resource="users_table"):
    # Action is verified, safe to proceed
    db.execute("INSERT INTO users VALUES (?)", user_data)

from aim_sdk import secure

# Automatically detects MCP servers from Claude Desktop config
agent = secure("my-agent")

# View detected MCP servers
detected_mcps = agent.get_detected_mcps()
for mcp in detected_mcps:
    print(f"Found MCP: {mcp['name']} - {mcp['command']}")

# Manual MCP specification (overrides auto-detection)
agent = secure(
    "my-agent",
    talks_to=[
        {"name": "filesystem", "command": "npx @modelcontextprotocol/server-filesystem"},
        {"name": "github", "command": "npx @modelcontextprotocol/server-github"}
    ]
)

# Report runtime MCP detection
agent.report_detected_mcps([
    {"name": "new-mcp", "command": "python mcp_server.py", "detected_at": "runtime"}
])

from aim_sdk import secure

agent = secure("capability-demo")

# Auto-detected capabilities from code analysis
capabilities = agent.get_capabilities()
print(f"Agent has {len(capabilities)} capabilities")

# Request additional capability (requires admin approval)
agent.request_capability(
    capability_type="write_production_database",
    resource="/prod/database",
    justification="Required for data migration task"
)

# Check if action is allowed
if agent.can_perform("delete_user", resource="users_table"):
    # Safe to proceed
    delete_user(user_id)
else:
    print("Action not permitted - insufficient capabilities")

# Get capability violations
violations = agent.get_violations()
if violations:
    print(f"Warning: {len(violations)} capability violations detected")

from aim_sdk import secure

agent = secure("trust-monitor")

# Get current trust score
trust_score = agent.get_trust_score()
print(f"Current trust score: {trust_score['score']}/100")
print(f"Risk level: {trust_score['risk_level']}")

# Get trust score factors
factors = trust_score['factors']
for factor, value in factors.items():
    print(f"  {factor}: {value}")

# Monitor trust score changes
@agent.on_trust_change
def handle_trust_change(old_score, new_score):
    if new_score < 70:
        alert_admin(f"Trust score dropped to {new_score}")

# Get trust score history
history = agent.get_trust_history(days=30)
for entry in history:
    print(f"{entry['timestamp']}: {entry['score']}")

from aim_sdk import secure
from aim_sdk.exceptions import (
    AIMError,
    AuthenticationError,
    VerificationError,
    ActionDeniedError
)

try:
    agent = secure("my-agent")
except AuthenticationError as e:
    print(f"Authentication failed: {e}")
    # Check API key or credentials
except AIMError as e:
    print(f"AIM error: {e}")
    # Handle general AIM errors

# Handle verification errors
try:
    @agent.perform_action("delete_database", resource="production")
    def dangerous_operation():
        # This might be denied
        pass

    dangerous_operation()
except ActionDeniedError as e:
    print(f"Action denied: {e.reason}")
    print(f"Required capability: {e.required_capability}")
except VerificationError as e:
    print(f"Verification failed: {e}")

from aim_sdk import secure
import asyncio

# Advanced configuration
agent = secure(
    "advanced-agent",
    api_key="aim_abc123...",

    # Retry configuration
    max_retries=3,
    retry_delay=1.0,

    # Timeout settings
    request_timeout=30,
    verification_timeout=5,

    # Caching
    enable_cache=True,
    cache_ttl=3600,

    # Debugging
    debug=True,
    log_level="DEBUG"
)

# Custom verification handler
@agent.verification_handler
def custom_verification(action, resource, context):
    """Custom logic before standard verification."""
    if context.get("emergency_override"):
        return True  # Skip verification in emergencies

    # Add custom checks
    if action == "delete" and "production" in resource:
        require_two_factor_auth()

    return None  # Continue with standard verification

# Batch operations
actions = [
    ("read_file", "/data/file1.csv"),
    ("read_file", "/data/file2.csv"),
    ("write_file", "/output/result.csv")
]

results = agent.verify_batch(actions)
for action, resource, allowed in results:
    print(f"{action} on {resource}: {'✓' if allowed else '✗'}")

# Performance monitoring
with agent.measure_performance():
    # Your code here
    process_large_dataset()

# Get performance metrics
metrics = agent.get_metrics()
print(f"Avg verification time: {metrics['avg_verification_time']}ms")
print(f"Total verifications: {metrics['total_verifications']}")

import pytest
from aim_sdk import secure
from aim_sdk.testing import MockAIMClient

def test_agent_registration():
    """Test agent registration with AIM."""
    agent = secure("test-agent", api_key="test_key")
    assert agent.agent_id is not None
    assert agent.is_verified is True

def test_with_mock():
    """Test with mocked AIM client."""
    with MockAIMClient() as mock_agent:
        mock_agent.set_trust_score(85)
        mock_agent.allow_action("read_file", "/test/*")

        # Test your code
        @mock_agent.perform_action("read_file", "/test/data.txt")
        def read_test_file():
            return "test data"

        result = read_test_file()
        assert result == "test data"
        assert mock_agent.verify_called_with("read_file", "/test/data.txt")

@pytest.mark.integration
def test_real_aim_connection():
    """Integration test with real AIM server."""
    agent = secure("integration-test")

    # Test real verification
    with agent.verify_action("test_action", "test_resource"):
        pass  # Should succeed

    # Cleanup
    agent.cleanup()