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

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

def think(state: AgentState) -> AgentState:
    # LLM推理节点
    response = llm.invoke(state["messages"])
    return {"messages": state["messages"] + [response]}

def act(state: AgentState) -> AgentState:
    # 工具执行节点
    result = tool.execute(state["next_action"])
    return {"messages": state["messages"] + [result]}

def should_continue(state: AgentState) -> str:
    if state["retry_count"] > 3:
        return "end"
    return "think"

builder = StateGraph(AgentState)
builder.add_node("think", think)
builder.add_node("act", act)
builder.add_edge(START, "think")
builder.add_conditional_edges("think", should_continue, {"think": "think", "end": END})
builder.add_edge("act", "think")

graph = builder.compile(checkpointer=SqliteSaver(conn))

from crewai import Agent, Task, Crew, Process

researcher = Agent(
    role="高级市场研究员",
    goal="发现关于{topic}的前沿趋势和数据",
    backstory="你是一位有15年经验的行业分析师，擅长从海量信息中提取洞察",
    tools=[search_tool, web_scraper],
    verbose=True,
)

writer = Agent(
    role="技术内容编辑",
    goal="将研究结果转化为有深度的分析报告",
    backstory="你是一位知名科技媒体的前任主编",
    tools=[file_writer],
    verbose=True,
)

research_task = Task(
    description="调研{topic}的最新发展动态",
    expected_output="包含数据和引用的调研摘要",
    agent=researcher,
)

write_task = Task(
    description="基于调研结果撰写深度分析报告",
    expected_output="3000字以上的专业分析报告",
    agent=writer,
)

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

result = crew.kickoff(inputs={"topic": "AI Agent框架2026"})

from agents import Runner
from agents.sandbox import SandboxAgent, Manifest
from agents.sandbox.entries import GitRepo
from agents.sandbox.sandboxes import UnixLocalSandboxClient

agent = SandboxAgent(
    name="代码审查助手",
    instructions="检查仓库代码质量并生成报告",
    default_manifest=Manifest(
        entries={"repo": GitRepo(repo="user/project", ref="main")}
    ),
)

result = Runner.run_sync(
    agent,
    "审查README和核心模块的代码质量",
    run_config=RunConfig(sandbox=SandboxRunConfig(
        client=UnixLocalSandboxClient()
    )),
)
print(result.final_output)

from google.adk import Agent, Workflow

generate_agent = Agent(
    name="generate_agent",
    model="gemini-2.5-flash",
    instruction="返回一个随机水果名称",
)

benefit_agent = Agent(
    name="benefit_agent",
    model="gemini-2.5-flash",
    instruction="告诉我指定水果的健康益处",
)

# Workflow定义确定性编排流
root_agent = Workflow(
    name="root_agent",
    edges=[("START", generate_agent, benefit_agent)],
)

// npm install @anthropic-ai/claude-agent-sdk
import { ClaudeAgentSDK } from '@anthropic-ai/claude-agent-sdk';

const sdk = new ClaudeAgentSDK();
const agent = await sdk.createAgent({
  instructions: "分析代码库并修复安全漏洞",
});

const result = await agent.run("检查所有API端点的输入验证");

from smolagents import CodeAgent, WebSearchTool, InferenceClientModel

model = InferenceClientModel(model_id="deepseek-ai/DeepSeek-R1", provider="together")
agent = CodeAgent(tools=[WebSearchTool()], model=model, stream_outputs=True)

result = agent.run(
    "一只猎豹以最高速度跑过巴黎艺术桥需要多少秒？"
)
# Agent生成的代码类似：
# speed_km_h = 120  # 猎豹最高速度
# bridge_length_m = 155  # 艺术桥长度
# speed_m_s = speed_km_h * 1000 / 3600
# time_seconds = bridge_length_m / speed_m_s
# print(f"需要 {time_seconds:.2f} 秒")

from pydantic_ai import Agent, RunContext
from pydantic import BaseModel

class SearchResult(BaseModel):
    title: str
    url: str
    relevance_score: float

search_agent = Agent(
    'openai:gpt-4o',
    result_type=SearchResult,  # 结构化输出有类型保证
    deps_type=SearchDB,        # 依赖注入也有类型
)

@search_agent.tool
async def search(ctx: RunContext[SearchDB], query: str) -> list[SearchResult]:
    # ctx.deps 有正确的类型提示
    return ctx.deps.search(query)

result = await search_agent.run("最新的Agent框架")
typed_result: SearchResult = result.data  # 类型安全

graph TB
    subgraph "图状态机派 - LangGraph"
        LG_S[START] --> LG_T[Think Node]
        LG_T -->|条件边| LG_A[Act Node]
        LG_A --> LG_C{Continue?}
        LG_C -->|Yes| LG_T
        LG_C -->|No| LG_E[END]
        LG_T -.->|Checkpoint| LG_DB[(SQLite/Postgres)]
    end

    subgraph "角色编排派 - CrewAI"
        CR_R[Researcher Agent] -->|顺序执行| CR_W[Writer Agent]
        CR_W -->|Flow编排| CR_E[Editor Agent]
        CR_R -.-> CR_C[Crew Context]
    end

    subgraph "厂商原语派"
        OA_A1[Sandbox Agent] -->|Handoff| OA_A2[Review Agent]
        OA_A1 -.-> OA_SB[Container Sandbox]

        GA_A1[Generate Agent] -->|Workflow Edge| GA_A2[Benefit Agent]
        GA_A1 -.-> GA_GCP[GCP/Gemini]

        CA_A1[Claude Agent] -->|Code Actions| CA_Files[File System]
        CA_A1 -.-> CA_CC[Claude Code Engine]
    end

    subgraph "代码优先派 - Smolagents"
        SM_Q[User Query] --> SM_Code[LLM generates Python]
        SM_Code --> SM_Exec[Sandbox Execute]
        SM_Exec --> SM_R[Result]
    end

    subgraph "类型安全派 - PydanticAI"
        PA_I[Typed Input] --> PA_Agent[Agent + DI]
        PA_Agent --> PA_O[Typed Output]
        PA_Agent -.-> PA_D[Dependencies]
    end

    style LG_DB fill:#f9f,stroke:#333
    style CR_C fill:#bbf,stroke:#333
    style OA_SB fill:#fbb,stroke:#333
    style SM_Exec fill:#bfb,stroke:#333
    style PA_D fill:#fbf,stroke:#333

graph TD
    START[选择Agent框架] --> Q1{需要多Agent编排?}
    Q1 -->|Yes| Q2{编排逻辑复杂度?}
    Q1 -->|No| Q3{主要任务类型?}

    Q2 -->|高:条件/循环/回滚| LANG[LangGraph<br/>图状态机]
    Q2 -->|中:角色分工| CREW[CrewAI<br/>角色编排]
    Q2 -->|低:简单接力| Q4{首选云厂商?}

    Q4 -->|OpenAI| OAI[OpenAI Agents SDK]
    Q4 -->|Google/Gemini| ADK[Google ADK]
    Q4 -->|Anthropic/Claude| CAS[Claude Agent SDK]
    Q4 -->|中立| AG2[AG2 社区版]

    Q3 -->|数据分析/脚本| SMOL[Smolagents<br/>代码优先]
    Q3 -->|结构化提取/分类| PYD[PydanticAI<br/>类型安全]
    Q3 -->|通用对话/工具| Q4

    style LANG fill:#e1f5fe
    style CREW fill:#f3e5f5
    style OAI fill:#e8f5e9
    style ADK fill:#fff3e0
    style CAS fill:#fce4ec
    style SMOL fill:#e0f2f1
    style PYD fill:#f1f8e9
    style AG2 fill:#ede7f6

from langgraph.graph import StateGraph, START, END

def research(state):
    state["research"] = search_tool(state["topic"])
    return state

def summarize(state):
    state["summary"] = llm.summarize(state["research"])
    return state

g = StateGraph(dict)
g.add_node("research", research)
g.add_node("summarize", summarize)
g.add_edge(START, "research")
g.add_edge("research", "summarize")
g.add_edge("summarize", END)
graph = g.compile()

from crewai import Agent, Task, Crew

researcher = Agent(role="研究员", goal="搜索{topic}", tools=[search])
writer = Agent(role="编辑", goal="撰写摘要报告")
crew = Crew(agents=[researcher, writer],
            tasks=[Task(description="搜索", agent=researcher),
                   Task(description="摘要", agent=writer)])
crew.kickoff(inputs={"topic": "AI Agents"})

from agents import Agent, Runner

researcher = Agent(name="研究员", instructions="搜索给定主题")
writer = Agent(name="编辑", instructions="将搜索结果整理成摘要",
               handoffs=[researcher])
result = Runner.run_sync(writer, "搜索AI Agents并写摘要")

from google.adk import Agent, Workflow

researcher = Agent(name="researcher", instruction="搜索主题")
writer = Agent(name="writer", instruction="整理成摘要")
root = Workflow(name="pipeline",
                edges=[("START", researcher, writer)])

from smolagents import CodeAgent, WebSearchTool, InferenceClientModel

agent = CodeAgent(tools=[WebSearchTool()], model=InferenceClientModel())
agent.run("搜索AI Agents最新进展，生成摘要报告")

from pydantic_ai import Agent
from pydantic import BaseModel

class Report(BaseModel):
    summary: str
    sources: list[str]

agent = Agent('openai:gpt-4o', result_type=Report)
result = agent.run_sync("搜索AI Agents最新进展并生成摘要")