union-app-chat-stream 1.0.5 → 1.0.7

package/app/service/chat_service.py

@@ -156,14 +156,14 @@ class ChatService:
         def tool_result_event(tool_result: str) -> ChatResponse:
             return ChatResponse(conversationId=conversation_id, tool_result=_public_tool_result(tool_result))
 
-        def heartbeat_event(tool_name: str, elapsed_seconds: float) -> ChatResponse:
+        def heartbeat_event(tool_name: str, elapsed_seconds: float, message: str = "") -> ChatResponse:
             return ChatResponse(
                 conversationId=conversation_id,
                 heartbeat={
                     "type": "tool_call_running",
                     "tool": tool_name,
                     "elapsedSeconds": round(elapsed_seconds, 3),
-                    "message": f"工具 {tool_name} 仍在执行，请继续等待。",
+                    "message": message or f"工具 {tool_name} 仍在执行，请继续等待。",
                 },
             )
 
@@ -241,16 +241,23 @@ class ChatService:
                     logger.info(f"执行工具调用。conversation_id={conversation_id} tool={name} args={_preview(args, 200)}")
                     yield tool_call_event(f"\n[调用工具: {name}({args})]\n")
 
+                    retry_notice = {"message": ""}
+
+                    def retry_callback(message: str) -> None:
+                        retry_notice["message"] = message
+
                     tool_context = ToolContext(
                         union_service=self._union_service,
                         rag_service=self._rag,
                         jsessionid=jsessionid,
+                        retry_callback=retry_callback,
                     )
                     result = yield from self._call_function_with_heartbeats(
                         name,
                         args,
                         tool_context,
                         heartbeat_event,
+                        retry_notice,
                     )
                     logger.info(f"工具调用完成。conversation_id={conversation_id} tool={name} result_preview={_preview(result, 300)}")
                     yield tool_result_event(result)
@@ -291,6 +298,7 @@ class ChatService:
         args: str,
         tool_context: ToolContext,
         heartbeat_event,
+        retry_notice,
     ) -> Generator[ChatResponse, None, str]:
         interval = self._tool_heartbeat_interval
         if interval <= 0:
@@ -304,7 +312,7 @@ class ChatService:
                 try:
                     return future.result(timeout=interval)
                 except FutureTimeoutError:
-                    yield heartbeat_event(name, time.monotonic() - started_at)
+                    yield heartbeat_event(name, time.monotonic() - started_at, retry_notice.get("message", ""))
         finally:
             executor.shutdown(wait=False, cancel_futures=True)
 
@@ -340,6 +348,6 @@ class ChatService:
         fn = getattr(tc, "function", None)
         if fn is not None:
             if getattr(fn, "name", None):
-                slot["function"]["name"] += fn.name
+                slot["function"]["name"] = fn.name
             if getattr(fn, "arguments", None):
                 slot["function"]["arguments"] += fn.arguments

package/app/service/union_service.py

@@ -12,7 +12,6 @@ class UnionService:
 
     # 常量定义
     API_MAX_RETRIES = 10  # API最大重试次数
-    BIGDATA_API_TIMEOUT = 300
     BIGDATA_INTERFACE_FULL_LINK = "running_cnt.full_link_monthly"
     BIGDATA_INTERFACE_BANK_MONTHLY = "running_cnt.bank_monthly"
 
@@ -72,6 +71,8 @@ class UnionService:
         jsessionid: str,
         description: str = "查询联合运维数据",
         path: str = "",
+        timeout: Optional[int] = None,
+        retry_callback=None,
     ) -> Tuple[Optional[Any], str]:
         """按 tool definition 中配置的 path 和 JSON 参数查询联合运维 API。"""
         url = self._build_union_url(self._union_base_url, path)
@@ -81,13 +82,17 @@ class UnionService:
             return None, f"{description}失败: 登录态ID为空"
 
         try:
-            response = common_utils.call_https_api(
-                url=url,
-                headers=self._get_union_headers(jsessionid),
-                json_data=payload,
-                timeout=self.BIGDATA_API_TIMEOUT,
-                max_retries=self.API_MAX_RETRIES,
-            )
+            kwargs = {
+                "url": url,
+                "headers": self._get_union_headers(jsessionid),
+                "json_data": payload,
+                "max_retries": self.API_MAX_RETRIES,
+            }
+            if timeout is not None:
+                kwargs["timeout"] = timeout
+            if retry_callback:
+                kwargs["retry_callback"] = retry_callback
+            response = common_utils.call_https_api(**kwargs)
             if not response.get("success", True):
                 raise RuntimeError(response.get("error_msg", "请求失败"))
             status_code = response.get("status_code")

package/app/utils/common_utils.py

@@ -1,5 +1,5 @@
 import requests
-from typing import Optional, Dict, Any
+from typing import Optional, Dict, Any, Callable
 from requests.exceptions import RequestException, Timeout, ConnectionError
 import json
 import time
@@ -30,12 +30,13 @@ def call_https_api(
         data: Optional[Dict[str, Any]] = None,
         json_data: Optional[Dict[str, Any]] = None,
         headers: Optional[Dict[str, str]] = None,
-    timeout: int = 10,
+        timeout: int = 10,
         verify_ssl: bool = False,
         auth: Optional[tuple] = None,
         proxies: Optional[Dict[str, Any]] = None,
         max_retries: int = 0,
-        retry_delay: float = 1.0
+        retry_delay: float = 1.0,
+        retry_callback: Optional[Callable[[str], None]] = None,
 
 ) -> Dict[str, Any]:
     default_headers = {
@@ -81,14 +82,20 @@ def call_https_api(
             logger.info(f"请求成功：{response.status_code},返回值:{response.text}")
             return result
         except ConnectionError as e:
-            logger.error(f"连接失败：{e}")
+            error_msg = f"连接失败：{e}"
+            logger.error(error_msg)
         except Timeout as e:
-            logger.error(f"请求超时：{e}")
+            error_msg = f"请求超时：{e}"
+            logger.error(error_msg)
         except RequestException as e:
-            logger.error(f"请求异常：{e}")
+            error_msg = f"请求异常：{e}"
+            logger.error(error_msg)
         except Exception as e:
-            logger.error(f"未知错误：{e}")
+            error_msg = f"未知错误：{e}"
+            logger.error(error_msg)
         if attempt < max_retries:
+            if retry_callback:
+                retry_callback(f"{error_msg}，正在重试（第{attempt + 2}次）")
             time.sleep(retry_delay)
         else:
             break

package/app/utils/function_utils.py

@@ -14,6 +14,7 @@ import yaml
 
 PROJECT_ROOT = Path(__file__).resolve().parents[2]
 DEFAULT_TOOL_DEFINITIONS_PATH = PROJECT_ROOT / "tools" / "tool_definitions.yaml"
+FIELD_DICTIONARY_PATH = PROJECT_ROOT / "tools" / "field_dictionary.yaml"
 
 
 @dataclass
@@ -21,6 +22,7 @@ class ToolContext:
     union_service: Optional[Any] = None
     rag_service: Optional[Any] = None
     jsessionid: str = ""
+    retry_callback: Optional[Callable[[str], None]] = None
 
 
 ToolFunction = Callable[[Dict[str, Any], ToolContext], Dict[str, Any]]
@@ -46,6 +48,44 @@ def _load_yaml(path: Path) -> Dict[str, Any]:
     return data if isinstance(data, dict) else {}
 
 
+def _normalize_field_name(name: str) -> str:
+    return re.sub(r"[\s_-]+", "", str(name)).lower()
+
+
+@lru_cache(maxsize=1)
+def _field_dictionary_index() -> Dict[str, Any]:
+    if not FIELD_DICTIONARY_PATH.exists():
+        return {"fallback_description": "", "exact": {}, "normalized": {}, "relations": []}
+
+    config = _load_yaml(FIELD_DICTIONARY_PATH)
+    if not isinstance(config, dict):
+        config = {}
+
+    exact: Dict[str, Dict[str, Any]] = {}
+    normalized: Dict[str, Dict[str, Any]] = {}
+    fields = config.get("fields") if isinstance(config.get("fields"), dict) else {}
+    for canonical, raw_info in fields.items():
+        if not isinstance(raw_info, dict):
+            continue
+        info = {key: value for key, value in raw_info.items() if key not in {"aliases", "patterns"}}
+        info["canonical"] = canonical
+        exact[canonical] = info
+        normalized[_normalize_field_name(canonical)] = info
+        aliases = raw_info.get("aliases") if isinstance(raw_info.get("aliases"), list) else []
+        for alias in aliases:
+            alias = str(alias)
+            exact[alias] = info
+            normalized[_normalize_field_name(alias)] = info
+
+    relations = config.get("relations") if isinstance(config.get("relations"), list) else []
+    return {
+        "fallback_description": str(config.get("fallback_description") or ""),
+        "exact": exact,
+        "normalized": normalized,
+        "relations": relations,
+    }
+
+
 @lru_cache(maxsize=1)
 def _tool_definition_config() -> Dict[str, Any]:
     path = Path(os.environ.get("TOOL_DEFINITIONS_PATH", DEFAULT_TOOL_DEFINITIONS_PATH))
@@ -54,6 +94,7 @@ def _tool_definition_config() -> Dict[str, Any]:
 
 def reload_tool_configs():
     _tool_definition_config.cache_clear()
+    _field_dictionary_index.cache_clear()
 
 
 def _raw_tool_definitions() -> List[Dict[str, Any]]:
@@ -177,6 +218,56 @@ def _render_value(value: Any, args: Dict[str, Any], *, allow_missing: bool = Fal
     return value
 
 
+def _collect_data_fields(data: Any, sample_size: int = 5) -> List[str]:
+    if not isinstance(data, list):
+        return []
+    fields: List[str] = []
+    seen = set()
+    for item in data[:sample_size]:
+        if not isinstance(item, dict):
+            continue
+        for key in item:
+            key = str(key)
+            if key not in seen:
+                seen.add(key)
+                fields.append(key)
+    return fields
+
+
+def _build_field_context(data: Any) -> Dict[str, Any]:
+    fields = _collect_data_fields(data)
+    if not fields:
+        return {}
+
+    index = _field_dictionary_index()
+    fallback = index["fallback_description"]
+    descriptions: Dict[str, Dict[str, Any]] = {}
+    canonical_fields = set()
+    for field in fields:
+        info = index["exact"].get(field) or index["normalized"].get(_normalize_field_name(field))
+        if info:
+            descriptions[field] = dict(info)
+            canonical_fields.add(str(info["canonical"]))
+        elif fallback:
+            descriptions[field] = {"description": fallback}
+
+    relations = []
+    for relation in index["relations"]:
+        if not isinstance(relation, dict):
+            continue
+        when_all = relation.get("when_all")
+        description = relation.get("description")
+        if isinstance(when_all, list) and description and all(str(field) in canonical_fields for field in when_all):
+            relations.append(str(description))
+
+    context: Dict[str, Any] = {}
+    if descriptions:
+        context["field_descriptions"] = descriptions
+    if relations:
+        context["field_relations"] = relations
+    return context
+
+
 def _base_result(spec: Dict[str, Any], args: Dict[str, Any]) -> Dict[str, Any]:
     result = {
         "tool_name": spec["name"],
@@ -213,7 +304,12 @@ def _run_backend_tool(
         if context.union_service is None:
             raise ValueError("Union服务未初始化")
         method = getattr(context.union_service, method_name)
-        data, message = method(payload, context.jsessionid, description=description, path=path)
+        kwargs = {"description": description, "path": path}
+        if isinstance(backend.get("timeout"), int):
+            kwargs["timeout"] = backend["timeout"]
+        if context.retry_callback:
+            kwargs["retry_callback"] = context.retry_callback
+        data, message = method(payload, context.jsessionid, **kwargs)
     elif service_name == "rag_service":
         if context.rag_service is None:
             raise ValueError("知识库检索服务未初始化")
@@ -236,6 +332,7 @@ def _run_backend_tool(
     })
     if path:
         result["backend"]["path"] = path
+    result.update(_build_field_context(data))
     return result
 
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "union-app-chat-stream",
-  "version": "1.0.5",
+  "version": "1.0.7",
   "description": "Union operations chat stream Flask application package.",
   "license": "UNLICENSED",
   "files": [

package/tools/field_dictionary.yaml

@@ -0,0 +1,28 @@
+fallback_description: 字段未命中全局字段字典。请结合字段名、字段值和上下文谨慎理解，不要编造枚举含义。
+fields:
+  sysSuccessPercent:
+    meaning: 系统成功率，表示成功交易占总交易的比例，通常越高越好。
+    aliases:
+      - sysSuccessPercent
+      - avgSuccessPercent
+      - avg_success_percent
+      - successPer
+  failRate:
+    meaning: 失败率，通常表示失败交易笔数占总交易笔数的比例。
+    aliases:
+      - failRate
+      - fail_rate
+  faultLevel:
+    meaning: 故障等级，表示故障严重程度。
+    enum:
+      P1: 重大故障
+      P2: 较大故障
+      P3: 一般故障
+    aliases:
+      - faultLevel
+      - fault_level
+relations:
+  - when_all:
+      - sysSuccessPercent
+      - failRate
+    description: 系统成功率和失败率通常反向相关。成功率下降时，应同时检查失败率是否上升。