完成世界书、骰子、apiconfig页面处理

This commit is contained in:
2026-04-30 01:35:10 +08:00
parent a3e3711b2b
commit ba9b925c32
4602 changed files with 785225 additions and 23 deletions

231
backend/models/README.md Normal file
View File

@@ -0,0 +1,231 @@
# Backend Models 数据模型说明
## 目录结构
```
models/
├── __init__.py # 包初始化,导出所有模型
├── sillytavern.py # SillyTavern 兼容模型 (仅用于导入/导出)
├── internal.py # 内部业务模型 (项目核心使用)
└── README.md # 本文件
```
## 模型分类
### 1. SillyTavern 兼容模型 (`sillytavern.py`)
**用途**: 仅用于与 SillyTavern 格式的数据进行导入/导出兼容
**特点**:
- 严格遵循 SillyTavern 官方规范
- 不参与内部业务逻辑
- 所有字段名、结构与 SillyTavern 保持一致
- 前缀 `ST` 表示 SillyTavern
**主要模型**:
- `STWorldInfo` - SillyTavern 世界书
- `STCharacterCard` - SillyTavern 角色卡
- `STChatHeader` / `STChatMessage` - SillyTavern 聊天记录
- `STGenerationPreset` - SillyTavern 采样预设
- `STPromptPreset` - SillyTavern 提示词预设
**使用场景**:
```python
# 从 SillyTavern 导入时
st_data = json.load(file)
st_character = STCharacterCard(**st_data)
# 转换为内部模型
internal_character = converter.st_to_internal(st_character)
# 导出到 SillyTavern 时
st_data = converter.internal_to_st(internal_character)
json.dump(st_data.dict(), file)
```
### 2. 内部业务模型 (`internal.py`)
**用途**: 项目内部真正使用的数据结构,所有业务逻辑都基于这些模型
**特点**:
- 继承并扩展了 SillyTavern 的功能
- 添加了项目特色功能 (如 LOGIC 激活、RAG 配置、outputSchema 等)
- 所有 API 响应、数据存储、工作流交换都使用这些模型
- 无前缀,直接使用语义化名称
**主要模型**:
#### 世界书相关
- `ActivationType` - 激活方式枚举 (PERMANENT/KEYWORD/RAG/LOGIC)
- `LogicExpression` - 逻辑表达式
- `RAGConfig` - RAG 检索配置
- `WorldInfoEntry` - 世界书条目
- `WorldInfo` - 世界书
#### 角色卡相关
- `OutputSchemaField` - 结构化输出 schema
- `CharacterCard` - 角色卡
#### 聊天记录相关
- `ChatHeader` - 聊天头
- `ChatMessage` - 聊天消息
- `ChatLog` - 完整聊天记录
#### 预设相关
- `GenerationPreset` - 采样参数预设
- `PromptRole` - Prompt 角色枚举
- `PromptEntry` - Prompt 条目
- `PromptPresetView` - Prompt 预设视图
#### RAG 配置
- `RAGSearchConfig` - RAG 搜索配置
- `CharacterRAGConfig` - 角色卡 RAG 配置
- `ChatRAGConfig` - 聊天 RAG 配置
**使用场景**:
```python
# 业务逻辑中直接使用
from models import CharacterCard, WorldInfo
character = CharacterCard(
id="uuid-123",
name="Alice",
description="...",
...
)
# API 响应
@app.get("/characters/{id}")
async def get_character(id: str):
character = service.get_character(id)
return character # 返回 internal 模型
```
## 数据转换流程
```
SillyTavern 文件
↓ (导入)
STCharacterCard (sillytavern.py)
↓ (转换器)
CharacterCard (internal.py)
↓ (业务处理)
CharacterCard (internal.py)
↓ (转换器)
STCharacterCard (sillytavern.py)
↓ (导出)
SillyTavern 文件
```
## 开发规范
### ✅ 正确做法
1. **业务逻辑使用 internal 模型**
```python
from models import CharacterCard
def create_character(data: dict) -> CharacterCard:
return CharacterCard(**data)
```
2. **导入时使用转换器**
```python
from models import STCharacterCard, CharacterCard
from models.converters import CharacterConverter
def import_character(file_path: str) -> CharacterCard:
st_data = load_json(file_path)
st_char = STCharacterCard(**st_data)
return CharacterConverter.st_to_internal(st_char)
```
3. **API 响应使用 internal 模型**
```python
@app.get("/characters")
async def list_characters() -> List[CharacterCard]:
return service.list_characters()
```
### ❌ 错误做法
1. **不要在业务逻辑中直接使用 ST 模型**
```python
# 错误!
from models import STCharacterCard
def process_character(char: STCharacterCard):
...
```
2. **不要混合使用两种模型**
```python
# 错误!
character = CharacterCard(...)
character.name = st_character.data.name # 不要混用
```
3. **不要在 API 中暴露 ST 模型**
```python
# 错误!
@app.get("/characters")
async def list_characters() -> List[STCharacterCard]:
...
```
## 添加新模型
当需要添加新的数据类型时:
1. **判断用途**:
- 如果是为了 SillyTavern 兼容 → 添加到 `sillytavern.py`
- 如果是项目内部使用 → 添加到 `internal.py`
2. **遵循命名规范**:
- SillyTavern 模型: 前缀 `ST`
- 内部模型: 无前缀,使用清晰的语义化名称
3. **添加详细注释**:
```python
class MyModel(BaseModel):
"""
模型用途说明
详细描述该模型的作用、使用场景等
"""
field1: str = Field(..., description="字段说明")
```
4. **在 `__init__.py` 中导出**:
```python
from .internal import MyModel
__all__ = [
...,
'MyModel',
]
```
## 转换器 (待实现)
`models/converters.py` 将提供双向转换功能:
```python
class CharacterConverter:
@staticmethod
def st_to_internal(st_char: STCharacterCard) -> CharacterCard:
"""SillyTavern → Internal"""
...
@staticmethod
def internal_to_st(int_char: CharacterCard) -> STCharacterCard:
"""Internal → SillyTavern"""
...
```
## 总结
- **sillytavern.py** = 外部兼容层 (Import/Export Only)
- **internal.py** = 内部业务层 (Core Business Logic)
- **永远在业务逻辑中使用 internal 模型**
- **通过转换器进行格式转换**

View File

@@ -0,0 +1,61 @@
"""
数据模型包
导出项目内部真正使用的数据结构 (Internal Models)。
SillyTavern 兼容模型将在需要导入/导出时单独引用。
"""
# 内部业务模型 (项目核心使用)
from .internal import (
# 世界书
ActivationType,
LogicOperator,
LogicExpression,
RAGConfig,
WorldInfoEntry,
WorldInfo,
# 角色卡
OutputSchemaField,
CharacterCard,
# 聊天记录
ChatHeader,
ChatMessage,
ChatLog,
# 预设
GenerationPreset,
# 提示词预设
PromptRole,
PromptEntry,
PromptPresetView,
# RAG 配置
RAGSearchConfig,
CharacterRAGConfig,
ChatRAGConfig,
)
__all__ = [
# 内部模型
'ActivationType',
'LogicOperator',
'LogicExpression',
'RAGConfig',
'WorldInfoEntry',
'WorldInfo',
'OutputSchemaField',
'CharacterCard',
'ChatHeader',
'ChatMessage',
'ChatLog',
'GenerationPreset',
'PromptRole',
'PromptEntry',
'PromptPresetView',
'RAGSearchConfig',
'CharacterRAGConfig',
'ChatRAGConfig',
]

View File

@@ -0,0 +1,379 @@
"""
数据模型转换器
提供 SillyTavern 格式与内部格式之间的双向转换功能。
所有导入/导出操作都应该通过转换器进行,确保数据格式的一致性。
"""
import uuid
from typing import Dict, Any, List, Optional
from datetime import datetime
from models.internal import (
WorldInfo,
WorldInfoEntry,
ActivationType,
)
class WorldBookConverter:
"""世界书数据转换器
负责 SillyTavern 格式和项目内部格式之间的转换。
SillyTavern 格式特点:
- entries 是 dict (key 为 uid)
- 使用 constant 字段表示常驻激活
- position 是字符串 (如 "after_char")
项目内部格式特点:
- entries 是 list
- 使用 activationType 枚举
- position 是数字 (0-5)
- 包含 trigger_config 结构(前端需要)
"""
@staticmethod
def detect_format(data: Dict[str, Any]) -> str:
"""
智能检测世界书数据格式
Args:
data: 世界书数据
Returns:
'sillytavern' | 'internal' | 'unknown'
"""
# 检查 entries 类型
entries = data.get("entries")
if not entries:
return "unknown"
# SillyTavern 特征: entries 是 dict
if isinstance(entries, dict):
return "sillytavern"
# 内部格式特征: entries 是 list
if isinstance(entries, list):
# 进一步检查是否有 trigger_config
if len(entries) > 0 and isinstance(entries[0], dict):
first_entry = entries[0]
if "trigger_config" in first_entry:
return "internal"
# 也可能是简化的内部格式
if "activationType" in first_entry or "position" in first_entry:
return "internal"
return "unknown"
# 位置映射: SillyTavern 字符串 -> 内部数字
POSITION_MAP_ST_TO_INTERNAL = {
"after_char": 0,
"before_char": 1,
"before_example": 2,
"after_example": 3,
"author_note": 4,
"system_prompt": 5,
}
# 位置映射: 内部数字 -> SillyTavern 字符串
POSITION_MAP_INTERNAL_TO_ST = {
0: "after_char",
1: "before_char",
2: "before_example",
3: "after_example",
4: "author_note",
5: "system_prompt",
}
@staticmethod
def st_to_internal(st_data: Dict[str, Any], name: str = None) -> Dict[str, Any]:
"""
将 SillyTavern 格式的世界书转换为内部格式
Args:
st_data: SillyTavern 格式的世界书数据
name: 世界书名称(可选,优先使用 st_data 中的 name)
Returns:
内部格式的世界书字典(包含 trigger_config)
"""
now = int(datetime.now().timestamp())
# 转换条目
entries = []
st_entries = st_data.get("entries", {})
# SillyTavern 的 entries 可能是 dict 或 list
if isinstance(st_entries, dict):
entries_list = list(st_entries.values())
elif isinstance(st_entries, list):
entries_list = st_entries
else:
entries_list = []
for st_entry in entries_list:
if not isinstance(st_entry, dict):
continue
# 判断激活类型
is_constant = st_entry.get("constant", False)
activation_type = ActivationType.PERMANENT if is_constant else ActivationType.KEYWORD
# 转换位置
st_position = st_entry.get("position", "after_char")
internal_position = WorldBookConverter.POSITION_MAP_ST_TO_INTERNAL.get(st_position, 0)
# 构建 trigger_config (前端期望的格式)
trigger_config = WorldBookConverter._build_trigger_config(
is_constant=is_constant,
key=st_entry.get("key", []),
keysecondary=st_entry.get("keysecondary", []),
selective=st_entry.get("selective", True)
)
# 创建内部格式的条目
entry_dict = {
"uid": st_entry.get("uid", str(uuid.uuid4())),
"key": st_entry.get("key", []),
"keysecondary": st_entry.get("keysecondary", []),
"content": st_entry.get("content", ""),
"comment": st_entry.get("comment", ""),
"activationType": activation_type.value,
"trigger_config": trigger_config,
"order": st_entry.get("order", 100),
"position": internal_position,
"depth": st_entry.get("depth", 4),
"role": st_entry.get("role", 0),
"probability": st_entry.get("probability", 100),
"group": st_entry.get("group", []),
"disable": st_entry.get("disable", False),
"createdAt": now,
"updatedAt": now
}
entries.append(entry_dict)
# 创建内部格式的世界书
worldbook_data = {
"id": str(uuid.uuid4()),
"name": name or st_data.get("name", "Unnamed"),
"description": st_data.get("description", ""),
"entries": entries,
"createdAt": now,
"updatedAt": now,
"version": 1
}
return worldbook_data
@staticmethod
def internal_to_st(worldbook_data: Dict[str, Any]) -> Dict[str, Any]:
"""
将内部格式的世界书转换为 SillyTavern 格式
Args:
worldbook_data: 内部格式的世界书字典
Returns:
SillyTavern 格式的世界书数据
"""
# 转换条目
st_entries = {}
for entry_data in worldbook_data.get("entries", []):
if not isinstance(entry_data, dict):
continue
uid = entry_data.get("uid", str(uuid.uuid4()))
# 从 trigger_config 或 activationType 判断是否常驻
is_constant = WorldBookConverter._is_constant_entry(entry_data)
# 提取关键词
key, keysecondary = WorldBookConverter._extract_keywords(entry_data)
# 转换位置
internal_position = entry_data.get("position", 0)
st_position = WorldBookConverter.POSITION_MAP_INTERNAL_TO_ST.get(internal_position, "after_char")
# 创建 SillyTavern 格式的条目
st_entry = {
"uid": uid,
"key": key,
"keysecondary": keysecondary,
"content": entry_data.get("content", ""),
"comment": entry_data.get("comment", ""),
"constant": is_constant,
"selective": not is_constant,
"order": entry_data.get("order", 100),
"position": st_position,
"depth": entry_data.get("depth", 4),
"probability": entry_data.get("probability", 100),
"group": entry_data.get("group", []),
"disable": entry_data.get("disable", False)
}
st_entries[uid] = st_entry
# 创建 SillyTavern 格式的世界书
st_data = {
"name": worldbook_data.get("name", ""),
"description": worldbook_data.get("description", ""),
"entries": st_entries
}
return st_data
@staticmethod
def normalize_entry(entry_data: Dict[str, Any]) -> Dict[str, Any]:
"""
规范化条目数据,确保包含所有必需字段和 trigger_config
Args:
entry_data: 条目数据(可能来自不同来源)
Returns:
规范化后的条目数据
"""
now = int(datetime.now().timestamp())
# 如果已经有 trigger_config,直接返回
if "trigger_config" in entry_data and entry_data["trigger_config"]:
return entry_data
# 否则从其他字段构建 trigger_config
is_constant = WorldBookConverter._is_constant_entry(entry_data)
key, keysecondary = WorldBookConverter._extract_keywords(entry_data)
trigger_config = WorldBookConverter._build_trigger_config(
is_constant=is_constant,
key=key,
keysecondary=keysecondary,
selective=entry_data.get("selective", True)
)
# 添加缺失的字段
normalized = {
"uid": entry_data.get("uid", str(uuid.uuid4())),
"key": key,
"keysecondary": keysecondary,
"content": entry_data.get("content", ""),
"comment": entry_data.get("comment", ""),
"activationType": entry_data.get("activationType",
ActivationType.PERMANENT.value if is_constant
else ActivationType.KEYWORD.value),
"trigger_config": trigger_config,
"order": entry_data.get("order", 100),
"position": entry_data.get("position", 0),
"depth": entry_data.get("depth", 4),
"role": entry_data.get("role", 0),
"probability": entry_data.get("probability", 100),
"group": entry_data.get("group", []),
"disable": entry_data.get("disable", False),
"createdAt": entry_data.get("createdAt", now),
"updatedAt": entry_data.get("updatedAt", now)
}
return normalized
@staticmethod
def _build_trigger_config(
is_constant: bool,
key: List[str],
keysecondary: List[str],
selective: bool = True
) -> Dict[str, Any]:
"""
构建 trigger_config 结构
Args:
is_constant: 是否常驻激活
key: 主关键词列表
keysecondary: 次要关键词列表
selective: 是否选择性匹配
Returns:
trigger_config 字典
"""
return {
"triggers": {
"constant": [is_constant, None],
"keyword": [
not is_constant,
{
"key": key,
"keysecondary": keysecondary,
"selective": selective,
"selectiveLogic": 0,
"matchWholeWords": False,
"caseSensitive": False
}
],
"rag": [False, {
"threshold": 0.75,
"top_k": 5,
"query_template": None
}],
"condition": [False, {
"variable_a": "",
"operator": "=",
"variable_b": ""
}]
}
}
@staticmethod
def _is_constant_entry(entry_data: Dict[str, Any]) -> bool:
"""
判断条目是否为常驻激活
Args:
entry_data: 条目数据
Returns:
是否常驻激活
"""
# 优先从 trigger_config 判断
if "trigger_config" in entry_data and entry_data["trigger_config"]:
try:
return entry_data["trigger_config"]["triggers"]["constant"][0]
except (KeyError, IndexError, TypeError):
pass
# 其次从 activationType 判断
if "activationType" in entry_data:
return entry_data["activationType"] == ActivationType.PERMANENT.value
# 最后从 constant 字段判断
if "constant" in entry_data:
return entry_data["constant"]
return False
@staticmethod
def _extract_keywords(entry_data: Dict[str, Any]) -> tuple:
"""
从条目数据中提取关键词
Args:
entry_data: 条目数据
Returns:
(key, keysecondary) 元组
"""
# 优先从 trigger_config 提取
if "trigger_config" in entry_data and entry_data["trigger_config"]:
try:
keyword_config = entry_data["trigger_config"]["triggers"]["keyword"][1]
if keyword_config:
key = keyword_config.get("key", [])
keysecondary = keyword_config.get("keysecondary", [])
return key, keysecondary
except (KeyError, IndexError, TypeError):
pass
# 否则从顶层字段提取
key = entry_data.get("key", [])
keysecondary = entry_data.get("keysecondary", [])
return key, keysecondary

301
backend/models/internal.py Normal file
View File

@@ -0,0 +1,301 @@
"""
项目内部数据结构定义
这是本项目真正使用的核心数据模型,所有业务逻辑都基于这些类型。
与 sillytavern.py 不同,这里的模型不参与导入导出兼容,而是专注于:
- 内部业务逻辑处理
- API 响应数据结构
- 数据存储格式
- 工作流引擎数据交换
所有从 SillyTavern 导入的数据都会转换为这些内部模型进行处理,
导出时再从内部模型转换回 SillyTavern 格式。
"""
from enum import Enum
from typing import List, Optional, Dict, Any
from pydantic import BaseModel, Field
from datetime import datetime
# ==================== 世界书 (World Info) ====================
class ActivationType(str, Enum):
"""
自定义激活方式类型4种枚举
这是项目的核心创新点之一,相比 SillyTavern 的简单 constant/selective 标志,
我们提供了更灵活的激活机制。
"""
PERMANENT = 'permanent' # 永久激活 - 始终包含在上下文中
KEYWORD = 'keyword' # 关键词触发 - 匹配关键词时激活
RAG = 'rag' # RAG 检索激活 - 基于向量相似度检索
LOGIC = 'logic' # 逻辑表达式激活 - 基于变量条件判断
class LogicOperator(str, Enum):
"""逻辑运算符(用于 LOGIC 激活类型)"""
EQUALS = 'equals' # 等于
NOT_EQUALS = 'not_equals' # 不等于
CONTAINS = 'contains' # 包含
NOT_CONTAINS = 'not_contains' # 不包含
GREATER = 'greater' # 大于
LESS = 'less' # 小于
class LogicExpression(BaseModel):
"""
逻辑表达式结构(用于 LOGIC 激活类型)
示例: variable1="mood", operator="equals", variable2="happy"
表示当 mood 变量等于 happy 时激活该条目
"""
variable1: str = Field(..., description="第一个变量名")
operator: LogicOperator = Field(..., description="比较运算符")
variable2: str = Field(..., description="第二个变量名或值")
class RAGConfig(BaseModel):
"""
RAG 配置(用于 RAG 激活类型)
控制如何从向量数据库中检索相关内容
"""
libraryId: str = Field(..., description="绑定的 RAG 库 ID")
threshold: Optional[float] = Field(0.7, ge=0, le=1, description="相似度阈值 (0-1)")
maxEntries: Optional[int] = Field(5, gt=0, description="最大返回条目数")
class WorldInfoEntry(BaseModel):
"""
项目内部世界书条目结构
这是世界书的核心单元,每个条目代表一段可以被动态注入到对话上下文中的知识。
相比 SillyTavern,我们添加了 activationType、logicExpression、ragConfig 等高级功能。
"""
uid: str = Field(..., description="条目唯一标识符 (UUID)")
key: Optional[List[str]] = Field(None, description="主关键词列表 (用于 KEYWORD 激活)")
keysecondary: Optional[List[str]] = Field(None, description="次要关键词列表 (可选过滤)")
content: str = Field(..., description="条目内容 - 激活时注入的文本")
activationType: ActivationType = Field(..., description="激活方式")
logicExpression: Optional[LogicExpression] = Field(None, description="逻辑表达式 (LOGIC 类型使用)")
ragConfig: Optional[RAGConfig] = Field(None, description="RAG 配置 (RAG 类型使用)")
order: int = Field(0, description="插入顺序 - 数值越大越靠近末尾")
position: Optional[str] = Field('after_char', description="插入位置")
depth: Optional[int] = Field(None, description="插入深度 (当 position='at_depth' 时使用)")
probability: Optional[float] = Field(100, ge=0, le=100, description="激活概率 (0-100)")
group: Optional[List[str]] = Field(None, description="所属组标签")
disable: bool = Field(False, description="是否禁用")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
class WorldInfo(BaseModel):
"""
项目内部世界书结构
世界书是角色知识的集合,可以绑定到角色卡上,在对话中动态提供背景信息。
"""
id: str = Field(..., description="世界书唯一标识符 (UUID)")
name: str = Field(..., description="世界书名称")
description: Optional[str] = Field(None, description="世界书描述")
entries: List[WorldInfoEntry] = Field(default_factory=list, description="条目数组")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
version: int = Field(1, description="版本号 (用于数据迁移)")
# ==================== 角色卡 (Character Card) ====================
class OutputSchemaField(BaseModel):
"""
Vercel AI SDK Output.object() 的表头定义
用于结构化输出,让 LLM 按照指定格式返回数据。
这是项目的特色功能,支持动态表格生成。
"""
name: str = Field(..., description="字段名称")
type: str = Field(..., description="字段类型 (string/number/boolean/array/object)")
description: str = Field(..., description="字段描述")
required: Optional[bool] = Field(None, description="是否必需")
enum: Optional[List[str]] = Field(None, description="枚举值 (字符串固定选项)")
fields: Optional[List['OutputSchemaField']] = Field(None, description="嵌套字段 (object 类型)")
class CharacterCard(BaseModel):
"""
项目内部角色卡结构
角色卡是对话 AI 的核心定义,包含人设、场景、开场白等。
相比 SillyTavern,我们添加了 categories、outputSchema、worldInfoId 等功能。
"""
id: str = Field(..., description="角色唯一标识符 (UUID)")
name: str = Field(..., description="角色名称")
description: str = Field(..., description="角色详细描述")
personality: str = Field(..., description="角色性格特征")
scenario: str = Field(..., description="场景设定")
first_mes: str = Field(..., description="首条开场消息")
mes_example: str = Field(..., description="对话示例")
categories: List[str] = Field(default_factory=list, description="分类标签 (用于前端筛选)")
worldInfoId: Optional[str] = Field(None, description="绑定的世界书 ID")
outputSchema: Optional[List[OutputSchemaField]] = Field(None, description="输出 schema 定义 (结构化输出)")
avatarPath: Optional[str] = Field(None, description="角色头像路径")
alternate_greetings: Optional[List[str]] = Field(None, description="替代问候语数组")
tags: Optional[List[str]] = Field(None, description="标签数组")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
lastChatAt: Optional[int] = Field(None, description="最后聊天时间戳")
isFavorite: bool = Field(False, description="收藏状态")
version: int = Field(1, description="版本号")
# ==================== 聊天记录 (Chat Log) ====================
class ChatHeader(BaseModel):
"""
项目内部聊天记录头
包含聊天的元数据,如参与角色、创建时间等。
"""
id: str = Field(..., description="聊天唯一标识符 (UUID)")
displayName: str = Field(..., description="显示名称 (聊天标题)")
characterId: str = Field(..., description="关联的角色卡 ID")
userName: str = Field("User", description="用户角色名")
characterName: str = Field(..., description="AI 角色名称")
tableData: Optional[Dict[str, Any]] = Field(None, description="表格数据 (对应 outputSchema)")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
messageCount: int = Field(0, description="消息数量")
ragLibraryId: Optional[str] = Field(None, description="关联的 RAG 历史消息库 ID")
class ChatMessage(BaseModel):
"""
项目内部聊天消息
单条对话消息,支持多版本 (swipes)、token 统计等功能。
"""
id: str = Field(..., description="消息唯一标识符 (UUID)")
name: str = Field(..., description="发送者名称")
is_user: bool = Field(..., description="是否为用户消息")
is_system: Optional[bool] = Field(None, description="是否为系统消息")
sendDate: str = Field(..., description="发送日期 ISO 字符串")
mes: str = Field(..., description="消息内容文本")
chatId: str = Field(..., description="关联的聊天 ID")
swipes: Optional[List[str]] = Field(None, description="替换回答数组 (多版本)")
swipe_id: Optional[int] = Field(0, description="当前选择的版本索引")
tokenCount: Optional[int] = Field(None, description="Token 数量 (用于统计)")
isTemporary: Optional[bool] = Field(None, description="是否为临时消息 (未保存)")
class ChatLog(BaseModel):
"""
项目内部完整聊天记录
包含聊天头和所有消息,是完整的对话历史。
"""
header: ChatHeader = Field(..., description="聊天头")
messages: List[ChatMessage] = Field(default_factory=list, description="消息列表")
# ==================== 预设 (Preset) ====================
class GenerationPreset(BaseModel):
"""
项目内部采样参数预设
控制 LLM 生成的参数配置,如温度、top_p 等。
"""
id: str = Field(..., description="预设唯一标识符 (UUID)")
name: str = Field(..., description="预设名称")
temperature: float = Field(1.0, ge=0, le=2, description="温度 (控制随机性)")
topP: float = Field(1.0, ge=0, le=1, description="Top P (核采样)")
topK: int = Field(0, ge=0, description="Top K")
repetitionPenalty: float = Field(1.0, ge=0, description="重复惩罚")
frequencyPenalty: Optional[float] = Field(None, description="频率惩罚")
presencePenalty: Optional[float] = Field(None, description="存在惩罚")
maxLength: Optional[int] = Field(None, gt=0, description="最大生成长度")
isDefault: bool = Field(False, description="是否为默认预设")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
# ==================== 提示词预设 (Prompt Preset) ====================
class PromptRole(str, Enum):
"""
Prompt 角色类型
内部业务层只保留三种角色,简化了 SillyTavern 的复杂角色系统。
"""
SYSTEM = 'system' # 系统指令
AI = 'ai' # AI 助手
USER = 'user' # 用户
class PromptEntry(BaseModel):
"""
内部业务层 - Prompt 条目
提示词模板的基本单元,可以组合成完整的提示词预设。
这是基于某个 character_id 生成的"当前视图"
"""
identifier: str = Field(..., description="稳定关联键 (用于回写)")
name: str = Field(..., description="条目名 (前端显示)")
enabled: bool = Field(True, description="是否启用 (当前作用域下的业务状态)")
content: str = Field(..., description="条目内容 (静态内容视图)")
order: int = Field(..., description="条目顺序 (前端展示和拖拽排序)")
role: PromptRole = Field(..., description="角色类型")
tokenCount: int = Field(0, description="总 token 数 (派生显示字段)")
isSystemNode: bool = Field(False, description="是否固有节点 (不可删除)")
class PromptPresetView(BaseModel):
"""
内部业务层 - Prompt 预设视图
基于某个 character_id 的"当前视图",包含已排序、已过滤的条目列表。
"""
characterId: str = Field(..., description="关联的角色 ID")
entries: List[PromptEntry] = Field(default_factory=list, description="当前视图的条目列表")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
version: int = Field(1, description="版本号")
# ==================== RAG 配置 ====================
class RAGSearchConfig(BaseModel):
"""RAG 搜索配置"""
topK: int = Field(5, gt=0, description="每次检索返回的结果数")
threshold: float = Field(0.7, ge=0, le=1, description="相似度阈值 (0-1)")
maxContextLength: int = Field(2000, gt=0, description="最大上下文长度 (字符数)")
class CharacterRAGConfig(BaseModel):
"""
角色卡 RAG 世界书库配置
记录角色卡关联的 RAG 知识库,用于动态检索相关知识。
"""
characterId: str = Field(..., description="角色卡ID")
ragLibraryIds: List[str] = Field(default_factory=list, description="关联的RAG库ID列表")
enabled: bool = Field(True, description="是否启用")
searchConfig: Optional[RAGSearchConfig] = Field(None, description="搜索配置")
position: str = Field('after_char', description="RAG内容插入位置")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")
class ChatRAGConfig(BaseModel):
"""
聊天会话 RAG 历史消息配置
记录聊天会话关联的 RAG 历史消息库,用于智能检索历史对话。
"""
chatId: str = Field(..., description="聊天会话ID")
ragLibraryId: Optional[str] = Field(None, description="关联的RAG历史消息库ID")
enabled: bool = Field(True, description="是否启用")
searchConfig: Optional[Dict[str, Any]] = Field(None, description="搜索配置")
autoIndex: bool = Field(True, description="是否自动索引新消息")
indexConfig: Optional[Dict[str, Any]] = Field(None, description="索引配置")
createdAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="创建时间戳")
updatedAt: int = Field(default_factory=lambda: int(datetime.now().timestamp()), description="最后更新时间戳")