from anthropic import Agent

class MyAgent:
    def __init__(self):
        self.agent = Agent(
            model="claude-sonnet-4-20260514",
            tools=[search_tool, code_tool],
            max_iterations=50
        )
        self.state = {}
    
    async def run(self, goal: str) -> str:
        # 70% 的代码是防御性编程
        try:
            # Token 超限检测
            if self.token_count > 180000:
                await self.truncate_context()
            
            # 调用 Agent
            result = await self.agent.run(goal)
            
            # 无限循环检测
            if self.iteration_count > self.max_iterations:
                raise AgentLoopError("Too many iterations")
            
            # 持久化中间结果
            await self.save_state()
            
            return result
            
        except ToolError as e:
            # 工具失败重试
            return await self.retry_with_backoff(e)
        except TokenLimitError:
            # Token 超限处理
            return await self.compress_and_continue()

from anthropic import AgentTeam

# 创建共享任务列表
team = AgentTeam(
    model="claude-sonnet-4-20260514",
    agents=[
        Agent(name="researcher", tools=[search_tool]),
        Agent(name="coder", tools=[code_tool]),
        Agent(name="reviewer", tools=[review_tool])
    ],
    shared_state=True  # 关键：启用共享状态
)

# 所有 Agent 可以看到彼此的任务
await team.run("""
完成以下项目：
1. 调研最新的 Agent 框架
2. 实现核心功能
3. 代码审查和优化
""")

# Agent A (researcher) 可以在任务列表中添加新任务：
# "发现依赖库 X 有安全问题，需要升级到 Y 版本"
# Agent B (coder) 会立即看到并处理

from anthropic import ManagedAgent

# 企业级 Agent：客户服务自动化
customer_agent = ManagedAgent(
    model="claude-sonnet-4-20260514",
    goal="""处理客户咨询，包括：
    1. 查询订单状态
    2. 处理退换货申请
    3. 解答常见问题
    4. 升级复杂问题到人工客服""",
    tools=[
        order_lookup_tool,      # 内部订单系统 API
        refund_tool,            # 退款系统 API
        knowledge_base_tool,    # 企业知识库
        ticket_escalation_tool  # 工单系统
    ],
    memory_config={
        "type": "persistent",  # 持久化记忆
        "retention_days": 90   # 客户对话保留 90 天
    },
    compliance_config={
        "data_residency": "EU",  # 数据驻留要求
        "audit_logging": True    # 审计日志
    }
)

# 生产环境部署
await customer_agent.deploy(
    environment="production",
    scaling_policy="auto",  # 自动扩缩容
    sla_target=99.9         # SLA 目标
)

# 核心支付流程必须用 SDK
class PaymentAgent:
    def __init__(self):
        # 自定义重试、补偿、审计日志
        self.retry_policy = ExponentialBackoff(max_retries=5)
        self.audit_log = AuditLogger()
    
    async def process_payment(self, order):
        # 100% 控制力
        pass

# 完全独立的任务，用传统子 Agent
tasks = [
    publish_to_wechat(article),
    publish_to_twitter(article),
    publish_to_blog(article)
]
await asyncio.gather(*tasks)

# 长周期项目用 Teams
project_team = AgentTeam(
    agents=[planner, executor, reviewer],
    shared_state=True
)
await project_team.run("重构用户认证模块")

# 简单任务用 Managed
await ManagedAgent(
    goal="整理昨天的错误日志",
    tools=[log_tool]
).run()

from openai import OpenAI

# OpenRouter 兼容 OpenAI SDK
client = OpenAI(
    base_url="https://openrouter.ai/api/v1",
    api_key="YOUR_OPENROUTER_KEY"
)

class MultiModelAgent:
    def __init__(self):
        self.client = client
        self.model_router = {
            "complex": "anthropic/claude-sonnet-4",
            "simple": "google/gemini-3-flash-preview",
            "code": "deepseek/deepseek-coder-v2",
            "local": "local/llama-3-70b"  # 本地模型
        }
    
    async def run(self, goal: str, complexity: str = "medium"):
        model = self.model_router.get(complexity, "complex")
        
        response = self.client.chat.completions.create(
            model=model,
            messages=[{"role": "user", "content": goal}],
            tools=self.tools,
            tool_choice="auto"
        )
        
        return self.parse_agent_response(response)

from openai import OpenAI

# 本地 Ollama 服务
local_client = OpenAI(
    base_url="http://localhost:11434/v1",
    api_key="ollama"
)

class HybridAgent:
    def __init__(self):
        # 云端 Claude 处理复杂任务
        self.cloud_client = Anthropic(api_key="...")
        # 本地模型处理敏感数据
        self.local_client = local_client
    
    async def process_sensitive_data(self, data: str):
        # 敏感数据不出本地
        response = self.local_client.chat.completions.create(
            model="llama3:70b",
            messages=[{"role": "user", "content": data}]
        )
        return response.choices[0].message.content
    
    async def complex_reasoning(self, goal: str):
        # 复杂推理用 Claude
        return await self.cloud_client.messages.create(
            model="claude-sonnet-4-20260514",
            max_tokens=4096,
            messages=[{"role": "user", "content": goal}]
        )

class SmartRouter:
    def __init__(self):
        self.models = {
            "claude": AnthropicClient(),
            "gemini": GeminiClient(),
            "local": OllamaClient()
        }
    
    def select_model(self, task: dict) -> str:
        # 根据任务特征选择模型
        if task.get("sensitive"):
            return "local"
        elif task.get("complexity", 0.5) > 0.8:
            return "claude"
        elif task.get("type") == "code":
            return "claude"  # 或 deepseek
        else:
            return "gemini"  # 便宜够用
    
    async def run(self, task: dict):
        model = self.select_model(task)
        return await self.models[model].run(task)

# 变通方案：外部模型作为"工具"
from anthropic import AgentTeam
import requests

def call_local_model(query: str) -> str:
    """作为工具调用的本地模型"""
    response = requests.post(
        "http://localhost:11434/api/generate",
        json={"model": "llama3", "prompt": query}
    )
    return response.json()["response"]

team = AgentTeam(
    model="claude-sonnet-4-20260514",
    agents=[
        Agent(name="researcher", tools=[search_tool]),
        # 本地模型作为工具被 Claude 调用
        Agent(name="local_processor", tools=[call_local_model])
    ]
)

class ProductionAgentSystem:
    """生产环境的混合模型架构"""
    
    def __init__(self):
        # 1. SDK 层：核心业务，支持任意模型
        self.core_agent = SmartRouter()
        
        # 2. Teams 层：协作任务，用 Claude
        self.project_team = AgentTeam(
            model="claude-sonnet-4-20260514",
            agents=[...]
        )
        
        # 3. Managed 层：简单任务，用 Claude
        self.simple_tasks = [
            ManagedAgent(goal="日志分析", ...),
            ManagedAgent(goal="数据清洗", ...)
        ]
    
    async def dispatch(self, task: dict):
        if task.get("requires_custom_model"):
            return await self.core_agent.run(task)
        elif task.get("long_running"):
            return await self.project_team.run(task)
        else:
            return await self.simple_tasks[0].run()