# Use environment variables
import os
from graphton import create_deep_agent

agent = create_deep_agent(
    model="claude-sonnet-4.5",
    system_prompt="...",
)

# API key is loaded from environment by LangChain
# ANTHROPIC_API_KEY=... python script.py

# Use secrets management
import boto3

def get_secret(secret_name):
    client = boto3.client('secretsmanager')
    response = client.get_secret_value(SecretId=secret_name)
    return response['SecretString']

os.environ['ANTHROPIC_API_KEY'] = get_secret('anthropic-key')

# Use .env files (not committed to git)
from dotenv import load_dotenv
load_dotenv()  # Loads from .env file

# .gitignore should include:
# .env
# .env.local

# NEVER hardcode API keys
agent = create_deep_agent(
    model="claude-sonnet-4.5",
    system_prompt="...",
)
os.environ['ANTHROPIC_API_KEY'] = "sk-ant-hardcoded-key"  # DON'T DO THIS!

# NEVER commit API keys to git
# Bad: config.py
ANTHROPIC_API_KEY = "sk-ant-..."  # DON'T DO THIS!

# NEVER log API keys
import logging
logging.info(f"Using key: {os.getenv('ANTHROPIC_API_KEY')}")  # DON'T DO THIS!

# ✅ Good: Per-user tokens
agent = create_deep_agent(
    model="claude-sonnet-4.5",
    system_prompt="...",
    mcp_servers={
        "api": {
            "url": "https://api.example.com",
            "headers": {
                "Authorization": "Bearer {{USER_TOKEN}}"  # Template variable
            }
        }
    },
    mcp_tools={"api": ["list_resources"]},
)

# Each user gets their own token
result = agent.invoke(
    {"messages": [...]},
    config={
        "configurable": {
            "USER_TOKEN": get_user_token(user_id)  # Per-user
        }
    }
)

# ⚠️ Use only when appropriate
# (shared credentials, internal services, etc.)
agent = create_deep_agent(
    model="claude-sonnet-4.5",
    system_prompt="...",
    mcp_servers={
        "api": {
            "url": "https://api.example.com",
            "headers": {
                "X-API-Key": os.getenv("API_KEY")  # From environment, not hardcoded
            }
        }
    },
    mcp_tools={"api": ["list_resources"]},
)

# ✅ Good: Validate and sanitize input
def safe_invoke(agent, user_input):
    # Validate input length
    if len(user_input) > 10000:
        raise ValueError("Input too long")
    
    # Sanitize input
    user_input = user_input.strip()
    
    # Check for obvious injection attempts
    if any(pattern in user_input for pattern in ["{{", "}}", "${"]):
        raise ValueError("Invalid input pattern")
    
    return agent.invoke({
        "messages": [{"role": "user", "content": user_input}]
    })

# ✅ Good: Don't allow user input in templates
mcp_servers = {
    "api": {
        "url": "https://api.example.com",
        "headers": {
            "Authorization": f"Bearer {{USER_TOKEN}}"  # Fixed template
        }
    }
}

# ❌ Bad: User input in template
user_server_url = request.get("server_url")  # DON'T DO THIS!
mcp_servers = {
    "api": {
        "url": user_server_url,  # DANGEROUS!
    }
}

# ✅ Good: Implement rate limiting
from functools import wraps
from time import time

def rate_limit(max_calls, period):
    calls = []
    
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            now = time()
            # Remove old calls
            calls[:] = [call for call in calls if call > now - period]
            
            if len(calls) >= max_calls:
                raise Exception("Rate limit exceeded")
            
            calls.append(now)
            return func(*args, **kwargs)
        return wrapper
    return decorator

@rate_limit(max_calls=10, period=60)  # 10 calls per minute
def invoke_agent(agent, message):
    return agent.invoke({"messages": [{"role": "user", "content": message}]})

# ✅ Good: Don't leak sensitive info in errors
try:
    result = agent.invoke(
        {"messages": [...]},
        config={
            "configurable": {
                "USER_TOKEN": user_token
            }
        }
    )
except Exception as e:
    # Log full error internally
    logger.error(f"Agent invocation failed: {str(e)}", exc_info=True)
    
    # Return generic error to user
    return {"error": "An error occurred processing your request"}

# ❌ Bad: Exposing internal details
except Exception as e:
    return {"error": str(e)}  # May contain tokens, URLs, etc.

# ✅ Good: HTTPS URLs
mcp_servers = {
    "api": {
        "url": "https://api.example.com",  # HTTPS
    }
}

# ❌ Bad: HTTP URLs (unless local dev)
mcp_servers = {
    "api": {
        "url": "http://api.example.com",  # Insecure!
    }
}

# Default behavior is to verify SSL
# Only disable for local development

# ⚠️ Development only
import os
if os.getenv("ENV") == "development":
    # Disable SSL verification (dev only!)
    pass

# ✅ Good: Load only necessary tools
mcp_tools = {
    "planton-cloud": [
        "list_organizations",  # Only what's needed
    ]
}

# ❌ Bad: Loading all tools
mcp_tools = {
    "planton-cloud": [
        "list_organizations",
        "create_cloud_resource",  # Not needed? Don't load!
        "delete_cloud_resource",  # Dangerous if not needed
        # ... many more tools
    ]
}

import logging

logger = logging.getLogger(__name__)

# Log security-relevant events
logger.info(f"Agent invoked by user {user_id}")
logger.warning(f"Rate limit exceeded for user {user_id}")
logger.error(f"Authentication failed for user {user_id}")

# DON'T log sensitive data
# logger.info(f"Token: {user_token}")  # DON'T DO THIS!

# Monitor usage patterns
def monitor_usage(user_id, action):
    # Track API calls per user
    # Alert on unusual patterns
    # Block suspicious activity
    pass