foxclaw 0.1.2 → 0.1.3

package/python/tests/test_skills_fetch.py

@@ -0,0 +1,282 @@
+"""`foxclaw skills install` 的来源解析与落地。
+
+全部离线:远端用 monkeypatch 替掉 `_http_get`,不打真网 —— 否则 CI 会因 ClawHub
+抖动而红,这类测试一旦不稳就会被跳过,等于没测。
+"""
+from __future__ import annotations
+
+import io
+import json
+import tarfile
+import zipfile
+
+import pytest
+
+from foxclaw.skills import fetch as fetch_mod
+from foxclaw.skills.archive import PackageError, has_code, read_package
+
+MD = "---\nname: Demo Skill\ndescription: 演示用技能\nversion: 1.2.3\n---\n\n正文指示"
+
+
+def _zip(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with zipfile.ZipFile(buf, "w") as z:
+        for name, body in files.items():
+            z.writestr(name, body)
+    return buf.getvalue()
+
+
+def _tgz(files: dict) -> bytes:
+    buf = io.BytesIO()
+    with tarfile.open(fileobj=buf, mode="w:gz") as t:
+        for name, text in files.items():
+            raw = text.encode("utf-8")
+            info = tarfile.TarInfo(name)
+            info.size = len(raw)
+            t.addfile(info, io.BytesIO(raw))
+    return buf.getvalue()
+
+
+def _mock_http(monkeypatch, routes: dict) -> None:
+    def fake(url: str, timeout: float = 25.0, max_bytes: int = 10 * 1024 * 1024):
+        for key, val in routes.items():
+            if key in url:
+                return val
+        raise PackageError(f"测试未配置这条路由: {url}")
+
+    monkeypatch.setattr(fetch_mod, "_http_get", fake)
+
+
+def test_read_zip_root_skill_md():
+    pkg = read_package(_zip({"SKILL.md": MD, "_meta.json": '{"slug": "demo"}'}))
+    assert pkg["skill_md"] == MD
+    assert pkg["meta"]["slug"] == "demo"
+
+
+def test_read_targz_picks_shallowest():
+    pkg = read_package(_tgz({
+        "repo-abc/SKILL.md": MD,
+        "repo-abc/docs/SKILL.md": "更深的同名副本应被忽略",
+    }))
+    assert pkg["skill_md"] == MD
+
+
+def test_read_package_rejects_traversal():
+    with pytest.raises(PackageError):
+        read_package(_zip({"../evil/SKILL.md": MD}))
+
+
+def test_read_package_without_skill_md():
+    with pytest.raises(PackageError, match="未找到 SKILL.md"):
+        read_package(_zip({"README.md": "nothing here"}))
+
+
+def test_subpath_narrows_search():
+    with pytest.raises(PackageError):
+        read_package(_tgz({"repo/a/SKILL.md": MD}), subpath="other")
+
+
+def test_has_code_detects_scripts():
+    assert has_code(["SKILL.md", "scripts/run.py"])
+    assert has_code(["SKILL.md", "tool.sh"])
+    assert not has_code(["SKILL.md", "skill-card.md"])
+
+
+def test_ref_routes_scoped_name_to_clawhub(monkeypatch):
+    seen: dict = {}
+
+    def fake(owner, slug, timeout):
+        seen["id"] = (owner, slug)
+        return fetch_mod.SkillPackage(skill_md=MD, source="clawhub", origin="x")
+
+    monkeypatch.setattr(fetch_mod, "_from_clawhub", fake)
+    assert fetch_mod.fetch("@snowfox/demo").origin == "x"
+    assert seen["id"] == ("snowfox", "demo")
+    fetch_mod.fetch("snowfox/demo")
+    assert seen["id"] == ("snowfox", "demo")
+
+
+def test_unknown_ref_rejected():
+    with pytest.raises(PackageError, match="无法识别"):
+        fetch_mod.fetch("no-such-thing-xyz")
+
+
+def test_local_dir_reads_skill_md(tmp_path):
+    (tmp_path / "SKILL.md").write_text(MD, encoding="utf-8")
+    pkg = fetch_mod.fetch(str(tmp_path))
+    assert pkg.source == "local"
+    assert "演示用技能" in pkg.skill_md
+
+
+def test_local_dir_without_skill_md(tmp_path):
+    with pytest.raises(PackageError):
+        fetch_mod.fetch(str(tmp_path))
+
+
+def test_clawhub_blocks_malware(monkeypatch):
+    _mock_http(monkeypatch, {
+        "/api/v1/skills/": (json.dumps({
+            "moderation": {"isMalwareBlocked": True, "summary": "窃取密钥"},
+            "latestVersion": {"version": "1.0.0"},
+        }).encode(), "application/json"),
+    })
+    with pytest.raises(fetch_mod.MalwareBlocked):
+        fetch_mod.fetch("@bad/skill")
+
+
+def test_clawhub_github_handoff(monkeypatch):
+    """download 返回 JSON 交接(GitHub 托底)时要改下 archiveUrl,而不是当 zip 解。"""
+    _mock_http(monkeypatch, {
+        "/api/v1/skills/": (json.dumps({
+            "moderation": {"isSuspicious": True},
+            "latestVersion": {"version": "2.0.0"},
+        }).encode(), "application/json"),
+        "/api/v1/download": (json.dumps({
+            "archiveUrl": "https://codeload.example/archive.tar.gz",
+        }).encode(), "application/json"),
+        "archive.tar.gz": (_tgz({"repo-main/SKILL.md": MD}), "application/gzip"),
+    })
+    pkg = fetch_mod.fetch("@snowfox/demo")
+    assert pkg.version == "2.0.0"
+    assert pkg.suspicious is True
+    assert "repo-main/SKILL.md" in pkg.files
+
+
+def test_clawhub_not_found(monkeypatch):
+    def boom(url, timeout=25.0, max_bytes=10 * 1024 * 1024):
+        raise fetch_mod.HttpError(404, url, "Not found")
+
+    monkeypatch.setattr(fetch_mod, "_http_get", boom)
+    with pytest.raises(PackageError, match="找不到"):
+        fetch_mod.fetch("@ghost/missing")
+
+
+def test_github_subpath(monkeypatch):
+    _mock_http(monkeypatch, {
+        "codeload.github.com": (_tgz({
+            "repo-main/skills/demo/SKILL.md": MD,
+            "repo-main/skills/other/SKILL.md": "x",
+        }), "application/gzip"),
+    })
+    pkg = fetch_mod.fetch("github:snowfox/repo/skills/demo@main")
+    assert pkg.source == "github"
+    assert pkg.skill_md == MD
+    assert pkg.origin == "github:snowfox/repo/skills/demo@main"
+
+
+def _src(tmp_path):
+    src = tmp_path / "src"
+    src.mkdir()
+    (src / "SKILL.md").write_text(MD, encoding="utf-8")
+    return src
+
+
+def test_cli_install_writes_file_when_service_down(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert [s["id"] for s in saved["skills"]] == ["demo_skill"]
+    assert saved["skills"][0]["version"] == "1.2.3"
+
+
+def test_cli_install_respects_explicit_id(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes",
+                     "--id", "my_demo"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert saved["skills"][0]["id"] == "my_demo"
+
+
+def test_cli_install_refuses_without_confirmation(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    monkeypatch.setattr(install_cmd, "_confirm", lambda: False)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path))]) == 1
+    assert not (tmp_path / "data" / "markdown_skills.json").exists()
+
+
+def test_cli_list_reads_file_when_service_down(tmp_path, monkeypatch, capsys):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    cli.main(["skills", "install", str(_src(tmp_path)), "--yes"])
+    capsys.readouterr()
+
+    assert cli.main(["skills", "list", "--json"]) == 0
+    got = json.loads(capsys.readouterr().out)
+    assert got["source"] == "file"
+    assert got["skills"][0]["id"] == "demo_skill"
+
+
+def test_cli_remove_deletes_skill(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    data = tmp_path / "data"
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(data))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    cli.main(["skills", "install", str(_src(tmp_path)), "--yes"])
+
+    assert cli.main(["skills", "remove", "demo_skill"]) == 0
+    saved = json.loads((data / "markdown_skills.json").read_text(encoding="utf-8"))
+    assert saved["skills"] == []
+
+
+def test_cli_remove_unknown_id_fails(tmp_path, monkeypatch):
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: False)
+    assert cli.main(["skills", "remove", "nope"]) == 1
+
+
+def test_cli_install_uses_api_when_service_alive(tmp_path, monkeypatch):
+    """服务在跑时必须打 API:直接改 json 会被运行中注册表的下次 save 整份覆盖。"""
+    from foxclaw import cli
+    from foxclaw.skills import install_cmd
+
+    monkeypatch.setenv("FOXCLAW_DATA_DIR", str(tmp_path / "data"))
+    monkeypatch.setattr(install_cmd, "_api_alive", lambda base: True)
+    calls: list = []
+
+    def fake_json(base, method, path, payload=None):
+        calls.append((method, path, payload))
+        return {"created": True}
+
+    monkeypatch.setattr(install_cmd, "_api_json", fake_json)
+
+    assert cli.main(["skills", "install", str(_src(tmp_path)), "--yes"]) == 0
+    method, path, payload = calls[0]
+    assert (method, path) == ("POST", "/api/ahs/md-skills")
+    assert payload["acknowledged"] is True
+    assert payload["id"] == "demo_skill"
+    assert "正文指示" in payload["content"]
+    assert not (tmp_path / "data" / "markdown_skills.json").exists()
+
+
+def test_local_zip_package(tmp_path):
+    p = tmp_path / "demo.zip"
+    p.write_bytes(_zip({"SKILL.md": MD, "_meta.json": '{"slug": "pack"}'}))
+    pkg = fetch_mod.fetch(str(p))
+    assert pkg.source == "local"
+    assert pkg.meta["slug"] == "pack"

package/python/tests/test_stats_and_events.py

@@ -33,14 +33,13 @@ def _adapter_with(hmr_obj):
     return s
 
 
-# ── 1. 记忆统计 ────────────────────────────────────────────────────────────────
 def test_stats_counts_from_memory_fs_not_vector_store():
     """核心回归:记忆在 memory_fs;vector_store 没有 count/size/memories 也不能让 total 归零。"""
     mems = [_mem(["agent:supervisor"]), _mem(["agent:supervisor"]),
             _mem(["agent:finance", "shared"]), _mem(["agent:office"])]
     hmr = types.SimpleNamespace(
         memory_fs=types.SimpleNamespace(list_memories=lambda: mems),
-        vector_store=types.SimpleNamespace(),      # 故意:没有 count/size/memories(复现旧 bug 条件)
+        vector_store=types.SimpleNamespace(),
         memory_graph=None)
     out = HMRAdapter.stats(_adapter_with(hmr))
     assert out["total_memories"] == 4, "必须从 memory_fs 数出真实记忆数"
@@ -75,14 +74,13 @@ def test_stats_survives_broken_hmr():
     assert out["total_memories"] == 0 and out["relations"] == 0
 
 
-# ── 1b. 记忆标题可读性 ─────────────────────────────────────────────────────────
 def test_derive_title_from_content():
     d = HMRAdapter._derive_title
     assert d("对话:你好 → 你好呀！周五中午,正是一周里…") == "你好"
     assert d("用户偏好:我喜欢简洁的回答") == "我喜欢简洁的回答"
     assert d("把这份报告存入HMR → 好的,我现在") == "把这份报告存入HMR"
     assert d("") == ""
-    assert len(d("很长" * 50)) <= 24          # 限长
+    assert len(d("很长" * 50)) <= 24
 
 
 def test_recent_replaces_timestamp_titles():
@@ -109,7 +107,6 @@ def test_recent_keeps_meaningful_title():
     assert s.recent(5)[0]["title"] == "季度财务复盘"
 
 
-# ── 2. 活动事件 ────────────────────────────────────────────────────────────────
 def test_chat_publishes_activity_event(monkeypatch):
     """核心回归:对话完成后必须往事件脊柱发 chat.completed,否则"活动"页永远空。"""
     monkeypatch.setenv("FOXCLAW_TOOL_USE", "1")

package/python/tests/test_streaming.py

@@ -6,26 +6,22 @@ import pytest
 
 
 def test_streaming():
-    # ISOLATION_GUARD:本用例依赖 import 时固化的模块级单例(网关/限流器/路由配置按 env 在 import 时定型),单进程全量跑会被前序用例污染 →
-    # 假红。全量请用 tests/run_all.py(每文件独立子进程)。
     if "foxclaw.api" in sys.modules:
         pytest.skip("需独立进程运行(模块级单例已固化),请用 tests/run_all.py")
     os.environ["FOXCLAW_SHADOW_ROUNDS"] = "6"
     os.environ.setdefault("FOXCLAW_EMBEDDING_MODEL", "foxclaw-nonexistent-fast")
-    os.environ["FOXCLAW_STREAM_RATE"] = "1"   # 令牌桶=1,测限流
+    os.environ["FOXCLAW_STREAM_RATE"] = "1"
     os.environ["FOXCLAW_DATA_DIR"] = tempfile.mkdtemp(prefix="foxclaw_stream_")
 
     print("=" * 60); print("LLM 流式输出验证"); print("=" * 60)
 
-    # 1) router.stream(stub 模式):分块拼接 == 完整文本、多块
     from foxclaw.core.model_router import ModelRouter
-    r = ModelRouter()   # 无 key → stub
+    r = ModelRouter()
     chunks = list(r.stream("sys", [{"role": "user", "content": "你好世界这是一段用于测试流式分块的文本"}]))
     assert len(chunks) > 1, f"应多块: {len(chunks)}"
     assert "".join(chunks), "拼接应非空"
     print(f"[1] router.stream stub 分块(chunk={len(chunks)}) OK")
 
-    # 2) /api/chat/stream SSE:多个 delta + done 收尾
     from fastapi.testclient import TestClient
     from foxclaw.api import app
     with TestClient(app) as c:
@@ -46,7 +42,6 @@ def test_streaming():
             assert "".join(deltas), "拼接应非空"
         print(f"[2] /api/chat/stream SSE(delta={len(deltas)}, done) OK")
 
-        # 3) 限流:桶=1,上面 [2] 已消耗 → 再请求被限流
         with c.stream("POST", "/api/chat/stream",
                       json={"task": "再来一次", "agent_id": "supervisor"}) as resp:
             txt = "".join(resp.iter_text())

package/python/tests/test_supervisor_pipeline.py

@@ -26,7 +26,7 @@ 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      # 自答/兜底路径不触发联网,保持离线
+ws.needs_search = lambda q: False
 
 from foxclaw import Foxclaw
 from foxclaw.agents.base import CognitiveAgent, HarnessBlockedError
@@ -59,7 +59,7 @@ def main():
     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.provider = "stub"
     os_.router._client = None
     sup = os_.supervisor
 
@@ -74,7 +74,7 @@ def main():
           "返回体由 base 模板统一组装(agent/session_id/thought_summary)")
 
     print("\n【3】单 Agent 分发:返回体顶层键与旧实现逐字一致")
-    r = asyncio.run(sup.run_task("帮我做个预算分析"))       # "预算" 命中 finance
+    r = asyncio.run(sup.run_task("帮我做个预算分析"))
     res = r["result"]
     check(res.get("dispatched_to") == "finance", f"关键词命中 → finance(实为 {res.get('dispatched_to')})")
     for k in ("schedule", "plan", "process_id"):
@@ -91,7 +91,7 @@ def main():
     print("\n【5】统一 execution.completed(文稿 Step 4)")
     spine = os_.event_spine
     before = len(spine.history("execution.completed"))
-    asyncio.run(sup.run_task("同时查今天的日程、分析本月理财、总结这篇论文"))   # 并行 3 子任务
+    asyncio.run(sup.run_task("同时查今天的日程、分析本月理财、总结这篇论文"))
     evts = spine.history("execution.completed")
     new_evts = evts[before:]
     check(len(new_evts) == 1,
@@ -112,7 +112,6 @@ def main():
     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 传播 + 中断")

package/python/tests/test_supervisor_triage.py

@@ -20,7 +20,7 @@ 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      # 自答路径不触发联网,保持离线
+ws.needs_search = lambda q: False
 
 from foxclaw import Foxclaw
 
@@ -31,8 +31,6 @@ def check(cond, msg):
     print(f"  ✓ {msg}")
 
 
-# 分诊 prompt 的特征串。历史上 _llm_classify 用它问模型;现已无此路径,
-# 故断言它**从不出现**,即「不再为分诊多花一次 LLM 往返」。
 CLASSIFY_MARK = "只输出一个词"
 
 
@@ -47,19 +45,16 @@ def main():
     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:      # 若真有人恢复分诊,这里会暴露
+        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))
@@ -73,13 +68,12 @@ def main():
     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
+    r2 = asyncio.run(os_.supervisor.run_task("帮我做个预算分析"))
     d2 = r2["result"].get("dispatched_to")
     check(d2 == "finance", f"命中'预算' → 直接 finance(实为 {d2})")
     check(not any(CLASSIFY_MARK in c for c in calls), "关键词命中时不发出分诊 prompt")
@@ -88,7 +82,7 @@ def main():
     os_.router.provider = "stub"
     os_.router._client = None
     calls.clear()
-    r3 = asyncio.run(os_.supervisor.run_task("解释一下什么是航天器"))   # 无关键词
+    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})")

package/python/tests/test_taint.py

@@ -36,18 +36,15 @@ def _skill(side_effect="read", read_only=True, external=False, destructive=False
     )
 
 
-# ── 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   # 未知来源不低估
+    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
@@ -77,19 +74,17 @@ def test_permission_taint_not_trigger_on_readonly():
 
 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    # 单调不减
+    assert _taint_get(a) == IG.TAINT_SENSITIVE
     _taint_reset(a)
     assert _taint_get(a) == 0
 

package/python/tests/test_task_stream.py

@@ -9,11 +9,8 @@ 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_STREAM_RATE"] = "60"
     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"):
@@ -24,16 +21,11 @@ def test_task_stream():
     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
@@ -53,9 +45,6 @@ def test_task_stream():
             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

package/python/tests/test_thinking_sse.py

@@ -15,7 +15,6 @@ 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")

package/python/tests/test_tool_center.py

@@ -19,67 +19,56 @@ def test_tool_center():
     with TestClient(app) as c:
         print("=" * 60); print("工具中心 · 技能台 + 审核门 + 治理 验证"); print("=" * 60)
 
-        # 1. 安装 web_api 技能(https 只读 → allow)
         r = c.post("/api/ahs/skills", json=WEBAPI)
         assert r.status_code == 200, r.text
         assert r.json()["created"] is True
         print("[1] 安装 web_api 技能 OK")
 
-        # 2. 列表里出现且 source=user
         r = c.get("/api/ahs/skills"); assert r.status_code == 200
         ids = {s["id"]: s for s in r.json()["skills"]}
         assert "wx_weather" in ids and ids["wx_weather"]["source"] == "user"
         print("[2] 列表含新技能且 source=user OK")
 
-        # 3. 拒绝 local kind
         r = c.post("/api/ahs/skills", json={**WEBAPI, "id": "x_local", "kind": "local"})
         assert r.status_code == 400
         print("[3] 拒绝 local kind(400) OK")
 
-        # 4. 拒绝非法 endpoint
         r = c.post("/api/ahs/skills", json={**WEBAPI, "id": "x_bad", "endpoint": "ftp://x"})
         assert r.status_code == 400
         print("[4] 拒非法 endpoint(400) OK")
 
-        # 5. mcp 缺字段
         r = c.post("/api/ahs/skills", json={"id": "x_mcp", "name": "m", "kind": "mcp", "side_effect": "read"})
         assert r.status_code == 400
         print("[5] mcp 缺 server/tool(400) OK")
 
-        # 6. 启停
         r = c.patch("/api/ahs/skills/wx_weather", json={"enabled": False})
         assert r.status_code == 200 and r.json()["skill"]["enabled"] is False
         r = c.patch("/api/ahs/skills/wx_weather", json={"enabled": True})
         assert r.json()["skill"]["enabled"] is True
         print("[6] 启停切换 OK")
 
-        # 7. 删内置 → 409(取列表里第一个 builtin)
         r = c.get("/api/ahs/skills")
         builtin = next((s["id"] for s in r.json()["skills"] if s["source"] == "builtin"), None)
         if builtin:
             rd = c.delete(f"/api/ahs/skills/{builtin}")
             assert rd.status_code == 409, rd.text
             print("[7] 内置技能不可删(409) OK")
-            # 7b. 用内置 id 安装 → 拒(不能覆盖内置)
             rc = c.post("/api/ahs/skills", json={**WEBAPI, "id": builtin})
             assert rc.status_code == 409, rc.text
             print("[7b] 用内置 id 安装被拒(409) OK")
         else:
             print("[7] 跳过(无内置技能)")
 
-        # 8. 测试调用:read 技能直接跑(返回 SkillResult 结构)
         r = c.post("/api/ahs/skills/wx_weather/test", json={"args": {}})
         assert r.status_code == 200 and "success" in r.json()
         print("[8] 测试调用返回 SkillResult OK")
 
-        # 9. 安装审核门:打本地地址的 web_api 安装期被 deny(403)
         r = c.post("/api/ahs/skills", json={"id": "ssrf_t", "name": "s", "description": "", "kind": "web_api",
                    "triggers": ["x"], "side_effect": "read", "endpoint": "http://127.0.0.1:8000/api/status"})
         assert r.status_code == 403, r.text
         assert r.json()["detail"]["error"] == "install_denied"
         print("[9] 安装审核门 deny 本地地址(403) OK")
 
-        # 9b. 有副作用技能未确认 → 409 needs_ack;acknowledged 后 → 200(且持久,供步12 round-trip)
         _send = {"id": "send_x", "name": "发信", "description": "", "kind": "web_api",
                  "triggers": ["发"], "side_effect": "send", "endpoint": "https://example.com/send"}
         r = c.post("/api/ahs/skills", json=_send)
@@ -88,19 +77,16 @@ def test_tool_center():
         assert r.status_code == 200, r.text
         print("[9b] 副作用技能需确认(409→200) OK")
 
-        # 10. 治理端点可用
         assert c.get("/api/ahs/breaker").status_code == 200
         assert c.get("/api/ahs/hooks/audit").status_code == 200
         print("[10] 治理端点(breaker/audit) OK")
 
-        # 10b. 信任分级:内置 calculator(local)=high、内置 mcp=low、用户 web_api=mid
         sk = {s["id"]: s for s in c.get("/api/ahs/skills").json()["skills"]}
         assert sk["calculator"]["trust"] == "high", sk["calculator"]["trust"]
-        assert sk["gmail_send"]["trust"] == "low", sk["gmail_send"]["trust"]   # 内置但 mcp→低
+        assert sk["gmail_send"]["trust"] == "low", sk["gmail_send"]["trust"]
         assert sk["wx_weather"]["trust"] == "mid"
         print("[10b] 信任分级 high/mid/low OK")
 
-        # 10c. deny 封杀:封杀后测试调用被拦 + blocked 标;解封恢复
         c.post("/api/ahs/policy/deny", json={"id": "wx_weather"})
         r = c.post("/api/ahs/skills/wx_weather/test", json={"args": {}, "confirmed": True}).json()
         assert r["status"] == "blocked" and "封杀" in r["message"], r
@@ -111,12 +97,10 @@ def test_tool_center():
         assert next(s for s in c.get("/api/ahs/skills").json()["skills"] if s["id"] == "wx_weather")["blocked"] is False
         print("[10c] deny 封杀/解封 kill-switch OK")
 
-        # 11. 删除用户技能
         assert c.delete("/api/ahs/skills/wx_weather").status_code == 200
         r = c.get("/api/ahs/skills"); assert "wx_weather" not in {s["id"] for s in r.json()["skills"]}
         print("[11] 删除用户技能 OK")
 
-    # 12. 持久化 round-trip:直建新 OS(同数据目录),已安装的 send_x 应仍在
     from foxclaw import Foxclaw
     os2 = Foxclaw(data_dir=_DATA)
     assert os2.skill_registry.get("send_x") is not None, "重启后用户技能丢失"