hey 0.1.0

//! Agent 循环集成测试：FakeProvider 驱动 + TestOutput 断言事件序列。
//!
//! 关键场景（docs/DESIGN.md §14）：单轮文本、多轮工具循环、权限拒绝。

mod common;

use std::sync::Arc;

use async_trait::async_trait;
use serde_json::json;

use common::{FakeProvider, FakeTurn, tool_call};
use hey::agent::{AgentOpts, run_agent};
use hey::config::{CompactionConfig, Config};
use hey::tools::{Registry, Tool, ToolCtx, ToolOutput};
use hey::ui::{Event, TestOutput};

/// 测试工具：固定返回 "output-ok"。
struct FakeTool;

#[async_trait]
impl Tool for FakeTool {
    fn name(&self) -> &str {
        "bash"
    }
    fn description(&self) -> &str {
        "Run a command (test)"
    }
    fn schema(&self) -> serde_json::Value {
        json!({"type": "object", "properties": {"cmd": {"type": "string"}}})
    }
    async fn run(&self, _ctx: &ToolCtx, _args: serde_json::Value) -> ToolOutput {
        ToolOutput::ok("output-ok")
    }
}

fn cfg() -> Config {
    let mut c = Config::default();
    c.agent.max_turns = Some(10);
    c
}

#[tokio::test]
async fn single_turn_text() {
    let provider = FakeProvider::new(
        "test",
        vec![FakeTurn {
            text: "hello",
            tool_calls: vec![],
        }],
    );
    let tools = Registry::new(); // 无工具 → 模型无工具可调，自然单轮
    let mut out = TestOutput::new();
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &cfg(),
        "hi",
        &AgentOpts::default(),
    )
    .await;

    assert_eq!(stats.turns, 1);
    assert_eq!(stats.end_reason, hey::agent::EndReason::Complete);
    assert_eq!(
        out.events,
        vec![
            Event::TextDelta("hello".into()),
            Event::Finished {
                reason: "complete".into(),
                turns: 1
            }
        ]
    );
}

#[tokio::test]
async fn multi_turn_tool_loop() {
    // 第一轮：工具调用 bash；第二轮：文本收尾
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c1", "bash", "{\"cmd\":\"ls\"}")],
            },
            FakeTurn {
                text: "done",
                tool_calls: vec![],
            },
        ],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    // 默认全权限（pi 方式）：无 allow 配置即放行
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &cfg(),
        "list files",
        &AgentOpts::default(),
    )
    .await;

    assert_eq!(stats.turns, 2);
    assert_eq!(stats.tool_calls, 1);
    assert_eq!(
        out.events[0],
        Event::ToolCall {
            name: "bash".into(),
            args: "{\"cmd\":\"ls\"}".into()
        }
    );
    assert_eq!(
        out.events[1],
        Event::ToolResult {
            name: "bash".into(),
            ok: true,
            output: "output-ok".into()
        }
    );
    assert_eq!(out.events[2], Event::TextDelta("done".into()));
}

#[tokio::test]
async fn permission_denied_blocks_tool() {
    // 显式 allow 收紧：只放行 `bash: echo`；rm 调用直接 blocked（无交互询问，pi 方式）
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c1", "bash", "{\"cmd\":\"rm -rf /\"}")],
            },
            FakeTurn {
                text: "ok, canceled",
                tool_calls: vec![],
            },
        ],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut cfg = cfg();
    cfg.permission.allow = vec!["bash: echo".into()]; // 收紧：rm 不在白名单
    let mut out = TestOutput::new();
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &cfg,
        "clean",
        &AgentOpts::default(),
    )
    .await;

    // 事件顺序：工具调用 → 直接拒绝结果（无 confirm 事件）；回填后模型在第 2 轮停止
    assert_eq!(stats.turns, 2);
    assert_eq!(
        out.events[0],
        Event::ToolCall {
            name: "bash".into(),
            args: "{\"cmd\":\"rm -rf /\"}".into()
        }
    );
    assert_eq!(
        out.events[1],
        Event::ToolResult {
            name: "bash".into(),
            ok: false,
            output: "blocked by user".into()
        }
    );
    // 拒绝消息回填后，模型在第 2 轮停止
    assert!(
        out.events
            .iter()
            .any(|e| e == &Event::TextDelta("ok, canceled".into()))
    );
}

#[tokio::test]
async fn max_turns_stops_loop() {
    // 模型一直请求工具 → 达到 max_turns 停止
    let provider = FakeProvider::new(
        "test",
        vec![FakeTurn {
            text: "",
            tool_calls: vec![tool_call("c1", "bash", "{}")],
        }],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.agent.max_turns = Some(3);
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &c,
        "loop",
        &AgentOpts::default(),
    )
    .await;

    assert_eq!(stats.turns, 3);
    assert_eq!(stats.end_reason, hey::agent::EndReason::MaxTurns);
    assert!(
        out.events
            .iter()
            .any(|e| matches!(e, Event::Finished { reason, .. } if reason == "max_turns"))
    );
}

#[tokio::test]
async fn unknown_tool_is_blocked_without_confirm() {
    // 未注册的工具：不询问，直接拒绝；回填后模型停止
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c1", "nope", "{}")],
            },
            FakeTurn {
                text: "done",
                tool_calls: vec![],
            },
        ],
    );
    let tools = Registry::new(); // 空注册表
    let mut out = TestOutput::new();
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &cfg(),
        "x",
        &AgentOpts::default(),
    )
    .await;

    // 无 confirm 事件（未注册工具不询问）、工具结果标记为失败、第二轮完成
    assert!(
        !out.events
            .iter()
            .any(|e| matches!(e, Event::ToolCall { name, .. } if name.starts_with("confirm:")))
    );
    assert!(matches!(out.events[1], Event::ToolResult { ok: false, .. }));
    assert!(
        out.events
            .iter()
            .any(|e| e == &Event::TextDelta("done".into()))
    );
    assert_eq!(stats.turns, 2);
}

/// 捕获请求的 provider（断言 resume 历史与消息序列）。
struct CaptureProvider {
    reqs: Arc<std::sync::Mutex<Vec<hey::llm::ir::ChatRequest>>>,
}

#[async_trait]
impl hey::llm::Provider for CaptureProvider {
    fn model(&self) -> &str {
        "test"
    }
    async fn stream(
        &self,
        req: &hey::llm::ir::ChatRequest,
        on_delta: &mut (dyn FnMut(hey::llm::Delta) + Send),
    ) -> Result<hey::llm::ir::Completion, hey::llm::LlmError> {
        self.reqs.lock().unwrap().push(req.clone());
        on_delta(hey::llm::Delta::Text("done".into()));
        Ok(hey::llm::ir::Completion {
            text: "done".into(),
            thinking: String::new(),
            tool_calls: vec![],
            usage: Default::default(),
        })
    }
}

// 会话目录覆盖是全局可变状态（sessions::DIR_OVERRIDE）——依赖它的测试必须串行，
// 否则并行运行时互相覆盖目录，造成消息累积/丢失（对齐 sessions.rs 内部 TEST_LOCK 的做法）。
// 用 tokio::sync::Mutex：guard 需跨 await 持有（std MutexGuard 非 Send 会编译失败）。
// tokio::sync::Mutex::new 非 const，用 LazyLock（MSRV 1.88 支持）。
static SESSION_LOCK: std::sync::LazyLock<tokio::sync::Mutex<()>> =
    std::sync::LazyLock::new(|| tokio::sync::Mutex::new(()));

#[tokio::test]
async fn session_persists_messages() {
    let _guard = SESSION_LOCK.lock().await;
    // run_agent 带 session_id → 消息/用量写入 JSONL（会话写入闭环 M3）
    let dir = std::env::temp_dir().join(format!("hey-agent-sess-{}", std::process::id()));
    hey::sessions::set_dir_override(Some(dir.clone()));
    let provider = FakeProvider::new(
        "test",
        vec![FakeTurn {
            text: "final",
            tool_calls: vec![],
        }],
    );
    let mut out = TestOutput::new();
    let opts = AgentOpts {
        session_id: Some("sess-1".into()),
        ..Default::default()
    };
    run_agent(
        Arc::new(provider),
        &Registry::new(),
        &mut out,
        &cfg(),
        "hello session",
        &opts,
    )
    .await;
    let msgs = hey::sessions::read_msgs("sess-1");
    assert!(
        msgs.iter().any(|m| m.plain_text() == "hello session"),
        "用户消息写入"
    );
    assert!(
        msgs.iter().any(|m| m.plain_text() == "final"),
        "assistant 回复写入"
    );
    // 系统提示不进会话（每轮动态构建）
    assert!(msgs.iter().all(|m| m.role != hey::llm::ir::Role::System));
    let _ = std::fs::remove_dir_all(&dir);
    hey::sessions::set_dir_override(None);
}

#[tokio::test]
async fn resume_history_is_included_in_request() {
    // resume_msgs 历史 → 首个请求 messages = System + 历史 + 本轮 prompt
    use hey::llm::ir::{Message, Role};
    let history = vec![
        Message::text(Role::User, "earlier question"),
        Message::text(Role::Assistant, "earlier answer"),
    ];
    let opts = AgentOpts {
        resume_msgs: history,
        ..Default::default()
    };
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    let provider = CaptureProvider { reqs: reqs.clone() };
    let mut out = TestOutput::new();
    run_agent(
        Arc::new(provider),
        &Registry::new(),
        &mut out,
        &cfg(),
        "current prompt",
        &opts,
    )
    .await;

    let reqs = reqs.lock().unwrap();
    let msgs = &reqs[0].messages;
    assert_eq!(msgs.len(), 4, "System + 2 历史 + 本轮");
    assert_eq!(msgs[0].role, hey::llm::ir::Role::System);
    assert_eq!(msgs[1].plain_text(), "earlier question");
    assert_eq!(msgs[2].plain_text(), "earlier answer");
    assert_eq!(msgs[3].plain_text(), "current prompt");
}

/// 固定失败的假工具（purge_errors_after 测试用）。
struct FailingTool;

#[async_trait]
impl Tool for FailingTool {
    fn name(&self) -> &str {
        "bash"
    }
    fn description(&self) -> &str {
        "failing bash"
    }
    fn schema(&self) -> serde_json::Value {
        serde_json::json!({"type": "object"})
    }
    async fn run(&self, _ctx: &ToolCtx, _args: serde_json::Value) -> ToolOutput {
        ToolOutput::err("bash: no such command (exit code 127)")
    }
}

#[tokio::test]
async fn purge_errors_after_removes_failed_inputs() {
    // 错误工具调用 → purge_errors_after 轮后输入被剥离（保留错误结果供模型恢复）
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    // 捕获请求：用一个包装 provider 转发到 FakeProvider 并记录请求
    struct LoggingProvider {
        inner: FakeProvider,
        reqs: Arc<std::sync::Mutex<Vec<hey::llm::ir::ChatRequest>>>,
    }
    #[async_trait]
    impl hey::llm::Provider for LoggingProvider {
        fn model(&self) -> &str {
            "test"
        }
        async fn stream(
            &self,
            req: &hey::llm::ir::ChatRequest,
            on_delta: &mut (dyn FnMut(hey::llm::Delta) + Send),
        ) -> Result<hey::llm::ir::Completion, hey::llm::LlmError> {
            self.reqs.lock().unwrap().push(req.clone());
            self.inner.stream(req, on_delta).await
        }
    }
    let logging = LoggingProvider {
        inner: FakeProvider::new(
            "test",
            vec![
                FakeTurn {
                    text: "",
                    tool_calls: vec![tool_call("c1", "bash", "{\"cmd\":\"bogus\"}")],
                },
                FakeTurn {
                    text: "",
                    tool_calls: vec![tool_call("c2", "bash", "{\"cmd\":\"still bogus\"}")],
                },
                FakeTurn {
                    text: "done",
                    tool_calls: vec![],
                },
            ],
        ),
        reqs: reqs.clone(),
    };
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.compaction = Some(CompactionConfig {
        purge_errors_after: 1,
        ..Default::default()
    });
    let mut tools = Registry::new();
    tools.register(Arc::new(FailingTool));
    run_agent(
        Arc::new(logging),
        &tools,
        &mut out,
        &c,
        "try it",
        &AgentOpts::default(),
    )
    .await;

    let reqs = reqs.lock().unwrap();
    // 第 3 个请求（turns=3 时）：第一个错误调用输入应已剥离（purge_errors_after=1 轮后）
    let last = reqs.last().unwrap();
    let texts: Vec<String> = last.messages.iter().map(|m| m.plain_text()).collect();
    assert!(
        texts
            .iter()
            .any(|t| t.contains("[pruned: failed call input]")),
        "错误输入被剥离: {texts:?}"
    );
    // 错误结果保留供模型恢复
    assert!(
        texts.iter().any(|t| t.contains("exit code 127")),
        "错误结果保留: {texts:?}"
    );
    // c1（最早）输入被剥离：assistant 消息 tool_calls 清空；c2（最近）保留
    let c1_gone = !last.messages.iter().any(|m| {
        m.role == hey::llm::ir::Role::Assistant && m.tool_calls.iter().any(|c| c.id == "c1")
    });
    assert!(c1_gone, "c1 输入剥离: {texts:?}");
    let c2_kept = last.messages.iter().any(|m| {
        m.role == hey::llm::ir::Role::Assistant && m.tool_calls.iter().any(|c| c.id == "c2")
    });
    assert!(c2_kept, "c2 最近保留: {texts:?}");
}

#[tokio::test]
async fn compress_tool_toggle_controls_schema() {
    // [compaction].compress_tool=false → 请求 schema 不含 compress
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    let capture = CaptureProvider { reqs: reqs.clone() };
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.compaction = Some(CompactionConfig {
        compress_tool: false,
        ..Default::default()
    });
    run_agent(
        Arc::new(capture),
        &Registry::new(),
        &mut out,
        &c,
        "x",
        &AgentOpts::default(),
    )
    .await;
    {
        let reqs = reqs.lock().unwrap();
        let names: Vec<String> = reqs[0].tools.iter().map(|t| t.name.clone()).collect();
        assert!(
            !names.contains(&"compress".to_string()),
            "开关关闭时不含 compress: {names:?}"
        );
    }
    // 默认（true）应包含
    let reqs2 = Arc::new(std::sync::Mutex::new(Vec::new()));
    let capture2 = CaptureProvider {
        reqs: reqs2.clone(),
    };
    let mut out2 = TestOutput::new();
    run_agent(
        Arc::new(capture2),
        &Registry::new(),
        &mut out2,
        &cfg(),
        "x",
        &AgentOpts::default(),
    )
    .await;
    {
        let reqs2 = reqs2.lock().unwrap();
        let names2: Vec<String> = reqs2[0].tools.iter().map(|t| t.name.clone()).collect();
        assert!(
            names2.contains(&"compress".to_string()),
            "默认含 compress: {names2:?}"
        );
    }
}

/// 慢工具：固定 150ms 延迟，用于验证并行执行与输出保序。
struct SlowTool;

#[async_trait]
impl Tool for SlowTool {
    fn name(&self) -> &str {
        "slow"
    }
    fn description(&self) -> &str {
        "Slow tool for parallel test"
    }
    fn schema(&self) -> serde_json::Value {
        json!({"type": "object", "properties": {}})
    }
    async fn run(&self, _ctx: &ToolCtx, _args: serde_json::Value) -> ToolOutput {
        tokio::time::sleep(std::time::Duration::from_millis(150)).await;
        ToolOutput::ok("slow-done")
    }
}

#[tokio::test]
async fn parallel_tool_calls_run_concurrently_and_preserve_order() {
    // 同 turn 3 个慢工具调用：默认并行（[agent] parallel_tools=true）
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![
                    tool_call("c1", "slow", "{}"),
                    tool_call("c2", "slow", "{}"),
                    tool_call("c3", "slow", "{}"),
                ],
            },
            FakeTurn {
                text: "all done",
                tool_calls: vec![],
            },
        ],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(SlowTool));
    let provider = Arc::new(provider);
    let mut out = TestOutput::new();
    let t0 = std::time::Instant::now();
    let stats = run_agent(
        provider.clone(),
        &tools,
        &mut out,
        &cfg(),
        "parallel",
        &AgentOpts::default(),
    )
    .await;
    let elapsed = t0.elapsed();

    assert_eq!(stats.turns, 2);
    // 并行：3×150ms ≈ 150ms（阈值 380ms 宽松；串行会是 ≥450ms）
    assert!(
        elapsed.as_millis() < 380,
        "3 个 150ms 工具应并行完成（实际 {:?}）",
        elapsed
    );
    // 事件保序：tool_call / tool_result 均按模型调用顺序（c1 → c2 → c3）
    let calls: Vec<String> = out
        .events
        .iter()
        .filter_map(|e| match e {
            Event::ToolCall { name, .. } => Some(name.clone()),
            _ => None,
        })
        .collect();
    assert_eq!(calls, vec!["slow", "slow", "slow"]);
    let results: Vec<String> = out
        .events
        .iter()
        .filter_map(|e| match e {
            Event::ToolResult { output, .. } => Some(output.clone()),
            _ => None,
        })
        .collect();
    assert_eq!(results, vec!["slow-done", "slow-done", "slow-done"]);
    // 执行前提示：所有 tool_call 事件都先于任何 tool_result（M12 后置 → 恢复提前输出）
    let first_result_at = out
        .events
        .iter()
        .position(|e| matches!(e, Event::ToolResult { .. }))
        .expect("有 tool_result 事件");
    let last_call_at = out
        .events
        .iter()
        .rposition(|e| matches!(e, Event::ToolCall { .. }))
        .expect("有 tool_call 事件");
    assert!(
        last_call_at < first_result_at,
        "所有 tool_call 应先于 tool_result 输出"
    );

    // 关掉并行 → 串行执行（保序仍成立；不测耗时，行为正确性由上述断言覆盖）
    let mut c = cfg();
    c.agent.parallel_tools = Some(false);
    let serial_provider = Arc::new(FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![
                    tool_call("c1", "slow", "{}"),
                    tool_call("c2", "slow", "{}"),
                    tool_call("c3", "slow", "{}"),
                ],
            },
            FakeTurn {
                text: "all done",
                tool_calls: vec![],
            },
        ],
    ));
    let mut out2 = TestOutput::new();
    let stats2 = run_agent(
        serial_provider,
        &tools,
        &mut out2,
        &c,
        "serial",
        &AgentOpts::default(),
    )
    .await;
    assert_eq!(stats2.turns, 2);
    let results2: Vec<String> = out2
        .events
        .iter()
        .filter_map(|e| match e {
            Event::ToolResult { output, .. } => Some(output.clone()),
            _ => None,
        })
        .collect();
    assert_eq!(results2, vec!["slow-done", "slow-done", "slow-done"]);
}

#[tokio::test]
async fn skills_injected_into_system_prompt() {
    // skills 清单 → 请求中 system 消息含技能名与描述
    use hey::llm::ir::Role;
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    let capture = CaptureProvider { reqs: reqs.clone() };
    let mut out = TestOutput::new();
    let opts = AgentOpts {
        skills: vec![hey::skills::Skill {
            name: "test-skill".into(),
            description: "A test skill".into(),
            path: std::path::PathBuf::from("/tmp/fake-skill/SKILL.md"),
        }],
        ..Default::default()
    };
    run_agent(
        Arc::new(capture),
        &Registry::new(),
        &mut out,
        &cfg(),
        "hello",
        &opts,
    )
    .await;

    let reqs = reqs.lock().unwrap();
    let system = reqs[0]
        .messages
        .iter()
        .find(|m| m.role == Role::System)
        .expect("应有 System 消息");
    assert!(
        system.plain_text().contains("test-skill"),
        "技能名应注入系统提示"
    );
    assert!(
        system.plain_text().contains("A test skill"),
        "技能描述应注入"
    );
}

#[tokio::test]
async fn dedup_removes_duplicate_call() {
    // 同工具+同参数两次 → 第二次 tool_result 标记为 pruned
    // 跨轮去重：第一轮调用 bash ls，第二轮再调用 bash ls → 第二次被标记
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c1", "bash", "{\"cmd\":\"ls\"}")],
            },
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c2", "bash", "{\"cmd\":\"ls\"}")],
            },
            FakeTurn {
                text: "done",
                tool_calls: vec![],
            },
        ],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.compaction = Some(CompactionConfig {
        dedup: true,
        ..Default::default()
    });
    let stats = run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &c,
        "list twice",
        &AgentOpts::default(),
    )
    .await;

    // 3 个 FakeTurn → 3 轮（前 2 轮带工具调用，第 3 轮收尾）
    assert_eq!(stats.turns, 3);
    let results: Vec<&str> = out
        .events
        .iter()
        .filter_map(|e| match e {
            Event::ToolResult { output, .. } => Some(output.as_str()),
            _ => None,
        })
        .collect();
    // 跨轮去重预期：c2（同工具+同参数）被标记为 pruned
    // 注：若 3 个 tool_result 说明有额外事件，打印辅助排查
    assert!(results.len() == 2, "应有 2 个 tool_result, got {results:?}");
    assert!(
        results[0] == "output-ok" || results[0].contains("pruned"),
        "第一次正常输出或 pruned: {results:?}"
    );
}

/// 捕获请求的 provider（thinking 回传用）。
struct MultiTurnCaptureProvider {
    reqs: Arc<std::sync::Mutex<Vec<hey::llm::ir::ChatRequest>>>,
    turn: std::sync::atomic::AtomicU32,
}

#[async_trait]
impl hey::llm::Provider for MultiTurnCaptureProvider {
    fn model(&self) -> &str {
        "capture-thinking"
    }
    async fn stream(
        &self,
        req: &hey::llm::ir::ChatRequest,
        on_delta: &mut (dyn FnMut(hey::llm::Delta) + Send),
    ) -> Result<hey::llm::ir::Completion, hey::llm::LlmError> {
        self.reqs.lock().unwrap().push(req.clone());
        let i = self.turn.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
        if i == 0 {
            // 第一轮：返回 thinking + 工具调用（触发第二轮）
            on_delta(hey::llm::Delta::Thinking("inner reasoning".to_string()));
            on_delta(hey::llm::Delta::Text("let me check".to_string()));
            Ok(hey::llm::ir::Completion {
                text: "let me check".into(),
                thinking: "inner reasoning".into(),
                tool_calls: vec![tool_call("c1", "bash", "{}")],
                usage: Default::default(),
            })
        } else {
            // 后续轮次：纯文本收尾
            on_delta(hey::llm::Delta::Text("done".to_string()));
            Ok(hey::llm::ir::Completion {
                text: "done".into(),
                thinking: String::new(),
                tool_calls: vec![],
                usage: Default::default(),
            })
        }
    }
}

#[tokio::test]
async fn thinking_round_trip() {
    // 模型返回 thinking → 下一轮请求中回传 Thinking 块
    use hey::llm::ir::ContentBlock;
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    let provider = MultiTurnCaptureProvider {
        reqs: reqs.clone(),
        turn: std::sync::atomic::AtomicU32::new(0),
    };
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.agent.max_turns = Some(3);
    run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &c,
        "think",
        &AgentOpts::default(),
    )
    .await;

    let reqs = reqs.lock().unwrap();
    assert!(reqs.len() >= 2, "至少 2 轮请求");
    // 第二轮请求中应包含 assistant 消息带 Thinking 块
    let second_req = &reqs[1];
    let assistant_msgs: Vec<&hey::llm::ir::Message> = second_req
        .messages
        .iter()
        .filter(|m| m.role == hey::llm::ir::Role::Assistant)
        .collect();
    let has_thinking = assistant_msgs.iter().any(|m| {
        m.content
            .iter()
            .any(|b| matches!(b, ContentBlock::Thinking(_)))
    });
    assert!(has_thinking, "第二轮请求应回传 Thinking 块");
    // 验证 Thinking 内容保留
    let thinking_text: String = assistant_msgs
        .iter()
        .flat_map(|m| &m.content)
        .filter_map(|b| match b {
            ContentBlock::Thinking(t) => Some(t.as_str()),
            _ => None,
        })
        .collect();
    assert!(
        thinking_text.contains("inner reasoning"),
        "Thinking 内容保留: {thinking_text}"
    );
}

#[tokio::test]
async fn context_compaction_triggers() {
    // 超预算 → 自动触发 compact_messages 裁剪
    use hey::llm::ir::Role;
    let reqs = Arc::new(std::sync::Mutex::new(Vec::new()));
    let provider = MultiTurnCaptureProvider {
        reqs: reqs.clone(),
        turn: std::sync::atomic::AtomicU32::new(0),
    };
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    let mut c = cfg();
    c.agent.max_turns = Some(3);
    c.agent.budget_tokens = Some(10); // 极低预算，强制裁剪
    // 用多轮历史让预算超限
    let history = vec![
        hey::llm::ir::Message::text(Role::User, "long history ".repeat(50)),
        hey::llm::ir::Message::text(Role::Assistant, "long answer ".repeat(50)),
    ];
    let opts = AgentOpts {
        resume_msgs: history,
        ..Default::default()
    };
    run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &c,
        "new prompt",
        &opts,
    )
    .await;

    let reqs = reqs.lock().unwrap();
    assert!(!reqs.is_empty(), "至少发送了请求");
    // 请求中消息数应少于原始历史 + 1（说明裁剪生效）
    let msg_count = reqs[0].messages.len();
    assert!(msg_count < 10, "预算 10 应大幅裁剪: {} 条消息", msg_count);
}

#[tokio::test]
async fn session_no_duplicate_messages_multi_turn() {
    let _guard = SESSION_LOCK.lock().await;
    // 防回归：多轮（含工具轮）会话写入 JSONL 时，同一条消息不得重复持久化。
    // 历史 bug：某些路径把 assistant/工具消息写两次，导致 resume 时看到重复历史。
    let ns = std::time::SystemTime::now()
        .duration_since(std::time::UNIX_EPOCH)
        .unwrap()
        .as_nanos();
    let dir = std::env::temp_dir().join(format!("hey-dup-{}-{}", std::process::id(), ns));
    hey::sessions::set_dir_override(Some(dir.clone()));
    // 3 轮：工具轮 → 工具轮 → 文本收尾（连续工具轮最易触发重叠）
    let provider = FakeProvider::new(
        "test",
        vec![
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c1", "bash", "{\"cmd\":\"ls\"}")],
            },
            FakeTurn {
                text: "",
                tool_calls: vec![tool_call("c2", "bash", "{\"cmd\":\"pwd\"}")],
            },
            FakeTurn {
                text: "done",
                tool_calls: vec![],
            },
        ],
    );
    let mut tools = Registry::new();
    tools.register(Arc::new(FakeTool));
    let mut out = TestOutput::new();
    let opts = AgentOpts {
        session_id: Some("dup-1".into()),
        ..Default::default()
    };
    run_agent(
        Arc::new(provider),
        &tools,
        &mut out,
        &cfg(),
        "multi turn",
        &opts,
    )
    .await;

    let msgs = hey::sessions::read_msgs("dup-1");
    // 同一消息 id 只能出现一次（id 是稳定标识）
    let mut seen = std::collections::HashSet::new();
    for m in &msgs {
        assert!(
            seen.insert(m.id.clone()),
            "消息重复持久化: id={} text={}",
            m.id,
            m.plain_text().chars().take(40).collect::<String>()
        );
    }
    // 应有：user + 2×assistant(工具) + 2×tool + 1×assistant(文本) = 6 条
    assert_eq!(
        msgs.len(),
        6,
        "期望 6 条消息，实际 {} 条: {:?}",
        msgs.len(),
        msgs.iter()
            .map(|m| m.plain_text().chars().take(15).collect::<String>())
            .collect::<Vec<_>>()
    );
    let _ = std::fs::remove_dir_all(&dir);
    hey::sessions::set_dir_override(None);
}