先添加一个数据模型你别管他用没用

src/common/data_models/__init__.py

@@ -0,0 +1,53 @@
+import copy
+from typing import Any
+
+
+class BaseDataModel:
+    def deepcopy(self):
+        return copy.deepcopy(self)
+
+def temporarily_transform_class_to_dict(obj: Any) -> Any:
+    # sourcery skip: assign-if-exp, reintroduce-else
+    """
+    将对象或容器中的 BaseDataModel 子类（类对象）或 BaseDataModel 实例
+    递归转换为普通 dict，不修改原对象。
+    - 对于类对象（isinstance(value, type) 且 issubclass(..., BaseDataModel)），
+      读取类的 __dict__ 中非 dunder 项并递归转换。
+    - 对于实例（isinstance(value, BaseDataModel)），读取 vars(instance) 并递归转换。
+    """
+
+    def _transform(value: Any) -> Any:
+        # 值是类对象且为 BaseDataModel 的子类
+        if isinstance(value, type) and issubclass(value, BaseDataModel):
+            return {k: _transform(v) for k, v in value.__dict__.items() if not k.startswith("__") and not callable(v)}
+
+        # 值是 BaseDataModel 的实例
+        if isinstance(value, BaseDataModel):
+            return {k: _transform(v) for k, v in vars(value).items()}
+
+        # 常见容器类型，递归处理
+        if isinstance(value, dict):
+            return {k: _transform(v) for k, v in value.items()}
+        if isinstance(value, list):
+            return [_transform(v) for v in value]
+        if isinstance(value, tuple):
+            return tuple(_transform(v) for v in value)
+        if isinstance(value, set):
+            return {_transform(v) for v in value}
+        # 基本类型，直接返回
+        return value
+
+    result = _transform(obj)
+
+    def flatten(target_dict: dict):
+        flat_dict = {}
+        for k, v in target_dict.items():
+            if isinstance(v, dict):
+                # 递归扁平化子字典
+                sub_flat = flatten(v)
+                flat_dict.update(sub_flat)
+            else:
+                flat_dict[k] = v
+        return flat_dict
+
+    return flatten(result) if isinstance(result, dict) else result

src/common/data_models/database_data_model.py

@@ -0,0 +1,235 @@
+import json
+from typing import Optional, Any, Dict
+from dataclasses import dataclass, field
+
+from . import BaseDataModel
+
+
+@dataclass
+class DatabaseUserInfo(BaseDataModel):
+    platform: str = field(default_factory=str)
+    user_id: str = field(default_factory=str)
+    user_nickname: str = field(default_factory=str)
+    user_cardname: Optional[str] = None
+
+    # def __post_init__(self):
+    #     assert isinstance(self.platform, str), "platform must be a string"
+    #     assert isinstance(self.user_id, str), "user_id must be a string"
+    #     assert isinstance(self.user_nickname, str), "user_nickname must be a string"
+    #     assert isinstance(self.user_cardname, str) or self.user_cardname is None, (
+    #         "user_cardname must be a string or None"
+    #     )
+
+
+@dataclass
+class DatabaseGroupInfo(BaseDataModel):
+    group_id: str = field(default_factory=str)
+    group_name: str = field(default_factory=str)
+    group_platform: Optional[str] = None
+
+    # def __post_init__(self):
+    #     assert isinstance(self.group_id, str), "group_id must be a string"
+    #     assert isinstance(self.group_name, str), "group_name must be a string"
+    #     assert isinstance(self.group_platform, str) or self.group_platform is None, (
+    #         "group_platform must be a string or None"
+    #     )
+
+
+@dataclass
+class DatabaseChatInfo(BaseDataModel):
+    stream_id: str = field(default_factory=str)
+    platform: str = field(default_factory=str)
+    create_time: float = field(default_factory=float)
+    last_active_time: float = field(default_factory=float)
+    user_info: DatabaseUserInfo = field(default_factory=DatabaseUserInfo)
+    group_info: Optional[DatabaseGroupInfo] = None
+
+    # def __post_init__(self):
+    #     assert isinstance(self.stream_id, str), "stream_id must be a string"
+    #     assert isinstance(self.platform, str), "platform must be a string"
+    #     assert isinstance(self.create_time, float), "create_time must be a float"
+    #     assert isinstance(self.last_active_time, float), "last_active_time must be a float"
+    #     assert isinstance(self.user_info, DatabaseUserInfo), "user_info must be a DatabaseUserInfo instance"
+    #     assert isinstance(self.group_info, DatabaseGroupInfo) or self.group_info is None, (
+    #         "group_info must be a DatabaseGroupInfo instance or None"
+    #     )
+
+
+@dataclass(init=False)
+class DatabaseMessages(BaseDataModel):
+    def __init__(
+        self,
+        message_id: str = "",
+        time: float = 0.0,
+        chat_id: str = "",
+        reply_to: Optional[str] = None,
+        interest_value: Optional[float] = None,
+        key_words: Optional[str] = None,
+        key_words_lite: Optional[str] = None,
+        is_mentioned: Optional[bool] = None,
+        is_at: Optional[bool] = None,
+        reply_probability_boost: Optional[float] = None,
+        processed_plain_text: Optional[str] = None,
+        display_message: Optional[str] = None,
+        priority_mode: Optional[str] = None,
+        priority_info: Optional[str] = None,
+        additional_config: Optional[str] = None,
+        is_emoji: bool = False,
+        is_picid: bool = False,
+        is_command: bool = False,
+        is_notify: bool = False,
+        selected_expressions: Optional[str] = None,
+        user_id: str = "",
+        user_nickname: str = "",
+        user_cardname: Optional[str] = None,
+        user_platform: str = "",
+        chat_info_group_id: Optional[str] = None,
+        chat_info_group_name: Optional[str] = None,
+        chat_info_group_platform: Optional[str] = None,
+        chat_info_user_id: str = "",
+        chat_info_user_nickname: str = "",
+        chat_info_user_cardname: Optional[str] = None,
+        chat_info_user_platform: str = "",
+        chat_info_stream_id: str = "",
+        chat_info_platform: str = "",
+        chat_info_create_time: float = 0.0,
+        chat_info_last_active_time: float = 0.0,
+        **kwargs: Any,
+    ):
+        self.message_id = message_id
+        self.time = time
+        self.chat_id = chat_id
+        self.reply_to = reply_to
+        self.interest_value = interest_value
+
+        self.key_words = key_words
+        self.key_words_lite = key_words_lite
+        self.is_mentioned = is_mentioned
+
+        self.is_at = is_at
+        self.reply_probability_boost = reply_probability_boost
+
+        self.processed_plain_text = processed_plain_text
+        self.display_message = display_message
+
+        self.priority_mode = priority_mode
+        self.priority_info = priority_info
+
+        self.additional_config = additional_config
+        self.is_emoji = is_emoji
+        self.is_picid = is_picid
+        self.is_command = is_command
+        self.is_notify = is_notify
+
+        self.selected_expressions = selected_expressions
+
+        self.group_info: Optional[DatabaseGroupInfo] = None
+        self.user_info = DatabaseUserInfo(
+            user_id=user_id,
+            user_nickname=user_nickname,
+            user_cardname=user_cardname,
+            platform=user_platform,
+        )
+        if chat_info_group_id and chat_info_group_name:
+            self.group_info = DatabaseGroupInfo(
+                group_id=chat_info_group_id,
+                group_name=chat_info_group_name,
+                group_platform=chat_info_group_platform,
+            )
+
+        self.chat_info = DatabaseChatInfo(
+            stream_id=chat_info_stream_id,
+            platform=chat_info_platform,
+            create_time=chat_info_create_time,
+            last_active_time=chat_info_last_active_time,
+            user_info=DatabaseUserInfo(
+                user_id=chat_info_user_id,
+                user_nickname=chat_info_user_nickname,
+                user_cardname=chat_info_user_cardname,
+                platform=chat_info_user_platform,
+            ),
+            group_info=self.group_info,
+        )
+
+        if kwargs:
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+    # def __post_init__(self):
+    #     assert isinstance(self.message_id, str), "message_id must be a string"
+    #     assert isinstance(self.time, float), "time must be a float"
+    #     assert isinstance(self.chat_id, str), "chat_id must be a string"
+    #     assert isinstance(self.reply_to, str) or self.reply_to is None, "reply_to must be a string or None"
+    #     assert isinstance(self.interest_value, float) or self.interest_value is None, (
+    #         "interest_value must be a float or None"
+    #     )
+    def flatten(self) -> Dict[str, Any]:
+        """
+        将消息数据模型转换为字典格式，便于存储或传输
+        """
+        return {
+            "message_id": self.message_id,
+            "time": self.time,
+            "chat_id": self.chat_id,
+            "reply_to": self.reply_to,
+            "interest_value": self.interest_value,
+            "key_words": self.key_words,
+            "key_words_lite": self.key_words_lite,
+            "is_mentioned": self.is_mentioned,
+            "is_at": self.is_at,
+            "reply_probability_boost": self.reply_probability_boost,
+            "processed_plain_text": self.processed_plain_text,
+            "display_message": self.display_message,
+            "priority_mode": self.priority_mode,
+            "priority_info": self.priority_info,
+            "additional_config": self.additional_config,
+            "is_emoji": self.is_emoji,
+            "is_picid": self.is_picid,
+            "is_command": self.is_command,
+            "is_notify": self.is_notify,
+            "selected_expressions": self.selected_expressions,
+            "user_id": self.user_info.user_id,
+            "user_nickname": self.user_info.user_nickname,
+            "user_cardname": self.user_info.user_cardname,
+            "user_platform": self.user_info.platform,
+            "chat_info_group_id": self.group_info.group_id if self.group_info else None,
+            "chat_info_group_name": self.group_info.group_name if self.group_info else None,
+            "chat_info_group_platform": self.group_info.group_platform if self.group_info else None,
+            "chat_info_stream_id": self.chat_info.stream_id,
+            "chat_info_platform": self.chat_info.platform,
+            "chat_info_create_time": self.chat_info.create_time,
+            "chat_info_last_active_time": self.chat_info.last_active_time,
+            "chat_info_user_platform": self.chat_info.user_info.platform,
+            "chat_info_user_id": self.chat_info.user_info.user_id,
+            "chat_info_user_nickname": self.chat_info.user_info.user_nickname,
+            "chat_info_user_cardname": self.chat_info.user_info.user_cardname,
+        }
+
+@dataclass(init=False)
+class DatabaseActionRecords(BaseDataModel):
+    def __init__(
+        self,
+        action_id: str,
+        time: float,
+        action_name: str,
+        action_data: str,
+        action_done: bool,
+        action_build_into_prompt: bool,
+        action_prompt_display: str,
+        chat_id: str,
+        chat_info_stream_id: str,
+        chat_info_platform: str,
+    ):
+        self.action_id = action_id
+        self.time = time
+        self.action_name = action_name
+        if isinstance(action_data, str):
+            self.action_data = json.loads(action_data)
+        else:
+            raise ValueError("action_data must be a JSON string")
+        self.action_done = action_done
+        self.action_build_into_prompt = action_build_into_prompt
+        self.action_prompt_display = action_prompt_display
+        self.chat_id = chat_id
+        self.chat_info_stream_id = chat_info_stream_id
+        self.chat_info_platform = chat_info_platform

src/common/data_models/info_data_model.py

@@ -0,0 +1,25 @@
+from dataclasses import dataclass, field
+from typing import Optional, Dict, TYPE_CHECKING
+from . import BaseDataModel
+
+if TYPE_CHECKING:
+    from .database_data_model import DatabaseMessages
+    from src.plugin_system.base.component_types import ActionInfo
+
+
+@dataclass
+class TargetPersonInfo(BaseDataModel):
+    platform: str = field(default_factory=str)
+    user_id: str = field(default_factory=str)
+    user_nickname: str = field(default_factory=str)
+    person_id: Optional[str] = None
+    person_name: Optional[str] = None
+
+
+@dataclass
+class ActionPlannerInfo(BaseDataModel):
+    action_type: str = field(default_factory=str)
+    reasoning: Optional[str] = None
+    action_data: Optional[Dict] = None
+    action_message: Optional["DatabaseMessages"] = None
+    available_actions: Optional[Dict[str, "ActionInfo"]] = None

src/common/data_models/llm_data_model.py

@@ -0,0 +1,16 @@
+from dataclasses import dataclass
+from typing import Optional, List, Tuple, TYPE_CHECKING, Any
+
+from . import BaseDataModel
+if TYPE_CHECKING:
+    from src.llm_models.payload_content.tool_option import ToolCall
+
+@dataclass
+class LLMGenerationDataModel(BaseDataModel):
+    content: Optional[str] = None
+    reasoning: Optional[str] = None
+    model: Optional[str] = None
+    tool_calls: Optional[List["ToolCall"]] = None
+    prompt: Optional[str] = None
+    selected_expressions: Optional[List[int]] = None
+    reply_set: Optional[List[Tuple[str, Any]]] = None

src/common/data_models/message_data_model.py

@@ -0,0 +1,36 @@
+from typing import Optional, TYPE_CHECKING
+from dataclasses import dataclass, field
+
+from . import BaseDataModel
+
+if TYPE_CHECKING:
+    from .database_data_model import DatabaseMessages
+
+
+@dataclass
+class MessageAndActionModel(BaseDataModel):
+    chat_id: str = field(default_factory=str)
+    time: float = field(default_factory=float)
+    user_id: str = field(default_factory=str)
+    user_platform: str = field(default_factory=str)
+    user_nickname: str = field(default_factory=str)
+    user_cardname: Optional[str] = None
+    processed_plain_text: Optional[str] = None
+    display_message: Optional[str] = None
+    chat_info_platform: str = field(default_factory=str)
+    is_action_record: bool = field(default=False)
+    action_name: Optional[str] = None
+
+    @classmethod
+    def from_DatabaseMessages(cls, message: "DatabaseMessages"):
+        return cls(
+            chat_id=message.chat_id,
+            time=message.time,
+            user_id=message.user_info.user_id,
+            user_platform=message.user_info.platform,
+            user_nickname=message.user_info.user_nickname,
+            user_cardname=message.user_info.user_cardname,
+            processed_plain_text=message.processed_plain_text,
+            display_message=message.display_message,
+            chat_info_platform=message.chat_info.platform,
+        )