foxclaw 0.1.0 → 0.1.2

package/python/tests/test_confirm_nonce.py

@@ -0,0 +1,197 @@
+"""关键操作(send/pay/destructive)的会话 nonce 二次确认。
+
+锁住:确认码绑定「会话 + 动作 + 参数」、单次使用、过期即废;无效码不会降级成放行
+(退回 needs_confirmation 并换发新码);只读技能与未注入 broker 的路径行为不变。
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from foxclaw.core.confirm_nonce import (
+    ConfirmationBroker,
+    action_fingerprint,
+    is_critical,
+)
+from foxclaw.skills import (
+    SkillAdapter,
+    SkillRegistry,
+    SkillSpec,
+    reset_loop_session,
+    set_loop_session,
+)
+from foxclaw.skills import pipeline as sk_pipeline
+
+SESSION = "sess-1"
+
+
+# ── broker 单元 ────────────────────────────────────────────
+
+def test_issue_consume_single_use() -> None:
+    b = ConfirmationBroker(ttl=300, clock=lambda: 1000.0)
+    ch = b.issue(SESSION, "skill:mail_send", {"to": "a@x"})
+    assert ch["nonce"] and ch["expires_at"] == 1300.0
+    assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
+                     now=1000.0) == (True, "ok")
+    # 第二次:已消费 → 拒绝(单次使用)
+    assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
+                     now=1000.0) == (False, "unknown_nonce")
+
+
+def test_expired_nonce_rejected() -> None:
+    b = ConfirmationBroker(ttl=60, clock=lambda: 1000.0)
+    ch = b.issue(SESSION, "skill:pay", {"amount": 1})
+    assert b.consume(SESSION, ch["nonce"], "skill:pay", {"amount": 1},
+                     now=1061.0) == (False, "expired")
+
+
+def test_args_and_action_drift_rejected() -> None:
+    b = ConfirmationBroker(clock=lambda: 1000.0)
+    ch = b.issue(SESSION, "skill:mail_send", {"to": "a@x"})
+    # 确认"发给 A"却执行"发给 B" → 指纹不匹配
+    assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "b@x"},
+                     now=1000.0) == (False, "args_mismatch")
+    assert b.consume(SESSION, ch["nonce"], "skill:pay", {"to": "a@x"},
+                     now=1000.0) == (False, "action_mismatch")
+    # 原动作原参数仍可用(前两次失败没有消费掉它)
+    assert b.consume(SESSION, ch["nonce"], "skill:mail_send", {"to": "a@x"},
+                     now=1000.0) == (True, "ok")
+
+
+def test_session_mismatch_and_missing_nonce() -> None:
+    b = ConfirmationBroker(clock=lambda: 1000.0)
+    ch = b.issue(SESSION, "skill:pay", {"amount": 1})
+    assert b.consume("other", ch["nonce"], "skill:pay", {"amount": 1},
+                     now=1000.0) == (False, "session_mismatch")
+    assert b.consume(SESSION, "", "skill:pay", {"amount": 1}, now=1000.0) == (False, "missing_nonce")
+    assert b.consume(SESSION, "deadbeef", "skill:pay", {"amount": 1},
+                     now=1000.0) == (False, "unknown_nonce")
+
+
+def test_fingerprint_is_arg_order_insensitive_and_critical_classification() -> None:
+    assert action_fingerprint("a", {"x": 1, "y": 2}) == action_fingerprint("a", {"y": 2, "x": 1})
+    assert is_critical("send") and is_critical("pay") and is_critical("read", destructive=True)
+    assert not is_critical("read")
+
+
+def test_pending_is_bounded() -> None:
+    b = ConfirmationBroker(max_pending=8, clock=lambda: 1000.0)
+    for _ in range(20):
+        b.issue(SESSION, "skill:pay", {"amount": 1})
+    assert len(b) == 8, "签到表要有界,不能当内存放大器"
+    assert len(b.pending(SESSION)) == 8
+    assert b.pending("nobody") == []
+
+
+# ── adapter 集成 ───────────────────────────────────────────
+
+class _Calls:
+    def __init__(self):
+        self.n = 0
+
+    def __call__(self, **kw):
+        self.n += 1
+        return {"sent": True}
+
+
+def _build(broker):
+    calls = _Calls()
+    reg = SkillRegistry()
+    reg.register(SkillSpec(id="mail_send", name="发邮件", description="发送邮件",
+                           triggers=["发邮件"], side_effect="send", handler=calls))
+    reg.register(SkillSpec(id="calc", name="计算", description="算数",
+                           triggers=["算"], side_effect="read",
+                           handler=lambda **kw: {"r": 1}))
+    return SkillAdapter(reg, confirms=broker), reg, calls
+
+
+def test_send_requires_nonce_even_when_confirmed():
+    broker = ConfirmationBroker()
+    adapter, reg, calls = _build(broker)
+    tok = set_loop_session(SESSION)
+    try:
+        skill = reg.get("mail_send")
+        args = {"to": "a@x", "body": "hi"}
+
+        first = adapter.invoke(skill, args, confirmed=False)
+        assert first.status == "needs_confirmation"
+        assert first.confirm_nonce and first.confirm_expires_at > 0
+        assert calls.n == 0
+
+        # 只有 confirmed=True 没有确认码 → 不放行(退回待确认,换发新码)
+        no_nonce = adapter.invoke(skill, args, confirmed=True)
+        assert no_nonce.status == "needs_confirmation" and calls.n == 0
+        assert "missing_nonce" in no_nonce.message
+        assert no_nonce.confirm_nonce and no_nonce.confirm_nonce != first.confirm_nonce
+
+        ok = adapter.invoke(skill, args, confirmed=True,
+                            confirm_nonce=no_nonce.confirm_nonce)
+        assert ok.success and calls.n == 1
+
+        # 重放同一个码 → 拒绝,不执行
+        replay = adapter.invoke(skill, args, confirmed=True,
+                                confirm_nonce=no_nonce.confirm_nonce)
+        assert replay.status == "needs_confirmation" and calls.n == 1
+        assert "unknown_nonce" in replay.message
+    finally:
+        reset_loop_session(tok)
+
+
+def test_nonce_bound_to_args():
+    broker = ConfirmationBroker()
+    adapter, reg, calls = _build(broker)
+    tok = set_loop_session(SESSION)
+    try:
+        skill = reg.get("mail_send")
+        ch = adapter.invoke(skill, {"to": "a@x"}, confirmed=False)
+        drift = adapter.invoke(skill, {"to": "b@x"}, confirmed=True,
+                               confirm_nonce=ch.confirm_nonce)
+        assert drift.status == "needs_confirmation" and calls.n == 0
+        assert "args_mismatch" in drift.message
+    finally:
+        reset_loop_session(tok)
+
+
+def test_read_skill_and_no_broker_unaffected():
+    adapter, reg, calls = _build(ConfirmationBroker())
+    assert adapter.invoke(reg.get("calc"), {}, confirmed=True).success
+
+    plain = SkillAdapter(reg)                      # 未注入 broker → 旧语义
+    assert plain.invoke(reg.get("mail_send"), {"to": "a@x"}, confirmed=True).success
+    assert calls.n >= 1
+
+
+# ── pipeline 兼容 ──────────────────────────────────────────
+
+def test_pipeline_invoke_tolerates_old_adapter():
+    """测试/第三方 adapter 只实现 4 参 invoke 时自动降级(签名探测,不吞内部 TypeError)。"""
+    seen = {}
+
+    class _Old:
+        def invoke(self, skill, args, confirmed=False, mode="strict"):
+            seen.update({"skill": skill.id, "confirmed": confirmed})
+            return "out"
+
+    out = sk_pipeline._invoke(_Old(), SkillSpec(id="s", name="n", description="d"),
+                              {"a": 1}, True, "nonce")
+    assert out == "out" and seen == {"skill": "s", "confirmed": True}
+
+
+def test_pipeline_passes_nonce_through(monkeypatch):
+    got = {}
+
+    class _New:
+        def invoke(self, skill, args, confirmed=False, mode="strict", confirm_nonce=""):
+            got["nonce"] = confirm_nonce
+            return "out"
+
+    sk_pipeline._invoke(_New(), SkillSpec(id="s", name="n", description="d"),
+                        {}, True, "abc")
+    assert got["nonce"] == "abc"
+
+
+@pytest.mark.parametrize("bad", ["", "  "])
+def test_empty_nonce_never_authorizes_broker(bad):
+    b = ConfirmationBroker(clock=lambda: 1000.0)
+    b.issue(SESSION, "skill:pay", {"amount": 1})
+    assert b.consume(SESSION, bad, "skill:pay", {"amount": 1}, now=1000.0)[0] is False

package/python/tests/test_context_compaction_wiring.py

@@ -0,0 +1,130 @@
+"""上下文压缩接线回归。
+
+背景:`core/compaction.py` 的 Compactor 实现完整,但长期**零生产调用点**——
+实际生效的只有 `_sanitize_history` 的「按条数砍到 12 条」,长对话/多工具轮
+会直接把 provider 上下文撑爆。本文件锁住三件事:
+
+1. `Compactor.maybe_compact` 的契约(未超预算不产结果、超预算真变小、原样兜底);
+2. `CognitiveAgent._compact_context` 的接入行为(可用 env 关、异常不外泄);
+3. 工具调用循环里**确实**每轮都过压缩闸(`_reply_with_tools`)。
+"""
+
+from __future__ import annotations
+
+from types import SimpleNamespace
+
+import pytest
+
+from foxclaw.agents.base import CognitiveAgent
+from foxclaw.agents.mixins.tool_exec import ToolExecMixin
+from foxclaw.core.compaction import Compactor, estimate_messages_tokens
+
+
+def _long_history(n: int = 12, chars: int = 400) -> list:
+    return [{"role": ("user" if i % 2 == 0 else "assistant"),
+             "content": f"第{i}轮:" + ("内容" * (chars // 2))}
+            for i in range(n)]
+
+
+# ── 1. Compactor.maybe_compact 契约 ─────────────────────────────
+
+def test_maybe_compact_noop_when_under_budget() -> None:
+    msgs = [{"role": "user", "content": "短问题"}]
+    out, res = Compactor(router=None, max_tokens=6000).maybe_compact(msgs)
+    assert res is None, "未超预算不该产生 CompactionResult"
+    assert out == msgs
+
+
+def test_maybe_compact_reduces_tokens_over_budget() -> None:
+    msgs = _long_history()
+    before = estimate_messages_tokens(msgs)
+    out, res = Compactor(router=None, max_tokens=100).maybe_compact(msgs)
+    assert res is not None
+    assert res.method == "truncate", "无 router 时应走截断兜底"
+    assert estimate_messages_tokens(out) < before, "压缩后必须真的更小"
+    assert out != msgs
+
+
+def test_maybe_compact_keeps_system_and_recent() -> None:
+    msgs = [{"role": "system", "content": "系统提示"}] + _long_history()
+    out, _ = Compactor(router=None, max_tokens=100).maybe_compact(msgs)
+    assert out[0].get("role") == "system", "系统提示必须保留"
+    assert any(m.get("role") == "assistant" for m in out), "近期消息应保留"
+
+
+def test_maybe_compact_never_raises_on_garbage() -> None:
+    out, res = Compactor(router=None, max_tokens=1).maybe_compact([{"role": None}])
+    assert isinstance(out, list)
+
+
+# ── 2. CognitiveAgent._compact_context 接入层 ────────────────────────
+
+def _stub_agent(thoughts: list) -> SimpleNamespace:
+    return SimpleNamespace(router=None,
+                           _think=lambda **kw: thoughts.append(kw.get("content", "")))
+
+
+def test_compact_context_applies_and_records_thought(monkeypatch) -> None:
+    monkeypatch.setenv("FOXCLAW_CONTEXT_MAX_TOKENS", "100")
+    thoughts: list = []
+    msgs = _long_history()
+    out = CognitiveAgent._compact_context(_stub_agent(thoughts), msgs, "chat")
+    assert estimate_messages_tokens(out) < estimate_messages_tokens(msgs)
+    assert any("上下文压缩[chat]" in t for t in thoughts), "压缩后应留可观测痕迹"
+
+
+def test_compact_context_noop_when_disabled(monkeypatch) -> None:
+    monkeypatch.setenv("FOXCLAW_CONTEXT_MAX_TOKENS", "0")
+    msgs = _long_history()
+    out = CognitiveAgent._compact_context(_stub_agent([]), msgs, "chat")
+    assert out is msgs, "预算置 0 时应整体关闭,原样返回"
+
+
+def test_compact_context_swallows_errors(monkeypatch) -> None:
+    monkeypatch.setenv("FOXCLAW_CONTEXT_MAX_TOKENS", "100")
+    msgs = _long_history()
+    out = CognitiveAgent._compact_context(SimpleNamespace(router=None), msgs, "chat")
+    assert isinstance(out, list)          # _think 缺失 → 内部异常被吞,不影响主流程
+
+
+# ── 3. 工具调用循环里确实过闸 ───────────────────────────────────
+
+class _NoToolRouter:
+    """supports_tools=True 但模型直接给答案:只跑一轮,便于断言压缩闸被调用。"""
+
+    def supports_tools(self) -> bool:
+        return True
+
+    def call_tools(self, system, messages, schemas, tool_choice=None, agent_id=None) -> dict:
+        return {"supported": True, "tool_calls": [], "text": "好的"}
+
+
+class _RecordingAgent(ToolExecMixin):
+    AGENT_ID = "test"
+
+    def __init__(self) -> None:
+        self.router = _NoToolRouter()
+        self.system_prompt = "sys"
+        self.stages: list = []
+
+    def _compact_context(self, messages, stage: str = "") -> list:
+        self.stages.append(stage)
+        return messages
+
+    def _think(self, **kwargs) -> None:
+        return
+
+
+def test_reply_with_tools_compacts_each_round() -> None:
+    agent = _RecordingAgent()
+    out = agent._reply_with_tools("任务", [{"role": "user", "content": "hi"}])
+    assert out == "好的"
+    assert agent.stages == ["tool_loop"], "工具轮每轮都应过上下文压缩闸"
+
+
+@pytest.mark.parametrize("limit", ["6000", "0"])
+def test_context_env_parsing(monkeypatch, limit) -> None:
+    monkeypatch.setenv("FOXCLAW_CONTEXT_MAX_TOKENS", limit)
+    msgs = [{"role": "user", "content": "x"}]
+    out = CognitiveAgent._compact_context(_stub_agent([]), msgs, "chat")
+    assert isinstance(out, list)

package/python/tests/test_dispatch.py

@@ -0,0 +1,95 @@
+"""
+D 阶段测试 — 主管真实调度子 Agent + 共享记忆。
+验证:
+  1. 主管把任务真实派发给对应子 Agent(关键词路由)
+  2. 子 Agent 结果汇聚回主管
+  3. 调度记录写入共享层,所有 Agent 可召回
+  4. 私有记忆隔离仍然成立(共享层 ≠ 打破隔离)
+"""
+import sys, os, tempfile
+from pathlib import Path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+os.environ["FOXCLAW_SHADOW_ROUNDS"] = "20"
+
+import asyncio
+from foxclaw import Foxclaw
+
+
+def check(cond, msg):
+    if not cond:
+        raise AssertionError(f"✗ {msg}")
+    print(f"  ✓ {msg}")
+
+
+async def main():
+    print("=" * 60)
+    print("D 阶段 · 主管真实调度 + 共享记忆")
+    print("=" * 60)
+    os_ = Foxclaw(data_dir=tempfile.mkdtemp(prefix="foxclaw_dispatch_"), shadow_rounds=20)
+
+    # 1. 主管调度不同类型任务,验证路由
+    print("\n【1】主管真实调度(关键词路由)")
+    routing_cases = [
+        ("分析本月家庭支出预算", "finance"),
+        ("学习一篇关于 RAG 的论文", "office"),
+        # 行政并入办公(日程/会议走 office);"整理邮件"不再有助手 Agent,归办公
+        ("安排周三下午的项目会议", "office"),
+        ("帮我整理今天的邮件要点", "office"),
+    ]
+    bad_routes = []
+    for task, expected in routing_cases:
+        r = await os_.supervisor.run_task(task)
+        dispatched = r.get("result", {}).get("dispatched_to", "?")
+        ok = dispatched == expected
+        if not ok:
+            bad_routes.append(f"「{task[:18]}」→ {dispatched}(预期 {expected})")
+        print(f"  {'✓' if ok else '✗'} 「{task[:18]}」→ {dispatched} (预期 {expected})")
+    check(not bad_routes, f"关键词路由 4/4 命中(失配: {bad_routes or '无'})")
+
+    # 2. 结果汇聚
+    print("\n【2】结果汇聚")
+    r = await os_.supervisor.run_task("评估我的投资组合风险")
+    res = r.get("result", {})
+    print(f"  派给: {res.get('dispatched_to')}")
+    print(f"  汇聚: {str(res.get('sub_result'))[:50]}...")
+    print(f"  主管摘要: {res.get('summary', '')}")
+    # 主管必须真的派出去并拿回子结果,而不是空转返回一句套话
+    check(res.get("dispatched_to") == "finance",
+          f"投资组合风险任务派给 finance(实为 {res.get('dispatched_to')})")
+    check(bool(str(res.get("sub_result") or "").strip()), "子 Agent 结果已汇聚回主管(非空)")
+
+    # 3. 共享记忆:其他 Agent 能召回主管的调度记录
+    print("\n【3】共享记忆层(所有 Agent 可见)")
+    empty_shared = []
+    for viewer in ["office", "finance", "supervisor"]:
+        shared = os_.hmr.recall(query="支出 预算 投资", agent_id=viewer, top_k=5)
+        shared_hits = [m for m in shared if m.get("shared")]
+        if not shared_hits:
+            empty_shared.append(viewer)
+        print(f"  {viewer:<10} 召回共享调度记录: {len(shared_hits)} 条")
+    check(not empty_shared, f"三个 Agent 都能召回共享调度记录(召回为空: {empty_shared or '无'})")
+
+    # 4. 隔离仍成立:私有记忆不跨 Agent
+    print("\n【4】私有记忆隔离(共享层不打破隔离)")
+    await os_.finance.run_task("记录我的私人理财偏好")
+    office_view = os_.hmr.recall(query="理财 偏好", agent_id="office", top_k=10)
+    finance_private = [
+        m for m in office_view
+        if (not m.get("shared")) and "agent:finance" in m.get("tags", [])
+    ]
+    status = "✓" if len(finance_private) == 0 else "✗"
+    print(f"  {status} office 拿到 finance 私有记忆: {len(finance_private)} 条(应为 0)")
+    check(len(finance_private) == 0,
+          f"office 未拿到 finance 私有记忆(泄漏 {len(finance_private)} 条)")
+
+    print("\n" + "=" * 60)
+    print("✓ D 阶段验证完成:双层记忆架构(私有隔离 + 共享协调)成立")
+    print("=" * 60)
+
+
+def test_dispatch():
+    asyncio.run(main())
+
+
+if __name__ == "__main__":
+    asyncio.run(main())