from langgraph.graph import StateGraph, END
from langgraph.checkpoint.postgres import PostgresSaver

# 定义状态
class AgentState(TypedDict):
    messages: list[dict]
    next_action: str

# 构建图
graph = StateGraph(AgentState)
graph.add_node("research", research_node)
graph.add_node("draft", draft_node)
graph.add_node("review", review_node)

# 条件边：审查通过则结束，否则返回修改
graph.add_conditional_edges("review", should_revise, {
    "revise": "draft",
    "publish": END
})
graph.add_edge("research", "draft")
graph.add_edge("draft", "review")

# 编译时注入持久化
checkpointer = PostgresSaver.from_conn_string("postgresql://...")
app = graph.compile(
    checkpointer=checkpointer,
    interrupt_before=["review"]  # 人工审核断点
)

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="市场研究员",
    goal="发现2026年AI Agent市场的最新趋势",
    backstory="你是一位有10年经验的技术市场分析师",
    tools=[search_tool, scrape_tool],
    verbose=True
)

writer = Agent(
    role="技术作家",
    goal="将研究发现转化为高质量报告",
    backstory="你擅长将复杂技术概念转化为清晰的商业文档",
    verbose=True
)

research_task = Task(
    description="研究2026年AI Agent框架市场格局",
    agent=researcher,
    expected_output="包含5个关键发现的市场分析摘要"
)

write_task = Task(
    description="基于研究发现撰写报告",
    agent=writer,
    expected_output="2000字的商业报告"
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[research_task, write_task],
    process=Process.sequential  # 或 Process.hierarchical
)

result = crew.kickoff()

from agents import Agent, Runner, function_tool, handoff
from agents.guardrails import input_guardrail, output_guardrail

@function_tool
def lookup_order(order_id: str) -> str:
    """查询订单状态"""
    return f"订单 {order_id} 已发货，预计明天送达"

triage_agent = Agent(
    name="接待Agent",
    instructions="你是客服接待员，判断用户需求并转接。",
    tools=[lookup_order],
)

refund_agent = Agent(
    name="退款Agent",
    instructions="你处理退款请求，验证订单后执行退款。",
)

# 配置交接
triage_agent.handoffs = [
    handoff(refund_agent, tool_name="transfer_to_refund")
]

# 输入护栏：检测敏感信息
@input_guardrail
async def check_pii(ctx, agent, input_data):
    if "信用卡" in input_data:
        return GuardrailResult(tripwire_triggered=True, message="请勿输入信用卡信息")
    return GuardrailResult(tripwire_triggered=False)

result = await Runner.run(triage_agent, "我想退款订单12345")

import { Agent, Tool, Hook } from '@anthropic-ai/claude-agent-sdk';

const searchTool: Tool = {
  name: 'web_search',
  description: '搜索网络信息',
  parameters: {
    query: { type: 'string', description: '搜索关键词' }
  },
  execute: async (params) => {
    const results = await fetch(`/api/search?q=${params.query}`);
    return results.json();
  }
};

// 工具调用前置Hook：记录审计日志
const auditHook: Hook = {
  beforeToolCall: async (toolName, params) => {
    await logAudit(toolName, params);
    return { proceed: true };
  },
  afterToolCall: async (toolName, result) => {
    await logResult(toolName, result);
  }
};

const agent = new Agent({
  model: 'claude-sonnet-4-6',
  tools: [searchTool],
  hooks: [auditHook],
  maxTurns: 20,
});

const result = await agent.run('调研2026年AI Agent市场格局并生成报告');

from google.adk import Agent, Runner
from google.adk.tools import FunctionTool
from google.adk.a2a import A2AClient

# 定义工具
@FunctionTool
def analyze_sentiment(text: str) -> dict:
    """分析文本情感"""
    return {"sentiment": "positive", "confidence": 0.92}

# 创建Agent
analyst = Agent(
    name="sentiment_analyst",
    model="gemini-2.5-pro",
    instruction="你是一个情感分析专家",
    tools=[analyze_sentiment]
)

# A2A远程Agent——可以是任何框架构建的
remote_summarizer = A2AClient(
    agent_url="https://other-agent.example.com/a2a"
)

# 编排多Agent工作流
runner = Runner(agents=[analyst, remote_summarizer])
result = runner.run("分析这批用户评论并生成摘要报告")

from pydantic_ai import Agent, RunContext
from pydantic import BaseModel

class AnalysisResult(BaseModel):
    summary: str
    confidence: float
    key_findings: list[str]

# 定义Agent，指定输出类型
analyst = Agent(
    'openai:gpt-4.1',
    result_type=AnalysisResult,
    system_prompt='你是一个数据分析专家，返回结构化的分析结果。'
)

# 依赖注入：运行时提供数据库连接
@analyst.tool
async def query_database(ctx: RunContext[DBConnection], sql: str) -> str:
    """查询数据库"""
    return await ctx.deps.execute(sql)

# 运行——输出自动验证
result = await analyst.run('分析最近30天的销售趋势')
print(result.data.summary)      # 类型安全访问
print(result.data.confidence)   # IDE自动补全

import autogen

# 配置LLM
config_list = [{"model": "gpt-4.1", "api_key": "your-key"}]

# 创建Agent
planner = autogen.AssistantAgent(
    name="Planner",
    system_message="你是一个项目规划专家，制定详细的执行计划。",
    llm_config={"config_list": config_list}
)

coder = autogen.AssistantAgent(
    name="Coder",
    system_message="你是一个高级程序员，根据计划编写代码。",
    llm_config={"config_list": config_list}
)

executor = autogen.UserProxyAgent(
    name="Executor",
    human_input_mode="NEVER",  # 或 "ALWAYS" 需要人工确认
    code_execution_config={"work_dir": "output", "use_docker": True}
)

# 启动群组对话
group_chat = autogen.GroupChat(
    agents=[planner, coder, executor],
    messages=[],
    max_round=10
)

manager = autogen.GroupChatManager(
    groupchat=group_chat,
    llm_config={"config_list": config_list}
)

executor.initiate_chat(manager, message="构建一个REST API服务")

graph TB
    subgraph "用户层"
        U[用户请求] --> ORCH[编排层]
    end

    subgraph "编排层"
        ORCH --> LG[LangGraph<br/>图状态机]
        ORCH --> CR[CrewAI<br/>角色编排]
        ORCH --> OA[OpenAI SDK<br/>Handoff链]
        ORCH --> CA[Claude SDK<br/>工具调度]
        ORCH --> GA[Google ADK<br/>A2A协议]
        ORCH --> PA[PydanticAI<br/>类型安全]
        ORCH --> AG[AutoGen<br/>对话协作]
    end

    subgraph "Agent核心能力"
        LG & CR & OA & CA & GA & PA & AG --> PLAN[规划Planning]
        LG & CR & OA & CA & GA & PA & AG --> MEM[记忆Memory]
        LG & CR & OA & CA & GA & PA & AG --> TOOL[工具Tool Use]
        LG & CR & OA & CA & GA & PA & AG --> REAS[推理Reasoning]
    end

    subgraph "基础设施层"
        PLAN --> LLM[LLM模型层<br/>GPT-4.1/Claude/Gemini]
        MEM --> STORE[存储层<br/>Postgres/Redis/向量库]
        TOOL --> API[外部API/服务]
        REAS --> LLM
    end

    subgraph "可观测性"
        LLM --> OBS[LangSmith/Logfire<br/>Tracing/Monitoring]
        STORE --> OBS
        API --> OBS
    end

    style LG fill:#4CAF50,color:#fff
    style CR fill:#FF9800,color:#fff
    style OA fill:#2196F3,color:#fff
    style CA fill:#9C27B0,color:#fff
    style GA fill:#F44336,color:#fff
    style PA fill:#607D8B,color:#fff
    style AG fill:#795548,color:#fff

graph TD
    START[选择Agent框架] --> Q1{团队技术栈?}
    Q1 -->|TypeScript| TS[→ Claude Agent SDK]
    Q1 -->|Python| Q2{需要多Agent协作?}
    Q1 -->|混合/多语言| Q2

    Q2 -->|否,单Agent| Q3{重视类型安全?}
    Q3 -->|是| PA[→ PydanticAI]
    Q3 -->|否| Q4{绑定哪个模型?}
    Q4 -->|OpenAI| OA[→ OpenAI Agents SDK]
    Q4 -->|Claude| CA[→ Claude Agent SDK]
    Q4 -->|Gemini| GA[→ Google ADK]

    Q2 -->|是,需要多Agent| Q5{协作模式?}
    Q5 -->|角色分工| CR[→ CrewAI]
    Q5 -->|复杂流程/合规| Q6{需要精确控制流?}
    Q5 -->|对话式协作| AG[→ AutoGen]
    Q5 -->|跨框架互操作| GA

    Q6 -->|是| LG[→ LangGraph]
    Q6 -->|否| CR

    style TS fill:#9C27B0,color:#fff
    style PA fill:#607D8B,color:#fff
    style OA fill:#2196F3,color:#fff
    style CA fill:#9C27B0,color:#fff
    style GA fill:#F44336,color:#fff
    style CR fill:#FF9800,color:#fff
    style AG fill:#795548,color:#fff
    style LG fill:#4CAF50,color:#fff