#DeepAgents 框架

"""
测试1：deepagents的第一个测试例子
"""

import os
from dotenv import load_dotenv
from tavily import TavilyClient
from typing import Literal

from langchain.chat_models import init_chat_model
from deepagents import create_deep_agent


# 加载.env环境配置，如果在环境变量中配置了，就不会加载.env文件
load_dotenv()

# 创建TavilyClient对象
tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))

# 定义一个联网搜索工具函数
def internet_search(
    query: str,
    max_results: int = 5,
    topic: Literal["general", "news", "finance"] = "general",
    include_raw_content: bool = False,
):
    """使用 Tavily 进行联网搜索"""
    print(f"正在搜索: {query}")
    return tavily_client.search(
        query=query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

if __name__ == "__main__":
    print(internet_search.invoke({"query": "langchain是什么？"}))

# 初始化一个LLM
llm = init_chat_model(
    model="qwen-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL"),
    model_provider="openai",
)

# 创建一个深度智能体（代理）
deep_agent = create_deep_agent(
        model="gpt-4o",
        # model=llm,
        tools=[internet_search],
        system_prompt="""你是一个助手，需要使用网络搜索工具来获取信息。
            请使用中文回答问题。
            """, 
        subagents=[],
    )

# 执行深度智能体
result = deep_agent.invoke(
    {
        "messages": [
            {
                "role": "user",
                "content": "今天武汉天气怎么样?",
            }
        ]
    }
)

#打印整个结果
print(result)
print("\n")

# 打印目标结果内容
print(result["messages"][-1].content)

"""
测试2：流式输出
    agent.stream()
"""
....
....

def query_stream(query:str):
    stream = deep_agent.stream({
        "messages": [
            {"role": "user", "content": query}
        ]
    })
    # print(stream)  # <generator object Pregel.stream at 0x000001F0401A18D0>

    for chunk in stream:
        for key, value in chunk.items():
            if not value or "messages" not in value: continue
            messages = value["messages"]
            if (messages and isinstance(messages, List)):
                last_msg = messages[-1]
                if key == 'model':
                    if last_msg.tool_calls:
                        for tool_call in last_msg.tool_calls:
                            print(f"智能体决定调用工具{tool_call['name']} 传入参数：{tool_call['args']}")
                    elif last_msg.content:
                        print(f"智能体最终执行结果：{last_msg.content}")
                elif key == 'tools':
                    print(f"智能体调用{last_msg.name}工具返回结果：{last_msg.conten}")

if __name__ == '__main__':
    query_stream("今天武汉天气怎么样? 搜索一下智能体最新资讯")
 
# =============================================================================
# Chunk 数据结构参考文档
# =============================================================================
# 流式输出的四种核心场景示例：
# 1. [场景 A：模型 思考并决定调用工具]
#    {
#      "model": {
#        "messages": [
#          AIMessage(
#            content="",
#            tool_calls=[{
#              "name": "read_file_content",
#              "args": {"filename": "需求.docx"},
#              "id": "call_123"
#            }]
#          )
#        ]
#      }
#    }
# 2. [场景 B：工具执行完毕，返回结果]
#    {
#      "tools": {
#        "messages": [
#          ToolMessage(
#            content="[文件内容]...",
#            name="read_file_content",
#            tool_call_id="call_123"
#          )
#        ]
#      }
#    }
# 3. [场景 C：Agent 决定调用子 Agent (特殊工具 'task')]
#    {
#      "model": {
#        "messages": [
#          AIMessage(
#            content="",
#            tool_calls=[{
#              "name": "task",
#              "args": {
#                "subagent_type": "网络搜索助手",  # 目标子 Agent
#                "description": "查询2024政策"     # 下发的具体任务
#              },
#              "id": "call_456"
#            }]
#          )
#        ]
#      }
#    }
# 4. [场景 D：Agent 最终回复用户]
#    {
#      "model": {
#        "messages": [
#          AIMessage(
#            content="根据查询结果，2024年新政策如下...",
#            tool_calls=[]
#          )
#        ]
#      }
#    }
# =============================================================================

"""
测试3：异步执行
    agent.ainvoke(): 异步非流式输出
    agent.astream()：异步流式输出
    注意：astream() 返回异步迭代器，必须用 `async for`进行遍历
"""
import asyncio
import os
from typing import Literal

from deepagents import create_deep_agent

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.tools import tool
from tavily import TavilyClient

# 加载.env配置
load_dotenv()

# 创建tavily客户端
tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))


# 定义工具函数: 使用tavily进行网络搜索
@tool
def internet_search(
    query: str, # 搜索内容
    max_results: int = 5, # 最大返回结果数量
    topic: Literal["general", "news", "finance"] = "general", # 搜索主题
    include_raw_content: bool = False, # 是否返回原始内容 False为精简内容
):
    """
    使用tavily进行网络搜索
    :param query: 搜索内容
    :param max_results: 最大返回结果数量
    :param topic: 搜索主题
    :param include_raw_content: 是否返回原始内容
    :return: 搜索结果
    """
    print(f"--开始搜索：{query}")
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

# 初始化模型
llm=init_chat_model(
    model="qwen-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL"),
    model_provider="openai",
)

# 创建深度代理
agent = create_deep_agent(
    # model="openai:gpt-5.4",
    # model="anthropic:claude-sonnet-4-6",
    model = llm,
    tools=[internet_search],
    system_prompt="你是一个强大的助手",
)


# 异步非流式输出执行： ainvoke
async def query_ainvoke(query: str):
    result = await agent.ainvoke({"messages": [{"role": "user", "content": query}]})
    print(result['messages'][-1].content)

# 多个异步之间是串行执行的
async def batch_ainvoke():
    await query_ainvoke("AI最新资讯")
    await query_ainvoke("智能体最新资讯")
    await query_ainvoke("大模型最新资讯")

# 多个异步非流式之间是并行执行的
async def batch_ainvoke2():
    cor1 = query_ainvoke("AI最新资讯")
    cor2 = query_ainvoke("智能体最新资讯")
    cor3 = query_ainvoke("大模型最新资讯")
    await asyncio.gather(cor1, cor2, cor3)

# 异步流式输出执行: astream
async def query_astream(query: str):
    stream_result = agent.astream(
        {"messages": [{"role": "user", "content": query}]}
    )
    
    # astream()返回的是一个异步迭代器（AsyncIterator），必须使用async for来遍历
    async for chunk in stream_result:
        for key, value in chunk.items():
            # print(f"=={key}==")
            # print(value)
            if not value or "messages" not in value: continue
            message = value["messages"][-1]
            if key == "model":
                if message.tool_calls:
                    for tool_call in message.tool_calls:
                        print(f"--智能体准备调用工具{tool_call['name']}, 参数：{tool_call['args']}")
                elif message.content:
                    print(f"--智能体返回最终结果: {message.content}")
            elif key == "tools":
                tool_name = message.name
                tool_result = message.content
                print(f"--智能体调用{tool_name}工具返回的结果为：{tool_result}")

# 多个异步流式之间是串行执行的
async def batch_astream():
    await query_astream("AI最新资讯")
    await query_astream("智能体最新资讯")
    await query_astream("大模型最新资讯")

# 多个异步流式之间是并行执行的
async def batch_astream2():
    cor1 = query_astream("AI最新资讯")
    cor2 = query_astream("智能体最新资讯")
    cor3 = query_astream("大模型最新资讯")
    await asyncio.gather(cor1, cor2, cor3)

if __name__ == "__main__":
    # asyncio.run(batch_ainvoke())
    # asyncio.run(batch_ainvoke2())
    # asyncio.run(batch_astream())
    asyncio.run(batch_astream2())

"""
测试4_1: 子智能体的基本使用  => 基于字典定义子agent
创建一个主智能体，它拥有三个助手：
    1.  **天气助手**：查询天气（固定返回“晴朗”）。
    2.  **计算助手**：处理数学问题。
    3.  **翻译助手**：负责中英互译。
"""

import os
from deepagents import create_deep_agent
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

# 加载.env配置
load_dotenv()

# 初始化模型
llm=init_chat_model(
    model="qwen-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL"),
    model_provider="openai",
)

# 创建深度代理
agent = create_deep_agent(
    model = llm,
    tools=[],
    system_prompt="你是一个强大的助手",
)

def query_test(query: str):
    stream_result = agent.stream(
        {"messages": [{"role": "user", "content": query}]}
    )
    for chunk in stream_result:
        # print(chunk)
        for key, value in chunk.items():
            if not value or "messages" not in value: continue
            message = value["messages"][-1]
            if key == "model":
                if message.tool_calls:
                    for tool_call in message.tool_calls:
                        print(f"--准备调用工具{tool_call['name']}, 参数：{tool_call['args']}")
                elif message.content:
                    print(f"--智能体返回最终结果: {message.content}")
            elif key == "tools":
                print(f"--调用工具{message.name}返回的结果为：{message.content}")

query_test("今天武汉天气怎么样? 再计算123+234-99等于几？，同时将'好好学习，天天向上'翻译为英文")

"""
测试4_1: 子智能体的基本使用  => 基于字典定义子agent
创建一个主智能体，它拥有三个助手：
    1.  **天气助手**：查询天气（固定返回“晴朗”）。
    2.  **计算助手**：处理数学问题。
    3.  **翻译助手**：负责中英互译。
"""

import os
from deepagents import create_deep_agent
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

# 加载.env配置
load_dotenv()

# 初始化模型
llm=init_chat_model(
    model="qwen-plus",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL"),
    model_provider="openai",
)

# 定义天气助手子agent
weather_agent = {
    "name": "weather_helper",
    "description": "一个天气助手",
    "system_prompt": "你是一个天气助手，统一回复：今天天气晴，温度25度",
    "tools": [],
    # "model": "openai:gpt-5.4",  # Optional override, defaults to main agent model
}

# 定义计算助手子agent
math_agent = {
    "name": "math_helper",
    "description": "一个用于处理数学计算的助手",
    "system_prompt": "你是一个严谨的数学助手，回答用户所有的数学计算问题",
    "tools": []
}

# 定义翻译助手子agent
translate_agent = {
    "name": "translate_helper",
    "description": "一个中英相互翻译助手",
    "system_prompt": "你是一个中英想到翻译助手，如果是中文翻译为英文，反之翻译为中文",
    "tools": []
}

# 创建深度代理
agent = create_deep_agent(
    # model="openai:gpt-5.4",
    # model="anthropic:claude-sonnet-4-6",
    model = llm,
    tools=[],
    system_prompt="你是一个强大的管家，将任务交给合适的子智能处理",
    subagents=[weather_agent, math_agent, translate_agent]  # 配置子智能体
)

def query_test(query: str):
    stream_result = agent.stream(
        {"messages": [{"role": "user", "content": query}]}
    )
    for chunk in stream_result:
        for key, value in chunk.items():
            # print(f"=={key}==")
            # print(value)
            if not value or "messages" not in value: continue
            message = value["messages"][-1]
            if key == "model":
                if message.tool_calls:
                    for tool_call in message.tool_calls:
                        # 区分子智能体和工具
                        if tool_call["name"] == "task":
                            print(f"--准备调用子智能体{tool_call['args']['subagent_type']}, 参数：{tool_call['args']['description']}")
                        else :
                            print(f"--智能体准备调用工具{tool_call['name']}, 参数：{tool_call['args']}")
                elif message.content:
                    print(f"--智能体返回最终结果: {message.content}")
            elif key == "tools":
                if message.name=="task":
                    print(f"--调用子智能体返回的结果为：{message.content}")
                else :
                    print(f"--调用工具{message.name}返回的结果为：{message.content}")

query_test("今天武汉天气怎么样? 再计算123+234-99等于几？，同时将'好好学习，天天向上'翻译为英文")

"""
  测试4_2: 兼容langchain子智能体格式
"""
import os
from dotenv import load_dotenv
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model


load_dotenv()

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)


# 创建主智能体，设置子智能体
main_agent = create_deep_agent(
    model=chat_model,
    subagents=[],
    system_prompt="你是一个智能助手，所有的业务动作，你不要亲自做，都找子智能体进行处理！"
)

print("开始执行任务...")
result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "武汉今天的天气怎么样？"}
    ]
})
print(f"最终结果：{result['messages'][-1].content}")

"""
  测试4_2: 兼容langchain子智能体格式
"""
import os
from dotenv import load_dotenv
from deepagents import create_deep_agent, CompiledSubAgent
from langchain.chat_models import init_chat_model
from langchain.agents import create_agent


load_dotenv()

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 工具函数
def get_weather(city: str) -> str:
    """
     查询指定城市天气
     """
    print(f"--get_weather工具正在查询：{city}天气")
    return f"{city}的天气是晴天，温度为25度。"

# 创建langchain的单智能体
chain_agent = create_agent(
    model=chat_model,
    tools=[get_weather]
)

sub_agent = CompiledSubAgent(
    name="sub_agent",
    description="子智能体，可以调用工具查询天气",
    runnable=chain_agent
)


# 创建主智能体，设置子智能体
main_agent = create_deep_agent(
    model=chat_model,
    subagents=[sub_agent],
    system_prompt="你是一个智能助手，所有的业务动作，你不要亲自做，都找子智能体进行处理！"
)

print("开始执行任务...")
result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "武汉今天的天气怎么样？"}
    ]
})
print(f"最终结果：{result['messages'][-1].content}")

"""
  测试4_3: 兼容langgraph的状态图
"""
import os
from typing import TypedDict, Annotated
from dotenv import load_dotenv
from deepagents import create_deep_agent, CompiledSubAgent
from langchain.chat_models import init_chat_model
from langchain_core.messages import AIMessage
from langgraph.constants import END
from langgraph.graph import add_messages, StateGraph

load_dotenv()

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 创建langgraph的状态图
class MyState(TypedDict):
    # 注解messages的类型为list, messaages的数据在多个节点之间是累加的方式
    messages: Annotated[list, add_messages]
def process_node(state: MyState):
    print(f"--开始处理节点：{state}")
    return {"messages": [AIMessage(f"经过节点处理后的结果：原数据为：{state['messages'][-1].content}")]}
state_graph = StateGraph(MyState)
state_graph.add_node("worker", process_node)
state_graph.set_entry_point("worker")
state_graph.add_edge("worker", END)
compiled_graph = state_graph.compile()


# 将状态图编译成子智能体
sub_agent = CompiledSubAgent(
    name="subagent",
    description="子任务，可以调用天气工具，查询天气信息！!",
    runnable=compiled_graph
)

# 创建主智能体，设置子智能体
main_agent = create_deep_agent(
    model=chat_model,
    subagents=[sub_agent],
    system_prompt="你是一个智能助手，所有的业务动作，你不要亲自做，都使用subagent进行处理！"
)

print("开始执行任务...")
result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "查询武汉的天气！"}
    ]
})

# print(result)
print(f"最终结果：{result['messages'][-1].content}")

"""
测试4_4: 通过response_format配置给子智能体指定输出数据的格式
"""

import os
from typing import Literal

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.tools import tool
from pydantic import BaseModel, Field
from deepagents import create_deep_agent
from tavily import TavilyClient

load_dotenv()

tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))

@tool
def internet_search(
    query: str, # 搜索内容
    max_results: int = 5, # 最大返回结果数量
    topic: Literal["general", "news", "finance"] = "general", # 搜索主题
    include_raw_content: bool = False, # 是否返回原始内容 False为精简内容
):
    """
    使用tavily进行网络搜索
    :param query: 搜索内容
    :param max_results: 最大返回结果数量
    :param topic: 搜索主题
    :param include_raw_content: 是否返回原始内容
    :return: 搜索结果
    """
    print(f"---开始搜索：{query}")
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)



subagent = {
    "name": "researcher",
    "description": "你是一个强大的助手",
    "system_prompt": "通过internet_search工具搜索结果",
    "tools": [internet_search],
}

agent = create_deep_agent(
    model=chat_model,
    subagents=[subagent],
    system_prompt="你是一个强大的管家，你不要亲自处理任务，将任务交给researcher子智能体处理",

)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "武汉的天气怎么样？以json的格式返回数据"}]}
)

print(result['messages'])
print(result['messages'][-1].content)

"""
测试4_5: 通过response_format配置给子智能体指定输出数据的格式
"""

import os
from typing import Literal

from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from langchain_core.tools import tool
from pydantic import BaseModel, Field
from deepagents import create_deep_agent
from tavily import TavilyClient

load_dotenv()

tavily_client = TavilyClient(api_key=os.getenv("TAVILY_API_KEY"))

@tool
def internet_search(
    query: str, # 搜索内容
    max_results: int = 5, # 最大返回结果数量
    topic: Literal["general", "news", "finance"] = "general", # 搜索主题
    include_raw_content: bool = False, # 是否返回原始内容 False为精简内容
):
    """
    使用tavily进行网络搜索
    :param query: 搜索内容
    :param max_results: 最大返回结果数量
    :param topic: 搜索主题
    :param include_raw_content: 是否返回原始内容
    :return: 搜索结果
    """
    print(f"---开始搜索：{query}")
    return tavily_client.search(
        query,
        max_results=max_results,
        include_raw_content=include_raw_content,
        topic=topic,
    )

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 自定义输出数据格式的类型
class WeatherResponse(BaseModel):
    city: str = Field(description="城市名称")
    temperature: int = Field(description="温度")
    condition: str = Field(description="天气状况")
    

subagent = {
    "name": "researcher",
    "description": "你是一个强大的助手",
    "system_prompt": "通过internet_search工具搜索结果",
    "tools": [internet_search],
    "response_format": WeatherResponse, # 给子代理配置结构化返回
}

agent = create_deep_agent(
    model=chat_model,
    subagents=[subagent],
    system_prompt="你是一个强大的管家，你不要亲自处理任务，将任务交给researcher子智能体处理"
)

result = agent.invoke(
    {"messages": [{"role": "user", "content": "武汉的天气怎么样？以json的形式保存数据"}]}
)

print(result['messages'])
print(result['messages'][-1].content)

"""
  测试4_5: 字典形式的嵌套子agent  (不支持)
"""
import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from deepagents import create_deep_agent

load_dotenv()

chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 底层CODER agent
# 职责明确：只有他能写代码
coder_agent = {
    "name": "CODER",
    "description": "高级Python工程师，他是唯一有权限编写具体代码的人。",
    "system_prompt": "你是一个高级Python工程师。你的职责是接收具体的编码任务并实现它。",
    "tools": [] # coder拥有默认的文件操作工具
}

# 中间层CTO agent
# 职责明确：承上启下，必须指挥coder
cto_config = {
    "name": "CTO",
    "description": "技术总监，负责将战略需求转化为技术任务并分配给工程师。指挥Coder写代码的！",
    # 关键修改：明确告诉CTO不要自己写代码，必须找CODER
    "system_prompt": """
        你是技术总监。
        注意：你没有编写代码的权限！
        你的职责是：
        1. 分析 CEO 的需求。
        2. 设计技术方案。
        3. 调用 'Coder' 子代理来完成具体的代码编写工作。
    """,
    "tools": [], # coder拥有默认的文件操作工具
    "subagents": [coder_agent] # 子智能体中没有一个配置，强写（底层不识别）
}

# 顶层CEO agent
# 职责明确：只负责战略，禁止干具体的活
ceo_agent = create_deep_agent(
    model=chat_model,
    name="CEO",
    # 关键修改：明确告诉CEO不要自己动手，必须找CTO
    system_prompt="""
        你是CEO，负责公司战略决策。
        注意：你严禁直接编写代码或操作文件！
        你必须将所有技术相关的开发任务委派给 'CTO' 处理。
        你的工作是验收 CTO 提交的结果。
    """,
    subagents=[cto_config]
)

print(">>>开始执行任务...")
stream = ceo_agent.stream(
    {
        "messages": [
            {"role": "user", "content": "使用python实现冒泡排序，只用生成代码字符串即可！！"}
        ]
    },
    # subgraphs=True
)

print("\n>>> 最终结果：")
for chunk in stream:
    print(chunk)

"""
测试4_6：使用CompiledSubAgent实现三级嵌套 SubAgent

层级：
CEO -> CTO -> CODER

实现方式：
1. 先创建最底层 CODER deep agent
2. 将 CODER 包装成 CompiledSubAgent，挂到 CTO
3. 再将 CTO 包装成 CompiledSubAgent，挂到 CEO

注意：
- 不在 SubAgent 字典里直接写 "subagents"
- 多层嵌套要通过 CompiledSubAgent 传递 runnable
"""
import os
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
from deepagents import (CompiledSubAgent, create_deep_agent)

# 加载.env配置
load_dotenv()

# 初始化model
chat_model = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)
chat_model2 = init_chat_model(
    model="qwen-max",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

chat_model3 = init_chat_model(
    model="qwen3.6-flash",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)


# 底层coder配置
# 职责明确：只有他能写代码
coder_agent = create_deep_agent(
        model=chat_model3,
        tools=[],
        subagents=[],
        name="CODER",
        system_prompt="""
你是 CODER，高级 Python 工程师。

职责边界：
1. 你只负责直接写代码。
2. 不要再继续分派任务。
3. 输出最终答案时，直接给出可运行的 Python 代码字符串。
4. 除代码外，只允许加极少量必要说明。
        """.strip(),
)

# 中间层CTO配置
# 职责明确：承上启下，必须指挥coder
coder_subagent = CompiledSubAgent(
    name="coder",
    description="负责编写 Python 代码。所有实际编码任务都必须交给它。",
    runnable=coder_agent,
)
cto_agent = create_deep_agent(
        model=chat_model2,
        tools=[],
        subagents=[coder_subagent],
        name="CTO",
        system_prompt="""
你是 CTO，技术负责人。

职责边界：
1. 你负责理解 CEO 下发的需求，并拆解成具体编码任务。
2. 你不能亲自写代码。
3. 只要任务涉及编写 Python 代码，必须调用 coder 子代理。
4. 你的最终输出应当是 coder 返回的代码结果，不要自行改写为伪代码。
        """.strip(),
)

# 顶层CEO配置
# 职责明确：只负责战略，禁止干具体的活
cto_subagent = CompiledSubAgent(
        name="cto",
        description="不要亲自生成代码，必须调用子代理完成编码。",
        runnable=cto_agent,
)
ceo_agent = create_deep_agent(
    model=chat_model,
    name="CEO",
    # 关键修改：明确告诉CEO不要自己动手，必须找CTO
    system_prompt="""
        你是CEO，负责公司战略决策。
        注意：你严禁直接编写代码或操作文件！
        你必须将所有技术相关的开发任务委派给 'CTO' 处理。
        你的工作是验收 CTO 提交的结果。
    """,
    subagents=[cto_subagent]
)

print(">>>开始执行任务...")
stream = ceo_agent.stream(
    {
        "messages": [
            {"role": "user", "content": "使用python实现冒泡排序，只用生成代码字符串即可！！"}
        ]
    },
    # subgraphs=True  #让 stream() 把“子图/子代理内部”的事件也一起流出来，而不只给你最外层主图的事件。
)

print("\n>>> 最终结果：")
for chunk in stream:
    print(chunk)

"""
  测试5_1: 人工审批
    演示高危工具调用前的人工审批流程，支持如：删除数据库表、修改文件等 的审批流程
"""
import os

from dotenv import load_dotenv
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

from langchain_core.tools import tool
from langchain_core.utils.uuid import uuid7
from langgraph.checkpoint.memory import InMemorySaver # 内存检查点，用于保存中断状态
from langgraph.types import Command # 恢复执行的指令类型

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

@tool
def delete_table(table_name: str):
    """
    高危动作工具，删除传入的表
    :param table_name: 要删除的表名
    :return: 操作的返回结果
    """
    print(f"调用了delete_table工具,删除了{table_name}表!")
    return f"删除了{table_name}表！"

# 删除文件的工具
@tool
def delete_file(file_name: str):
     """
     高危动作工具，删除传入的文件
     :param file_name: 要删除的文件
     :return: 操作的返回结果
     """
     print(f"调用了delete_file工具,删除了{file_name}文件!")
     return f"删除了{file_name}文件！"

# 查询表数据的工具
@tool
def query_table(table_name: str):
     """
     查询动作工具，查询传入的表数据
     :param table_name: 要查询的表名
     :return: 查询结果
     """
     print(f"调用了query_table工具,查询了{table_name}表数据!")
     return f"查询了{table_name}表的数据！"

main_agent = create_deep_agent(
    model=llm,
    tools=[delete_table, delete_file, query_table],
    system_prompt="""回答使用中文，调用对应的工具实现对应的功能！""",
)

result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "先查询product表的数据！再删除user表，最后，删除zhangsan.txt文件"}
    ]
})

print(f"--最终结果: {result['messages'][-1].content}")

# create_deep_agent的属性，配置工具是否需要人工互动
main_agent = create_deep_agent(
    model=llm,
    tools=[delete_table, delete_file, query_table],
    system_prompt="""回答使用中文，调用对应的工具实现对应的功能！""",
    # 1. 配置工具是否需要审批
    interrupt_on={
        "query_table": False,  # 不需要审批
        "delete_table": True, # 需要审批 (包含: 同意|approve, 拒绝|reject, 修改|edit, 返回人类消息|respond)
        "delete_file": {"allowed_decisions": ["approve", "reject"]}, # 需要审批 (只包含: 同意|approve, 拒绝|reject)
    },
    # 2. 配置检查点, 在审批前保存状态,在审批通过后恢复状态
    checkpointer=InMemorySaver(),
)

from langgraph.checkpoint.memory import MemorySaver

main_agent = create_deep_agent(
    tools=[...],
    interrupt_on={...},
    checkpointer=MemorySaver()  # 必须，否则没有进度！
)

# 第1次调用，不会立即执行，会判断是否有中断动作
config = {"configurable": {"thread_id": "my-thread"}}
result = main_agent.invoke(input, config=config)

# 第2次调用，配置相同的线程id以及审批行为，最终执行
# 必须是相同的线程id才能确保同一个agent线程状态执行
result = main_agent.invoke(Command(resume={...}), config=config)

if (result["__interrupt__"]):
    # 4. 给不同工具操作添加审批意见
    decisions = []
    action_requests = result["__interrupt__"][0].value['action_requests']
    for action in action_requests:
        action_name = action['name']
        if action_name == "delete_table":
            # 此处进行逻辑判断,来决定拒绝还是同意此操作 => 此处拒绝
            decisions.append({"type": "reject"})
        elif action_name == "delete_file":
            # 此处进行逻辑判断,来决定拒绝还是同意此操作 => 此处同意
            decisions.append({"type": "approve"})

 	# 5. 再次执行agent,配置thread_id和审批意见
    result2 = main_agent.invoke(
        Command(resume={"decisions": decisions}),
        config=config,  # Must use the same config!
    )
    print(f"最终结果: {result2['messages'][-1].content}")

"""
  测试5_1: 人工审批
    演示高危工具调用前的人工审批流程，支持如：删除数据库表、修改文件等 的审批流程
"""
import os

from dotenv import load_dotenv
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model

from langchain_core.tools import tool
from langchain_core.utils.uuid import uuid7
from langgraph.checkpoint.memory import InMemorySaver # 内存检查点，用于保存中断状态
from langgraph.types import Command # 恢复执行的指令类型

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

@tool
def delete_table(table_name: str):
    """
    高危动作工具，删除传入的表
    :param table_name: 要删除的表名
    :return: 操作的返回结果
    """
    print(f"调用了delete_table工具,删除了{table_name}表!")
    return f"删除了{table_name}表！"

# 删除文件的工具
@tool
def delete_file(file_name: str):
     """
     高危动作工具，删除传入的文件
     :param file_name: 要删除的文件
     :return: 操作的返回结果
     """
     print(f"调用了delete_file工具,删除了{file_name}文件!")
     return f"删除了{file_name}文件！"

# 查询表数据的工具
@tool
def query_table(table_name: str):
     """
     查询动作工具，查询传入的表数据
     :param table_name: 要查询的表名
     :return: 查询结果
     """
     print(f"调用了query_table工具,查询了{table_name}表数据!")
     return f"查询了{table_name}表的数据！"

main_agent = create_deep_agent(
    model=llm,
    tools=[delete_table, delete_file, query_table],
    system_prompt="""回答使用中文，调用对应的工具实现对应的功能！""",
    # 1. 配置工具是否需要审批
    interrupt_on={
        "query_table": False,  # 不需要审批
        "delete_table": True, # 需要审批 (包含: 同意|approve, 拒绝|reject, 修改|edit, 返回人类消息|respond)
        "delete_file": {"allowed_decisions": ["approve", "reject"]}, # 需要审批 (只包含: 同意|approve, 拒绝|reject)
    },
    # 2. 配置检查点, 在审批前保存状态,在审批通过后恢复状态
    checkpointer=InMemorySaver(),
)

# 3. 定义thread_id配置, 并在预调用和调用时传入相同的配置
# 3.1. 定义包含thread_id的配置
config = {"configurable": {"thread_id": str(uuid7())}}

# 3.2. 第一次预调用,配置thread_id: 不会真正调用工具, 只是读取中断配置, 返回中断配置相关信息
result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "先查询product表的数据！再删除user表，最后，删除zhaoweifeng.txt文件"}
    ]
}, config=config)
print(f"--预调用result: {result}")

if (result["__interrupt__"]):
    # 4. 给不同工具操作添加审批意见
    decisions = []
    action_requests = result["__interrupt__"][0].value['action_requests']
    for action in action_requests:
        action_name = action['name']
        if action_name == "delete_table":
            # 此处进行逻辑判断,来决定进行哪个操作 => 此处拒绝
            decisions.append({"type": "reject"})
        elif action_name == "delete_file":
            # 此处进行逻辑判断,来决定拒绝还是同意此操作 => 此处同意
            decisions.append({"type": "approve"})
    # 5. 再次执行agent,配置thread_id和审批意见
    result2 = main_agent.invoke(
        Command(resume={"decisions": decisions}),
        config=config,  # Must use the same config!
    )
    print(f"最终结果: {result2['messages'][-1].content}")

"""
  测试5_2: 人工审批
    演示高危工具调用前的人工审批流程的编辑工具参数
"""
。。。
		if action_name == "delete_table":
            # 此处进行逻辑判断,来决定进行哪个操作 => 此处编辑
            decisions.append({
                "type": "edit",  # 操作类型为编辑
                "edited_action": {
                    "name": "delete_table", # 工具名称
                    "args": {"table_name": "user2"}  # 指定要删除的表名是user2
                }
            })
 。。。

"""
  测试06_1: 演示使用fileSystemBackEnd实现长期记忆
   实现跨会话的数据共享
"""
import os

from dotenv import load_dotenv
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model
from pathlib import Path
from deepagents.backends import FilesystemBackend, StateBackend, StoreBackend, CompositeBackend

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)


main_agent = create_deep_agent(
    model=llm,
    tools=[],
    system_prompt="""
        你是一个智能助手，可以使用文件工具进行文件读写操作！但是只有在用户明确要求的情况下，你才可以创建文件
    """,
)

result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "帮我查询下python语言的介绍,并且帮我写到 xxx.txt文件"}
    ]
})
print(f"最终结果: {result['messages'][-1].content}")

"""
  测试06_1: 演示使用fileSystemBackEnd实现长期记忆
  跨会话 实现数据共享
"""
import os

from dotenv import load_dotenv
from deepagents import create_deep_agent
from langchain.chat_models import init_chat_model
from pathlib import Path
from deepagents.backends import FilesystemBackend, StateBackend, StoreBackend, CompositeBackend

load_dotenv()

# 1.创建工作区文件夹
workspace_dir = Path("./agent_workspace").resolve()
if not workspace_dir.exists():
    workspace_dir.mkdir()
# 2.创建文件系统后端
file_backend = FilesystemBackend(workspace_dir, virtual_mode=True)


llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 3. 创建agent时,将backend配置为文件系统后端
main_agent = create_deep_agent(
    model=llm,
    tools=[],
    system_prompt="""
        你是一个智能助手，可以使用文件工具进行文件操作和读写！但是只有在用户明确要求的情况下，你才可以创建文件！！
    """,
    backend=file_backend
)

# 运行并验证
# 4.1 执行agent, 将结果保存到工作区目录的指定文件中
result = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "帮我查询下python语言的介绍,并且帮我写到'python.txt'文件"}
    ]
})
print(f"最终结果: {result['messages'][-1].content}")

# 4.2 执行agent, 读取工作区目录的指定文件内容
result2 = main_agent.invoke({
    "messages": [
        {"role": "user", "content": "从文件中读取Python编程语言的详细介绍数据"}
    ]
})
print(f"最终结果2: {result2['messages'][-1].content}")

"""
  测试06_2: 演示使用StoreBackend实现长期记忆
  实现跨会话的数据共享
"""

from deepagents import create_deep_agent
from deepagents.backends import StoreBackend, StateBackend,FilesystemBackend,CompositeBackend
from langgraph.store.memory import InMemoryStore
from dotenv import load_dotenv, find_dotenv
from langchain.chat_models import init_chat_model
import os
load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)



main_agent = create_deep_agent(
    model=llm,
    system_prompt="""
    你要把用户的重要信息保存到user_profile.txt文件中！
    获取用户信息可以读取user_profile.txt文件！
    """
)


config_a  = {
    "configurable":{
        "thread_id":"a"
    }
}
config_b  = {
    "configurable":{
        "thread_id":"b"
    }
}

#第一遍执行 =>保存一些重要数据
result_a = main_agent.invoke(
    {
        "messages":[
            {"role":"user","content":"我叫张三，今年23岁！"}
        ]
    },
    config=config_a
)

print(f"第1次回复结果：{result_a['messages'][-1].content}")



#第二遍执行 -》 读取一些重要信息

result_b = main_agent.invoke(
    {
        "messages":[
            {"role":"user","content":"我叫啥和我的年龄！"}
        ]
    },
    config=config_b
)

print(f"第2次回复结果：{result_b['messages'][-1].content}")

"""
  测试06_2: 演示使用StoreBackend实现长期记忆
  实现跨会话的数据共享
"""

from deepagents import create_deep_agent
from deepagents.backends import StoreBackend, StateBackend,FilesystemBackend,CompositeBackend
from langgraph.store.memory import InMemoryStore
from dotenv import load_dotenv, find_dotenv
from langchain.chat_models import init_chat_model
import os
load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)



main_agent = create_deep_agent(
    model=llm,
    # 1. 创建内存存储并配置到store
    #  InMemoryStore 是轻量级内存存储，以Key-Value的形式存储, 重启后数据丢失。
    store=InMemoryStore(),
    # 2. 创建store后端并配置到backend
    backend= StoreBackend(
        namespace= lambda rt : ("deepagent_test", )
    ),
    system_prompt="""
    你要把用户的重要信息保存到user_profile.txt文件中！
    获取用户信息可以读取user_profile.txt文件！
    """
)

# 3. 测试时多次执行agent,配置不同的thread_id,先保存, 后读取
# 如果能得到前面保存的,说明实现的跨会话的数据共享功能
config_a  = {
    "configurable":{
        "thread_id":"a"
    }
}
config_b  = {
    "configurable":{
        "thread_id":"b"
    }
}

#第一遍执行
result_a = main_agent.invoke(
    {
        "messages":[
            {"role":"user","content":"我叫张三，今年23岁！"}
        ]
    },
    config=config_a
)

print(f"第1次回复结果：{result_a['messages'][-1].content}")



#第二遍执行 -》 读取一些重要信息

result_b = main_agent.invoke(
    {
        "messages":[
            {"role":"user","content":"我叫啥和我的年龄！"}
        ]
    },
    config=config_b
)

print(f"第2次回复结果：{result_b['messages'][-1].content}")

"""
  测试06_3: 演示使用CompositeBackend实现长期记忆
 不同路由采用不同的存储方案

"""
from deepagents import create_deep_agent
from deepagents.backends import StoreBackend, FilesystemBackend, CompositeBackend
from langgraph.store.memory import InMemoryStore
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
import os
from pathlib import Path

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

agent = create_deep_agent(
    model=llm,
    tools=[],
    system_prompt="""你是一个智能助手。
    - 普通文件：直接写入文件名（如 `report.txt`），保存到本地工作区。
    - 重要记忆：写入 `/store/` 目录（如 `/store/profile.txt`），保存到store指定的存储方式中。
    """
)

# 运行 Agent 测试
config = {"configurable": {"thread_id": "thread_composite"}}

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": """1. 创建本地文件 local.txt，内容'本地文件内容...'。
                      2. 创建文件 /store/memory，内容'重要记忆...'。"""
    }]
}, config=config)

print("Agent 回复:", result["messages"][-1].content)

"""
  测试06_3: 演示使用CompositeBackend实现长期记忆
  不同路由采用不同的存储方案
"""
from deepagents import create_deep_agent
from deepagents.backends import StoreBackend, FilesystemBackend, CompositeBackend
from langgraph.store.memory import InMemoryStore
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model
import os


load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

# 准备用于内存存储的对象
store = InMemoryStore()
# 准备用于混合后端存储的对象
composite_backend = CompositeBackend(
    # 默认用文件存储
    default=FilesystemBackend("./agent_workspace", virtual_mode=True),
    # 以下路由使用内存存储
    routes={
        "/store": StoreBackend(
            namespace= lambda rt: ("ns_test", )
        )
    }
)
agent = create_deep_agent(
    model=llm,
    tools=[],
    system_prompt="""你是一个智能助手。
    - 普通文件：直接写入文件名（如 `report.txt`），保存到本地工作区。
    - 重要记忆：写入 `/store/` 目录（如 `/store/profile.txt`），保存到store指定的存储方式中。
    """,
    store=store, # 配置内存存储
    backend=composite_backend # 配置混合后端存储
)

# 运行 Agent 测试
config = {"configurable": {"thread_id": "thread_composite"}}
config2 = {"configurable": {"thread_id": "thread_composite2"}}

result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": """1. 创建本地文件 local.txt，内容'本地文件内容数据...'。
                      2. 创建文件 /store/memory，内容'重要记忆内容数据...'。"""
    }]
}, config=config)

print("Agent 回复:", result["messages"][-1].content)

# 读取混合存储中的内存存储数据
data = store.search(("ns_test",))
for item in data:
    print(f"--key={item.key}--value={item.value['content']}")

# 通过agent读取数据
result2 = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "读取local.txt文件内容"
    }]
}, config=config2)

print("Agent 回复2: ", result2["messages"][-1].content)

result3 = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "读取内存存储/store/memory的内容"
    }]
}, config=config2)

print("Agent 回复3: ", result3["messages"][-1].content)

"""
测试01：智能体的整个工作区目录下：能读能写
"""
import os
from deepagents import create_deep_agent, FilesystemPermission
from deepagents.backends import FilesystemBackend
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

agent = create_deep_agent(
    model=llm,
    backend=FilesystemBackend(
        root_dir="./agent_workspace", virtual_mode=True
    )
)

print("=== 测试：智能体权限 ===")

# 测试1：让智能体执行【读取文件】→ 允许
result1 = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "读取test.txt文件内容"
    }]
})
print(f"读取结果：{result1['messages'][-1].content}")

# 测试2：让智能体执行【写入文件】→ 允许
result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "向test.txt写入: hello world"
    }]
})
print(f"写入结果：{result['messages'][-1].content}")

"""
测试02：智能体的整个工作区目录下：只能读文件，不能写（禁止写入）
"""
import os
from deepagents import create_deep_agent, FilesystemPermission
from deepagents.backends import FilesystemBackend
from dotenv import load_dotenv
from langchain.chat_models import init_chat_model

load_dotenv()

llm = init_chat_model(
    model="qwen-plus",
    model_provider="openai",
    api_key=os.getenv("DASHSCOPE_API_KEY"),
    base_url=os.getenv("DASHSCOPE_BASE_URL")
)

agent = create_deep_agent(
    model=llm,
    backend=FilesystemBackend(
        root_dir="./agent_workspace", virtual_mode=True
    ),
    permissions=[
        # 配置工作区的文件操作权限: 限制工作区所有文件只读
        FilesystemPermission(
            operations=["write"],
            paths=["/**"], # 针对的路径是工作区目录及其子目录
            mode="deny" # 拒绝/禁止上面的写操作
        )
    ]
)


print("=== 测试：智能体只读权限 ===")

# 测试1：让智能体执行【读取文件】→ 允许
result1 = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "读取test.txt文件内容"
    }]
})
print(f"读取结果：{result1['messages'][-1].content}")

# 测试2：让智能体执行【写入文件】→ 拒绝
result = agent.invoke({
    "messages": [{
        "role": "user",
        "content": "向test.txt写入: hello world"
    }]
})
print(f"写入结果：{result['messages'][-1].content}")