1491 lines
60 KiB
Python
1491 lines
60 KiB
Python
"""
|
||
聊天工作流服务
|
||
负责处理完整的LLM对话生成流程
|
||
"""
|
||
import json
|
||
import re
|
||
import asyncio
|
||
import time
|
||
from typing import Dict, Any, List, Optional
|
||
from pathlib import Path
|
||
from datetime import datetime
|
||
|
||
try:
|
||
from backend.services.character_service import CharacterService
|
||
from backend.services.worldbook_service import WorldBookService
|
||
from backend.services.prompt_assembler import PromptAssembler, PromptConfig
|
||
from backend.utils.llm_client import LLMClient
|
||
from backend.services.task_queue_manager import task_queue_manager, TaskType
|
||
from backend.core.config import settings
|
||
except ImportError:
|
||
from services.character_service import CharacterService
|
||
from services.worldbook_service import WorldBookService
|
||
from services.prompt_assembler import PromptAssembler, PromptConfig
|
||
from utils.llm_client import LLMClient
|
||
from services.task_queue_manager import task_queue_manager, TaskType
|
||
from core.config import settings
|
||
|
||
|
||
class ChatWorkflowService:
|
||
"""
|
||
聊天工作流服务
|
||
|
||
负责：
|
||
1. 接收前端发送的完整数据
|
||
2. 加载角色卡和世界书
|
||
3. 激活世界书条目
|
||
4. 组装提示词
|
||
5. 调用LLM生成回复
|
||
6. 返回生成的内容
|
||
"""
|
||
|
||
def __init__(self):
|
||
self.character_service = CharacterService()
|
||
self.worldbook_service = WorldBookService()
|
||
self.prompt_assembler = PromptAssembler()
|
||
self.llm_client = LLMClient()
|
||
|
||
# ==================== 动态表格条件判断 ====================
|
||
|
||
def _parse_table_condition(self, condition: str, table_data: Dict[str, Any]) -> bool:
|
||
"""
|
||
解析动态表格条件
|
||
|
||
支持的语法：
|
||
- (tb.力量 > 10) # 数值比较
|
||
- (tb.态度 包括 "爱情") # 字符串包含
|
||
- (tb.状态 = "战斗") # 字符串相等
|
||
|
||
Args:
|
||
condition: 条件字符串，如 "(tb.力量 > 10)"
|
||
table_data: 动态表格数据 {"力量": 15, "态度": "友好", ...}
|
||
|
||
Returns:
|
||
bool: 条件是否满足
|
||
"""
|
||
try:
|
||
# 去除括号
|
||
condition = condition.strip().strip('()')
|
||
|
||
# 匹配 tb.字段名 操作符 值
|
||
# 模式1: tb.字段 > 数值
|
||
match_num = re.match(r'tb\.(\S+)\s*(>|<|>=|<=|=|!=)\s*(\d+(?:\.\d+)?)', condition)
|
||
if match_num:
|
||
field_name = match_num.group(1)
|
||
operator = match_num.group(2)
|
||
target_value = float(match_num.group(3))
|
||
|
||
actual_value = table_data.get(field_name)
|
||
if actual_value is None:
|
||
return False
|
||
|
||
# 转换为数值比较
|
||
try:
|
||
actual_value = float(actual_value)
|
||
except (ValueError, TypeError):
|
||
return False
|
||
|
||
# 执行比较
|
||
if operator == '>':
|
||
return actual_value > target_value
|
||
elif operator == '<':
|
||
return actual_value < target_value
|
||
elif operator == '>=':
|
||
return actual_value >= target_value
|
||
elif operator == '<=':
|
||
return actual_value <= target_value
|
||
elif operator == '=':
|
||
return actual_value == target_value
|
||
elif operator == '!=':
|
||
return actual_value != target_value
|
||
|
||
# 模式2: tb.字段 包括 "字符串"
|
||
match_str_include = re.match(r'tb\.(\S+)\s*包括\s*["\'](.+?)["\']', condition)
|
||
if match_str_include:
|
||
field_name = match_str_include.group(1)
|
||
target_str = match_str_include.group(2)
|
||
|
||
actual_value = table_data.get(field_name, '')
|
||
return target_str in str(actual_value)
|
||
|
||
# 模式3: tb.字段 = "字符串"
|
||
match_str_eq = re.match(r'tb\.(\S+)\s*=\s*["\'](.+?)["\']', condition)
|
||
if match_str_eq:
|
||
field_name = match_str_eq.group(1)
|
||
target_str = match_str_eq.group(2)
|
||
|
||
actual_value = str(table_data.get(field_name, ''))
|
||
return actual_value == target_str
|
||
|
||
return False
|
||
|
||
except Exception as e:
|
||
print(f"[TableCondition] 解析条件失败: {condition}, 错误: {e}")
|
||
return False
|
||
|
||
|
||
async def process_chat_request(
|
||
self,
|
||
request_data: Dict[str, Any]
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
处理聊天请求的核心工作流
|
||
|
||
Args:
|
||
request_data: 前端发送的完整数据
|
||
|
||
Returns:
|
||
{
|
||
"success": bool,
|
||
"content": str, # 生成的回复内容
|
||
"error": str | None
|
||
}
|
||
"""
|
||
try:
|
||
# === 第1步：解析请求数据 ===
|
||
current_role = request_data.get("currentRole")
|
||
current_chat = request_data.get("currentChat")
|
||
user_message = request_data.get("mes", "")
|
||
|
||
if not current_role or not user_message:
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": "缺少必要的参数：currentRole 或 mes"
|
||
}
|
||
|
||
print(f"[ChatWorkflow] 开始处理请求: role={current_role}, chat={current_chat}")
|
||
|
||
# ✅ 获取预设名称（用于加载预设绑定的正则规则）
|
||
preset_config = request_data.get("presetConfig", {})
|
||
preset_name = preset_config.get("selectedPreset")
|
||
|
||
# ✅ 第1.5步：应用用户输入的正则规则
|
||
from services.regex_service import regex_service
|
||
from models.regex_rules import RegexPlacement
|
||
|
||
processed_user_message = regex_service.apply_rules_by_placement(
|
||
text=user_message,
|
||
placement=RegexPlacement.USER_INPUT.value,
|
||
character_name=current_role,
|
||
preset_name=preset_name,
|
||
message_depth=0,
|
||
is_for_llm=True, # ✅ 用户输入会发送给LLM
|
||
is_markdown_rendered=False
|
||
)
|
||
|
||
if processed_user_message != user_message:
|
||
print(f"[Regex] ✅ 已应用用户输入正则规则")
|
||
|
||
user_message = processed_user_message
|
||
|
||
# === 第2步：加载角色卡 ===
|
||
character_data = request_data.get("characterData")
|
||
if not character_data:
|
||
# 如果没有提供角色卡数据，从后端加载
|
||
character = self.character_service.get_character_by_name(current_role)
|
||
if not character:
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": f"角色 '{current_role}' 不存在"
|
||
}
|
||
else:
|
||
# 使用前端提供的角色卡数据（可能包含用户修改）
|
||
try:
|
||
from backend.models.internal import CharacterCard
|
||
except ImportError:
|
||
from models.internal import CharacterCard
|
||
character = CharacterCard(**character_data)
|
||
|
||
print(f"[ChatWorkflow] 已加载角色卡: {character.name}")
|
||
|
||
# === 第3步：收集并激活世界书条目 ===
|
||
active_entries = await self._collect_and_activate_worldbooks(
|
||
request_data,
|
||
character
|
||
)
|
||
print(f"[ChatWorkflow] 激活了 {len(active_entries)} 个世界书条目")
|
||
|
||
# === 第4步：加载聊天历史 ===
|
||
chat_history = await self._load_chat_history(current_role, current_chat)
|
||
print(f"[ChatWorkflow] 加载了 {len(chat_history)} 条历史消息")
|
||
|
||
# === 第5步：组装提示词 ===
|
||
prompt_messages = self._assemble_prompt(
|
||
character,
|
||
chat_history,
|
||
user_message,
|
||
active_entries,
|
||
request_data
|
||
)
|
||
print(f"[ChatWorkflow] 组装了 {len(prompt_messages)} 条提示消息")
|
||
|
||
# === 第6步：调用LLM生成回复 ===
|
||
api_config = request_data.get("apiConfig", {})
|
||
preset_config = request_data.get("presetConfig", {})
|
||
stream_output = request_data.get("stream", False)
|
||
|
||
result = await self._generate_response(
|
||
prompt_messages,
|
||
api_config,
|
||
preset_config,
|
||
stream_output
|
||
)
|
||
|
||
generated_content = result["content"]
|
||
token_usage = result.get("usage", {})
|
||
duration = result.get("duration")
|
||
|
||
print(f"[ChatWorkflow] 生成完成，内容长度: {len(generated_content)}")
|
||
print(f"[ChatWorkflow] Token 使用: {token_usage}")
|
||
|
||
# ✅ 第6.5步：应用 AI 输出的正则规则
|
||
processed_ai_output = regex_service.apply_rules_by_placement(
|
||
text=generated_content,
|
||
placement=RegexPlacement.AI_OUTPUT.value,
|
||
character_name=current_role,
|
||
preset_name=preset_name,
|
||
message_depth=0,
|
||
is_for_llm=False, # ✅ AI输出是显示给用户的
|
||
is_markdown_rendered=False
|
||
)
|
||
|
||
if processed_ai_output != generated_content:
|
||
print(f"[Regex] ✅ 已应用 AI 输出正则规则")
|
||
generated_content = processed_ai_output
|
||
|
||
# === 第7步：记录 Token 使用 ===
|
||
chat_id = f"{current_role}/{request_data.get('currentChat', '')}"
|
||
floor = request_data.get("floor", 0)
|
||
|
||
try:
|
||
try:
|
||
from backend.services.token_usage_service import token_usage_service
|
||
from backend.models.internal import TokenUsageStatus
|
||
except ImportError:
|
||
from services.token_usage_service import token_usage_service
|
||
from models.internal import TokenUsageStatus
|
||
|
||
await token_usage_service.record_usage(
|
||
chat_id=chat_id,
|
||
role_name=current_role,
|
||
chat_name=request_data.get('currentChat', ''),
|
||
prompt_tokens=token_usage.get("prompt_tokens", 0),
|
||
completion_tokens=token_usage.get("completion_tokens", 0),
|
||
total_tokens=token_usage.get("total_tokens", 0),
|
||
status=TokenUsageStatus.COMPLETED,
|
||
floor=floor + 1, # AI 回复的楼层
|
||
duration=duration,
|
||
model=api_config.get("model"),
|
||
api_provider="openai", # TODO: 从 API URL 检测提供商
|
||
api_url=api_config.get("api_url") # ✅ 记录 API URL
|
||
)
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow] 记录 Token 使用失败: {e}")
|
||
|
||
# === 第8步：启动异步并行任务 ===
|
||
|
||
# 创建任务ID
|
||
image_task_id = None
|
||
table_task_id = None
|
||
|
||
options = request_data.get("options", {})
|
||
if options.get("imageWorkflow", False):
|
||
import uuid
|
||
image_task_id = f"img_{uuid.uuid4().hex[:8]}"
|
||
await task_queue_manager.add_task(image_task_id, TaskType.IMAGE_WORKFLOW, chat_id)
|
||
|
||
if options.get("dynamicTable", False):
|
||
import uuid
|
||
table_task_id = f"tbl_{uuid.uuid4().hex[:8]}"
|
||
await task_queue_manager.add_task(table_task_id, TaskType.DYNAMIC_TABLE, chat_id)
|
||
|
||
await self._start_parallel_tasks(request_data, generated_content, image_task_id, table_task_id)
|
||
|
||
return {
|
||
"success": True,
|
||
"content": generated_content,
|
||
"error": None,
|
||
"activeEntries": active_entries,
|
||
"taskIds": {
|
||
"imageWorkflow": image_task_id,
|
||
"dynamicTable": table_task_id
|
||
}
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow] 错误: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": f"工作流执行失败: {str(e)}"
|
||
}
|
||
|
||
def _normalize_worldbook_entry(self, entry_data: Dict[str, Any]) -> Dict[str, Any]:
|
||
"""
|
||
标准化世界书条目数据，修复类型不匹配问题
|
||
|
||
Args:
|
||
entry_data: 原始条目数据
|
||
|
||
Returns:
|
||
标准化后的条目数据
|
||
"""
|
||
normalized = entry_data.copy()
|
||
|
||
# ✅ content 必须是字符串（如果是字典或列表，转换为 JSON 字符串）
|
||
if 'content' in normalized:
|
||
content = normalized['content']
|
||
if not isinstance(content, str):
|
||
import json
|
||
normalized['content'] = json.dumps(content, ensure_ascii=False)
|
||
|
||
# uid 必须是字符串
|
||
if 'uid' in normalized and not isinstance(normalized['uid'], str):
|
||
normalized['uid'] = str(normalized['uid'])
|
||
|
||
# position 必须是整数或 None
|
||
if 'position' in normalized:
|
||
pos = normalized['position']
|
||
if pos is not None:
|
||
try:
|
||
normalized['position'] = int(pos)
|
||
except (ValueError, TypeError):
|
||
normalized['position'] = 0
|
||
|
||
# group 必须是列表或 None
|
||
if 'group' in normalized:
|
||
grp = normalized['group']
|
||
if grp is not None and not isinstance(grp, list):
|
||
# 如果是空字符串，转为None；否则尝试解析
|
||
if grp == '' or grp is None:
|
||
normalized['group'] = None
|
||
elif isinstance(grp, str):
|
||
# 尝试将逗号分隔的字符串转为列表
|
||
normalized['group'] = [g.strip() for g in grp.split(',') if g.strip()]
|
||
else:
|
||
normalized['group'] = None
|
||
|
||
return normalized
|
||
|
||
def _get_trigger_type(self, entry_data: Dict[str, Any]) -> str:
|
||
"""
|
||
获取条目的触发类型
|
||
|
||
Args:
|
||
entry_data: 世界书条目数据
|
||
|
||
Returns:
|
||
str: 触发类型 ('constant', 'keyword', 'condition', 'rag', 'unknown')
|
||
"""
|
||
trigger_config = entry_data.get("trigger_config", {})
|
||
triggers = trigger_config.get("triggers", {})
|
||
|
||
# 检查常驻触发
|
||
constant_trigger = triggers.get("constant", [False, None])
|
||
if constant_trigger[0]:
|
||
return "constant"
|
||
|
||
# 检查关键词触发
|
||
keyword_trigger = triggers.get("keyword", [False, None])
|
||
if keyword_trigger[0]:
|
||
return "keyword"
|
||
|
||
# 检查条件触发
|
||
condition_trigger = triggers.get("condition", [False, None])
|
||
if condition_trigger[0]:
|
||
return "condition"
|
||
|
||
# 检查RAG触发
|
||
rag_trigger = triggers.get("rag", [False, None])
|
||
if rag_trigger[0]:
|
||
return "rag"
|
||
|
||
return "unknown"
|
||
|
||
def _get_position_label(self, position) -> str:
|
||
"""
|
||
获取位置的中文标签
|
||
|
||
Args:
|
||
position: 位置编号 (0-7)
|
||
|
||
Returns:
|
||
str: 位置标签
|
||
"""
|
||
position_labels = {
|
||
0: '角色定义之后',
|
||
1: '角色定义之前',
|
||
2: '示例对话之前',
|
||
3: '示例对话之后',
|
||
4: '系统提示/作者注释',
|
||
5: '作为系统消息',
|
||
6: '深度插入',
|
||
7: '宏替换'
|
||
}
|
||
|
||
try:
|
||
pos_int = int(position) if position is not None else 0
|
||
return position_labels.get(pos_int, f'未知位置({position})')
|
||
except (ValueError, TypeError):
|
||
return f'未知位置({position})'
|
||
|
||
async def _collect_and_activate_worldbooks(
|
||
self,
|
||
request_data: Dict[str, Any],
|
||
character
|
||
) -> List:
|
||
"""
|
||
收集并激活世界书条目
|
||
|
||
支持的触发类型：
|
||
1. permanent/constant - 永久激活
|
||
2. keyword - 关键词匹配（用户输入、历史消息）
|
||
3. condition - 条件判断（动态表格、用户输入等）
|
||
4. rag - RAG检索（暂不实现）
|
||
|
||
Args:
|
||
request_data: 前端发送的请求数据
|
||
character: 角色卡对象
|
||
|
||
Returns:
|
||
List[WorldInfoEntry]: 激活的条目列表（已按位置和顺序排序）
|
||
"""
|
||
try:
|
||
from backend.models.internal import WorldInfoEntry
|
||
except ImportError:
|
||
from models.internal import WorldInfoEntry
|
||
|
||
active_entries = []
|
||
|
||
# 提取必要的数据
|
||
user_message = request_data.get("mes", "")
|
||
dynamic_table_data = request_data.get("dynamicTableData") or {}
|
||
table_data = dynamic_table_data.get("currentValues", {}) if dynamic_table_data else {}
|
||
chat_history = request_data.get("chatHistory", []) # 前端传来的历史消息文本
|
||
|
||
world_book_data = request_data.get("worldBookData", {})
|
||
if not world_book_data:
|
||
print(f"[WorldBook] ⚠️ 未收到 worldBookData")
|
||
return active_entries
|
||
|
||
# ✅ 详细日志：检查接收到的世界书数据
|
||
global_books = world_book_data.get("globalBooks", [])
|
||
character_book_id = world_book_data.get("characterBookId") or (character.worldInfoId if character else None)
|
||
|
||
print(f"[WorldBook] 📋 接收到的世界书数据:")
|
||
print(f" - 全局世界书数量: {len(global_books)}")
|
||
for wb in global_books:
|
||
print(f" * {wb.get('name')}")
|
||
print(f" - 角色绑定世界书: {character_book_id}")
|
||
|
||
if not global_books and not character_book_id:
|
||
print(f"[WorldBook] ⚠️ 既没有全局世界书，也没有角色绑定世界书")
|
||
return active_entries
|
||
|
||
# === 1. 加载全局世界书 ===
|
||
for wb in global_books:
|
||
try:
|
||
wb_name = wb.get("name")
|
||
if wb_name:
|
||
wb_data = self.worldbook_service._load_worldbook(wb_name)
|
||
if wb_data and "entries" in wb_data:
|
||
print(f"[WorldBook] 📖 加载全局世界书 '{wb_name}'，共 {len(wb_data['entries'])} 个条目")
|
||
for entry_data in wb_data["entries"]:
|
||
# 检查是否禁用
|
||
if entry_data.get("disable", False):
|
||
continue
|
||
|
||
# ✅ 标准化数据类型
|
||
normalized_entry = self._normalize_worldbook_entry(entry_data)
|
||
|
||
# 检查激活条件
|
||
if self._check_entry_activation(normalized_entry, user_message, table_data, chat_history):
|
||
try:
|
||
entry = WorldInfoEntry(**normalized_entry)
|
||
active_entries.append(entry)
|
||
trigger_type = self._get_trigger_type(normalized_entry)
|
||
position_label = self._get_position_label(normalized_entry.get("position", 0))
|
||
print(f"[WorldBook] ✅ 全局世界书 '{wb_name}' 条目激活 | UID: {entry_data.get('uid')} | 触发: {trigger_type} | 位置: {position_label}")
|
||
except Exception as validation_error:
|
||
print(f"[WorldBook] ⚠️ 条目验证失败: {entry_data.get('uid')}, 错误: {validation_error}")
|
||
except Exception as e:
|
||
print(f"[WorldBook] ❌ 加载全局世界书失败: {wb.get('name')}, 错误: {e}")
|
||
|
||
# === 2. 加载角色绑定的世界书 ===
|
||
if character_book_id:
|
||
print(f"[WorldBook] 📖 开始加载角色绑定世界书: {character_book_id}")
|
||
try:
|
||
wb_data = self.worldbook_service._load_worldbook(character_book_id)
|
||
if wb_data and "entries" in wb_data:
|
||
print(f"[WorldBook] ✅ 成功加载世界书 '{character_book_id}'，共 {len(wb_data['entries'])} 个条目")
|
||
for entry_data in wb_data["entries"]:
|
||
if entry_data.get("disable", False):
|
||
continue
|
||
|
||
# ✅ 标准化数据类型
|
||
normalized_entry = self._normalize_worldbook_entry(entry_data)
|
||
|
||
if self._check_entry_activation(normalized_entry, user_message, table_data, chat_history):
|
||
try:
|
||
entry = WorldInfoEntry(**normalized_entry)
|
||
active_entries.append(entry)
|
||
trigger_type = self._get_trigger_type(normalized_entry)
|
||
position_label = self._get_position_label(normalized_entry.get("position", 0))
|
||
print(f"[WorldBook] ✅ 角色世界书 '{character_book_id}' 条目激活 | UID: {entry_data.get('uid')} | 触发: {trigger_type} | 位置: {position_label}")
|
||
except Exception as validation_error:
|
||
print(f"[WorldBook] ⚠️ 条目验证失败: {entry_data.get('uid')}, 错误: {validation_error}")
|
||
else:
|
||
print(f"[WorldBook] ⚠️ 世界书 '{character_book_id}' 不存在或无条目")
|
||
except Exception as e:
|
||
print(f"[WorldBook] ❌ 加载角色世界书失败: {character_book_id}, 错误: {e}")
|
||
else:
|
||
print(f"[WorldBook] ℹ️ 角色未绑定世界书")
|
||
|
||
# === 3. 按位置和顺序排序 ===
|
||
active_entries.sort(key=lambda x: (x.position or 0, x.order or 0))
|
||
|
||
# === 4. 统计激活条目的分布情况 ===
|
||
position_stats = {}
|
||
trigger_stats = {}
|
||
for entry in active_entries:
|
||
pos = entry.position or 0
|
||
position_stats[pos] = position_stats.get(pos, 0) + 1
|
||
|
||
trigger_type = self._get_trigger_type(entry.model_dump())
|
||
trigger_stats[trigger_type] = trigger_stats.get(trigger_type, 0) + 1
|
||
|
||
print(f"\n[WorldBook] 📊 激活统计:")
|
||
print(f" - 总激活条目数: {len(active_entries)}")
|
||
print(f" - 按位置分布:")
|
||
for pos, count in sorted(position_stats.items()):
|
||
pos_label = self._get_position_label(pos)
|
||
print(f" * {pos_label} (pos={pos}): {count} 个")
|
||
print(f" - 按触发类型分布:")
|
||
for trigger_type, count in sorted(trigger_stats.items()):
|
||
print(f" * {trigger_type}: {count} 个")
|
||
print()
|
||
|
||
return active_entries
|
||
|
||
def _check_entry_activation(
|
||
self,
|
||
entry_data: Dict[str, Any],
|
||
user_message: str,
|
||
table_data: Dict[str, Any],
|
||
chat_history: List[str]
|
||
) -> bool:
|
||
"""
|
||
检查世界书条目的激活条件
|
||
|
||
Args:
|
||
entry_data: 世界书条目数据
|
||
user_message: 用户当前输入
|
||
table_data: 动态表格数据
|
||
chat_history: 聊天历史文本列表
|
||
|
||
Returns:
|
||
bool: 是否应该激活
|
||
"""
|
||
trigger_config = entry_data.get("trigger_config", {})
|
||
triggers = trigger_config.get("triggers", {})
|
||
|
||
# 1. 常驻触发 (constant) - 总是激活
|
||
constant_trigger = triggers.get("constant", [False, None])
|
||
if constant_trigger[0]: # [true, null]
|
||
print(f"[WorldBook-Check] 📌 常驻触发 | UID: {entry_data.get('uid')}")
|
||
return True
|
||
|
||
# 2. 关键词触发 (keyword) - 检查用户输入和聊天历史
|
||
keyword_trigger = triggers.get("keyword", [False, None])
|
||
if keyword_trigger[0] and keyword_trigger[1]:
|
||
keyword_config = keyword_trigger[1]
|
||
keys = keyword_config.get("key", []) or keyword_config.get("keys", [])
|
||
|
||
if keys:
|
||
# 检查用户输入
|
||
if self._check_keyword_trigger_with_config(keys, user_message, keyword_config):
|
||
print(f"[WorldBook-Check] 🔑 关键词触发(用户输入) | UID: {entry_data.get('uid')} | 匹配关键词: {keys}")
|
||
return True
|
||
|
||
# 检查聊天历史
|
||
for i, history_text in enumerate(chat_history):
|
||
if self._check_keyword_trigger_with_config(keys, history_text, keyword_config):
|
||
print(f"[WorldBook-Check] 🔑 关键词触发(历史消息#{i}) | UID: {entry_data.get('uid')} | 匹配关键词: {keys}")
|
||
return True
|
||
|
||
# 3. 条件触发 (condition) - 支持动态表格语法
|
||
condition_trigger = triggers.get("condition", [False, None])
|
||
if condition_trigger[0] and condition_trigger[1]:
|
||
conditions = condition_trigger[1].get("conditions", [])
|
||
if conditions:
|
||
# 所有条件都必须满足 (AND逻辑)
|
||
all_conditions_met = True
|
||
for condition in conditions:
|
||
cond_text = condition.get("text", "")
|
||
if cond_text:
|
||
# 解析条件，如 (tb.力量 > 10)
|
||
if not self._parse_table_condition(cond_text, table_data):
|
||
all_conditions_met = False
|
||
break
|
||
|
||
if all_conditions_met:
|
||
print(f"[WorldBook-Check] ⚙️ 条件触发 | UID: {entry_data.get('uid')} | 条件数: {len(conditions)}")
|
||
return True
|
||
|
||
# 4. RAG触发 (暂不实现)
|
||
# rag_trigger = triggers.get("rag", [False, None])
|
||
|
||
return False
|
||
|
||
def _check_keyword_trigger_with_config(self, keywords: List[str], text: str, config: Dict[str, Any] = None) -> bool:
|
||
"""
|
||
检查文本中是否包含关键词（带配置）
|
||
|
||
Args:
|
||
keywords: 关键词列表
|
||
text: 要检查的文本
|
||
config: 关键词配置（可选）
|
||
|
||
Returns:
|
||
bool: 是否匹配
|
||
"""
|
||
if not keywords or not text:
|
||
return False
|
||
|
||
config = config or {}
|
||
case_sensitive = config.get("caseSensitive", False)
|
||
match_whole_words = config.get("matchWholeWords", False)
|
||
|
||
# 处理大小写
|
||
if not case_sensitive:
|
||
text_lower = text.lower()
|
||
keywords_lower = [kw.lower() for kw in keywords]
|
||
else:
|
||
text_lower = text
|
||
keywords_lower = keywords
|
||
|
||
# 检查每个关键词
|
||
for keyword in keywords_lower:
|
||
if not keyword:
|
||
continue
|
||
|
||
if match_whole_words:
|
||
# 全词匹配：使用正则表达式
|
||
pattern = r'\b' + re.escape(keyword) + r'\b'
|
||
if re.search(pattern, text_lower):
|
||
return True
|
||
else:
|
||
# 部分匹配：直接检查子串
|
||
if keyword in text_lower:
|
||
return True
|
||
|
||
return False
|
||
|
||
async def _load_chat_history(
|
||
self,
|
||
role_name: str,
|
||
chat_name: str
|
||
) -> List:
|
||
"""
|
||
加载聊天历史
|
||
|
||
TODO: 从chat_service加载完整的聊天历史
|
||
"""
|
||
try:
|
||
from backend.models.internal import ChatMessage
|
||
except ImportError:
|
||
from models.internal import ChatMessage
|
||
|
||
try:
|
||
# 读取聊天文件
|
||
chat_dir = settings.CHATS_PATH / role_name
|
||
chat_file = chat_dir / f"{chat_name}.jsonl"
|
||
|
||
if not chat_file.exists():
|
||
return []
|
||
|
||
messages = []
|
||
with open(chat_file, 'r', encoding='utf-8') as f:
|
||
lines = f.readlines()
|
||
# 跳过第一行header
|
||
for line in lines[1:]:
|
||
if line.strip():
|
||
try:
|
||
msg_data = json.loads(line)
|
||
|
||
# ✅ 确保必需字段存在
|
||
if 'id' not in msg_data:
|
||
msg_data['id'] = f"msg_{len(messages)}_{msg_data.get('name', 'unknown')}"
|
||
if 'sendDate' not in msg_data:
|
||
from datetime import datetime
|
||
msg_data['sendDate'] = datetime.now().isoformat()
|
||
if 'chatId' not in msg_data:
|
||
msg_data['chatId'] = f"{role_name}/{chat_name}"
|
||
|
||
msg = ChatMessage(**msg_data)
|
||
messages.append(msg)
|
||
except Exception as msg_error:
|
||
print(f"[ChatWorkflow] ⚠️ 解析消息失败: {msg_error}")
|
||
continue
|
||
|
||
return messages
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow] 加载聊天历史失败: {e}")
|
||
return []
|
||
|
||
def _assemble_prompt(
|
||
self,
|
||
character,
|
||
chat_history: List,
|
||
user_message: str,
|
||
active_entries: List,
|
||
request_data: Dict[str, Any]
|
||
) -> List:
|
||
"""
|
||
组装提示词
|
||
|
||
根据预设组件（promptComponents）动态组装LLM消息列表
|
||
"""
|
||
# 从预设配置中获取prompt components
|
||
preset_config = request_data.get("presetConfig", {})
|
||
prompt_components = preset_config.get("promptComponents", [])
|
||
|
||
# ✅ 检查是否启用调试模式
|
||
debug_prompt = request_data.get("debugPrompt", False)
|
||
|
||
if debug_prompt:
|
||
print(f"\n{'='*80}")
|
||
print(f"[Prompt Debug] 🧩 预设组件配置")
|
||
print(f"{'='*80}")
|
||
print(f"[Prompt Debug] 组件数量: {len(prompt_components)}")
|
||
for i, comp in enumerate(prompt_components, 1):
|
||
print(f" {i}. {comp.get('name', 'Unknown')} (enabled={comp.get('enabled', True)}, type={comp.get('type', 'N/A')})")
|
||
print(f"{'='*80}\n")
|
||
|
||
# ✅ 如果有预设组件，使用预设组件组装
|
||
if prompt_components and len(prompt_components) > 0:
|
||
return self._assemble_prompt_from_components(
|
||
character,
|
||
chat_history,
|
||
user_message,
|
||
active_entries,
|
||
prompt_components,
|
||
debug_prompt
|
||
)
|
||
else:
|
||
# ✅ 否则使用默认的 SillyTavern 规范组装
|
||
print(f"[PromptAssembler] ⚠️ 未检测到预设组件，使用默认SillyTavern规范")
|
||
|
||
# 创建配置
|
||
config = PromptConfig(
|
||
an_position="after_history", # 默认在历史之后
|
||
an_depth=4,
|
||
post_history_instructions=None
|
||
)
|
||
|
||
# 组装提示词
|
||
messages = self.prompt_assembler.assemble(
|
||
character=character,
|
||
chat_history=chat_history,
|
||
user_input=user_message,
|
||
active_entries=active_entries,
|
||
config=config
|
||
)
|
||
|
||
return messages
|
||
|
||
def _assemble_prompt_from_components(
|
||
self,
|
||
character,
|
||
chat_history: List,
|
||
user_message: str,
|
||
active_entries: List,
|
||
prompt_components: List[Dict],
|
||
debug_prompt: bool = False
|
||
) -> List:
|
||
"""
|
||
根据预设组件组装提示词
|
||
|
||
Args:
|
||
character: 角色卡数据
|
||
chat_history: 聊天历史
|
||
user_message: 用户输入
|
||
active_entries: 激活的世界书条目
|
||
prompt_components: 预设组件列表
|
||
debug_prompt: 是否输出调试信息
|
||
|
||
Returns:
|
||
List[BaseMessage]: 组装好的消息列表
|
||
"""
|
||
from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
|
||
|
||
messages = []
|
||
|
||
# ✅ 按顺序处理每个启用的组件
|
||
enabled_components = [comp for comp in prompt_components if comp.get('enabled', True)]
|
||
|
||
if debug_prompt:
|
||
print(f"\n[Prompt Debug] 🔄 开始组装 {len(enabled_components)} 个启用的组件")
|
||
|
||
for i, component in enumerate(enabled_components, 1):
|
||
comp_name = component.get('name', 'Unknown')
|
||
comp_type = component.get('type', 'text') # text, system, user, assistant
|
||
comp_content = component.get('content', '')
|
||
|
||
if debug_prompt:
|
||
print(f"\n[Prompt Debug] --- 组件 {i}: {comp_name} ---")
|
||
print(f" 类型: {comp_type}")
|
||
print(f" 内容长度: {len(comp_content)} 字符")
|
||
|
||
# ✅ 替换模板变量
|
||
processed_content = self._process_component_content(
|
||
comp_content,
|
||
character,
|
||
chat_history,
|
||
user_message,
|
||
active_entries,
|
||
comp_type # ✅ 传递组件类型
|
||
)
|
||
|
||
if debug_prompt:
|
||
print(f" 处理后长度: {len(processed_content)} 字符")
|
||
if len(processed_content) < 500:
|
||
print(f" 完整内容:\n{processed_content}")
|
||
else:
|
||
print(f" 预览:\n{processed_content[:200]}...")
|
||
|
||
# ✅ 跳过空内容
|
||
if not processed_content or processed_content.strip() == "":
|
||
if debug_prompt:
|
||
print(f" ⚠️ 内容为空，跳过")
|
||
continue
|
||
|
||
# ✅ 根据组件类型创建对应的消息
|
||
if comp_type == 'system':
|
||
messages.append(SystemMessage(content=processed_content))
|
||
elif comp_type == 'user':
|
||
messages.append(HumanMessage(content=processed_content))
|
||
elif comp_type == 'assistant':
|
||
messages.append(AIMessage(content=processed_content))
|
||
else:
|
||
# 默认为 system
|
||
messages.append(SystemMessage(content=processed_content))
|
||
|
||
# ✅ 最后添加用户输入（如果还没有添加）
|
||
# 检查最后一个消息是否是用户输入
|
||
if messages and isinstance(messages[-1], HumanMessage):
|
||
# 已经包含用户输入，不需要再添加
|
||
pass
|
||
else:
|
||
# 添加用户输入
|
||
messages.append(HumanMessage(content=user_message))
|
||
|
||
if debug_prompt:
|
||
print(f"\n[Prompt Debug] ✅ 组装完成，总消息数: {len(messages)}")
|
||
print(f"{'='*80}\n")
|
||
|
||
return messages
|
||
|
||
def _process_component_content(
|
||
self,
|
||
content: str,
|
||
character,
|
||
chat_history: List,
|
||
user_message: str,
|
||
active_entries: List,
|
||
component_type: str = 'system' # ✅ 新增：组件类型（system/user/assistant）
|
||
) -> str:
|
||
"""
|
||
处理组件内容，替换模板变量
|
||
|
||
支持的变量：
|
||
- {{char}}: 角色名称
|
||
- {{user}}: 用户名称（暂时用 User）
|
||
- {{description}}: 角色描述
|
||
- {{personality}}: 角色性格
|
||
- {{scenario}}: 场景
|
||
- {{mes_example}}: 对话示例
|
||
- {{first_mes}}: 第一条消息
|
||
- {{history}}: 聊天历史
|
||
- {{world_info}}: 世界书信息
|
||
|
||
Args:
|
||
content: 原始内容
|
||
character: 角色卡数据
|
||
chat_history: 聊天历史
|
||
user_message: 用户输入
|
||
active_entries: 激活的世界书条目
|
||
component_type: 组件类型（system/user/assistant）
|
||
|
||
Returns:
|
||
str: 处理后的内容
|
||
"""
|
||
if not content:
|
||
return ""
|
||
|
||
# 替换角色相关变量
|
||
content = content.replace('{{char}}', getattr(character, 'name', 'Character'))
|
||
content = content.replace('{{user}}', 'User') # TODO: 从配置获取用户名
|
||
content = content.replace('{{description}}', getattr(character, 'description', ''))
|
||
content = content.replace('{{personality}}', getattr(character, 'personality', ''))
|
||
content = content.replace('{{scenario}}', getattr(character, 'scenario', ''))
|
||
content = content.replace('{{mes_example}}', getattr(character, 'mes_example', ''))
|
||
content = content.replace('{{first_mes}}', getattr(character, 'first_mes', ''))
|
||
|
||
# 替换聊天历史
|
||
if '{{history}}' in content:
|
||
history_text = self._format_chat_history(chat_history)
|
||
content = content.replace('{{history}}', history_text)
|
||
|
||
# 替换世界书信息
|
||
if '{{world_info}}' in content and active_entries:
|
||
world_info_text = self._format_world_info(active_entries)
|
||
content = content.replace('{{world_info}}', world_info_text)
|
||
|
||
# ✅ 应用 System Prompt 正则规则（placement=0）
|
||
if component_type == 'system':
|
||
from services.regex_service import regex_service
|
||
from models.regex_rules import RegexPlacement
|
||
|
||
# 获取预设名称
|
||
# TODO: 这里应该从请求数据中获取 preset_name，暂时传 None
|
||
content = regex_service.apply_rules_by_placement(
|
||
text=content,
|
||
placement=RegexPlacement.SYSTEM_PROMPT.value,
|
||
character_name=getattr(character, 'name', None),
|
||
preset_name=None, # TODO: 从请求中获取
|
||
message_depth=0,
|
||
is_for_llm=True, # ✅ 系统提示词会发送给 LLM
|
||
is_markdown_rendered=False
|
||
)
|
||
|
||
return content
|
||
|
||
def _format_chat_history(self, chat_history: List) -> str:
|
||
"""
|
||
格式化聊天历史为文本
|
||
|
||
Args:
|
||
chat_history: 聊天历史列表
|
||
|
||
Returns:
|
||
str: 格式化后的历史文本
|
||
"""
|
||
lines = []
|
||
for msg in chat_history:
|
||
# ✅ 过滤已被总结的空消息
|
||
if hasattr(msg, 'is_summarized') and msg.is_summarized and (msg.mes == "" or msg.mes.strip() == ""):
|
||
continue
|
||
|
||
name = getattr(msg, 'name', 'User' if msg.is_user else 'Assistant')
|
||
mes = getattr(msg, 'mes', '')
|
||
lines.append(f"{name}: {mes}")
|
||
|
||
return "\n".join(lines)
|
||
|
||
def _format_world_info(self, active_entries: List) -> str:
|
||
"""
|
||
格式化世界书信息为文本
|
||
|
||
Args:
|
||
active_entries: 激活的世界书条目列表
|
||
|
||
Returns:
|
||
str: 格式化后的世界书文本
|
||
"""
|
||
lines = []
|
||
for entry in active_entries:
|
||
name = getattr(entry, 'name', 'Unknown')
|
||
content = getattr(entry, 'content', '')
|
||
lines.append(f"[{name}]\n{content}")
|
||
|
||
return "\n\n".join(lines)
|
||
|
||
async def _generate_response(
|
||
self,
|
||
prompt_messages: List,
|
||
api_config: Dict[str, str],
|
||
preset_config: Dict[str, Any],
|
||
stream: bool = False
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
调用LLM生成回复
|
||
|
||
Args:
|
||
prompt_messages: 组装好的提示词消息列表
|
||
api_config: API配置 {api_url, api_key, model}
|
||
preset_config: 预设配置 {parameters, ...}
|
||
stream: 是否启用流式输出
|
||
|
||
Returns:
|
||
{
|
||
"content": str, # 生成的文本内容
|
||
"usage": dict, # Token 使用信息
|
||
"duration": float # 请求耗时
|
||
}
|
||
"""
|
||
try:
|
||
# 提取API配置
|
||
api_url = api_config.get("api_url", "")
|
||
api_key = api_config.get("api_key", "")
|
||
model = api_config.get("model", "gpt-3.5-turbo")
|
||
|
||
# 提取生成参数
|
||
parameters = preset_config.get("parameters", {})
|
||
temperature = parameters.get("temperature", 1.0)
|
||
max_tokens = parameters.get("max_tokens", 500)
|
||
|
||
# 调用LLM客户端
|
||
response = await self.llm_client.chat_completion(
|
||
messages=prompt_messages,
|
||
api_url=api_url,
|
||
api_key=api_key,
|
||
model=model,
|
||
temperature=temperature,
|
||
max_tokens=max_tokens,
|
||
request_timeout=parameters.get("request_timeout", 60), # ✅ 传递超时时间
|
||
stream=stream
|
||
)
|
||
|
||
# 提取回复内容
|
||
if isinstance(response, dict):
|
||
content = response.get("choices", [{}])[0].get("message", {}).get("content", "")
|
||
usage = response.get("usage", {})
|
||
duration = response.get("duration", 0)
|
||
else:
|
||
content = str(response)
|
||
usage = {}
|
||
duration = 0
|
||
|
||
return {
|
||
"content": content,
|
||
"usage": usage,
|
||
"duration": duration
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow] LLM调用失败: {e}")
|
||
raise
|
||
|
||
# ==================== 异步并行任务 ====================
|
||
|
||
async def _start_parallel_tasks(
|
||
self,
|
||
request_data: Dict[str, Any],
|
||
ai_response: str,
|
||
image_task_id: str = None,
|
||
table_task_id: str = None
|
||
):
|
||
"""
|
||
启动异步并行任务
|
||
|
||
包括：
|
||
1. LLM维护动态表格（如果启用）
|
||
2. 生图工作流（如果启用）
|
||
|
||
这些任务与主工作流互不干扰，在后台异步执行
|
||
|
||
Args:
|
||
request_data: 前端发送的请求数据
|
||
ai_response: AI生成的回复内容
|
||
image_task_id: 生图任务ID
|
||
table_task_id: 动态表格任务ID
|
||
"""
|
||
options = request_data.get("options", {})
|
||
|
||
# 创建任务列表
|
||
tasks = []
|
||
|
||
# 1. 动态表格维护任务
|
||
if options.get("dynamicTable", False) and table_task_id:
|
||
task = asyncio.create_task(
|
||
self._update_dynamic_table(request_data, ai_response, table_task_id)
|
||
)
|
||
tasks.append(task)
|
||
print(f"[ParallelTask] 启动动态表格维护任务: {table_task_id}")
|
||
|
||
# 2. 生图工作流任务
|
||
if options.get("imageWorkflow", False) and image_task_id:
|
||
task = asyncio.create_task(
|
||
self._generate_image(request_data, ai_response, image_task_id)
|
||
)
|
||
tasks.append(task)
|
||
print(f"[ParallelTask] 启动生图工作流任务: {image_task_id}")
|
||
|
||
# 等待所有任务完成（但不阻塞主流程）
|
||
if tasks:
|
||
try:
|
||
await asyncio.gather(*tasks, return_exceptions=True)
|
||
print("[ParallelTask] 所有并行任务完成")
|
||
except Exception as e:
|
||
print(f"[ParallelTask] 并行任务执行失败: {e}")
|
||
|
||
async def _update_dynamic_table(
|
||
self,
|
||
request_data: Dict[str, Any],
|
||
ai_response: str,
|
||
task_id: str
|
||
):
|
||
"""
|
||
使用LLM维护动态表格
|
||
|
||
TODO: 实现具体逻辑
|
||
- 分析AI回复，提取表格字段的变化
|
||
- 根据时间戳解决冲突（前端优先）
|
||
- 更新聊天文件中的表格数据
|
||
|
||
Args:
|
||
request_data: 请求数据
|
||
ai_response: AI回复
|
||
task_id: 任务ID
|
||
"""
|
||
try:
|
||
await task_queue_manager.start_task(task_id)
|
||
print(f"[DynamicTable] 开始维护动态表格: {task_id}")
|
||
|
||
# 获取当前表格数据和时间戳
|
||
table_data = request_data.get("dynamicTableData", {})
|
||
client_timestamp = request_data.get("timestamp", datetime.now().timestamp())
|
||
|
||
# TODO: 调用LLM分析AI回复，提取表格变化
|
||
# TODO: 检查时间戳，如果前端有更新则跳过
|
||
# TODO: 更新表格数据到聊天文件
|
||
|
||
await task_queue_manager.complete_task(task_id, {
|
||
"modifiedFields": [], # TODO: 实际修改的字段
|
||
"prompt": "TODO: 使用的提示词"
|
||
})
|
||
print(f"[DynamicTable] 动态表格维护完成: {task_id}")
|
||
|
||
except asyncio.CancelledError:
|
||
await task_queue_manager.cancel_task(task_id)
|
||
print(f"[DynamicTable] 任务被取消: {task_id}")
|
||
except Exception as e:
|
||
await task_queue_manager.fail_task(task_id, str(e))
|
||
print(f"[DynamicTable] 维护失败: {e}")
|
||
|
||
async def _generate_image(
|
||
self,
|
||
request_data: Dict[str, Any],
|
||
ai_response: str,
|
||
task_id: str
|
||
):
|
||
"""
|
||
生图工作流
|
||
|
||
TODO: 实现具体逻辑
|
||
- 从AI回复中提取场景描述
|
||
- 调用ComfyUI API生成图片
|
||
- 保存图片并返回路径
|
||
|
||
Args:
|
||
request_data: 请求数据
|
||
ai_response: AI回复
|
||
task_id: 任务ID
|
||
"""
|
||
try:
|
||
await task_queue_manager.start_task(task_id)
|
||
print(f"[ImageWorkflow] 开始生图: {task_id}")
|
||
|
||
# TODO: 提取场景描述
|
||
# TODO: 调用ComfyUI
|
||
# TODO: 保存图片
|
||
|
||
await task_queue_manager.complete_task(task_id, {
|
||
"imagePath": "TODO: 生成的图片路径",
|
||
"prompt": "TODO: 使用的提示词"
|
||
})
|
||
print(f"[ImageWorkflow] 生图完成: {task_id}")
|
||
|
||
except asyncio.CancelledError:
|
||
await task_queue_manager.cancel_task(task_id)
|
||
print(f"[ImageWorkflow] 任务被取消: {task_id}")
|
||
except Exception as e:
|
||
await task_queue_manager.fail_task(task_id, str(e))
|
||
print(f"[ImageWorkflow] 生图失败: {e}")
|
||
|
||
async def process_chat_request_stream(
|
||
self,
|
||
request_data: Dict[str, Any],
|
||
on_chunk
|
||
) -> Dict[str, Any]:
|
||
"""
|
||
处理流式聊天请求
|
||
|
||
Args:
|
||
request_data: 前端发送的完整数据
|
||
on_chunk: 回调函数，每次收到 chunk 时调用
|
||
|
||
Returns:
|
||
{
|
||
"success": bool,
|
||
"content": str, # 完整的生成内容
|
||
"error": str | None,
|
||
"activeEntries": List,
|
||
"taskIds": Dict
|
||
}
|
||
"""
|
||
try:
|
||
# === 第1步：解析请求数据 ===
|
||
current_role = request_data.get("currentRole")
|
||
current_chat = request_data.get("currentChat")
|
||
user_message = request_data.get("mes", "")
|
||
|
||
if not current_role or not user_message:
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": "缺少必要的参数：currentRole 或 mes"
|
||
}
|
||
|
||
print(f"\n{'#'*80}")
|
||
print(f"[ChatWorkflow-Stream] 🚀 开始处理请求")
|
||
print(f" - Role: {current_role}")
|
||
print(f" - Chat: {current_chat}")
|
||
print(f" - Message Length: {len(user_message)}")
|
||
print(f"{'#'*80}\n")
|
||
|
||
# ✅ 获取预设名称（用于加载预设绑定的正则规则）
|
||
preset_config = request_data.get("presetConfig", {})
|
||
preset_name = preset_config.get("selectedPreset")
|
||
|
||
# ✅ 第1.5步：应用用户输入的正则规则
|
||
from services.regex_service import regex_service
|
||
from models.regex_rules import RegexPlacement
|
||
|
||
processed_user_message = regex_service.apply_rules_by_placement(
|
||
text=user_message,
|
||
placement=RegexPlacement.USER_INPUT.value,
|
||
character_name=current_role,
|
||
preset_name=preset_name,
|
||
message_depth=0,
|
||
is_for_llm=True, # ✅ 用户输入会发送给LLM
|
||
is_markdown_rendered=False
|
||
)
|
||
|
||
if processed_user_message != user_message:
|
||
print(f"[Regex] ✅ 已应用用户输入正则规则")
|
||
|
||
user_message = processed_user_message
|
||
|
||
# === 第2步：加载角色卡 ===
|
||
character_data = request_data.get("characterData")
|
||
if not character_data:
|
||
character = self.character_service.get_character_by_name(current_role)
|
||
if not character:
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": f"角色 '{current_role}' 不存在"
|
||
}
|
||
else:
|
||
try:
|
||
from backend.models.internal import CharacterCard
|
||
except ImportError:
|
||
from models.internal import CharacterCard
|
||
character = CharacterCard(**character_data)
|
||
|
||
print(f"[ChatWorkflow-Stream] ✅ 已加载角色卡: {character.name}")
|
||
|
||
# === 第3步：收集并激活世界书条目 ===
|
||
active_entries = await self._collect_and_activate_worldbooks(
|
||
request_data,
|
||
character
|
||
)
|
||
print(f"\n[ChatWorkflow-Stream] 📚 世界书激活结果: {len(active_entries)} 个条目")
|
||
for i, entry in enumerate(active_entries, 1):
|
||
print(f" {i}. {getattr(entry, 'name', 'N/A')} (UID: {getattr(entry, 'uid', 'N/A')})")
|
||
|
||
# === 第4步：加载聊天历史 ===
|
||
chat_history = await self._load_chat_history(current_role, current_chat)
|
||
print(f"[ChatWorkflow-Stream] 💬 聊天历史加载结果: {len(chat_history)} 条消息")
|
||
|
||
# === 第5步：组装提示词 ===
|
||
prompt_messages = self._assemble_prompt(
|
||
character,
|
||
chat_history,
|
||
user_message,
|
||
active_entries,
|
||
request_data
|
||
)
|
||
print(f"[ChatWorkflow-Stream] 📝 提示词组装结果: {len(prompt_messages)} 条消息")
|
||
for i, msg in enumerate(prompt_messages, 1):
|
||
role = getattr(msg, 'role', 'unknown')
|
||
content_preview = str(getattr(msg, 'content', ''))[:50]
|
||
print(f" {i}. [{role}] {content_preview}...")
|
||
|
||
# === 第6步：流式调用LLM生成回复 ===
|
||
api_config = request_data.get("apiConfig", {})
|
||
preset_config = request_data.get("presetConfig", {})
|
||
|
||
print(f"\n[ChatWorkflow-Stream] 🤖 开始流式调用 LLM")
|
||
print(f" - Model: {api_config.get('model', 'N/A')}")
|
||
print(f" - API URL: {api_config.get('api_url', 'N/A')[:50]}...")
|
||
print(f" - API Key: {'已设置' if api_config.get('api_key') else '⚠️ 未设置'}")
|
||
print(f" - Temperature: {preset_config.get('parameters', {}).get('temperature', 1.0)}")
|
||
print(f" - Max Tokens: {preset_config.get('parameters', {}).get('max_tokens', 30000)}")
|
||
print(f" - Request Timeout: {preset_config.get('parameters', {}).get('request_timeout', 60)}s")
|
||
print(f"{'~'*80}")
|
||
|
||
# ✅ 验证 API Key
|
||
if not api_config.get('api_key'):
|
||
print(f"[ChatWorkflow-Stream] ❌ 错误: API Key 为空！")
|
||
print(f" - 请检查配置文件中是否保存了 API Key")
|
||
print(f" - Profile ID: {request_data.get('currentProfile', {}).get('id', 'N/A')}")
|
||
raise Exception("API Key 未配置，请先在 API 配置页面保存密钥")
|
||
|
||
generated_content = ""
|
||
token_usage = {}
|
||
duration = 0
|
||
chunk_count = 0
|
||
start_time = time.time()
|
||
|
||
print(f"[ChatWorkflow-Stream] 📡 正在调用 llm_client.stream_chat()...")
|
||
|
||
try:
|
||
async for chunk_dict in self.llm_client.stream_chat(
|
||
messages=prompt_messages,
|
||
api_url=api_config.get("api_url", ""),
|
||
api_key=api_config.get("api_key", ""),
|
||
model=api_config.get("model", ""),
|
||
temperature=preset_config.get("parameters", {}).get("temperature", 1.0),
|
||
max_tokens=preset_config.get("parameters", {}).get("max_tokens", 30000),
|
||
request_timeout=preset_config.get("parameters", {}).get("request_timeout", 60) # ✅ 传递超时时间
|
||
):
|
||
# ✅ 处理 LLM 返回的字典格式数据
|
||
if isinstance(chunk_dict, dict):
|
||
if chunk_dict.get("type") == "chunk":
|
||
chunk_content = chunk_dict.get("content", "")
|
||
elif chunk_dict.get("type") == "usage":
|
||
# 跳过 usage 信息，不拼接到内容中
|
||
continue
|
||
else:
|
||
# 兼容旧格式或未知类型，尝试直接获取 content
|
||
chunk_content = chunk_dict.get("content", str(chunk_dict))
|
||
else:
|
||
# 如果直接返回字符串（兼容情况）
|
||
chunk_content = str(chunk_dict)
|
||
|
||
# ✅ 拼接纯文本内容
|
||
generated_content += chunk_content
|
||
chunk_count += 1
|
||
|
||
# 第一个 chunk 到达时记录
|
||
if chunk_count == 1:
|
||
first_chunk_time = time.time()
|
||
print(f"[ChatWorkflow-Stream] ✨ 收到第一个 chunk (耗时: {first_chunk_time - start_time:.2f}s)")
|
||
|
||
# 每20个chunk记录一次进度
|
||
if chunk_count % 20 == 0:
|
||
elapsed = time.time() - start_time
|
||
print(f"[ChatWorkflow-Stream] 📊 已接收 {chunk_count} 个 chunks, 当前长度: {len(generated_content)}, 耗时: {elapsed:.2f}s")
|
||
|
||
# ✅ 调用回调函数发送纯文本 chunk
|
||
await on_chunk(chunk_content)
|
||
|
||
except Exception as stream_error:
|
||
elapsed = time.time() - start_time
|
||
print(f"[ChatWorkflow-Stream] ❌ 流式调用失败 (耗时: {elapsed:.2f}s)")
|
||
print(f" - 错误类型: {type(stream_error).__name__}")
|
||
print(f" - 错误信息: {str(stream_error)}")
|
||
raise
|
||
|
||
elapsed = time.time() - start_time
|
||
print(f"{'~'*80}")
|
||
print(f"[ChatWorkflow-Stream] ✅ LLM 流式调用完成")
|
||
print(f" - 总 Chunks: {chunk_count}")
|
||
print(f" - 内容长度: {len(generated_content)}")
|
||
print(f" - 总耗时: {elapsed:.2f}s")
|
||
print(f" - 平均速度: {len(generated_content)/elapsed if elapsed > 0 else 0:.0f} chars/s")
|
||
print(f"{'#'*80}\n")
|
||
|
||
# ✅ 第6.5步：应用 AI 输出的正则规则
|
||
processed_ai_output = regex_service.apply_rules_by_placement(
|
||
text=generated_content,
|
||
placement=RegexPlacement.AI_OUTPUT.value,
|
||
character_name=current_role,
|
||
preset_name=preset_name,
|
||
message_depth=0,
|
||
is_for_llm=False, # ✅ AI输出是显示给用户的
|
||
is_markdown_rendered=False
|
||
)
|
||
|
||
if processed_ai_output != generated_content:
|
||
print(f"[Regex] ✅ 已应用 AI 输出正则规则")
|
||
generated_content = processed_ai_output
|
||
|
||
# === 第7步：记录 Token 使用（估算） ===
|
||
chat_id = f"{current_role}/{request_data.get('currentChat', '')}"
|
||
floor = request_data.get("floor", 0)
|
||
|
||
try:
|
||
try:
|
||
from backend.services.token_usage_service import token_usage_service
|
||
from backend.models.internal import TokenUsageStatus
|
||
except ImportError:
|
||
from services.token_usage_service import token_usage_service
|
||
from models.internal import TokenUsageStatus
|
||
|
||
# 估算 token 数量
|
||
prompt_tokens = len(str(prompt_messages)) // 4
|
||
completion_tokens = len(generated_content) // 4
|
||
|
||
await token_usage_service.record_usage(
|
||
chat_id=chat_id,
|
||
role_name=current_role,
|
||
chat_name=request_data.get('currentChat', ''),
|
||
prompt_tokens=prompt_tokens,
|
||
completion_tokens=completion_tokens,
|
||
total_tokens=prompt_tokens + completion_tokens,
|
||
status=TokenUsageStatus.COMPLETED,
|
||
floor=floor + 1,
|
||
duration=duration,
|
||
model=api_config.get("model"),
|
||
api_provider="openai",
|
||
api_url=api_config.get("api_url") # ✅ 记录 API URL
|
||
)
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow-Stream] 记录 Token 使用失败: {e}")
|
||
|
||
# === 第8步：启动异步并行任务 ===
|
||
image_task_id = None
|
||
table_task_id = None
|
||
|
||
options = request_data.get("options", {})
|
||
if options.get("imageWorkflow", False):
|
||
import uuid
|
||
image_task_id = f"img_{uuid.uuid4().hex[:8]}"
|
||
await task_queue_manager.add_task(image_task_id, TaskType.IMAGE_WORKFLOW, chat_id)
|
||
|
||
if options.get("dynamicTable", False):
|
||
import uuid
|
||
table_task_id = f"tbl_{uuid.uuid4().hex[:8]}"
|
||
await task_queue_manager.add_task(table_task_id, TaskType.DYNAMIC_TABLE, chat_id)
|
||
|
||
await self._start_parallel_tasks(request_data, generated_content, image_task_id, table_task_id)
|
||
|
||
return {
|
||
"success": True,
|
||
"content": generated_content,
|
||
"error": None,
|
||
"activeEntries": active_entries,
|
||
"taskIds": {
|
||
"imageWorkflow": image_task_id,
|
||
"dynamicTable": table_task_id
|
||
}
|
||
}
|
||
|
||
except Exception as e:
|
||
print(f"[ChatWorkflow-Stream] 错误: {str(e)}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
return {
|
||
"success": False,
|
||
"content": "",
|
||
"error": f"工作流执行失败: {str(e)}"
|
||
}
|