from langgraph.graph import StateGraph, START, END
from typing import TypedDict

class AgentState(TypedDict):
    messages: list
    next_action: str
    retry_count: int

def researcher(state: AgentState) -> AgentState:
    """研究节点：分析用户输入并收集信息"""
    result = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [result],
            "next_action": "write"}

def writer(state: AgentState) -> AgentState:
    """写作节点：基于研究结果生成内容"""
    draft = llm.invoke(f"Write based on: {state['messages'][-1]}")
    return {"messages": state["messages"] + [draft]}

def router(state: AgentState) -> str:
    if state["retry_count"] > 3:
        return END
    return "researcher"

graph = StateGraph(AgentState)
graph.add_node("researcher", researcher)
graph.add_node("writer", writer)
graph.add_edge(START, "researcher")
graph.add_conditional_edges("researcher", router)
graph.add_edge("writer", END)

app = graph.compile(checkpointer=SqliteSaver("agent.db"))

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="Senior Data Analyst",
    goal="Discover actionable insights from data",
    backstory="You are a veteran analyst with 15 years of experience...",
    tools=[search_tool, csv_tool],
    verbose=True
)

writer = Agent(
    role="Technical Writer",
    goal="Transform analysis into clear executive reports",
    backstory="Former McKinsey consultant specializing in...",
    verbose=True
)

analysis_task = Task(
    description="Analyze Q2 sales data and identify trends",
    agent=researcher,
    expected_output="A structured analysis with 3-5 key findings"
)

report_task = Task(
    description="Write an executive summary from the analysis",
    agent=writer,
    expected_output="A 2-page executive report in Markdown"
)

crew = Crew(
    agents=[researcher, writer],
    tasks=[analysis_task, report_task],
    process=Process.sequential
)

result = crew.kickoff()

// C# 示例 - Microsoft Agent Framework
var agent = new AgentBuilder()
    .WithName("SalesAnalyzer")
    .WithModel("gpt-4.1")
    .WithPlugin(new DataPlugin())
    .WithPlugin(new SearchPlugin())
    .WithMemory(new VolatileMemoryStore())
    .Build();

var orchestrator = new AgentOrchestrator()
    .AddAgent(agent)
    .AddAgent(reportAgent)
    .WithPattern(OrchestrationPattern.RoundRobin)
    .Build();

var result = await orchestrator.InvokeAsync("Analyze Q2 performance");

from agents import Agent, Runner, function_tool, guardrail

@function_tool
def lookup_order(order_id: str) -> str:
    """查询订单状态"""
    return f"Order {order_id}: Shipped, ETA 2 days"

@guardrail
def check_input(input_text: str) -> bool:
    """确保输入不包含敏感信息"""
    sensitive = ["ssn", "credit card", "password"]
    return not any(s in input_text.lower() for s in sensitive)

triage_agent = Agent(
    name="Triage Agent",
    instructions="Route customer queries to the right department",
    tools=[lookup_order],
    input_guardrails=[check_input]
)

refund_agent = Agent(
    name="Refund Agent",
    instructions="Handle refund requests according to policy",
    handoff_description="Handles all refund and return requests"
)

# Handoff: triage -> refund when needed
triage_agent.handoffs = [refund_agent]

result = await Runner.run(triage_agent, "I want to refund order #12345")

from google.adk import Agent, Runner
from google.adk.tools import google_search

market_analyst = Agent(
    name="market_analyst",
    model="gemini-2.5-pro",
    instruction="Analyze market trends and provide investment insights",
    tools=[google_search]
)

# A2A: 跨平台Agent通信
from google.adk.a2a import A2AClient

remote_agent = A2AClient("https://finance-agent.example.com/a2a")
market_analyst.add_remote_agent(remote_agent)

runner = Runner(agent=market_analyst)
response = await runner.run("What's the outlook for renewable energy stocks?")

# MCP Server 示例
from mcp.server import Server, NotificationOptions
from mcp.server.models import InitializationOptions

server = Server("my-tools")

@server.list_tools()
async def list_tools() -> list[Tool]:
    return [
        Tool(
            name="query_database",
            description="Execute SQL queries against the sales database",
            inputSchema={
                "type": "object",
                "properties": {
                    "sql": {"type": "string", "description": "SQL query"}
                },
                "required": ["sql"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict) -> list[TextContent]:
    if name == "query_database":
        result = await db.execute(arguments["sql"])
        return [TextContent(type="text", text=str(result))]

graph TB
    subgraph "用户层"
        U[用户请求]
    end

    subgraph "编排层 - 三条路线"
        direction LR
        subgraph "厂牌SDK"
            O[OpenAI Agents SDK<br/>Agent Loop + Handoff]
            G[Google ADK 2.0<br/>A2A Protocol]
            M[MS Agent Framework<br/>Event-Driven]
        end
        subgraph "中立编排"
            L[LangGraph 2.0<br/>Stateful Graph]
            C[CrewAI<br/>Role-Based Crew]
        end
    end

    subgraph "协议层"
        MCP[MCP<br/>Agent ↔ Tool<br/>9700万安装]
        A2A[A2A Protocol<br/>Agent ↔ Agent<br/>跨平台互操作]
    end

    subgraph "模型层"
        GPT[GPT-4.1/o3]
        Gemini[Gemini 2.5]
        Claude[Claude 4.x]
    end

    subgraph "基础设施"
        VAI[Vertex AI<br/>Agent Engine]
        AAI[Azure AI<br/>Foundry]
        OS[自托管/Cloud Run]
    end

    U --> O & G & M & L & C
    O & G & M & L & C --> MCP
    G --> A2A
    M --> A2A
    MCP --> GPT & Gemini & Claude
    A2A --> GPT & Gemini & Claude
    G --> VAI
    M --> AAI
    O & L & C --> OS

graph LR
    subgraph "路线A: 厂牌绑定SDK"
        A1["快速上市<br/>零配置优化<br/>模型绑定风险"]
    end
    subgraph "路线B: 中立编排层"
        B1["模型自由<br/>复杂工作流<br/>学习曲线陡峭"]
    end
    subgraph "路线C: 协议优先"
        C1["最大灵活性<br/>自行组装<br/>集成复杂度高"]
    end

    Q{你的需求是?} -->|"3个月内上线<br/>团队<5人"| A1
    Q -->|"复杂工作流<br/>长期项目"| B1
    Q -->|"企业级集成<br/>多系统打通"| C1