from __future__ import annotations import json import re from dataclasses import dataclass from datetime import UTC, datetime from typing import Any from sqlalchemy.orm import Session from app.core.agent_enums import AgentAssetDomain, AgentAssetStatus, AgentAssetType from app.models.agent_asset import AgentAsset, AgentAssetVersion from app.schemas.agent_asset import AgentAssetRiskRuleGenerateRequest from app.services.agent_asset_rule_library import AgentAssetRuleLibraryManager from app.services.agent_asset_spreadsheet import RISK_RULES_LIBRARY from app.services.audit import AuditLogService from app.services.expense_type_keywords import EXPENSE_TYPE_LABEL_BY_CODE from app.services.risk_rule_flow_diagram import ( RiskRuleFlowDiagramField, RiskRuleFlowDiagramRenderer, RiskRuleFlowDiagramSpec, ) from app.services.runtime_chat import RuntimeChatService @dataclass(frozen=True) class RiskRuleField: key: str label: str field_type: str source: str aliases: tuple[str, ...] BUSINESS_DOMAIN_LABELS: dict[str, str] = { AgentAssetDomain.EXPENSE.value: "报销", AgentAssetDomain.AR.value: "应收", AgentAssetDomain.AP.value: "应付", } RISK_LEVEL_LABELS: dict[str, str] = { "low": "低风险", "medium": "中风险", "high": "高风险", } EXPENSE_RISK_CATEGORY_CODES: tuple[str, ...] = ( "travel", "hotel", "transport", "meal", "meeting", "office", "training", "communication", "welfare", ) EXPENSE_RISK_CATEGORY_LABELS: dict[str, str] = { code: EXPENSE_TYPE_LABEL_BY_CODE[code] for code in EXPENSE_RISK_CATEGORY_CODES } EXPENSE_RISK_CATEGORY_ALIASES = { "entertainment": "meal", } FIELD_ONTOLOGY: tuple[RiskRuleField, ...] = ( RiskRuleField("claim.reason", "报销事由", "text", "claim", ("事由", "说明", "理由", "用途")), RiskRuleField( "claim.location", "申报地点", "text", "claim", ("地点", "城市", "出差地", "申报地点", "申报目的地", "目的地"), ), RiskRuleField("claim.amount", "申报金额", "number", "claim", ("金额", "费用", "超额", "额度")), RiskRuleField("claim.employee_name", "报销人", "text", "claim", ("报销人", "员工", "申请人")), RiskRuleField("claim.department_name", "部门", "text", "claim", ("部门", "组织")), RiskRuleField("item.item_type", "费用类型", "enum", "item", ("费用类型", "科目", "类型")), RiskRuleField("item.item_reason", "明细事由", "text", "item", ("明细事由", "明细说明")), RiskRuleField("item.item_location", "明细地点", "text", "item", ("明细地点", "发生地点")), RiskRuleField( "attachment.invoice_no", "发票号码", "text", "attachment", ("发票号", "发票号码", "票号") ), RiskRuleField( "attachment.buyer_name", "购买方名称", "text", "attachment", ("抬头", "购买方", "开票单位") ), RiskRuleField( "attachment.goods_name", "商品服务名称", "text", "attachment", ("品名", "商品", "服务名称", "摘要"), ), RiskRuleField( "attachment.issue_date", "开票日期", "date", "attachment", ("开票日期", "发票日期", "票据日期"), ), RiskRuleField( "attachment.hotel_city", "住宿城市", "text", "attachment", ("住宿城市", "酒店城市", "酒店地点", "酒店发票城市", "酒店票城市", "住宿发票城市"), ), RiskRuleField( "attachment.route_cities", "行程城市", "list", "attachment", ("行程", "路线", "途经城市", "出差城市", "交通票行程", "交通票城市"), ), RiskRuleField( "attachment.ocr_text", "票据全文", "text", "attachment", ("票据内容", "OCR", "全文", "关键字", "关键词"), ), RiskRuleField( "receivable.aging_days", "应收账龄", "number", "receivable", ("账龄", "逾期", "应收逾期") ), RiskRuleField( "receivable.amount_outstanding", "应收未收金额", "number", "receivable", ("未收金额", "欠款", "应收余额"), ), RiskRuleField( "payable.vendor_name", "供应商名称", "text", "payable", ("供应商", "付款方", "往来单位") ), RiskRuleField( "payable.amount_outstanding", "应付未付金额", "number", "payable", ("未付金额", "应付余额") ), ) DOMAIN_FIELD_PREFIXES: dict[str, tuple[str, ...]] = { AgentAssetDomain.EXPENSE.value: ("claim.", "item.", "attachment."), AgentAssetDomain.AR.value: ("receivable.",), AgentAssetDomain.AP.value: ("payable.",), } class RiskRuleGenerationService: def __init__( self, db: Session, *, rule_library_manager: AgentAssetRuleLibraryManager | None = None, runtime_chat_service: RuntimeChatService | None = None, ) -> None: self.db = db self.rule_library_manager = rule_library_manager or AgentAssetRuleLibraryManager() self.runtime_chat_service = runtime_chat_service or RuntimeChatService(db) self.audit_service = AuditLogService(db) self.flow_diagram_renderer = RiskRuleFlowDiagramRenderer() def generate_rule_asset( self, body: AgentAssetRiskRuleGenerateRequest, *, actor: str, request_id: str | None = None, ) -> str: domain = body.business_domain.value if domain not in BUSINESS_DOMAIN_LABELS: raise ValueError("当前仅支持报销、应收、应付业务域的新建风险规则。") natural_language = self._clean_text(body.natural_language) if len(natural_language) < 8: raise ValueError("请至少输入 8 个字的风险规则描述。") risk_level = str(body.risk_level or "medium").strip().lower() if risk_level not in RISK_LEVEL_LABELS: raise ValueError("风险等级仅支持 low、medium、high。") requires_attachment = bool(body.requires_attachment) expense_category = self._normalize_expense_category(body.expense_category, domain) expense_category_label = EXPENSE_RISK_CATEGORY_LABELS.get(expense_category or "", "") created_at = datetime.now(UTC) fields = self._resolve_fields(natural_language, domain=domain) draft = self._compile_with_model( natural_language=natural_language, domain=domain, expense_category=expense_category, expense_category_label=expense_category_label, risk_level=risk_level, fields=fields, ) or self._build_fallback_draft( natural_language=natural_language, domain=domain, expense_category_label=expense_category_label, risk_level=risk_level, fields=fields, ) draft = self._align_draft_fields( draft, natural_language=natural_language, fields=fields, ) payload = self._build_rule_payload( draft, natural_language=natural_language, domain=domain, expense_category=expense_category, expense_category_label=expense_category_label, risk_level=risk_level, fields=fields, created_at=created_at, actor=actor, requires_attachment=requires_attachment, ) rule_code = str(payload["rule_code"]) file_name = f"{rule_code}.json" self.rule_library_manager.write_rule_library_json( library=RISK_RULES_LIBRARY, file_name=file_name, payload=payload, ) asset = AgentAsset( asset_type=AgentAssetType.RULE.value, code=rule_code, name=str(payload["name"]), description=str(payload["description"]), domain=domain, scenario_json=[str(payload.get("risk_category") or BUSINESS_DOMAIN_LABELS[domain])], owner=actor, reviewer=None, status=AgentAssetStatus.DRAFT.value, current_version="v0.1.0", published_version=None, working_version="v0.1.0", config_json={ "severity": risk_level, "enabled": True, "requires_attachment": requires_attachment, "tag": "风险规则", "detail_mode": "json_risk", "expense_category": expense_category, "expense_category_label": expense_category_label, "risk_category": payload.get("risk_category"), "rule_library": RISK_RULES_LIBRARY, "rule_document": { "file_name": file_name, "storage_key": f"rules/{RISK_RULES_LIBRARY}/{file_name}", }, "ontology_signal": payload.get("ontology_signal"), "evaluator": payload.get("evaluator"), "generated_by": "natural_language", "source_ref": "自然语言风险规则", }, ) self.db.add(asset) self.db.flush() self.db.add( AgentAssetVersion( asset_id=asset.id, version="v0.1.0", content=self._build_version_markdown(payload), content_type="markdown", change_note="通过自然语言新建风险规则草稿。", created_by=actor, ) ) self.audit_service.log_action( actor=actor, action="generate_agent_asset_risk_rule", resource_type=AgentAssetType.RULE.value, resource_id=asset.id, before_json=None, after_json={ "rule_code": rule_code, "risk_level": risk_level, "domain": domain, "expense_category": expense_category, "requires_attachment": requires_attachment, }, request_id=request_id, ) self.db.refresh(asset) return asset.id def _compile_with_model( self, *, natural_language: str, domain: str, expense_category: str | None, expense_category_label: str, risk_level: str, fields: list[RiskRuleField], ) -> dict[str, Any] | None: field_payload = [ { "key": item.key, "label": item.label, "type": item.field_type, "source": item.source, } for item in fields ] messages = [ { "role": "system", "content": ( "你是 X-Financial 风险规则编译器。只能输出 JSON 对象，不要解释。" "必须从给定字段本体中选择字段，不允许编造字段。" "template_key 只能是 field_required_v1、field_compare_v1、keyword_match_v1。" ), }, { "role": "user", "content": json.dumps( { "business_domain": domain, "business_domain_label": BUSINESS_DOMAIN_LABELS[domain], "expense_category": expense_category, "expense_category_label": expense_category_label, "risk_level": risk_level, "risk_level_label": RISK_LEVEL_LABELS[risk_level], "natural_language": natural_language, "available_fields": field_payload, "required_json_shape": { "name": "规则名称", "description": "面向业务用户的说明", "template_key": "field_required_v1", "field_keys": ["claim.reason"], "condition_summary": "判断依据", "keywords": [], "flow": { "start": "提交业务单据", "evidence": "读取字段", "decision": "判断依据", "pass": "继续流转", "fail": "提示风险", }, }, }, ensure_ascii=False, ), }, ] answer = self.runtime_chat_service.complete( messages, max_tokens=700, temperature=0.1, timeout_seconds=12, max_attempts=1, ) if not answer: return None try: payload = json.loads(self._extract_json_object(answer)) except (json.JSONDecodeError, ValueError): return None if not isinstance(payload, dict): return None return self._sanitize_model_draft(payload, fields=fields) def _sanitize_model_draft( self, payload: dict[str, Any], *, fields: list[RiskRuleField], ) -> dict[str, Any]: allowed_fields = {item.key for item in fields} template_key = str(payload.get("template_key") or "").strip() if template_key not in {"field_required_v1", "field_compare_v1", "keyword_match_v1"}: template_key = "field_required_v1" raw_field_keys = payload.get("field_keys") field_keys = [ str(item or "").strip() for item in (raw_field_keys if isinstance(raw_field_keys, list) else []) if str(item or "").strip() in allowed_fields ] if not field_keys and fields: field_keys = [fields[0].key] keywords = [ str(item or "").strip() for item in ( payload.get("keywords") if isinstance(payload.get("keywords"), list) else [] ) if str(item or "").strip() ] flow = payload.get("flow") if isinstance(payload.get("flow"), dict) else {} return { "name": self._clean_text(payload.get("name"))[:80], "description": self._clean_text(payload.get("description")), "template_key": template_key, "field_keys": field_keys, "condition_summary": self._clean_text(payload.get("condition_summary")), "keywords": keywords[:12], "flow": { "start": self._clean_text(flow.get("start")) or "提交业务单据", "evidence": self._clean_text(flow.get("evidence")) or "读取规则字段", "decision": self._clean_text(flow.get("decision")) or "判断是否命中风险", "pass": self._clean_text(flow.get("pass")) or "继续流转", "fail": self._clean_text(flow.get("fail")) or "提示风险并进入复核", }, } def _build_fallback_draft( self, *, natural_language: str, domain: str, expense_category_label: str, risk_level: str, fields: list[RiskRuleField], ) -> dict[str, Any]: field_keys = [item.key for item in fields[:4]] template_key = self._infer_template_key(natural_language) condition_summary = self._build_condition_summary( natural_language, template_key=template_key, fields=fields, ) name = self._infer_rule_name(natural_language) business_label = expense_category_label or BUSINESS_DOMAIN_LABELS[domain] description = ( f"当{business_label}业务满足“{natural_language}”时，系统会按" f"{RISK_LEVEL_LABELS[risk_level]}进行提示，并要求经办人或审核人补充核对依据。" ) return { "name": name, "description": description, "template_key": template_key, "field_keys": field_keys, "condition_summary": condition_summary, "keywords": self._infer_keywords(natural_language), "flow": { "start": f"{business_label}单据提交", "evidence": "读取" + "、".join(item.label for item in fields[:3]), "decision": condition_summary, "pass": "未命中风险，继续业务流转", "fail": f"命中{RISK_LEVEL_LABELS[risk_level]}，提示复核", }, } def _build_rule_payload( self, draft: dict[str, Any], *, natural_language: str, domain: str, expense_category: str | None, expense_category_label: str, risk_level: str, fields: list[RiskRuleField], created_at: datetime, actor: str, requires_attachment: bool, ) -> dict[str, Any]: created_stamp = created_at.strftime("%Y%m%d%H%M%S%f") domain_slug = {"expense": "expense", "ar": "ar", "ap": "ap"}[domain] category_slug = f".{expense_category}" if expense_category else "" rule_code = f"risk.{domain_slug}{category_slug}.generated_{created_stamp}" template_key = str(draft.get("template_key") or "field_required_v1").strip() field_keys = [ str(item or "").strip() for item in list(draft.get("field_keys") or []) if str(item or "").strip() ] condition_summary = ( self._clean_text(draft.get("condition_summary")) or "判断是否符合自然语言规则描述" ) risk_category = expense_category_label or BUSINESS_DOMAIN_LABELS[domain] keywords = list(draft.get("keywords") or []) field_by_key = {item.key: item for item in fields} params: dict[str, Any] = { "template_key": template_key, "field_keys": field_keys, "condition_summary": condition_summary, "natural_language": natural_language, } if template_key == "field_required_v1": params["required_fields"] = field_keys if template_key == "field_compare_v1": params["conditions"] = self._build_compare_conditions(field_keys) if template_key == "keyword_match_v1": params["keywords"] = keywords params["search_fields"] = field_keys applies_to: dict[str, Any] = {"domains": [domain]} if expense_category: applies_to["expense_categories"] = [expense_category] payload = { "schema_version": "2.0", "rule_code": rule_code, "name": self._clean_text(draft.get("name")) or self._infer_rule_name(natural_language), "description": self._clean_text(draft.get("description")) or natural_language, "enabled": True, "requires_attachment": requires_attachment, "risk_dimension": "natural_language_rule", "risk_category": risk_category, "ontology_signal": "natural_language_risk", "evaluator": "template_rule", "template_key": template_key, "applies_to": applies_to, "inputs": { "fields": [ { "key": item.key, "label": item.label, "type": item.field_type, "source": item.source, } for item in [field_by_key[key] for key in field_keys if key in field_by_key] ], }, "params": params, "outcomes": { "pass": {"severity": "none", "action": "continue"}, "fail": { "severity": risk_level, "action": "manual_review", }, }, "metadata": { "owner": actor, "stability": "generated_draft", "source_ref": "自然语言风险规则", "created_at": created_at.isoformat(), "created_by": actor, "requires_attachment": requires_attachment, "expense_category": expense_category, "expense_category_label": expense_category_label, "natural_language": natural_language, "business_explanation": self._clean_text(draft.get("description")), "condition_summary": condition_summary, "flow": draft.get("flow") if isinstance(draft.get("flow"), dict) else {}, }, } payload["flow_diagram_svg"] = self._build_flow_diagram_svg( payload, fields=[field_by_key[key] for key in field_keys if key in field_by_key], domain=domain, domain_label=risk_category, risk_level=risk_level, ) return payload def _build_flow_diagram_svg( self, payload: dict[str, Any], *, fields: list[RiskRuleField], domain: str, domain_label: str | None = None, risk_level: str, ) -> str: metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {} flow = metadata.get("flow") if isinstance(metadata.get("flow"), dict) else {} condition_summary = self._clean_text(metadata.get("condition_summary")) return self.flow_diagram_renderer.render( RiskRuleFlowDiagramSpec( title=self._clean_text(payload.get("name")) or "风险规则判断流程", domain_label=domain_label or BUSINESS_DOMAIN_LABELS.get(domain, "业务"), severity=risk_level, severity_label=RISK_LEVEL_LABELS.get(risk_level, "中风险"), fields=tuple( RiskRuleFlowDiagramField(key=field.key, label=field.label) for field in fields ), start=self._clean_text(flow.get("start")) or "业务单据提交", evidence=self._clean_text(flow.get("evidence")) or "读取规则字段", decision=self._clean_text(flow.get("decision")) or condition_summary or "判断是否命中风险", basis=( condition_summary or self._clean_text(flow.get("decision")) or "根据规则字段判断" ), pass_text=self._clean_text(flow.get("pass")) or "未命中风险，继续流转", fail_text=self._clean_text(flow.get("fail")) or f"命中{RISK_LEVEL_LABELS.get(risk_level, '风险')}，进入人工复核", ) ) @staticmethod def _normalize_expense_category(value: str | None, domain: str) -> str | None: if domain != AgentAssetDomain.EXPENSE.value: return None normalized = str(value or "").strip().lower() if not normalized: return None normalized = EXPENSE_RISK_CATEGORY_ALIASES.get(normalized, normalized) if normalized not in EXPENSE_RISK_CATEGORY_LABELS: allowed = "、".join(EXPENSE_RISK_CATEGORY_LABELS.values()) raise ValueError(f"费用领域仅支持：{allowed}。") return normalized def _resolve_fields(self, text: str, *, domain: str) -> list[RiskRuleField]: prefixes = DOMAIN_FIELD_PREFIXES.get(domain, ()) candidates = [field for field in FIELD_ONTOLOGY if field.key.startswith(prefixes)] normalized = text.lower() matched: list[tuple[int, RiskRuleField]] = [] for field in candidates: score = self._score_field_match(field, text, normalized) if score > 0: matched.append((score, field)) if domain == AgentAssetDomain.EXPENSE.value: if any(keyword in text for keyword in ("住宿", "酒店", "行程", "城市", "出差")): matched.extend( (10, field) for field in candidates if field.key in {"claim.location", "attachment.hotel_city", "attachment.route_cities"} ) if any(keyword in text for keyword in ("发票", "票据", "品名", "抬头", "开票")): matched.extend( (6, field) for field in candidates if field.key in { "attachment.invoice_no", "attachment.buyer_name", "attachment.goods_name", "attachment.ocr_text", } ) matched.sort(key=lambda item: item[0], reverse=True) deduped: list[RiskRuleField] = [] seen: set[str] = set() for _, field in matched: if field.key in seen: continue seen.add(field.key) deduped.append(field) if deduped: return deduped[:8] return candidates[:4] @staticmethod def _score_field_match(field: RiskRuleField, text: str, normalized: str) -> int: score = 0 if field.label in text: score += 8 for alias in field.aliases: if alias.lower() in normalized: score += 4 + min(len(alias), 6) if field.key == "attachment.hotel_city" and any(term in text for term in ("酒店", "住宿")): score += 12 if field.key == "attachment.route_cities" and any( term in text for term in ("行程", "交通票", "路线", "途经") ): score += 10 if field.key == "claim.location" and any( term in text for term in ("申报目的地", "申报地点", "目的地", "出差地") ): score += 10 if field.key.startswith("attachment.") and any(term in text for term in ("发票", "票据")): score += 2 return score def _align_draft_fields( self, draft: dict[str, Any], *, natural_language: str, fields: list[RiskRuleField], ) -> dict[str, Any]: field_by_key = {field.key: field for field in fields} original_keys = [ str(item or "").strip() for item in list(draft.get("field_keys") or []) if str(item or "").strip() in field_by_key ] preferred_keys: list[str] = [] def add_preferred(key: str, *terms: str) -> None: if key in field_by_key and any(term in natural_language for term in terms): preferred_keys.append(key) add_preferred("attachment.hotel_city", "酒店", "住宿") add_preferred("claim.location", "申报目的地", "申报地点", "目的地", "出差地") add_preferred("attachment.route_cities", "行程", "交通票", "路线", "途经") merged_keys: list[str] = [] for key in [*preferred_keys, *original_keys, *[field.key for field in fields]]: if key in field_by_key and key not in merged_keys: merged_keys.append(key) if len(merged_keys) >= 4: break if draft.get("template_key") == "field_compare_v1" and len(merged_keys) < 2: for field in fields: if field.key not in merged_keys: merged_keys.append(field.key) if len(merged_keys) >= 2: break aligned = {**draft, "field_keys": merged_keys} selected_fields = [field_by_key[key] for key in merged_keys if key in field_by_key] if selected_fields: aligned["condition_summary"] = self._build_condition_summary( natural_language, template_key=str(aligned.get("template_key") or "field_required_v1"), fields=selected_fields, ) flow = aligned.get("flow") if isinstance(aligned.get("flow"), dict) else {} aligned["flow"] = { **flow, "evidence": "读取" + "、".join(field.label for field in selected_fields[:3]), "decision": aligned["condition_summary"], } return aligned @staticmethod def _build_compare_conditions(field_keys: list[str]) -> list[dict[str, str]]: if len(field_keys) >= 2: return [{"left": field_keys[0], "operator": "overlap", "right": field_keys[1]}] if field_keys: return [{"left": field_keys[0], "operator": "is_empty", "right": ""}] return [] @staticmethod def _infer_template_key(text: str) -> str: if any( keyword in text for keyword in ("一致", "匹配", "相同", "不一致", "不符", "对应", "出现在") ): return "field_compare_v1" if any( keyword in text for keyword in ("关键词", "包含", "出现", "品名", "摘要", "服务费", "咨询费") ): return "keyword_match_v1" return "field_required_v1" @staticmethod def _infer_keywords(text: str) -> list[str]: quoted = re.findall(r"[“\"']([^“”\"']{2,20})[”\"']", text) keywords = [item.strip() for item in quoted if item.strip()] for candidate in ("咨询费", "服务费", "其他", "办公用品", "招待", "红冲", "作废"): if candidate in text and candidate not in keywords: keywords.append(candidate) return keywords[:8] @staticmethod def _infer_rule_name(text: str) -> str: normalized = re.sub(r"\s+", "", str(text or "")) normalized = re.sub(r"[，。；;：:、,.!?！？]", "", normalized) if not normalized: return "自然语言风险规则" return f"{normalized[:18]}风险规则" @staticmethod def _build_condition_summary( natural_language: str, *, template_key: str, fields: list[RiskRuleField], ) -> str: field_text = "、".join(item.label for item in fields[:3]) or "业务字段" if template_key == "field_compare_v1": return f"对比{field_text}之间是否一致或存在交集" if template_key == "keyword_match_v1": return f"检查{field_text}是否出现规则描述中的风险关键词" return f"检查{field_text}是否满足必填和完整性要求" @staticmethod def _clean_text(value: Any) -> str: return re.sub(r"\s+", " ", str(value or "")).strip() @staticmethod def _extract_json_object(text: str) -> str: normalized = re.sub(r"^```(?:json)?|```$", "", str(text or "").strip(), flags=re.IGNORECASE) start = normalized.find("{") end = normalized.rfind("}") if start < 0 or end <= start: raise ValueError("JSON object not found.") return normalized[start : end + 1] @staticmethod def _build_version_markdown(payload: dict[str, Any]) -> str: metadata = payload.get("metadata") if isinstance(payload.get("metadata"), dict) else {} fields = ( payload.get("inputs", {}).get("fields") if isinstance(payload.get("inputs"), dict) else [] ) field_labels = [ str(item.get("label") or item.get("key") or "").strip() for item in fields if isinstance(item, dict) and str(item.get("label") or item.get("key") or "").strip() ] return "\n".join( [ f"# {payload.get('name')}", "", "## 业务说明", "", str(payload.get("description") or ""), "", "## 自然语言原文", "", str(metadata.get("natural_language") or ""), "", "## 使用字段", "", "、".join(field_labels) or "未识别字段", "", "## 运行时 JSON", "", "```json", json.dumps(payload, ensure_ascii=False, indent=2), "```", ] )