```

refactor(api): 使用常量替代硬编码字符串

- 在health_check接口中使用ApiResponseKey.STATUS和ApiStatus.OK常量
- 替换硬编码的状态返回值为枚举常量

refactor(core): 配置模块错误信息统一使用常量

- 从constants模块导入ConfigErrorDetail并替换CORS_ORIGINS和LEGACY_ALLOWED_QUERIES的验证错误信息
- 配置类中的默认值使用constants中定义的常量

feat(constants): 添加API响应、安全错误和配置错误常量类

- 新增ApiResponseKey用于API状态键名
- 新增ApiStatus用于API状态值
- 新增SecurityErrorDetail用于安全认证错误详情
- 新增ConfigErrorDetail用于配置验证错误详情
- 添加DEFAULT_MODEL_PROVIDER和DEFAULT_OPENCLAW_ACTION_JSON常量

refactor(security): 安全认证模块使用错误常量

- 将硬编码的安全错误信息替换为SecurityErrorDetail常量
- 包括API密钥、审批密钥和审计密钥的相关错误信息

refactor(ai-agent): AI代理适配器改进错误处理

- 将HTTP状态码替换为FastAPI状态常量
- 添加OpenClaw工具和操作的错误常量
- 修复健康检查和工具调用中的状态码比较逻辑
- 添加AIToolAuditKey用于工具审计键名

feat(ai-agent): 扩展AI代理常量定义

- 新增AIToolAuditKey用于工具审计字段
- 添加OpenClaw相关的错误常量如OPENCLAW_CHAT_PROVIDER_REQUIRED等
- 添加UNSUPPORTED_AI_SKILL_TEMPLATE模板字符串

refactor(approvals): 审批模块常量化重构

- 新增ApprovalPayloadKey用于审批载荷字段
- 添加approval_action函数和APPROVAL_ACTION_SEPARATOR分隔符
- 使用常量替换字面量值

feat(audit): 审计模块新增飞书事件动作类型

- 添加FEISHU_WEBHOOK_EVENT和FEISHU_LONG_CONNECTION_EVENT审计动作

refactor(business): 业务模块全面常量化

- 新增BusinessDomain枚举包含所有业务域
- 添加BusinessResponseKey、BusinessPayloadKey等常量类
- 重构DOMAIN_MODELS为frozenset以提高性能
- 添加normalize_domain等辅助函数用于域标准化
- 使用常量替换路由和业务服务中的硬编码字符串
- 添加业务错误常量和字段验证模板

refactor(feishu): 飞书客户端错误处理优化

- 将HTTP状态码替换为FastAPI标准状态常量
- 改进错误处理的一致性

refactor(approvals): 审批服务使用新常量结构

- 使用ApprovalPayloadKey常量重构载荷字段
- 使用approval_action函数统一动作命名格式
- 优化高风险域判断逻辑
```

app/modules/feishu/events.py

@@ -4,21 +4,22 @@ from sqlalchemy.exc import IntegrityError
 from sqlalchemy.orm import Session
 
 from app.core.constants import ActorValue
-from app.modules.audit.constants import AuditSource
+from app.modules.audit.constants import AuditAction, AuditSource
 from app.modules.audit.schemas import AuditLogCreate
 from app.modules.feishu.commands import FeishuCommandService
 from app.modules.feishu.constants import (
-    FEISHU_LONG_CONNECTION_EVENT_ACTION,
-    FEISHU_WEBHOOK_EVENT_ACTION,
     FeishuCommandKey,
+    FeishuEventReceiptKey,
+    FeishuEventSource,
     FeishuPayloadKey,
+    FeishuResponseKey,
 )
 from app.modules.feishu.models import FeishuEventReceipt
 from app.modules.feishu.service import FeishuService
 
 FEISHU_EVENT_ACTIONS = {
-    "webhook": FEISHU_WEBHOOK_EVENT_ACTION,
-    "long_connection": FEISHU_LONG_CONNECTION_EVENT_ACTION,
+    FeishuEventSource.WEBHOOK: AuditAction.FEISHU_WEBHOOK_EVENT,
+    FeishuEventSource.LONG_CONNECTION: AuditAction.FEISHU_LONG_CONNECTION_EVENT,
 }
 
 
@@ -33,41 +34,57 @@ class FeishuEventService:
     def handle_event(
         self,
         payload: dict[str, Any],
-        source: str,
+        source: str | FeishuEventSource,
         auto_reply: bool = True,
     ) -> dict[str, Any]:
         self.feishu.verify_event(payload)
+        challenge = payload.get(FeishuPayloadKey.CHALLENGE)
+        if challenge:
+            return {FeishuResponseKey.CHALLENGE: challenge}
+        source_value = _normalize_source(source)
         event_identity = _event_identity(payload, source)
         if event_identity and not self._register_event(event_identity):
-            return {"ok": True, "handled": False, "duplicate": True}
+            return {
+                FeishuResponseKey.OK: True,
+                FeishuResponseKey.HANDLED: False,
+                FeishuResponseKey.DUPLICATE: True,
+            }
         self.feishu.audit.log(
             AuditLogCreate(
                 actor=ActorValue.FEISHU,
                 source=AuditSource.FEISHU,
-                action=FEISHU_EVENT_ACTIONS.get(source, FEISHU_WEBHOOK_EVENT_ACTION),
-                target_type=source,
-                target_id=event_identity.get("event_key") if event_identity else None,
+                action=FEISHU_EVENT_ACTIONS[source_value],
+                target_type=source_value,
+                target_id=(
+                    event_identity.get(FeishuEventReceiptKey.EVENT_KEY)
+                    if event_identity
+                    else None
+                ),
                 request_payload=payload,
-                response_payload={"accepted": True},
+                response_payload={FeishuResponseKey.ACCEPTED: True},
             )
         )
         command = self.commands.extract_event_command(payload)
         if not command:
-            return {"ok": True, "handled": False}
+            return {FeishuResponseKey.OK: True, FeishuResponseKey.HANDLED: False}
         result = self.commands.handle_text(
             command[FeishuCommandKey.TEXT],
             chat_id=command[FeishuCommandKey.CHAT_ID],
             actor=command[FeishuCommandKey.ACTOR],
             auto_reply=auto_reply,
         )
-        return {"ok": True, "handled": True, "result": result}
+        return {
+            FeishuResponseKey.OK: True,
+            FeishuResponseKey.HANDLED: True,
+            FeishuResponseKey.RESULT: result,
+        }
 
     def _register_event(self, event_identity: dict[str, str | None]) -> bool:
         receipt = FeishuEventReceipt(
-            event_key=str(event_identity["event_key"]),
-            source=str(event_identity["source"]),
-            event_id=event_identity.get("event_id"),
-            message_id=event_identity.get("message_id"),
+            event_key=str(event_identity[FeishuEventReceiptKey.EVENT_KEY]),
+            source=str(event_identity[FeishuEventReceiptKey.SOURCE]),
+            event_id=event_identity.get(FeishuEventReceiptKey.EVENT_ID),
+            message_id=event_identity.get(FeishuEventReceiptKey.MESSAGE_ID),
         )
         self.db.add(receipt)
         try:
@@ -78,7 +95,15 @@ class FeishuEventService:
         return True
 
 
-def _event_identity(payload: dict[str, Any], source: str) -> dict[str, str | None] | None:
+def _normalize_source(source: str | FeishuEventSource) -> FeishuEventSource:
+    return FeishuEventSource(source)
+
+
+def _event_identity(
+    payload: dict[str, Any],
+    source: str | FeishuEventSource,
+) -> dict[str, str | None] | None:
+    source_value = _normalize_source(source)
     header = payload.get(FeishuPayloadKey.HEADER) or {}
     event = payload.get(FeishuPayloadKey.EVENT) or {}
     message = event.get(FeishuPayloadKey.MESSAGE) or {}
@@ -90,11 +115,11 @@ def _event_identity(payload: dict[str, Any], source: str) -> dict[str, str | Non
     event_type = header.get(FeishuPayloadKey.EVENT_TYPE)
     event_key = ":".join(
         str(part)
-        for part in (source, event_type or FeishuPayloadKey.EVENT, stable_id)
+        for part in (source_value, event_type or FeishuPayloadKey.EVENT, stable_id)
     )
     return {
-        "event_key": event_key,
-        "source": source,
-        "event_id": str(event_id) if event_id else None,
-        "message_id": str(message_id) if message_id else None,
+        FeishuEventReceiptKey.EVENT_KEY: event_key,
+        FeishuEventReceiptKey.SOURCE: source_value,
+        FeishuEventReceiptKey.EVENT_ID: str(event_id) if event_id else None,
+        FeishuEventReceiptKey.MESSAGE_ID: str(message_id) if message_id else None,
     }