from mcp.etdi import ETDIClient

# Simple client usage
async with ETDIClient.from_config("~/.etdi/config/etdi-config.json") as client:
    tools = await client.discover_tools()
    for tool in tools:
        if tool.verification_status.value == "verified":
            await client.approve_tool(tool)

# Before (standard MCP)
from mcp.client import ClientSession

session = ClientSession()
tools = await session.list_tools()

# After (ETDI-enhanced)
from mcp.etdi import ETDISecureClientSession, ETDIClient

client = ETDIClient(config)
await client.initialize()

session = ETDISecureClientSession(
    verifier=client.verifier,
    approval_manager=client.approval_manager
)
tools = await session.list_tools()  # Now with security verification

from mcp.etdi import ETDIVerifier, ApprovalManager
from mcp.etdi.oauth import OAuthManager

# Add ETDI security to existing MCP client
oauth_manager = OAuthManager()
oauth_manager.register_provider_config("auth0", oauth_config)

verifier = ETDIVerifier(oauth_manager)
approval_manager = ApprovalManager()

# Verify tools before use
for tool in existing_tools:
    result = await verifier.verify_tool(tool)
    if result.valid:
        await approval_manager.approve_tool_with_etdi(tool)

# Before (standard MCP server)
from mcp.server.fastmcp import FastMCP

app = FastMCP()

@app.tool()
async def my_tool(param: str) -> str:
    return f"Result: {param}"

# After (ETDI-secured)
from mcp.etdi import ETDISecureServer

app = ETDISecureServer(oauth_configs=[oauth_config])

@app.secure_tool(permissions=["read:data", "execute:tools"])
async def my_tool(param: str) -> str:
    return f"Secure result: {param}"

from mcp.etdi.server import OAuthSecurityMiddleware

# Add security middleware to existing server
middleware = OAuthSecurityMiddleware([oauth_config])
await middleware.initialize()

# Enhance existing tool definitions
enhanced_tool = await middleware.enhance_tool_definition(
    existing_tool_definition,
    provider_name="auth0"
)

config = {
    "security_level": "basic",
    "allow_non_etdi_tools": True,
    "show_unverified_tools": True
}

config = {
    "security_level": "enhanced",
    "oauth_config": oauth_config,
    "allow_non_etdi_tools": True,
    "show_unverified_tools": False
}

config = {
    "security_level": "strict",
    "oauth_config": oauth_config,
    "allow_non_etdi_tools": False,
    "show_unverified_tools": False
}

from mcp.etdi.inspector import SecurityAnalyzer, TokenDebugger, OAuthValidator

# Analyze tool security
analyzer = SecurityAnalyzer()
result = await analyzer.analyze_tool(tool)
print(f"Security Score: {result.overall_security_score}/100")

# Debug OAuth tokens
debugger = TokenDebugger()
debug_info = debugger.debug_token(token)
print(debugger.format_debug_report(debug_info))

# Validate OAuth providers
validator = OAuthValidator()
validation_result = await validator.validate_provider("auth0", oauth_config)

# Check ETDI client health
async with ETDIClient(config) as client:
    stats = await client.get_stats()
    print(f"Healthy providers: {stats['oauth_providers']}")
    print(f"Verification cache: {stats['verification']['cache_size']}")

import logging

# Enable ETDI logging
logging.getLogger('mcp.etdi').setLevel(logging.INFO)

# Custom log handler
handler = logging.FileHandler('/var/log/etdi.log')
formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s')
handler.setFormatter(formatter)
logging.getLogger('mcp.etdi').addHandler(handler)