union-py-app-stream-chat 1.0.0 → 1.1.0

package/README.md

@@ -14,10 +14,10 @@ glm-ops-assistant/
 │   ├── service/
 │   │   └── chat_service.py      # Service 层 - 业务逻辑（问题筛选、流程编排）
 │   ├── manager/
-│   │   ├── llm_manager.py       # Manager 层 - GLM SDK 调用封装
-│   │   └── session_manager.py   # Manager 层 - 多轮会话管理
+│   │   └── toolcall_manager.py  # Manager 层 - 工具调用封装
 │   ├── core/
-│   │   └── config_loader.py     # 核心工具 - 配置加载（支持环境变量覆盖）
+│   │   ├── config_loader.py     # 核心工具 - 配置加载（支持环境变量覆盖）
+│   │   └── logging_config.py    # 核心工具 - 日志配置
 │   └── models/
 │       └── schemas.py           # Pydantic 数据模型
 ├── tests/
@@ -48,8 +48,10 @@ llm:
 或通过环境变量覆盖：
 
 ```bash
+export APP_CONFIG_PATH="/path/to/config.yaml"
 export LLM_API_KEY="your-api-key"
 export LLM_MODEL="glm-4-flash"
+export RAG_ENABLED="true"
 ```
 
 ### 3. 启动服务
@@ -64,10 +66,7 @@ uvicorn main:app --host 0.0.0.0 --port 8000 --reload
 
 | 方法 | 路径 | 说明 |
 |------|------|------|
-| POST | `/api/v1/chat` | 普通对话（非流式） |
 | POST | `/api/v1/chat/stream` | 流式对话（SSE） |
-| POST | `/api/v1/session/clear` | 清空会话历史 |
-| GET | `/api/v1/session/info` | 获取会话信息 |
 | GET | `/api/v1/health` | 健康检查 |
 
 ## 多轮对话
@@ -83,3 +82,18 @@ uvicorn main:app --host 0.0.0.0 --port 8000 --reload
 ## 流式输出
 
 调用 `/api/v1/chat/stream` 接口，服务端使用 SSE 协议逐字推送模型生成内容。
+
+每条 `message` 事件的 `data` 为 `ChatResponse` JSON：
+
+```json
+{
+  "session_id": "sess-xxx",
+  "content": "正式回复增量",
+  "reasoning_content": null,
+  "tool_call": null,
+  "tool_result": null,
+  "finish_reason": null
+}
+```
+
+模型正式回复写入 `content`，推理内容写入 `reasoning_content`，工具过程写入 `tool_call` / `tool_result`。

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "union-py-app-stream-chat",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "Source package for the union operations stream chat Python app.",
   "license": "UNLICENSED",
   "private": false,

package/src/api/routes.py

@@ -1,11 +1,16 @@
-import json
 from fastapi import APIRouter
 from sse_starlette.sse import EventSourceResponse, ServerSentEvent
 
-from src.models.schemas import ChatRequest
+from src.models.schemas import ChatRequest, ChatResponse
 from src.manager.toolcall_manager import ToolCallManager
 
 router = APIRouter()
+tool_call_manager = ToolCallManager()
+
+
+@router.get("/health")
+def health_check():
+    return {"status": "ok"}
 
 
 @router.post("/chat/stream")
@@ -16,19 +21,18 @@ def chat_stream_endpoint(request: ChatRequest):
     - 接收用户问题
     - 逐块返回生成的内容
     """
-    manager = ToolCallManager()
-
     def event_generator():
-        for chunk in manager.tool_call_stream(request.session_id, request.question):
+        for chunk in tool_call_manager.tool_call_stream(request.session_id, request.question):
             yield ServerSentEvent(
                 event="message",
-                data=json.dumps(chunk, ensure_ascii=False),
+                data=chunk.model_dump_json(),
             )
 
         # SSE 结束标记
+        done = ChatResponse(session_id=request.session_id, finish_reason="done")
         yield ServerSentEvent(
             event="done",
-            data=json.dumps({"session_id": request.session_id, "finish_reason": "done"}, ensure_ascii=False),
+            data=done.model_dump_json(),
         )
 
     return EventSourceResponse(event_generator())

package/src/core/config_loader.py

@@ -1,26 +1,25 @@
 import os
+import threading
 import yaml
 from typing import Any, Dict
 
+from src.core.logging_config import get_logger
 
-class ConfigLoader:
-    """配置加载器，支持从YAML文件加载配置，并可通过环境变量覆盖。"""
 
-    _instance = None
-    _config = None
+logger = get_logger(__name__)
 
-    def __new__(cls, *args, **kwargs):
-        if not cls._instance:
-            cls._instance = super().__new__(cls)
-        return cls._instance
 
-    def __init__(self, config_path: str = None):
-        if self._config is not None:
-            return
+class ConfigLoader:
+    """配置加载器，支持从YAML文件加载配置，并可通过环境变量覆盖。"""
 
+    def __init__(self, config_path: str = None):
+        base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
         if config_path is None:
-            base_dir = os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-            config_path = os.path.join(base_dir, "config", "config.yaml")
+            config_path = os.environ.get("APP_CONFIG_PATH") or os.path.join(base_dir, "config", "config.yaml")
+            if not os.path.exists(config_path):
+                fallback_path = os.path.join(base_dir, "config", "config.example.yaml")
+                logger.warning("配置文件不存在，使用示例配置。config_path=%s fallback=%s", config_path, fallback_path)
+                config_path = fallback_path
 
         self._config_path = config_path
         self._config = self._load_yaml()
@@ -28,7 +27,10 @@ class ConfigLoader:
 
     def _load_yaml(self) -> Dict[str, Any]:
         with open(self._config_path, "r", encoding="utf-8") as f:
-            return yaml.safe_load(f)
+            data = yaml.safe_load(f) or {}
+        if not isinstance(data, dict):
+            raise ValueError(f"配置文件格式错误，顶层必须是对象: {self._config_path}")
+        return data
 
     def _override_from_env(self):
         """通过环境变量覆盖配置，支持 LLM_API_KEY, LLM_MODEL, LLM_BASE_URL 等。"""
@@ -40,21 +42,28 @@ class ConfigLoader:
             "LLM_TEMPERATURE": ["llm", "temperature"],
             "SESSION_TTL": ["session", "ttl_seconds"],
             "SESSION_MAX_HISTORY": ["session", "max_history"],
+            "RAG_ENABLED": ["rag", "enabled"],
+            "RAG_TOP_K": ["rag", "top_k"],
         }
 
         for env_var, path in env_mappings.items():
             value = os.environ.get(env_var)
             if value is not None:
-                # 尝试数字转换
-                try:
-                    if "." in value:
-                        value = float(value)
-                    else:
-                        value = int(value)
-                except ValueError:
-                    pass
+                value = self._parse_env_value(value)
                 self._set_nested_value(self._config, path, value)
 
+    @staticmethod
+    def _parse_env_value(value: str) -> Any:
+        lower_value = value.lower()
+        if lower_value in {"true", "false"}:
+            return lower_value == "true"
+        try:
+            if "." in value:
+                return float(value)
+            return int(value)
+        except ValueError:
+            return value
+
     def _set_nested_value(self, config: Dict, path: list, value: Any):
         current = config
         for key in path[:-1]:
@@ -95,5 +104,33 @@ class ConfigLoader:
         return self._config
 
 
-# 全局配置实例
-config = ConfigLoader()
+class LazyConfig:
+    """Import-safe config proxy; real files/env are read only on first use."""
+
+    def __init__(self):
+        self._loader = None
+        self._lock = threading.Lock()
+
+    def load(self, config_path: str = None) -> ConfigLoader:
+        with self._lock:
+            if self._loader is None or config_path is not None:
+                self._loader = ConfigLoader(config_path)
+            return self._loader
+
+    def reload(self, config_path: str = None) -> ConfigLoader:
+        with self._lock:
+            self._loader = ConfigLoader(config_path)
+            return self._loader
+
+    def __getattr__(self, name: str) -> Any:
+        return getattr(self.load(), name)
+
+    def get(self, *keys: str, default: Any = None) -> Any:
+        return self.load().get(*keys, default=default)
+
+
+config = LazyConfig()
+
+
+def get_config() -> ConfigLoader:
+    return config.load()

package/src/core/logging_config.py

@@ -0,0 +1,16 @@
+import logging
+
+
+LOG_FORMAT = "%(asctime)s %(levelname)s [%(name)s] %(message)s"
+
+
+def get_logger(name: str) -> logging.Logger:
+    """Return a console logger with a small, consistent default format."""
+    logger = logging.getLogger(name)
+    if not logger.handlers:
+        handler = logging.StreamHandler()
+        handler.setFormatter(logging.Formatter(LOG_FORMAT))
+        logger.addHandler(handler)
+    logger.setLevel(logging.INFO)
+    logger.propagate = False
+    return logger

package/src/manager/toolcall_manager.py

@@ -1,12 +1,21 @@
 """使用官方的sdk调用模型，整合工具调用能力"""
+from typing import Generator
+
+from src.models.schemas import ChatResponse
 from src.utils.function_utils import tools
-from src.service.chat_service import chat_service
+from src.service.chat_service import ChatService, get_chat_service
 
 
 class ToolCallManager:
     def __init__(self):
-        self._chat_service = chat_service
+        self._chat_service = None
+
+    @property
+    def chat_service(self) -> ChatService:
+        if self._chat_service is None:
+            self._chat_service = get_chat_service()
+        return self._chat_service
 
-    def tool_call_stream(self, session_id: str, question: str):
+    def tool_call_stream(self, session_id: str, question: str) -> Generator[ChatResponse, None, None]:
         """调用service层的工具调用方法，传入自定义的tools，格式化返回流式结果"""
-        yield from self._chat_service.tool_call_stream(session_id, question, tools)
+        yield from self.chat_service.tool_call_stream(session_id, question, tools)

package/src/models/schemas.py

@@ -1,3 +1,5 @@
+from typing import Literal, Optional
+
 from pydantic import BaseModel, Field
 
 
@@ -5,3 +7,16 @@ class ChatRequest(BaseModel):
     """聊天请求模型"""
     session_id: str = Field(..., description="会话ID，用于多轮对话上下文")
     question: str = Field(..., min_length=1, max_length=4096, description="用户问题")
+
+
+class ChatResponse(BaseModel):
+    """聊天流式响应模型"""
+    session_id: str = Field(..., description="会话ID")
+    content: Optional[str] = Field(default=None, description="模型正式回复内容增量")
+    reasoning_content: Optional[str] = Field(default=None, description="模型推理内容增量")
+    tool_call: Optional[str] = Field(default=None, description="工具调用信息")
+    tool_result: Optional[str] = Field(default=None, description="工具执行结果")
+    finish_reason: Optional[Literal["stop", "error", "rejected", "done"]] = Field(
+        default=None,
+        description="结束原因；中间流式增量为空",
+    )

package/src/service/chat_service.py

@@ -1,14 +1,23 @@
 import threading
 import time
-from typing import Dict, Generator, List
+from typing import Dict, Generator, List, Optional
 
 from zai import ZhipuAiClient
 
 from src.core.config_loader import config
+from src.core.logging_config import get_logger
+from src.models.schemas import ChatResponse
 from src.utils.function_utils import call_function
 from src.service.rag_service import RagService
 
 
+logger = get_logger(__name__)
+
+
+def _preview(text: str, limit: int = 300) -> str:
+    return str(text).replace("\n", " ")[:limit]
+
+
 TOOL_ROUTING_PROMPT = """
 你正在处理网络支付清算平台联合运维客服问题。选择工具前先识别用户真实业务场景：
 1. 提到变更、投产、升级、发布、回滚、灾备、演练、通知、报备、关闭渠道，优先判断为生产变更，使用 evaluate_change_strategy。
@@ -135,25 +144,40 @@ class ChatService:
         messages.insert(insert_at, {"role": "system", "content": TOOL_ROUTING_PROMPT})
         return messages
 
-    def tool_call_stream(self, session_id: str, question: str, tools) -> Generator[dict, None, None]:
+    def tool_call_stream(self, session_id: str, question: str, tools) -> Generator[ChatResponse, None, None]:
         """
         带工具调用的流式对话（支持交错思考与工具调用）
         - stream=True + tool_stream=True：模型在流式输出中同时返回推理过程、回答内容与工具调用
         - 工具执行结果回传模型后继续流式生成，循环直至模型不再调用工具或达到最大轮次
         """
         if not self._check_question_valid(question):
-            yield {"session_id": session_id, "delta": self._rejection_message, "finish_reason": "rejected"}
+            logger.info("问题未通过业务过滤。session_id=%s question=%s", session_id, _preview(question, 120))
+            yield ChatResponse(
+                session_id=session_id,
+                content=self._rejection_message,
+                finish_reason="rejected",
+            )
             return
 
-        def event(delta: str, etype: str) -> dict:
-            return {"session_id": session_id, "delta": delta, "type": etype, "finish_reason": None}
+        def content_event(content: str) -> ChatResponse:
+            return ChatResponse(session_id=session_id, content=content)
+
+        def reasoning_event(reasoning_content: str) -> ChatResponse:
+            return ChatResponse(session_id=session_id, reasoning_content=reasoning_content)
+
+        def tool_call_event(tool_call: str) -> ChatResponse:
+            return ChatResponse(session_id=session_id, tool_call=tool_call)
+
+        def tool_result_event(tool_result: str) -> ChatResponse:
+            return ChatResponse(session_id=session_id, tool_result=tool_result)
 
         try:
             messages = self._build_tool_messages(session_id, question)
             max_rounds = config.tools.get("max_rounds", 5)
             final_answer = ""
 
-            for _ in range(max_rounds):
+            logger.info("开始模型流式调用。session_id=%s model=%s question=%s", session_id, self._model, _preview(question, 120))
+            for round_idx in range(max_rounds):
                 response = self._client.chat.completions.create(
                     model=self._model,
                     messages=messages,
@@ -167,6 +191,7 @@ class ChatService:
                 )
 
                 current_content = ""
+                reasoning_len = 0
                 tool_calls_map: Dict[int, Dict] = {}
 
                 for chunk in response:
@@ -176,16 +201,27 @@ class ChatService:
 
                     reasoning = getattr(delta, "reasoning_content", None)
                     if reasoning:
-                        yield event(reasoning, "reasoning")
+                        reasoning_len += len(reasoning)
+                        yield reasoning_event(reasoning)
 
                     content = getattr(delta, "content", None)
                     if content:
                         current_content += content
-                        yield event(content, "content")
+                        yield content_event(content)
 
                     for tc in getattr(delta, "tool_calls", None) or []:
                         self._merge_tool_call_delta(tool_calls_map, tc)
 
+                logger.info(
+                    "模型流式返回完成。session_id=%s round=%s content_chars=%s reasoning_chars=%s tool_calls=%s content_preview=%s",
+                    session_id,
+                    round_idx + 1,
+                    len(current_content),
+                    reasoning_len,
+                    len(tool_calls_map),
+                    _preview(current_content),
+                )
+
                 if not tool_calls_map:
                     final_answer = current_content
                     break
@@ -200,10 +236,22 @@ class ChatService:
                 for tc in assistant_tool_calls:
                     name = tc["function"]["name"]
                     args = tc["function"]["arguments"]
-                    yield event(f"\n[调用工具: {name}({args})]\n", "tool_call")
+                    logger.info(
+                        "执行工具调用。session_id=%s tool=%s args=%s",
+                        session_id,
+                        name,
+                        _preview(args, 200),
+                    )
+                    yield tool_call_event(f"\n[调用工具: {name}({args})]\n")
 
                     result = call_function(name, args)
-                    yield event(result, "tool_result")
+                    logger.info(
+                        "工具调用完成。session_id=%s tool=%s result_preview=%s",
+                        session_id,
+                        name,
+                        _preview(result, 300),
+                    )
+                    yield tool_result_event(result)
 
                     messages.append({
                         "role": "tool",
@@ -212,17 +260,24 @@ class ChatService:
                     })
             else:
                 final_answer = current_content or "[系统提示: 工具调用轮次已达上限]"
-                yield event(final_answer, "content")
+                yield content_event(final_answer)
 
             self._append_exchange(session_id, question, final_answer)
-            yield {"session_id": session_id, "delta": "", "finish_reason": "stop"}
+            logger.info(
+                "对话完成。session_id=%s final_answer_chars=%s final_answer_preview=%s",
+                session_id,
+                len(final_answer),
+                _preview(final_answer),
+            )
+            yield ChatResponse(session_id=session_id, finish_reason="stop")
 
         except Exception as e:
-            yield {
-                "session_id": session_id,
-                "delta": f"[错误] 模型调用异常: {str(e)}",
-                "finish_reason": "error",
-            }
+            logger.exception("模型调用异常。session_id=%s question=%s", session_id, _preview(question, 120))
+            yield ChatResponse(
+                session_id=session_id,
+                content=f"[错误] 模型调用异常: {str(e)}",
+                finish_reason="error",
+            )
 
     @staticmethod
     def _merge_tool_call_delta(tool_calls_map: Dict[int, Dict], tc) -> None:
@@ -242,4 +297,14 @@ class ChatService:
                 slot["function"]["arguments"] += fn.arguments
 
 
-chat_service = ChatService()
+_chat_service: Optional[ChatService] = None
+_chat_service_lock = threading.Lock()
+
+
+def get_chat_service() -> ChatService:
+    global _chat_service
+    if _chat_service is None:
+        with _chat_service_lock:
+            if _chat_service is None:
+                _chat_service = ChatService()
+    return _chat_service

package/src/service/rag_service.py

@@ -7,6 +7,14 @@ import yaml
 from zai import ZhipuAiClient
 
 from src.core.config_loader import config
+from src.core.logging_config import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def _preview(text: str, limit: int = 300) -> str:
+    return str(text).replace("\n", " ")[:limit]
 
 
 class RagService:
@@ -15,7 +23,7 @@ class RagService:
     def __init__(self):
         self._cfg = config.get("rag", default={})
         self._enabled = self._cfg.get("enabled", False)
-        self._top_k = self._cfg.get("top_k", 5)
+        self._top_k = self._positive_int(self._cfg.get("top_k", 5), default=5)
         self._collection = None
         self._client = ZhipuAiClient(
             api_key=config.llm.get("api_key"),
@@ -25,13 +33,16 @@ class RagService:
             self._init_collection()
 
     def search(self, question: str) -> Tuple[str, List[Dict]]:
-        if not self._collection:
+        if not self._ensure_collection():
+            logger.info("RAG 未启用或集合不可用，跳过检索。question=%s", _preview(question, 120))
             return "", []
 
         try:
             if self._collection.count() == 0:
+                logger.info("RAG 集合为空，开始重建知识库。")
                 self.rebuild()
             if self._collection.count() == 0:
+                logger.info("RAG 重建后仍无可用文档。question=%s", _preview(question, 120))
                 return "", []
             result = self._collection.query(
                 query_embeddings=[self._embed(question)],
@@ -39,6 +50,7 @@ class RagService:
                 include=["documents", "metadatas"],
             )
         except Exception:
+            logger.exception("RAG 检索异常，已降级为空上下文。question=%s", _preview(question, 120))
             self._collection = None
             return "", []
         docs = result.get("documents", [[]])[0]
@@ -50,12 +62,35 @@ class RagService:
             f"内容：{doc}"
             for i, (doc, m) in enumerate(zip(docs, metas))
         )
+        logger.info(
+            "RAG 检索完成。question=%s hit_count=%s sources=%s context_preview=%s",
+            _preview(question, 120),
+            len(docs),
+            sources,
+            _preview(context),
+        )
         return context, sources
 
+    def _ensure_collection(self) -> bool:
+        if self._collection:
+            return True
+        if not self._enabled:
+            return False
+        self._init_collection()
+        return self._collection is not None
+
+    @staticmethod
+    def _positive_int(value, default: int) -> int:
+        try:
+            return max(int(value), 1)
+        except (TypeError, ValueError):
+            return default
+
     def _init_collection(self):
         try:
             import chromadb
         except ImportError:
+            logger.warning("未安装 chromadb，RAG 检索不可用。")
             return
 
         root = Path(__file__).resolve().parents[2]
@@ -67,11 +102,13 @@ class RagService:
             if self._cfg.get("rebuild_on_startup", False):
                 self.rebuild()
         except Exception:
+            logger.exception("RAG 初始化重建失败，已关闭当前集合。")
             self._collection = None
 
     def rebuild(self):
         docs = self._load_documents()
         if not docs:
+            logger.info("RAG 未加载到知识库文档，跳过重建。")
             return
         self._collection.upsert(
             ids=[d["id"] for d in docs],
@@ -79,6 +116,7 @@ class RagService:
             metadatas=[d["metadata"] for d in docs],
             embeddings=[self._embed(d["content"]) for d in docs],
         )
+        logger.info("RAG 知识库重建完成。doc_chunks=%s", len(docs))
 
     def _load_documents(self) -> List[Dict]:
         docs = []

package/src/utils/function_utils.py

@@ -8,6 +8,8 @@ LARGE_UNITS = {
     "微众银行", "网商银行", "农信银中心", "支付宝", "财付通",
 }
 
+UNIT_CATEGORIES = {"大型单位", "中型单位", "小型单位"}
+
 MEDIUM_UNITS = {
     "中信银行", "光大银行", "民生银行", "兴业银行", "广发银行", "平安银行", "浦发银行",
     "浙江联社", "网银在线",
@@ -49,6 +51,13 @@ def _normalize_unit_name(unit_name: Optional[str]) -> str:
     return (unit_name or "").strip().replace("中国邮政储蓄银行", "邮储银行")
 
 
+def _resolve_unit_category(unit_category: Optional[str] = None, unit_name: Optional[str] = None) -> str:
+    """Resolve a valid unit category and avoid tool-call input causing KeyError."""
+    if unit_category in UNIT_CATEGORIES:
+        return unit_category
+    return classify_member_unit(unit_name).get("category", "小型单位")
+
+
 def classify_member_unit(unit_name: Optional[str] = None, daily_txn_count: Optional[int] = None) -> Dict[str, Any]:
     """按指引附录B或上一年全年日均交易量识别成员单位分类。"""
     normalized = _normalize_unit_name(unit_name)
@@ -111,7 +120,7 @@ def evaluate_fault_grade(
     duration_minutes: Optional[float] = None,
 ) -> Dict[str, Any]:
     """根据异常交易笔数或异常持续时间判断运行故障级别。"""
-    category = unit_category or classify_member_unit(unit_name).get("category")
+    category = _resolve_unit_category(unit_category, unit_name)
     thresholds = {
         "大型单位": {
             "轻微故障": {"txn_min": 1000, "txn_max": 25000, "duration_min": 0, "duration_max": 10},
@@ -170,7 +179,7 @@ def evaluate_operation_scene(
     bandwidth_usage_pct: Optional[float] = None,
 ) -> Dict[str, Any]:
     """按生产运行场景识别风险、联合处置或关闭渠道策略。"""
-    category = unit_category or classify_member_unit(unit_name).get("category")
+    category = _resolve_unit_category(unit_category, unit_name)
     evidence = []
     scene = "未触发明确处置场景"
     action = "继续监控，补充系统成功率、失败笔数、耗时、异常交易数量、持续时间等指标后再判断"

package/tests/test_chat_service.py

@@ -1,3 +1,9 @@
+from fastapi.testclient import TestClient
+
+from main import app
+from src.core.config_loader import LazyConfig
+from src.manager.toolcall_manager import ToolCallManager
+from src.models.schemas import ChatResponse
 from src.service.chat_service import ChatService
 from src.utils.function_utils import (
     classify_member_unit,
@@ -7,6 +13,9 @@ from src.utils.function_utils import (
 )
 
 
+client = TestClient(app)
+
+
 def test_question_filter_allowed():
     """测试允许的问题"""
     svc = ChatService()
@@ -28,9 +37,28 @@ def test_rejected_response_format():
     """测试拒绝返回格式"""
     svc = ChatService()
     result = next(svc.tool_call_stream("session-test", "讲个笑话", tools=[]))
-    assert result["session_id"] == "session-test"
-    assert result["finish_reason"] == "rejected"
-    assert result["delta"]
+    assert result.session_id == "session-test"
+    assert result.finish_reason == "rejected"
+    assert result.content
+
+
+def test_chat_response_separates_stream_fields():
+    response = ChatResponse(session_id="session-test", reasoning_content="推理")
+    assert response.reasoning_content == "推理"
+    assert response.content is None
+    assert response.tool_call is None
+
+
+def test_config_proxy_is_lazy_until_first_use():
+    lazy_config = LazyConfig()
+    assert lazy_config._loader is None
+    assert lazy_config.get("missing", default="fallback") == "fallback"
+    assert lazy_config._loader is not None
+
+
+def test_tool_call_manager_does_not_init_chat_service_on_construction():
+    manager = ToolCallManager()
+    assert manager._chat_service is None
 
 
 def test_conversation_history_uses_session_id():
@@ -57,6 +85,12 @@ def test_evaluate_fault_grade_uses_highest_matched_rule():
     assert "或关系" in result["rule"]
 
 
+def test_evaluate_fault_grade_handles_invalid_category():
+    result = evaluate_fault_grade(unit_category="未知类型", abnormal_txn_count=12000)
+    assert result["unit_category"] == "小型单位"
+    assert result["fault_level"] == "严重故障"
+
+
 def test_evaluate_operation_scene_close_channel():
     result = evaluate_operation_scene(
         unit_category="中型单位",
@@ -73,3 +107,9 @@ def test_evaluate_change_strategy_shutdown():
     assert result["change_scene"] == "场景四"
     assert "关闭渠道" in result["recommended_action"]
     assert "小于30分钟" in result["notice_judgement"]
+
+
+def test_health_endpoint():
+    response = client.get("/api/v1/health")
+    assert response.status_code == 200
+    assert response.json() == {"status": "ok"}