codebee 0.1.72 → 0.1.74

package/app/main.py

@@ -247,6 +247,18 @@ class Handler(BaseHTTPRequestHandler):
                 return self._json(401, {"error": "需要访问令牌（启动 CodeBee 时控制台会显示）"})
             if path == "/api/state":
                 return self._json(200, _state_payload(self._client_id()))
+            if path == "/api/openapi.json":
+                from core import openapi
+                return self._json(200, openapi.document())
+            m = re.match(r"^/api/a2a/tasks/([^/]+)$", path)
+            if m:
+                task = store.get_task(m.group(1))
+                if not task:
+                    return self._json(404, {"error": "not found"})
+                run = store.latest_run_by_task().get(m.group(1))
+                from core import contracts
+                return self._json(200, {"task": task, "run": run,
+                                        "contract": contracts.get(m.group(1))})
             if path == "/api/browse":
                 return self._api_browse()
             if path == "/api/dir/scan":
@@ -266,6 +278,9 @@ class Handler(BaseHTTPRequestHandler):
             if path == "/api/board":
                 # 任务驾驶舱大屏的轻量聚合（KB 级；别让它去拉 /api/state 全量）
                 return self._json(200, board.payload())
+            if path == "/api/analytics":
+                from core import analytics
+                return self._json(200, analytics.summary(store))
             if path == "/api/connect":
                 # 供设置页「手机连接」弹框生成二维码；远程打开需令牌，天然受保护
                 return self._json(200, {"urls": remote.build_connect_urls(PORT),
@@ -303,9 +318,27 @@ class Handler(BaseHTTPRequestHandler):
                 except Exception:
                     pass
                 return self._json(200, v)
+            if path == "/api/plugins":
+                # 本地插件（.codex-plugin/plugin.json 契约）：发现+安装台账的
+                # 聚合视图。坏 manifest 以 blocked/broken 行呈现，不 500。
+                from core import plugins
+                return self._json(200, plugins.view())
             if path == "/api/knowledge":
                 from core import knowledge
                 return self._json(200, knowledge.view())
+            if path == "/api/agents/presence":
+                from core import presence
+                return self._json(200, {"agents": presence.list_agents()})
+            if path == "/api/retrieval/search":
+                from core import retrieval
+                q = parse_qs(urlparse(self.path).query)
+                try:
+                    results = retrieval.search((q.get("q") or [""])[0],
+                                               (q.get("limit") or [10])[0])
+                except ValueError as exc:
+                    return self._json(400, {"error": str(exc)})
+                return self._json(200, {"query": (q.get("q") or [""])[0][:500],
+                                        "results": results})
             if path == "/api/settings":
                 return self._json(200, dict(settings.load(), **jobs.workers_info()))
             if path == "/api/settings-v2":
@@ -532,7 +565,26 @@ class Handler(BaseHTTPRequestHandler):
             m = re.match(r"^/api/tasks/([^/]+)/detail$", path)
             if m:
                 task = store.get_task(m.group(1))
-                return self._json(200, {"task": task}) if task else self._json(404, {"error": "not found"})
+                if not task:
+                    return self._json(404, {"error": "not found"})
+                from core import contracts
+                return self._json(200, {"task": task, "contract": contracts.get(m.group(1))})
+            m = re.match(r"^/api/tasks/([^/]+)/contract$", path)
+            if m:
+                from core import contracts
+                item = contracts.get(m.group(1))
+                return self._json(200, {"contract": item}) if item else self._json(404, {"error": "not found"})
+            m = re.match(r"^/api/tasks/([^/]+)/story-tracking$", path)
+            if m:
+                from core import story_tracking
+                task = store.get_task(m.group(1))
+                if not task:
+                    return self._json(404, {"error": "not found"})
+                try:
+                    return self._json(200, {"state": story_tracking.load(task.get("workdir")),
+                                            "check": story_tracking.check(task.get("workdir"))})
+                except ValueError as exc:
+                    return self._json(409, {"error": str(exc)})
             m = re.match(r"^/api/tasks/([^/]+)/runs$", path)
             if m:
                 # 任务级详情用：该任务全部 run（含 steps），不受前端 run 窗口限制
@@ -540,13 +592,18 @@ class Handler(BaseHTTPRequestHandler):
                     return self._json(404, {"error": "not found"})
                 query = parse_qs(urlparse(self.path).query)
                 if "limit" not in query:
-                    return self._json(200, {"runs": store.task_runs(m.group(1))})
+                    from core import contracts
+                    return self._json(200, {"runs": store.task_runs(m.group(1)),
+                                            "contract": contracts.get(m.group(1))})
                 try:
                     limit = max(1, min(20, int((query.get("limit") or [3])[0])))
                     offset = max(0, int((query.get("offset") or [0])[0]))
                 except (TypeError, ValueError):
                     return self._json(400, {"error": "invalid pagination"})
-                return self._json(200, store.task_runs_page(m.group(1), offset, limit))
+                payload = store.task_runs_page(m.group(1), offset, limit)
+                from core import contracts
+                payload["contract"] = contracts.get(m.group(1))
+                return self._json(200, payload)
             m = re.match(r"^/api/tasks/([^/]+)/bible$", path)
             if m:
                 # 故事圣经：查看（无令牌豁免走 _authed 已过；本机免令牌）
@@ -557,14 +614,15 @@ class Handler(BaseHTTPRequestHandler):
             m = re.match(r"^/api/tasks/([^/]+)/book-meta$", path)
             if m:
                 # 作品信息（番茄/七猫建书表单资料）：读取生成状态与结果。
-                # 连载链沿链继承（都是用第一个）：续写批次读到的就是首批的结果。
+                # 生成可从链上任意任务触发、落点在根任务（都是用第一个），
+                # running/failed 状态也要沿链可见（chain_book_meta）。
                 task = store.get_task(m.group(1))
                 if not task:
                     return self._json(404, {"error": "not found"})
                 return self._json(200, {"book_meta": {
-                    p: store.inherited_book_meta(task, p)
+                    p: store.chain_book_meta(task, p)
                     for p in ("fanqie", "qimao")
-                    if store.inherited_book_meta(task, p)}})
+                    if store.chain_book_meta(task, p)}})
             if path == "/api/publish":
                 # 一键发布：平台连接状态 + 最近台账（详情页发布面板）
                 from core.publish import manager as pub
@@ -758,6 +816,9 @@ class Handler(BaseHTTPRequestHandler):
                 return deny
         if path == "/api/tasks":
             return self._api_create_task()
+        if path == "/api/a2a/tasks":
+            status, resp = self._create_and_start(self._body() or {})
+            return self._json(status, {"protocol": "a2a-lite", **resp})
         if path == "/api/hooks/save":
             # 生命周期钩子配置整表保存（本机设置）
             from core import hooks
@@ -775,6 +836,87 @@ class Handler(BaseHTTPRequestHandler):
             return self._json(200, {"ok": ok, "output": out})
         if path == "/api/tasks/clarify":
             return self._api_task_clarify()
+        if path == "/api/agents/presence":
+            from core import presence
+            body = self._body() or {}
+            try:
+                row = presence.heartbeat(body.get("agent_id"), body.get("label"),
+                                         body.get("capabilities"), body.get("task_id"),
+                                         body.get("status"), body.get("metadata"))
+            except ValueError as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"ok": True, "agent": row})
+        if path == "/api/retrieval/index":
+            from core import retrieval
+            body = self._body() or {}
+            try:
+                if body.get("source"):
+                    row = retrieval.upsert(body.get("source"), body.get("text"), body.get("metadata"), body.get("doc_id"))
+                    return self._json(200, {"ok": True, "document": row})
+                root = body.get("root")
+                if not root:
+                    raise ValueError("root 必填")
+                # Indexing is intentionally scoped to the configured workspace
+                # or an existing task workdir; never accept an arbitrary disk path.
+                allowed = [settings.default_workdir()]
+                task_id = str(body.get("task_id") or "").strip()
+                if task_id:
+                    task = store.get_task(task_id)
+                    if not task:
+                        return self._json(404, {"error": "任务不存在"})
+                    allowed.append(task.get("workdir"))
+                result = retrieval.index_directory(root, limit=body.get("limit") or 500,
+                                                   allowed_roots=allowed)
+            except (ValueError, TypeError) as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"ok": True, **result})
+        m = re.match(r"^/api/tasks/([^/]+)/contract$", path)
+        if m:
+            from core import contracts
+            body = self._body() or {}
+            op = str(body.get("op") or "update").lower()
+            tid = m.group(1)
+            try:
+                if op in ("update", "create"):
+                    item = contracts.create(tid, body)
+                    return self._json(200, {"ok": True, "contract": item})
+                if op == "evidence":
+                    item = contracts.add_evidence(tid, body.get("evidence") or body,
+                                                   actor=body.get("actor") or self._client_name())
+                    return self._json(200, {"ok": True, "contract": item})
+                if op == "approve":
+                    item, err = contracts.approve(tid, body.get("actor") or self._client_name(), body.get("note"))
+                elif op == "reject":
+                    item, err = contracts.reject(tid, body.get("actor") or self._client_name(), body.get("note"))
+                elif op == "blocked":
+                    item, err = contracts.set_blocked(tid, body.get("reason"), body.get("actor") or self._client_name())
+                else:
+                    return self._json(400, {"error": "未知 contract 操作"})
+            except ValueError as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(400 if err else 200, {"error": err} if err else {"ok": True, "contract": item})
+        m = re.match(r"^/api/tasks/([^/]+)/story-tracking$", path)
+        if m:
+            from core import story_tracking
+            task = store.get_task(m.group(1))
+            if not task:
+                return self._json(404, {"error": "not found"})
+            body = self._body() or {}
+            try:
+                if body.get("op") == "init":
+                    state = story_tracking.init(task.get("workdir"), task.get("id"),
+                                                task.get("title"), body.get("premise") or task.get("goal"))
+                else:
+                    state = story_tracking.commit_chapter(
+                        task.get("workdir"), body.get("chapter"), body.get("outline"), body.get("prose"),
+                        facts=body.get("facts"), characters=body.get("characters"),
+                        timeline=body.get("timeline"), foreshadowing=body.get("foreshadowing"),
+                        next_promises=body.get("next_promises"), author_truth=body.get("author_truth"),
+                        reader_known=body.get("reader_known"))
+            except (ValueError, OSError) as exc:
+                return self._json(400, {"error": str(exc)})
+            return self._json(200, {"ok": True, "state": state,
+                                    "check": story_tracking.check(task.get("workdir"))})
         if path == "/api/notify/test":
             # 设置页「发送测试」：向全部已配置推送通道发一条测试消息
             from core import notify
@@ -1048,6 +1190,12 @@ class Handler(BaseHTTPRequestHandler):
             store.update_run(m.group(1), cancelled_by_user=True)
             ok = jobs.cancel(m.group(1))
             return self._json(200, {"ok": ok})
+        m = re.match(r"^/api/runs/([^/]+)/resume_now$", path)
+        if m:
+            # 立即重试：跳过自动续跑的退避等待马上入队（用户点按钮 = 主动
+            # 选择不等退避窗口）。设备控制权由 do_POST 顶部的统一写闸把关。
+            ok, err = jobs.enqueue_now(m.group(1))
+            return self._json(400, {"error": err}) if not ok else self._json(200, {"ok": True})
         m = re.match(r"^/api/runs/([^/]+)/delete$", path)
         if m:
             ok, err = store.delete_run(m.group(1))
@@ -1306,6 +1454,23 @@ class Handler(BaseHTTPRequestHandler):
             from core import knowledge
             n = knowledge.learn_from_run((self._body().get("run_id") or ""))
             return self._json(200, {"ok": True, "learned": n})
+        m = re.match(r"^/api/plugins/([^/]+)/(install|enable|disable|remove)$", path)
+        if m:
+            # 本地插件生命周期：只搬文件+记账（skills 走 market.install_files、
+            # MCP 只暴露声明），永不执行插件代码。前端 loadPlugins 拉的就是
+            # 上面 GET /api/plugins；缺这组路由时设置页会显示「插件加载失败」。
+            from core import plugins
+            pid, op = m.group(1), m.group(2)
+            if op == "install":
+                result, err = plugins.install(pid)
+                if err:
+                    return self._json(400, {"error": err})
+                return self._json(200, result or {"ok": True})
+            if op == "remove":
+                err = plugins.remove(pid)
+                return self._json(400, {"error": err}) if err else self._json(200, {"ok": True})
+            err = plugins.toggle(pid, op == "enable")
+            return self._json(400, {"error": err}) if err else self._json(200, {"ok": True})
         m = re.match(r"^/api/flows/([^/]+)/reset$", path)
         if m:
             err = flows.reset_flow(m.group(1))
@@ -1689,6 +1854,13 @@ class Handler(BaseHTTPRequestHandler):
         task = store.get_task(task_id)
         if not task:
             return self._json(404, {"error": "任务不存在"})
+        if op == "git-merge":
+            from core import contracts
+            contract = contracts.get(task_id)
+            if (contract and contract.get("approval_required")) or task.get("approval_required"):
+                if not contracts.release_allowed(task_id):
+                    return self._json(409, {"error": "任务需要先完成审批，才能合并产物",
+                                            "contract": contract})
         if op == "git-merge":
             from core import operations
             operation_id = operations.begin(
@@ -1751,7 +1923,10 @@ class Handler(BaseHTTPRequestHandler):
 
         后台线程跑（编排者→作者CLI→模板的降级链可能数分钟），请求立即返回；
         前端靠任务 book_meta 状态（SSE 全量状态里带）轮进度。已有 running 时
-        幂等拒绝，不重复起线程。"""
+        幂等拒绝，不重复起线程。生成权不限定首批（2026-09-30 实案：
+        start_chapter>1 的独立任务被误拦，用户点首版也撞墙）——任何任务都能
+        触发；但开书资料属于「这本书」，素材与落点统一取连载链根任务
+        （都是用第一个），续写批次触发的生成整链可见、建书口径不分叉。"""
         from core import bookmeta
         task = store.get_task(task_id)
         if not task:
@@ -1760,27 +1935,22 @@ class Handler(BaseHTTPRequestHandler):
         platform = (body.get("platform") or "").strip()
         if platform not in bookmeta.PLATFORMS:
             return self._json(400, {"error": "platform 必须是 fanqie 或 qimao"})
-        if not bookmeta.needs_book_meta(task):
-            # 生成权留在首批（一本书一份资料）：指路根任务，别让用户在续写批次上撞墙
-            root = next((store.get_task(t) for t
-                         in store.serial_chain_ids(task_id) if t != task_id), None)
-            return self._json(400, {"error": (
-                "开书资料在连载首批任务《%s》上生成与维护，请到首批任务的「作品信息」页操作"
-                % ((root or {}).get("title") or "首批")
-                if root else "只有连载首批任务需要作品信息；续写批次沿用第一批的开书资料")})
-        if task.get("status") in ("queued", "running"):
+        chain = store.serial_chain_ids(task_id)
+        target = (store.get_task(chain[0]) if chain else None) or task
+        target_id = str(target.get("id"))
+        if target.get("status") in ("queued", "running"):
             return self._json(400, {"error": "任务正在运行，请等本轮结束后再生成作品信息"})
-        cur = ((task.get("book_meta") or {}).get(platform) or {})
+        cur = ((target.get("book_meta") or {}).get(platform) or {})
         if cur.get("status") == "running":
             return self._json(200, {"ok": True, "already": True})
-        if not store.set_book_meta(task_id, platform,
+        if not store.set_book_meta(target_id, platform,
                                    {"status": "running",
                                     "at": time.strftime("%Y-%m-%d %H:%M:%S")}):
             return self._json(404, {"error": "任务不存在"})
-        author = bookmeta._resolve_author(task)
+        author = bookmeta._resolve_author(target)
         threading.Thread(target=bookmeta.generate_async, daemon=True,
                          name="book-meta-%s" % platform,
-                         args=(task_id, platform, author)).start()
+                         args=(target_id, platform, author)).start()
         return self._json(200, {"ok": True, "started": True})
 
     def _api_publish_platform_op(self, platform, op):
@@ -1815,6 +1985,12 @@ class Handler(BaseHTTPRequestHandler):
         force = bool(body.get("force"))
         force_confirmed = bool(body.get("force_confirmed"))
         force_reason = str(body.get("force_reason") or "").strip()
+        from core import contracts
+        contract = contracts.get(task_id)
+        if ((contract and contract.get("approval_required")) or task.get("approval_required")) \
+                and not contracts.release_allowed(task_id):
+            return self._json(409, {"error": "任务需要先完成审批，才能发布产物",
+                                    "contract": contract})
         if op == "create-book":
             kwargs = ({"force": force, "force_confirmed": force_confirmed,
                        "force_reason": force_reason}
@@ -1834,6 +2010,13 @@ class Handler(BaseHTTPRequestHandler):
                 if not ap:
                     return self._json(400, {"error": ap_err})
                 ap["enabled"] = False
+            if ap.get("enabled") and ap.get("auto_submit"):
+                from core import contracts
+                contract = contracts.get(task_id)
+                if ((contract and contract.get("approval_required")) or
+                        task.get("approval_required")) and not contracts.release_allowed(task_id):
+                    return self._json(409, {"error": "任务需要先完成审批，才能启用自动提交",
+                                            "contract": contract})
             ok, err = store.set_auto_publish(task_id, ap), ""
             if ok:
                 return self._json(200, {"ok": True, "auto_publish": ap})
@@ -3094,36 +3277,10 @@ def main():
     from core import notify as _notify
     usage_ledger.set_alert_push(_notify.push_text)  # 花费预警推送注入（防 usage→notify 静态环）
     from core import mcp_client as _mcp
+    from core.plugins import merged_servers_text as _plugins_mcp_text
     def _mcp_servers_text():
         """settings 清单 + 已启用插件的 MCP 服务器合成（plugin 名隔离防撞名）。"""
-        import json as _json
-        try:
-            raw = str(settings.load().get("mcp_servers") or "")
-            configured = _json.loads(raw) if raw.strip() else []
-        except Exception:
-            return raw or ""
-        if not isinstance(configured, list):
-            return raw or ""
-        try:
-            from core import plugins as _plugins
-            plugin_servers = _plugins.active_mcp_servers()
-        except Exception:
-            plugin_servers = []          # 坏插件不能连累用户显式配置的服务器
-        import hashlib as _hashlib
-        import re as _re
-        for item in plugin_servers or []:
-            if not isinstance(item, dict):
-                continue
-            plugin_id = str(item.pop("plugin_id", "plugin"))
-            server_name = str(item.get("name") or "server")
-            digest = _hashlib.sha256(
-                (plugin_id + ":" + server_name).encode("utf-8")).hexdigest()[:6]
-            safe = _re.sub(r"[^a-z0-9_-]", "-", plugin_id.lower())
-            item["name"] = ("plg_" + safe[:11] + "_" + digest)[:24]
-            if not any(x.get("name") == item["name"] for x in configured
-                       if isinstance(x, dict)):
-                configured.append(item)
-        return _json.dumps(configured, ensure_ascii=False)
+        return _plugins_mcp_text(settings.load().get("mcp_servers"))
     _mcp.set_settings_text(_mcp_servers_text)  # MCP 清单注入（防 mcp_client→settings 边）
     _step("正在回填用量台账…")
     n_bf = usage.backfill_from_runs()  # 历史运行 token 回填台账（幂等，仅补缺失步骤）

package/app/mcp_server.py

@@ -25,7 +25,9 @@ TOOLS = [
          "goal": {"type": "string", "description": "任务目标（一句话说清要做什么）"},
          "type": {"type": "string", "description": "任务类型 id（如 code/novel/doc/direct），默认 doc"},
          "workdir": {"type": "string", "description": "工作目录绝对路径；留空用 CodeBee 默认保存路径"},
-         "title": {"type": "string", "description": "任务标题；留空取目标前 30 字"}},
+         "title": {"type": "string", "description": "任务标题；留空取目标前 30 字"},
+         "acceptance_criteria": {"type": "array", "items": {"type": "string"}},
+         "approval_required": {"type": "boolean"}},
          "required": ["goal"]}},
     {"name": "get_status", "description": "查任务与最近一次运行的状态：进度、当前步骤、评分、错误。",
      "inputSchema": {"type": "object", "properties": {
@@ -38,6 +40,17 @@ TOOLS = [
     {"name": "bench_leaderboard", "description": "模型评测基准台能力榜（综合分 Top N）。",
      "inputSchema": {"type": "object", "properties": {
          "top": {"type": "integer", "description": "取前 N，默认 5"}}}},
+    {"name": "get_contract", "description": "读取任务验收标准、证据、审批和完成回执。",
+     "inputSchema": {"type": "object", "properties": {
+         "task_id": {"type": "string"}}, "required": ["task_id"]}},
+    {"name": "record_evidence", "description": "向任务契约追加结构化验收证据。",
+     "inputSchema": {"type": "object", "properties": {
+         "task_id": {"type": "string"}, "criterion": {"type": "string"},
+         "status": {"type": "string", "enum": ["passed", "failed", "unknown", "not_evaluated"]},
+         "summary": {"type": "string"}}, "required": ["task_id", "status"]}},
+    {"name": "search_knowledge", "description": "在本地检索索引中搜索带来源和命中词解释的上下文。",
+     "inputSchema": {"type": "object", "properties": {
+         "query": {"type": "string"}, "limit": {"type": "integer"}}, "required": ["query"]}},
 ]
 
 
@@ -57,10 +70,38 @@ def _tool_create_task(args):
                "goal": goal[:4000],
                "workdir": str(args.get("workdir") or "").strip()
                or settings_mod.default_workdir()}
-    task = store.create_task(payload)
-    run = store.create_run("orchestration", task["title"], task_id=task["id"])
-    store.update_task_status(task["id"], "queued")
-    _enqueue({"kind": "orchestration", "run_id": run["id"], "task_id": task["id"]})
+    criteria = args.get("acceptance_criteria")
+    if criteria is not None and not isinstance(criteria, list):
+        return {"isError": True, "content": "acceptance_criteria 必须是列表"}
+    if isinstance(criteria, list):
+        payload["acceptance_criteria"] = [str(x).strip()[:500] for x in criteria if str(x).strip()][:40]
+    approval_required = args.get("approval_required", False)
+    if not isinstance(approval_required, bool):
+        return {"isError": True, "content": "approval_required 必须是布尔值"}
+    payload["approval_required"] = approval_required
+    try:
+        task = store.create_task(payload)
+    except ValueError as exc:
+        return {"isError": True, "content": str(exc)}
+    run = None
+    try:
+        run = store.create_run("orchestration", task["title"], task_id=task["id"])
+        store.update_task_status(task["id"], "queued")
+        _enqueue({"kind": "orchestration", "run_id": run["id"], "task_id": task["id"]})
+    except Exception as exc:
+        # Mirror the HTTP creator: every partially-created task/run is closed
+        # so MCP clients never receive a success while the UI shows queued.
+        if run:
+            try:
+                store.update_run(run["id"], status="failed", error="任务启动失败，请稍后重试",
+                                 ended_at=__import__("time").strftime("%Y-%m-%d %H:%M:%S"))
+            except Exception:
+                pass
+        try:
+            store.update_task_status(task["id"], "failed")
+        except Exception:
+            pass
+        return {"isError": True, "content": "任务启动失败，请稍后重试"}
     return {"content": "已创建并排队：task_id=%s run_id=%s（可用 get_status 查进度）"
             % (task["id"], run["id"])}
 
@@ -121,9 +162,37 @@ def _tool_bench(args):
     return {"content": json.dumps(rows, ensure_ascii=False, indent=1)}
 
 
+def _tool_contract(args):
+    from core import contracts
+    item = contracts.get(str(args.get("task_id") or "").strip())
+    if not item:
+        return {"isError": True, "content": "任务契约不存在"}
+    return {"content": json.dumps(item, ensure_ascii=False, indent=1)}
+
+
+def _tool_evidence(args):
+    from core import contracts
+    try:
+        item = contracts.add_evidence(str(args.get("task_id") or "").strip(), args,
+                                      actor=str(args.get("actor") or "mcp")[:120])
+    except ValueError as exc:
+        return {"isError": True, "content": str(exc)}
+    return {"content": json.dumps(item, ensure_ascii=False, indent=1)}
+
+
+def _tool_search(args):
+    from core import retrieval
+    try:
+        rows = retrieval.search(args.get("query"), args.get("limit") or 10)
+    except (TypeError, ValueError) as exc:
+        return {"isError": True, "content": str(exc)}
+    return {"content": json.dumps(rows, ensure_ascii=False, indent=1)}
+
+
 _TOOL_IMPL = {"create_task": _tool_create_task, "get_status": _tool_get_status,
               "list_recent": _tool_list_recent, "usage_summary": _tool_usage_summary,
-              "bench_leaderboard": _tool_bench}
+              "bench_leaderboard": _tool_bench, "get_contract": _tool_contract,
+              "record_evidence": _tool_evidence, "search_knowledge": _tool_search}
 
 
 def handle_request(msg):