foxclaw 0.1.0 → 0.1.2

package/python/tests/test_supervisor_pipeline.py

@@ -0,0 +1,177 @@
+"""P1-1 · 主管 pipeline 化回归。
+
+主管不再重写 run_task,路由分发拆成 8 个 pipeline stage
+(recall→meta_check→schedule→route→plan→dispatch→replan→aggregate),走 base 统一模板
+`_run_task_core`。本文件锁定:
+
+  [1] 结构:SupervisorAgent.run_task 即基类模板;主管 pipeline 是 SUPERVISOR_STAGES;
+  [2] 元问题短路:meta_check 自答,后续 stage 跳过,内部标记不外泄;
+  [3] 单 Agent 分发:返回体顶层键与旧实现逐字一致(result/schedule/plan/process_id);
+  [4] stub 兜底:无关键词命中 + stub → 兜底派发 assistant(不经自答);
+  [5] 统一 execution.completed:多步并行任务也只发**一条**任务级事件、
+      agent_id=supervisor(文稿 Step 4:删手动 bus.publish);blocked 子任务 →
+      顶层 status=blocked 且执行事件 blocked=True(未完成不沉淀真值);
+  [6] 流式:run_task_stream 逐 stage 出 8 个进度事件;子 Agent 的 act token 随
+      contextvar 传播流出(delta 非空);stop_event 预置 → interrupted;
+  [7] 恢复记账:经 base 生命周期钩子,started/finished 配对、异常路径记 failed。
+
+全离线:ws.needs_search 关掉联网;router 强制 stub(共享实例,五个 Agent 同源)。
+"""
+import asyncio
+import sys
+import tempfile
+import threading
+import types
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws
+ws.needs_search = lambda q: False      # 自答/兜底路径不触发联网,保持离线
+
+from foxclaw import Foxclaw
+from foxclaw.agents.base import CognitiveAgent, HarnessBlockedError
+from foxclaw.agents.agents import SupervisorAgent
+from foxclaw.pipeline import SUPERVISOR_STAGES
+
+EXPECTED_STAGES = ["recall", "meta_check", "schedule", "route", "plan", "dispatch", "replan", "aggregate"]
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+def _names():
+    return [getattr(s, "stage_name", getattr(s, "__name__", "?")) for s in SUPERVISOR_STAGES]
+
+
+def main():
+    print("=" * 60)
+    print("P1-1 · 主管 pipeline 化回归")
+    print("=" * 60)
+
+    print("\n【1】结构:主管走统一模板,不再重写 run_task")
+    check(SupervisorAgent.run_task is CognitiveAgent.run_task,
+          "SupervisorAgent.run_task 即基类模板(P1-1 达成)")
+    check(SupervisorAgent._cognitive_pipeline is not CognitiveAgent._cognitive_pipeline,
+          "主管覆盖 _cognitive_pipeline(路由分发走 SUPERVISOR_STAGES)")
+    check(_names() == EXPECTED_STAGES, f"主管 stage 序列={EXPECTED_STAGES}(实为 {_names()})")
+
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp(prefix="foxclaw_svpipe_"))
+    os_.router.provider = "stub"        # 共享 router,五 Agent 同源 → 全离线确定性
+    os_.router._client = None
+    sup = os_.supervisor
+
+    print("\n【2】元问题短路:meta_check 自答,内部标记不外泄")
+    r = asyncio.run(sup.run_task("你是谁,能做什么"))
+    res = r["result"]
+    check(res.get("dispatched_to") == "supervisor" and res.get("self_answered") is True,
+          "元问题 → 主管自答(dispatched_to=supervisor, self_answered=True)")
+    check("_meta_answered" not in r and "_self_answer" not in r,
+          "内部短路标记不外泄到返回体")
+    check(r.get("agent") == "supervisor" and "session_id" in r and "thought_summary" in r,
+          "返回体由 base 模板统一组装(agent/session_id/thought_summary)")
+
+    print("\n【3】单 Agent 分发:返回体顶层键与旧实现逐字一致")
+    r = asyncio.run(sup.run_task("帮我做个预算分析"))       # "预算" 命中 finance
+    res = r["result"]
+    check(res.get("dispatched_to") == "finance", f"关键词命中 → finance(实为 {res.get('dispatched_to')})")
+    for k in ("schedule", "plan", "process_id"):
+        check(k in r, f"顶层键 {k} 保留(与旧主管返回体一致)")
+    check(r["plan"].get("multi_step") is False, "单步任务 plan.multi_step=False")
+    check(res.get("blocked") is False, "正常分发 blocked=False")
+
+    print("\n【4】stub 兜底:无关键词命中 + stub → 主管自处理(助手已下放为技能)")
+    r = asyncio.run(sup.run_task("解释一下什么是航天器"))
+    res = r["result"]
+    check(res.get("dispatched_to") == "supervisor" and not res.get("self_answered"),
+          f"stub 下未命中 → 主管自身处理(实为 {res.get('dispatched_to')})")
+
+    print("\n【5】统一 execution.completed(文稿 Step 4)")
+    spine = os_.event_spine
+    before = len(spine.history("execution.completed"))
+    asyncio.run(sup.run_task("同时查今天的日程、分析本月理财、总结这篇论文"))   # 并行 3 子任务
+    evts = spine.history("execution.completed")
+    new_evts = evts[before:]
+    check(len(new_evts) == 1,
+          f"并行 3 子任务只发 1 条任务级 execution.completed(实为 {len(new_evts)} 条)"
+          "——逐子任务手动 publish 已删")
+    check(new_evts and new_evts[0]["payload"].get("agent_id") == "supervisor",
+          "任务级事件归因 supervisor(子 Agent 带 _no_emit 不双发)")
+
+    print("\n【5b】blocked 子任务 → 顶层 status=blocked + 事件 blocked=True(不沉淀真值)")
+    async def _boom(self, task, context, session_id, memories):
+        raise HarnessBlockedError(types.SimpleNamespace(reason="模拟越界"), None)
+    os_.finance._execute = types.MethodType(_boom, os_.finance)
+    before = len(spine.history("execution.completed"))
+    r = asyncio.run(sup.run_task("帮我做个预算分析"))
+    check(r["result"].get("blocked") is True, "子 Agent 被拦 → result.blocked=True")
+    check(r.get("status") == "blocked",
+          "被拦提升为顶层 status=blocked(与 base 模板 skill_status 机制一致)")
+    new_evts = spine.history("execution.completed")[before:]
+    check(len(new_evts) == 1 and new_evts[0]["payload"].get("blocked") is True,
+          "被拦任务的执行事件 blocked=True → 真值链不沉淀")
+    # 还原 finance,别污染后续用例
+    del os_.finance._execute
+
+    print("\n【6】流式:run_task_stream 八 stage + 子 Agent token 传播 + 中断")
+    events = list(sup.run_task_stream("帮我做个预算分析"))
+    stages = [e["stage"] for e in events if "stage" in e]
+    deltas = [e["delta"] for e in events if "delta" in e]
+    results = [e["result"] for e in events if "result" in e]
+    check(stages == EXPECTED_STAGES, f"流式逐 stage 进度=主管八 stage(实为 {stages})")
+    check(len(results) == 1 and results[0].get("agent") == "supervisor",
+          "恰一个最终 result,agent=supervisor")
+    check(results[0]["result"].get("dispatched_to") == "finance", "流式与非流式路由结论一致")
+    check(len(deltas) > 0,
+          "delta 非空:子 Agent 的 act token 随 _act_stream contextvar 传播流出(文稿坑5实测反转)")
+    check("".join(deltas) == str(results[0]["result"].get("sub_result")),
+          "流式 token 拼接 == 子 Agent 最终结果(透传忠实)")
+
+    ev = threading.Event(); ev.set()
+    ev_events = list(sup.run_task_stream("这个任务会被中断", stop_event=ev))
+    ev_results = [e["result"] for e in ev_events if "result" in e]
+    check(ev_results and ev_results[0].get("interrupted") is True,
+          "stop_event 预置 → result.interrupted=True(stage 边界优雅停)")
+    check(not [e for e in ev_events if "stage" in e], "起步即停:无 stage 进度事件")
+
+    print("\n【7】恢复记账:base 生命周期钩子,started/finished 配对")
+    calls = []
+
+    class _Spy:
+        def task_started(self, task_id, description, session_id, channel=""):
+            calls.append(("started", task_id))
+        def task_finished(self, sid, status="done"):
+            calls.append(("finished", sid, status))
+
+    sup._recovery = _Spy()
+    asyncio.run(sup.run_task("帮我做个预算分析", context={"channel": "test"}))
+    check(calls[0][0] == "started" and calls[1][0] == "finished" and calls[1][2] == "done",
+          f"正常任务:started→finished(done) 配对(实为 {calls})")
+    check(calls[0][1] == calls[1][1], "started/finished 同一 task_id(可配对)")
+
+    calls.clear()
+    async def _raise(self, task, context=None, **kw):
+        raise RuntimeError("子 Agent 崩溃")
+    sup._subagents["finance"].run_task = _raise
+    try:
+        asyncio.run(sup.run_task("帮我做个预算分析"))
+        raised = False
+    except RuntimeError:
+        raised = True
+    check(raised, "子 Agent 未兜底异常向上传播(不吞)")
+    check(calls[0][0] == "started" and calls[1] == ("finished", calls[0][1], "failed"),
+          f"异常任务记 failed(区别于正常完成)(实为 {calls})")
+
+    print("\n" + "=" * 60)
+    print("P1-1 主管 pipeline 化回归通过")
+    print("=" * 60)
+
+
+def test_supervisor_pipeline():
+    main()
+
+
+if __name__ == "__main__":
+    main()

package/python/tests/test_supervisor_triage.py

@@ -0,0 +1,108 @@
+"""主管分诊与自答策略回归。
+
+覆盖主管在「是否命中领域关键词」×「模型是否可用」下的派发决策:
+  · 关键词命中        → 直接路由到领域 Agent(快、确定),不额外调用一次 LLM 分诊;
+  · 未命中 + 模型可用 → 主管**直接自答**(dispatched_to=supervisor, self_answered=True);
+  · 未命中 + stub     → 走派发兜底(assistant),保持离线确定性。
+
+⚠ 历史说明(改名前为 test_llm_routing.py):本文件曾断言「关键词未命中 → LLM 分诊精修到
+finance」。那次精修实现在 `agents.py:_llm_classify`,但因每次要多一次约 5s 的串行 LLM
+往返,产品上被「主管直接自答」取代而退化为**死代码**(全仓库零调用点),已随本轮删除。
+原断言随之永远无法满足,长期为红,却被归因为「环境问题」——这是**误判**:它不是环境问题,
+是**测试过期**。现按真实行为重写,并把三种组合都锁住。
+
+用"假 router"模拟真机(is_stub=False),避免依赖真实 API key,全离线。
+"""
+import asyncio
+import sys
+import tempfile
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+import foxclaw.core.web_search as ws
+ws.needs_search = lambda q: False      # 自答路径不触发联网,保持离线
+
+from foxclaw import Foxclaw
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+# 分诊 prompt 的特征串。历史上 _llm_classify 用它问模型;现已无此路径,
+# 故断言它**从不出现**,即「不再为分诊多花一次 LLM 往返」。
+CLASSIFY_MARK = "只输出一个词"
+
+
+def main():
+    print("=" * 56)
+    print("主管分诊与自答策略回归")
+    print("=" * 56)
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp())
+
+    calls = []
+
+    def fake(system, messages, max_tokens=2048, agent_id=""):
+        content = str(messages[-1]["content"]) if messages else ""
+        calls.append(content)
+        if CLASSIFY_MARK in content:      # 若真有人恢复分诊,这里会暴露
+            return "finance"
+        return "已处理"
+
+    # 让路由认为模型可用(非 stub)
+    os_.router.provider = "deepseek"
+    os_.router._client = object()
+    os_.router.complete = fake
+    check(os_.router.is_stub is False, "router 处于'可用'状态(非 stub)")
+
+    print("\n【1】关键词未命中 + 模型可用 → 主管直接自答(不再二次分诊)")
+    # 这句不含任何领域关键词,也不像"花了钱"的报备(没有完成态动词),
+    # 所以仍然走自答 —— 花费报备现在已算作财务命中,见【1b】。
+    no_kw = "讲个笑话听听"
+    check(os_.supervisor._has_keyword_hit(no_kw) is False, f"「{no_kw[:12]}…」确无关键词命中")
+    r = asyncio.run(os_.supervisor.run_task(no_kw))
+    d1 = r["result"].get("dispatched_to")
+    check(d1 == "supervisor", f"未命中 → 主管自答(dispatched_to={d1},预期 supervisor)")
+    check(r["result"].get("self_answered") is True, "标记 self_answered=True(确为自答而非派发)")
+    check(bool(str(r["result"].get("sub_result") or "").strip()), "自答产出非空答复")
+    check(not any(CLASSIFY_MARK in c for c in calls), "全程未发出分诊 prompt(不再多花一次 LLM 往返)")
+
+    print("\n【1b】零星花费报备(无财务关键词)→ 认作财务命中,派给财务")
+    for line in ("今天买了一件衣服花了105块", "后天花了100洗车"):
+        check(os_.supervisor._has_keyword_hit(line), f"「{line[:12]}…」算作领域命中")
+        check(os_.supervisor._route(line) == "finance", f"「{line[:12]}…」→ finance")
+    # 讨论额度/比例不算报备,但仍属于财务问题 → 也交财务,而不是主管自答
+    check(os_.supervisor._route("每月房租3000占收入10000这样合理吗") == "finance",
+          "房租占比咨询 → finance")
+
+    print("\n【2】关键词命中 → 直接路由,不问 LLM 分诊(省成本)")
+    calls.clear()
+    r2 = asyncio.run(os_.supervisor.run_task("帮我做个预算分析"))   # "预算" 命中 finance
+    d2 = r2["result"].get("dispatched_to")
+    check(d2 == "finance", f"命中'预算' → 直接 finance(实为 {d2})")
+    check(not any(CLASSIFY_MARK in c for c in calls), "关键词命中时不发出分诊 prompt")
+
+    print("\n【3】stub + 关键词未命中 → 主管自处理(离线确定性)")
+    os_.router.provider = "stub"
+    os_.router._client = None
+    calls.clear()
+    r3 = asyncio.run(os_.supervisor.run_task("解释一下什么是航天器"))   # 无关键词
+    check(os_.router.is_stub is True, "router 回到 stub")
+    d3 = r3["result"].get("dispatched_to")
+    check(d3 == "supervisor", f"stub 下未命中 → 主管自身处理(实为 {d3})")
+    check(not r3["result"].get("self_answered"), "stub 下走派发路径,而非主管自答")
+    check(not any(CLASSIFY_MARK in c for c in calls), "stub 下不发出分诊 prompt")
+
+    print("\n" + "=" * 56)
+    print("主管分诊与自答策略回归通过")
+    print("=" * 56)
+
+
+def test_supervisor_triage():
+    main()
+
+
+if __name__ == "__main__":
+    main()

package/python/tests/test_taint.py

@@ -0,0 +1,117 @@
+"""
+数据污点追踪 + 动态审批门槛测试 —— 全离线。
+
+对齐 Meta Muse「eBPF 污点追踪」的软件版:会话一旦取回用户/敏感数据就打污点,
+之后外发/副作用动作的审批门槛动态提高。覆盖:
+  1. injection_guard.taint_level:来源 → 敏感度分级。
+  2. permission.evaluate 污点门槛:默认关闭(行为不变)/ 达标+外发 → TAINT_CONFIRM /
+     达标+只读 → 不触发 / 未达标 → 不触发。
+  3. base 污点传播:_dispatch_tool 取回 memory/web_search 后会话污点单调上升;
+     会话开始 _taint_reset 清零。
+"""
+import os, sys, types
+from pathlib import Path
+os.environ.setdefault("HF_HUB_OFFLINE", "1")
+os.environ.setdefault("TRANSFORMERS_OFFLINE", "1")
+os.environ["FOXCLAW_EMBEDDING_MODEL"] = "foxclaw-nonexistent-fast"
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from foxclaw.core import injection_guard as IG
+from foxclaw.skills import permission as PERM
+from foxclaw.agents.base import (
+    CognitiveAgent, _taint_get, _taint_raise, _taint_reset,
+)
+
+
+def _skill(side_effect="read", read_only=True, external=False, destructive=False):
+    """构造一个 permission.evaluate 可用的最小 skill-spec(duck-typed)。"""
+    return types.SimpleNamespace(
+        id=f"tool:test_{side_effect}",
+        params={},
+        side_effect=side_effect,
+        read_only=read_only,
+        external=external,
+        destructive=destructive,
+        trust_level=lambda: "high",
+    )
+
+
+# ── 1. taint_level 分级 ───────────────────────────────────────────────
+def test_taint_level_grading():
+    assert IG.taint_level("web_search") == IG.TAINT_EXTERNAL == 1
+    assert IG.taint_level("knowledge") == IG.TAINT_PERSONAL == 2
+    assert IG.taint_level("file") == IG.TAINT_PERSONAL == 2
+    assert IG.taint_level("memory") == IG.TAINT_SENSITIVE == 3
+    assert IG.taint_level("unknown_source") == IG.TAINT_EXTERNAL   # 未知来源不低估
+
+
+# ── 2. permission 污点门槛 ─────────────────────────────────────────────
+def test_permission_taint_default_off_behavior_unchanged():
+    # 不传污点参数(默认关闭)→ 外发工具走原有 Stage 4 副作用确认
+    s = _skill(side_effect="send", read_only=False)
+    d = PERM.evaluate(s, {})
+    assert d.decision == "ask" and d.reason_code == PERM.SIDE_EFFECT_CONFIRM
+
+
+def test_permission_taint_blocks_send_when_sensitive():
+    s = _skill(side_effect="send", read_only=False)
+    d = PERM.evaluate(s, {}, taint_level=IG.TAINT_SENSITIVE,
+                      taint_threshold=IG.TAINT_PERSONAL)
+    assert d.decision == "ask" and d.reason_code == PERM.TAINT_CONFIRM
+    assert d.requires_confirmation
+
+
+def test_permission_taint_blocks_external_when_personal():
+    s = _skill(side_effect="read", read_only=False, external=True)
+    d = PERM.evaluate(s, {}, taint_level=IG.TAINT_PERSONAL,
+                      taint_threshold=IG.TAINT_PERSONAL)
+    assert d.decision == "ask" and d.reason_code == PERM.TAINT_CONFIRM
+
+
+def test_permission_taint_not_trigger_on_readonly():
+    s = _skill(side_effect="read", read_only=True)
+    d = PERM.evaluate(s, {}, taint_level=IG.TAINT_SENSITIVE,
+                      taint_threshold=IG.TAINT_PERSONAL)
+    assert d.decision == "allow"
+
+
+def test_permission_taint_not_trigger_below_threshold():
+    s = _skill(side_effect="send", read_only=False)
+    # 污点只有 EXTERNAL(1) < 阈值 PERSONAL(2)→ 不因污点拦,走副作用确认
+    d = PERM.evaluate(s, {}, taint_level=IG.TAINT_EXTERNAL,
+                      taint_threshold=IG.TAINT_PERSONAL)
+    assert d.reason_code == PERM.SIDE_EFFECT_CONFIRM
+
+
+# ── 3. base 污点传播 ───────────────────────────────────────────────────
+def test_taint_helpers_on_fake_agent():
+    a = types.SimpleNamespace(_think=lambda **k: None)
+    assert _taint_get(a) == 0
+    _taint_raise(a, IG.TAINT_EXTERNAL)
+    _taint_raise(a, IG.TAINT_SENSITIVE)
+    assert _taint_get(a) == IG.TAINT_SENSITIVE    # 单调不减
+    _taint_reset(a)
+    assert _taint_get(a) == 0
+
+
+def test_dispatch_recall_memory_raises_taint():
+    a = types.SimpleNamespace(
+        _think=lambda **k: None,
+        _recall_memory=lambda q, top_k=5: [{"content": "用户偏好:喜欢简洁"}])
+    out = CognitiveAgent._dispatch_tool(a, "recall_memory", {"query": "偏好"})
+    assert "喜欢简洁" in out
+    assert _taint_get(a) == IG.TAINT_SENSITIVE
+
+
+def test_dispatch_web_search_raises_taint(monkeypatch):
+    from foxclaw.core import web_search as WS
+    monkeypatch.setattr(WS, "search_answer", lambda q: {"answer": "答案ABC", "references": []})
+    a = types.SimpleNamespace(_think=lambda **k: None)
+    out = CognitiveAgent._dispatch_tool(a, "web_search", {"query": "问题"})
+    assert "答案ABC" in out
+    assert _taint_get(a) == IG.TAINT_EXTERNAL
+
+
+if __name__ == "__main__":
+    import pytest
+    pytest.main([__file__, "-v"])

package/python/tests/test_task_stream.py

@@ -0,0 +1,85 @@
+"""D1:/api/task/stream SSE —— 任务执行流式化(逐 stage 进度 + act 逐 token + 最终 result)。
+与 test_streaming.py 的 /api/chat/stream 端点测试对称:那条测对话直答流式,这条测**走完整认知
+管线**的任务流式。核心逻辑(run_task_stream)在 test_agent_lifecycle 已直测,这里补端点级 SSE 打通。"""
+import os, sys, tempfile, json
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+def test_task_stream():
+    os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
+    os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
+    os.environ["FOXCLAW_STREAM_RATE"] = "60"   # 放开限流(限流由 test_streaming 覆盖),这里只验通路
+    os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_taskstream_")
+    # 强制 stub(离线/确定性/免费):关掉 .env,使进程环境变量成为唯一来源。
+    # (旧写法是逐个把 key 置空以依赖 load_dotenv(override=False)——但那挡不住「先 pop 再
+    #  import」的路径,也挡不住 .env 里的 FOXCLAW_MCP_SERVER 等非 key 变量。见 api.py 说明。)
+    os.environ["FOXCLAW_SKIP_DOTENV"] = "1"
+    for _k in ("DEEPSEEK_API_KEY", "ANTHROPIC_API_KEY", "OPENAI_API_KEY",
+               "GOOGLE_API_KEY", "DASHSCOPE_API_KEY", "FOXCLAW_API_KEY"):
+        os.environ[_k] = ""
+
+    print("=" * 60); print("D1 · /api/task/stream 任务流式化验证"); print("=" * 60)
+
+    from fastapi.testclient import TestClient
+    import foxclaw.api as _api
+    from foxclaw.api import app
+    # pytest 同进程下,test_streaming.py 可能已把模块级流式限流桶设为 rate=1(并耗尽),
+    # 而本测试要放开限流跑两条流式通路 —— 复位桶容量/速率/余量(限流语义由 test_streaming 覆盖)。
+    _api._STREAM_LIMITER.capacity = 60
+    _api._STREAM_LIMITER.rate = 1.0
+    _api._STREAM_LIMITER.tokens = 60.0
+
+    with TestClient(app) as c:
+        # 1) 正常流式:SSE 收到 stage 进度 + act delta + 恰一个 result,无 error
+        #    拓扑 5 → 3:领域 Agent 才走 DEFAULT_STAGES(含 act),主管走路由管线
+        #    (recall→route→dispatch→aggregate),不会产出 act —— 故此处用 office。
+        with c.stream("POST", "/api/task/stream",
+                      json={"task": "帮我分析一下本月开销", "agent_id": "office"}) as resp:
+            assert resp.status_code == 200, resp.status_code
+            stages, deltas, results, errors = [], [], [], []
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                ev = json.loads(line[6:])
+                if "stage" in ev: stages.append(ev["stage"])
+                if "delta" in ev: deltas.append(ev["delta"])
+                if "result" in ev: results.append(ev["result"])
+                if "error" in ev: errors.append(ev["error"])
+            assert not errors, f"不应有 error 事件: {errors}"
+            assert "act" in stages, f"应有 stage 进度事件(含 act): {stages}"
+            assert len(deltas) > 0, "应有 act 逐 token delta 事件(证明流式透传经端点打通)"
+            assert len(results) == 1, f"应恰有一个最终 result 事件,实得 {len(results)}"
+            assert results[0].get("agent") == "office" and "result" in results[0], results[0]
+        print(f"[1] /api/task/stream SSE(stage={len(stages)} delta={len(deltas)} result=1) OK")
+
+        # 2) 【P3-3】主管不再回落领域 Agent:P1-1 pipeline 化后主管自身支持流式,
+        #    stage 事件是主管管线七阶段,result.agent=supervisor,路由结论照常(stub 无关键词
+        #    → 主管自身处理)。
+        with c.stream("POST", "/api/task/stream",
+                      json={"task": "随便问问", "agent_id": "supervisor"}) as resp:
+            assert resp.status_code == 200, resp.status_code
+            stages, results, errors = [], [], []
+            for line in resp.iter_lines():
+                if not line or not line.startswith("data: "):
+                    continue
+                ev = json.loads(line[6:])
+                if "stage" in ev: stages.append(ev["stage"])
+                if "result" in ev: results.append(ev["result"])
+                if "error" in ev: errors.append(ev["error"])
+            assert not errors, f"不应有 error 事件: {errors}"
+            assert len(results) == 1, f"应恰有一个最终 result 事件,实得 {len(results)}"
+            r0 = results[0]
+            assert r0.get("agent") == "supervisor", \
+                f"P3-3:主管走自身 pipeline,不再回落 assistant(实为 {r0.get('agent')})"
+            assert "dispatch" in stages and "route" in stages, \
+                f"应见主管管线 stage(route/dispatch): {stages}"
+            assert r0["result"].get("dispatched_to") == "supervisor", \
+                f"stub 无关键词 → 主管自身处理(实为 {r0['result'].get('dispatched_to')})"
+        print("[2] agent_id=supervisor → 主管自身流式管线(P3-3,不再回落) OK")
+
+    print("\nD1 /api/task/stream 验证通过")
+
+
+if __name__ == "__main__":
+    test_task_stream()

package/python/tests/test_thinking_sse.py

@@ -0,0 +1,67 @@
+"""/api/chat/stream 的命名 SSE 事件:`event: thinking` 与正文 delta 分离。
+
+前端按事件名折叠展示推理;正文 delta 里不得出现推理文本(否则复制/落库会被污染)。
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import sys
+import tempfile
+from pathlib import Path
+
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+
+def test_chat_stream_emits_named_thinking_event():
+    # ISOLATION_GUARD:依赖 import 期固化的单例(路由配置/限流器),须独立进程跑。
+    if "foxclaw.api" in sys.modules:
+        import pytest
+        pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
+    os.environ.setdefault("FOXCLAW_DATA_DIR", tempfile.mkdtemp(prefix="foxclaw_think_"))
+
+    from fastapi.testclient import TestClient
+    from foxclaw.agents.base import CognitiveAgent
+    from foxclaw.api import app
+
+    def _fake_stream(self, task, stop_event=None, images=None, history=None,
+                     attachments=None, on_thinking=None, on_evidence=None):
+        if on_thinking is not None:
+            on_thinking("先分析一下用户意图")
+        yield "好的"
+
+    original = CognitiveAgent.stream_reply
+    CognitiveAgent.stream_reply = _fake_stream
+    try:
+        with TestClient(app) as c:
+            resp = c.post("/api/chat/stream", json={"task": "hi", "agent_id": "supervisor"})
+            assert resp.status_code == 200, resp.status_code
+            body = resp.text
+    finally:
+        CognitiveAgent.stream_reply = original
+
+    assert "event: thinking" in body, "推理必须以命名事件送出"
+    blocks = [b for b in body.split("\n\n") if b.strip()]
+    think_payloads, delta_payloads = [], []
+    for b in blocks:
+        name = "message"
+        data = None
+        for line in b.splitlines():
+            if line.startswith("event: "):
+                name = line[7:].strip()
+            elif line.startswith("data: "):
+                data = line[6:].strip()
+        if data is None:
+            continue
+        ev = json.loads(data)
+        if name == "thinking":
+            think_payloads.append(ev)
+        elif "delta" in ev:
+            delta_payloads.append(ev["delta"])
+
+    assert think_payloads, "应有 thinking 事件块"
+    assert "先分析一下用户意图" == "".join(p.get("thinking", "") for p in think_payloads)
+    joined = "".join(delta_payloads)
+    assert joined == "好的"
+    assert "先分析一下" not in joined, "推理不得混入正文 delta"

package/python/tests/test_thinking_stream.py

@@ -0,0 +1,76 @@
+"""推理过程可见:`_ThinkStripper` 不再丢弃思考,原生 reasoning 走独立 thinking 通道。
+
+背景:`core/model_router.py` 的 `_ThinkStripper.feed` 只返回可见正文,think 块内容被整段
+淘汰;openai-compatible 的 `delta.reasoning_content`(deepseek-reasoner 等)更是完全没读,
+用户只看到结论,看不到推理。现在两者都转成 `on_thinking` 回调 → SSE `event: thinking`。
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+from foxclaw.core.model_router import ModelRouter, _ThinkStripper
+
+
+class _FakeCompletions:
+    def __init__(self, chunks):
+        self.chunks = chunks
+        self.kwargs: dict = {}
+
+    def create(self, **kwargs):
+        self.kwargs = kwargs
+        return iter(self.chunks)
+
+
+class _FakeClient:
+    def __init__(self, chunks):
+        self.chat = SimpleNamespace(completions=_FakeCompletions(chunks))
+
+
+def _chunk(content=None, reasoning=None):
+    delta = SimpleNamespace(content=content, reasoning_content=reasoning)
+    return SimpleNamespace(choices=[SimpleNamespace(delta=delta)])
+
+
+def _router(chunks) -> ModelRouter:
+    r = ModelRouter(provider="openai", model="gpt-4o-mini")
+    r._client = _FakeClient(chunks)
+    return r
+
+
+def test_stripper_returns_think_text_separately() -> None:
+    s = _ThinkStripper()
+    vis1, th1 = s.feed_events("答案前<thi")
+    assert (vis1, th1) == ("答案前", ""), "半个标签不能当正文吐出"
+    vis2, th2 = s.feed_events("nk>内部推理</think>答案")
+    assert vis2 == "答案"
+    assert th2 == "内部推理"
+
+
+def test_stripper_feed_still_visible_only() -> None:
+    s = _ThinkStripper()
+    assert s.feed("a<think>b</think>c") == "ac"
+
+
+def test_reasoning_content_goes_to_thinking_only() -> None:
+    r = _router([_chunk(None, "先想一下"), _chunk("你好"), _chunk("世界")])
+    think: list[str] = []
+    text = "".join(r.stream("sys", [{"role": "user", "content": "hi"}],
+                            on_thinking=think.append))
+    assert "".join(think) == "先想一下", "原生 reasoning_content 必须进推理通道"
+    assert text == "你好世界", "正文不得混入推理"
+
+
+def test_embedded_think_routed_to_callback() -> None:
+    r = _router([_chunk("<think>内嵌思考</think>答案是 42<think>补一句")])
+    think: list[str] = []
+    text = "".join(r.stream("sys", [{"role": "user", "content": "hi"}],
+                            on_thinking=think.append))
+    assert text == "答案是 42"
+    assert "内嵌思考" in "".join(think)
+    assert "补一句" not in text, "未闭合的 think 尾巴不得漏进正文"
+
+
+def test_no_callback_keeps_old_behavior() -> None:
+    r = _router([_chunk("<think>x</think>ok")])
+    assert "".join(r.stream("sys", [{"role": "user", "content": "hi"}])) == "ok"