foxclaw 0.1.2 → 0.1.3

package/python/foxclaw/api/routes/knowledge.py

@@ -1,6 +1,6 @@
 """知识核心(HKC)端点:同进程 DirectClient,惰性装配,缺依赖降级。
 
-从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api._os_instance`
+从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api.current_os()`
 晚绑定读取;路由用 `@app` 装饰器在 import 时注册。
 """
 
@@ -13,13 +13,9 @@ import foxclaw.api as _api
 from .. import app
 
 
-# ── 知识核心(HKC)：同进程 DirectClient,惰性装配,缺依赖降级 ─────────
-# HKC = Foxclaw Knowledge Core:KDE 抽取 → KEE 演化 → 混合检索(BM25+向量+图)。
-# 首次命中任一路由时才装配(见 Foxclaw.hkc 惰性属性);未 vendor/缺依赖时 available=False。
-
 class KnowledgeSearchPayload(BaseModel):
     query: str
-    mode: str = "hybrid"          # bm25 | vector | graph | hybrid
+    mode: str = "hybrid"
     top_k: int = 10
     domain: str = ""
 
@@ -33,15 +29,11 @@ class KnowledgeIngestPayload(BaseModel):
 def _hkc_or_none():
     """惰性取 HKCService;None 表示降级(未 vendor/缺依赖/装配失败)。"""
     try:
-        return _api._os_instance.hkc
+        return _api.os_instance().hkc
     except Exception:
         return None
 
 
-# 【P3-7】异常分类用 isinstance 优先:hasattr(e, "missing_skills") 是鸭子判断,
-# 任何恰好带了同名属性的无关异常都会被误吞成「覆盖不足」证据 gate(真实错误被掩盖)。
-# 真实类型在 vendor 的 hkc_sdk.exceptions(test_hkc.py 同源引用);缺 vendor/hkc 时
-# import 失败降级 None,运行时回退 hasattr 判断,行为与旧版一致。
 try:
     from hkc_sdk.exceptions import HKCInsufficientCoverage as _HKCInsuffCov
 except Exception:
@@ -76,9 +68,6 @@ async def knowledge_ingest(p: KnowledgeIngestPayload):
             hkc.client.ingest_text, p.text, p.source_title, p.domain)
         return {"ku_count": res.ku_count, "ku_ids": res.ku_ids, "counts": res.counts}
     except Exception as e:
-        # 抽取全段失败时 KDE 现在会抛错(带 provider/model/最后一次 LLM 报错原文)。
-        # 不能像旧版那样返回 ku_count=0 + 200 —— 那会让「库里其实什么都没有」看起来
-        # 像「录入成功只是没内容」,复习板块于是永远 0 卡。
         msg = str(e).strip() or e.__class__.__name__
         raise HTTPException(502, f"摄入失败:{msg}")
 
@@ -103,7 +92,6 @@ async def knowledge_recent(limit: int = 10):
     except Exception as e:
         return {"available": True, "total": 0, "kus": [], "error": str(e)}
 
-    # ISO 字符串,字典序即时间序
     kus.sort(key=lambda k: getattr(k, "created_at", "") or "", reverse=True)
     n = max(1, min(int(limit or 10), 200))
     return {"available": True, "total": len(kus), "kus": [
@@ -114,7 +102,6 @@ async def knowledge_recent(limit: int = 10):
         for ku in kus[:n]]}
 
 
-# ── HKC 融合第 2 档 Step1:ACE 能力(只读查询面,无 LLM、零成本)─────────
 @app.get("/api/knowledge/abilities")
 async def knowledge_abilities():
     """列出可编译的能力 key(来自 ACE skill_taxonomy)。只读、确定性、无 LLM。"""
@@ -139,11 +126,6 @@ async def knowledge_ability(ability_key: str):
     try:
         ab = await asyncio.to_thread(hkc.client.compile_ability, ability_key)
     except Exception as e:
-        # 覆盖不足(HKCInsufficientCoverage 带 coverage/missing_skills)→ 证据 gate,非错误。
-        # 【P3-7】isinstance 可用时**只**用 isinstance(精确判断:带 missing_skills 属性的
-        # 无关异常不再被误吞成「覆盖不足」);import 失败(缺 vendor)才回退 hasattr 鸭子判断。
-        # 文稿骨架写的是 isinstance OR hasattr 叠加,与其自身设计决策(「失败才回退」=二选一)
-        # 不一致——OR 下鸭子判断永远生效,精确化形同虚设,故按设计决策实现。
         if _HKCInsuffCov is not None:
             is_insufficient = isinstance(e, _HKCInsuffCov)
         else:

package/python/foxclaw/api/routes/llm_admin.py

@@ -28,7 +28,6 @@ CUSTOM_MODELS_PATH = _DATA_DIR / "custom_models.json"
 CURRENT_MODEL_PATH = _DATA_DIR / ".current_model"
 
 
-# 预置 provider(展示用:标签 + 配色 + 探测 key 名)
 _PRESET_PROVIDERS = [
     {"provider": "generic",   "label": "通用 OpenAI 兼容", "color": "#7e93b8"},
     {"provider": "anthropic", "label": "Claude",            "color": "#ff9d00"},
@@ -52,8 +51,6 @@ _PROVIDER_KEY_ENV = {
 }
 
 
-# ── 工具 ─────────────────────────────────────────────────
-
 def _save_key(name: str, key: str) -> dict:
     """把 key 存到最安全的地方,返回该写进 custom_models.json 的字段。
 
@@ -98,7 +95,8 @@ def _sync_hkc_llm() -> None:
     extractor 自带 ``reconfigure``(HKC 自己的界面也用它),这里复用同一条路径。
     """
     try:
-        hkc = _api._os_instance.hkc if _api._os_instance else None
+        os_inst = _api.current_os()
+        hkc = os_inst.hkc if os_inst is not None else None
         if hkc is None or not getattr(hkc, "available", False):
             return
         from foxclaw.knowledge import _detect_llm
@@ -109,12 +107,10 @@ def _sync_hkc_llm() -> None:
             model=model or None,
             base_url=base or None,
         )
-    except Exception as e:      # 同步失败绝不影响"切模型"这个主操作
+    except Exception as e:
         print(f"[llm_admin] 同步知识抽取(HKC)配置失败: {e}")
 
 
-# ── 端点 ─────────────────────────────────────────────────
-
 @app.get("/api/llm/models")
 async def list_models():
     """列出所有可用模型:预置(按 .env 探测) + 自定义(从 custom_models.json) + 当前选中。"""
@@ -143,7 +139,7 @@ async def list_models():
 
 
 class _SelectReq(BaseModel):
-    source: str                  # "auto" | "preset" | "custom"
+    source: str
     provider: Optional[str] = None
     name: Optional[str] = None
 
@@ -155,7 +151,8 @@ async def select_model(req: _SelectReq):
     (key 空 / BASE URL 非法 / 记录已被删),前端显示"已切换",聊天却继续走旧 provider,
     用户看到的是"填了填不上"。现在选中前先自检,失败直接 400 带原因。
     """
-    router = _api._os_instance.router if _api._os_instance else None
+    os_inst = _api.current_os()
+    router = os_inst.router if os_inst is not None else None
     if req.source == "auto":
         if CURRENT_MODEL_PATH.exists():
             CURRENT_MODEL_PATH.unlink()
@@ -171,24 +168,25 @@ async def select_model(req: _SelectReq):
             raise HTTPException(400, f"{req.provider} 未在 .env 配置 Key({env_key})")
         data = {"source": "preset", "provider": req.provider}
     elif req.source == "custom":
+        name = req.name
+        if not name:
+            raise HTTPException(400, "缺少自定义模型名称 name")
         models = _load_custom()
-        match = next((m for m in models if m.get("name") == req.name), None)
+        match = next((m for m in models if m.get("name") == name), None)
         if not match:
-            raise HTTPException(404, f"未找到自定义模型: {req.name}")
-        # 预检:能不能真构造出 client(否则"切换成功"是假象)
+            raise HTTPException(404, f"未找到自定义模型: {name}")
         if router is not None:
-            client, _model, err = router._build_custom_client(req.name)
+            client, _model, err = router._build_custom_client(name)
             if client is None:
                 raise HTTPException(400, f"该自定义模型不可用: {err}")
-        data = {"source": "custom", "name": req.name, "model_id": match.get("model", "")}
+        data = {"source": "custom", "name": name, "model_id": match.get("model", "")}
     else:
         raise HTTPException(400, f"未知 source: {req.source}")
     CURRENT_MODEL_PATH.parent.mkdir(parents=True, exist_ok=True)
     CURRENT_MODEL_PATH.write_text(json.dumps(data, ensure_ascii=False), encoding="utf-8")
-    # 立即 reload(mtime 变了);正常聊天路径也会 lazy reload,这里只是让 /runtime 立刻正确
     if router is not None:
         router._maybe_reload_selection()
-    _sync_hkc_llm()      # 知识抽取跟着切,别让它继续用旧 key
+    _sync_hkc_llm()
     return {"ok": True, "current": data,
             "runtime": ({"provider": router.provider,
                          "model": getattr(router, "model", ""),
@@ -248,7 +246,7 @@ class _CustomUpdateReq(BaseModel):
     api_key:       Optional[str] = None
     model:         Optional[str] = None
     extra_headers: Optional[Dict[str, str]] = None
-    group_id:      Optional[str] = None   # 显式空字符串 = 移除 MiniMax-Group-Id header
+    group_id:      Optional[str] = None
     note:          Optional[str] = None
 
 
@@ -262,7 +260,6 @@ async def get_custom_model(name: str):
         raise HTTPException(404, f"未找到: {name}")
     extra = dict(match.get("extra_headers") or {})
     gid = extra.get("MiniMax-Group-Id", "")
-    # extra_headers 拆成 group_id + 其它(避免两边都返回重复键)
     extra_only = {k: v for k, v in extra.items() if k != "MiniMax-Group-Id"}
     return {
         "name":          match.get("name", ""),
@@ -291,18 +288,15 @@ async def update_custom_model(name: str, req: _CustomUpdateReq):
         raise HTTPException(404, f"未找到: {name}")
     target = models[idx]
 
-    # 改名冲突检测
     new_name = (req.name or "").strip() or target["name"]
     if new_name != name and any(m.get("name") == new_name for m in models):
         raise HTTPException(409, f"已存在同名模型: {new_name}")
 
-    # 必填校验
     if req.base_url is not None and not req.base_url.strip():
         raise HTTPException(400, "base_url 不能为空")
     if req.model is not None and not req.model.strip():
         raise HTTPException(400, "model 不能为空")
 
-    # 应用普通字段
     if req.base_url is not None:
         try:
             target["base_url"] = normalize_base_url(req.base_url)
@@ -311,12 +305,10 @@ async def update_custom_model(name: str, req: _CustomUpdateReq):
     if req.model is not None:
         target["model"] = req.model.strip()
     if req.api_key is not None and req.api_key.strip():
-        # 留空 = 保留原 key(防误清);非空 = 覆盖(按新名字存,改名时不会留下孤儿条目)
         target.update(_save_key(new_name, req.api_key))
     if req.note is not None:
         target["note"] = req.note
 
-    # extra_headers + group_id 合并处理
     if req.extra_headers is not None or req.group_id is not None:
         extra = dict(target.get("extra_headers") or {})
         if req.extra_headers is not None:
@@ -329,10 +321,7 @@ async def update_custom_model(name: str, req: _CustomUpdateReq):
                 extra.pop("MiniMax-Group-Id", None)
         target["extra_headers"] = extra
 
-    # 改名:同步 .current_model
     if new_name != name:
-        # 凭据按模型名存放 → 不改名搬迁就再也 load 不到(key 静默丢失)。
-        # 已换新 key 时新条目已在 new_name 下,这里只需清掉旧的。
         if req.api_key is not None and req.api_key.strip():
             _secrets.delete(name)
         else:
@@ -361,8 +350,7 @@ async def delete_custom_model(name: str):
     if len(new_models) == len(models):
         raise HTTPException(404, f"未找到: {name}")
     _save_custom(new_models)
-    _secrets.delete(name)        # 别在 OS 凭据库里留孤儿条目
-    # 如果当前选的就是它 → 清空选择
+    _secrets.delete(name)
     if CURRENT_MODEL_PATH.exists():
         try:
             cur = json.loads(CURRENT_MODEL_PATH.read_text(encoding="utf-8"))
@@ -374,7 +362,7 @@ async def delete_custom_model(name: str):
 
 
 class _TestReq(BaseModel):
-    source: str                  # "preset" | "custom"
+    source: str
     provider: Optional[str] = None
     name: Optional[str] = None
 
@@ -391,7 +379,8 @@ async def test_model(req: _TestReq):
     if req.source == "preset":
         if not req.provider:
             raise HTTPException(400, "preset 必须给 provider")
-        router = _api._os_instance.router if _api._os_instance else None
+        os_inst = _api.current_os()
+        router = os_inst.router if os_inst is not None else None
         if router is None:
             raise HTTPException(503, "OS 未就绪")
         client, err = router._build_client(req.provider)
@@ -444,11 +433,10 @@ async def test_model(req: _TestReq):
 @app.get("/api/llm/runtime")
 async def get_runtime():
     """当前真正生效的 provider/model(供前端高亮 + 调试)。"""
-    router = _api._os_instance.router if _api._os_instance else None
+    os_inst = _api.current_os()
+    router = os_inst.router if os_inst is not None else None
     if router is None:
         return {"ok": False, "error": "OS 未就绪"}
-    # runtime 端点也走 lazy reload,让前端选完模型 → 立刻看到生效值
-    # (complete() 入口也会调;这里额外调一次,GET 路径无副作用)
     try:
         router._maybe_reload_selection()
     except Exception:

package/python/foxclaw/api/routes/memory.py

@@ -1,7 +1,7 @@
 """记忆统计 / 会话历史 / 用户偏好 路由。
 
-从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api._os_instance`
-晚绑定读取(保持测试可重绑定 `api._os_instance`);路由用 `@app` 装饰器在 import 时注册。
+从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api.current_os()`
+晚绑定读取(状态在 `_state`,测试可重绑 `_state._os_instance`);路由用 `@app` 装饰器在 import 时注册。
 """
 
 from fastapi import HTTPException
@@ -15,12 +15,11 @@ from .. import app
 async def get_memory_stats():
     """记忆中心统计:供前端 vecRecall 面板展示真实数字。"""
     try:
-        return _api._os_instance.hmr.stats()
+        return _api.os_instance().hmr.stats()
     except Exception:
         return {"backend": "?", "total_memories": 0, "relations": 0}
 
 
-# ── 会话历史 ───────────────────────────────────────────────
 class SessionCreate(BaseModel):
     title: str = ""
     agent_id: str = "supervisor"
@@ -34,7 +33,7 @@ class SessionRename(BaseModel):
 async def list_sessions(limit: int = 50):
     """会话列表(按更新时间倒序,轻字段不含 messages)。"""
     try:
-        return {"sessions": _api._os_instance.sessions.list(limit)}
+        return {"sessions": _api.os_instance().sessions.list(limit)}
     except Exception:
         return {"sessions": []}
 
@@ -42,13 +41,13 @@ async def list_sessions(limit: int = 50):
 @app.post("/api/sessions")
 async def create_session(req: SessionCreate):
     """新建会话。"""
-    return _api._os_instance.sessions.create(req.title, req.agent_id)
+    return _api.os_instance().sessions.create(req.title, req.agent_id)
 
 
 @app.get("/api/sessions/{sid}")
 async def get_session(sid: str):
     """取单个会话(含完整 messages),供前端恢复对话。"""
-    d = _api._os_instance.sessions.get(sid)
+    d = _api.os_instance().sessions.get(sid)
     if d is None:
         raise HTTPException(404, "会话不存在")
     return d
@@ -56,19 +55,19 @@ async def get_session(sid: str):
 
 @app.post("/api/sessions/{sid}/rename")
 async def rename_session(sid: str, req: SessionRename):
-    return {"ok": _api._os_instance.sessions.rename(sid, req.title)}
+    return {"ok": _api.os_instance().sessions.rename(sid, req.title)}
 
 
 @app.delete("/api/sessions/{sid}")
 async def delete_session(sid: str):
-    return {"ok": _api._os_instance.sessions.delete(sid)}
+    return {"ok": _api.os_instance().sessions.delete(sid)}
 
 
 @app.get("/api/memory/recent")
 async def get_recent_memories(limit: int = 20):
     """最近的记忆条目(倒序),供前端右栏"记忆信息条"。轻字段,不含 embedding。"""
     try:
-        fn = getattr(_api._os_instance.hmr, "recent", None)
+        fn = getattr(_api.os_instance().hmr, "recent", None)
         return {"memories": fn(limit) if callable(fn) else []}
     except Exception:
         return {"memories": []}
@@ -78,12 +77,29 @@ async def get_recent_memories(limit: int = 20):
 async def list_preferences():
     """列出已记住的用户偏好(供查看/清理误存)。偏好是 shared,任一 Agent 视角一致,
     这里用主管取全量(偏好是 shared,任一 Agent 视角一致)。返回 [{id, content, ...}]。"""
-    ag = _api._os_instance.supervisor
+    ag = _api.os_instance().supervisor
     return {"preferences": ag.list_preferences()}
 
 
 @app.delete("/api/preferences/{pref_id}")
 async def delete_preference(pref_id: str):
     """删一条误存的用户偏好(F3:防误报偏好持久注入污染)。返回 {ok}。"""
-    ag = _api._os_instance.supervisor
+    ag = _api.os_instance().supervisor
     return {"ok": ag.delete_preference(pref_id)}
+
+
+class ProfilePayload(BaseModel):
+    nickname: str = ""
+
+
+@app.get("/api/profile")
+async def get_profile():
+    """当前称呼。没设置过返回空串(前端据此决定要不要显示首次引导)。"""
+    return {"nickname": _api.os_instance().supervisor.get_nickname()}
+
+
+@app.put("/api/profile")
+async def update_profile(payload: ProfilePayload):
+    """设置称呼。传空串 = 清除。返回生效后的值(已 trim/截断)。"""
+    nick = _api.os_instance().supervisor.set_nickname(payload.nickname)
+    return {"ok": True, "nickname": nick}

package/python/foxclaw/api/routes/orchestration.py

@@ -1,6 +1,6 @@
 """主管编排端点(全局态势 + 跨 Agent)。
 
-从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api._os_instance`
+从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api.current_os()`
 晚绑定读取;路由用 `@app` 装饰器在 import 时注册。
 """
 
@@ -11,13 +11,11 @@ import foxclaw.api as _api
 from .. import app
 
 
-# ── 主管编排端点（全局态势 + 跨 Agent)──────────────────────
-
 @app.get("/api/orchestration/situation")
 async def global_situation():
     """主管全局态势:三内核状态汇总 + 跨域告警(驾驶舱视图)。"""
     try:
-        return _api._os_instance.supervisor.global_situation()
+        return _api.os_instance().supervisor.global_situation()
     except Exception as e:
         raise HTTPException(500, f"态势汇总失败: {e}")
 
@@ -34,7 +32,7 @@ class CrossReqPayload(BaseModel):
 async def cross_request(p: CrossReqPayload):
     """跨 Agent 请求:目标 Agent 用守门人裁决(如行程申请差旅预算)。"""
     try:
-        return _api._os_instance.supervisor.cross_request(
+        return _api.os_instance().supervisor.cross_request(
             from_agent=p.from_agent, to_agent=p.to_agent,
             request_type=p.request_type, payload=p.payload, reason=p.reason)
     except Exception as e:

package/python/foxclaw/api/routes/recovery.py

@@ -16,7 +16,7 @@ from .. import app
 @app.get("/api/recovery/status")
 async def recovery_status():
     """中断任务清单 + 每任务最近步骤 + 续跑所需 context(直接可回灌 /api/task)。"""
-    os_ = _api._os_instance
+    os_ = _api.current_os()
     if os_ is None:
         return {"enabled": False, "interrupted": [], "plan": {}}
     rec = getattr(os_, "recovery", None)
@@ -34,10 +34,11 @@ async def recovery_status():
             "channel": t.channel,
             "status": t.status,
             "steps_count": len(steps),
-            "last_steps": steps[-10:],      # 只回最近 10 步,避免响应体失控
+            "last_steps": steps[-10:],
             "resume_hint": {"endpoint": "/api/task",
                             "context": {"_resume_task_id": t.task_id}},
         })
     plan = getattr(os_, "recovery_plan", None)
+    as_dict = getattr(plan, "to_dict", None)
     return {"enabled": rec is not None, "interrupted": out,
-            "plan": plan.to_dict() if hasattr(plan, "to_dict") else {}}
+            "plan": as_dict() if callable(as_dict) else {}}

package/python/foxclaw/api/routes/review.py

@@ -23,12 +23,8 @@ _SR = SpacedRepetition()
 
 _CARD_TYPES = {"Concept", "Fact", "Claim", "Entity"}
 
-# 扫描上限(每种卡片类型)。之前统一 query_all(4000),一是把 Evidence 这种绝对不会
-# 成卡的原文出处也一起拉出来(大文档导入后它是绝大多数行),二是 4000 之后的部分
-# 会被静默截断 → 复习统计少算。这里只查四种卡片类型,上限给到实际用不满的量级。
 _SCAN_LIMIT = 50000
 
-# ReviewState.to_dict() 会额外塞 mastery / is_due,读回来时必须剔掉才能重建
 _STATE_FIELDS = ("repetitions", "interval", "ease_factor", "due_date",
                  "last_review", "total_reviews", "lapses")
 
@@ -36,7 +32,7 @@ _STATE_FIELDS = ("repetitions", "interval", "ease_factor", "due_date",
 def _store():
     """惰性取 HKC 的 graph_store,None 表示知识库没装配好(降级成空队列)。"""
     try:
-        hkc = _api._os_instance.hkc
+        hkc = _api.os_instance().hkc
         if hkc is None or not hkc.available:
             return None
         return hkc.container.graph_store
@@ -73,7 +69,7 @@ def _hours_left(state) -> float:
 
 def _load7(learned) -> dict:
     """未来 7 天(0..6)的复习负荷,口径与队列一致。"""
-    by_day = {}
+    by_day: dict[str, int] = {}
     for s in learned:
         d = 0 if s.is_due else _days_left(s)
         if d <= 6:
@@ -251,11 +247,6 @@ async def review_grade(body: GradeIn):
         if ku is None or _status_of(ku) != "active":
             raise HTTPException(404, f"没有这条知识:{body.ku_id}")
 
-        # 关键:只更新 extra 这一列,而且「读 extra → SM-2 推演 → 写回」整段在
-        # graph_store 的锁里完成。走 put() 是整行 UPSERT,会把整行其它列按写入前的
-        # 快照回写 —— 知识星球正在摄入时,KEE 刚合并进去的 sources / confidence /
-        # supports 会被这次评分悄悄冲掉(反向亦然:复习进度被 KEE 写回覆盖)。
-        # 锁内做还有个好处:连点两次评分不会两次都基于同一份旧状态推演。
         graded: list[ReviewState] = []
 
         def _apply(extra: dict) -> dict:

package/python/foxclaw/api/routes/search.py

@@ -1,6 +1,6 @@
 """认知搜索(HSR)端点:内部记忆 + 内部知识 + 联网,统一证据融合。
 
-从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api._os_instance`
+从 foxclaw/api.py 原样搬移(纯搬移,零行为变更)。共享 OS 实例经 `_api.current_os()`
 晚绑定读取;路由用 `@app` 装饰器在 import 时注册。
 """
 
@@ -13,15 +13,11 @@ import foxclaw.api as _api
 from .. import app
 
 
-# ── 认知搜索(HSR)：内部记忆 + 内部知识 + 联网,统一证据融合 ─────────
-# 一次 search() 统一"查 HMR 记忆 / 查 HKC 知识 / 联网(百度)",走 planner→retriever→
-# fusion→strategy 迭代循环(有上限),只产出证据图,不写任何持久化(边界:不代 Agent 决策)。
-
 class SearchQueryPayload(BaseModel):
     query: str
     agent_id: str = "supervisor"
     context: dict = {}
-    internal_only: bool = False   # True=只查内部(HMR+HKC+Agent态势),跳过联网
+    internal_only: bool = False
 
 
 @app.post("/api/search/query")
@@ -29,7 +25,7 @@ async def search_query(p: SearchQueryPayload):
     """认知搜索(面向 AI/Agent 的证据管线):返回证据图 + 置信度 + 迭代轨迹。
     internal_only=True 时只查内部三源(记忆/知识/Agent),不联网。搜索内核惰性构造。"""
     try:
-        rt = _api._os_instance.search_runtime
+        rt = _api.os_instance().search_runtime
         result = await asyncio.to_thread(
             rt.search, p.query, p.agent_id, p.context, p.internal_only)
         return result.to_dict()