284 lines
11 KiB
Python
284 lines
11 KiB
Python
"""聊天主链路:单角色扮演 + 动态小说两种模式。上下文不做节省。"""
|
||
import datetime as dt
|
||
import json
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException
|
||
from fastapi.responses import Response
|
||
from pydantic import BaseModel
|
||
from sqlalchemy import select, delete
|
||
|
||
from ...db.session import get_db
|
||
from ...db import repos
|
||
from ...models.entities import (User, ChatSession, Message, Character,
|
||
Memory, WorldbookEntry)
|
||
from ...api.routers.auth import current_user
|
||
from ...api.routers.characters import _enc_persona, _key # noqa
|
||
from ...core import security
|
||
from ...services.llm import LLMClient
|
||
from ...services import novel_pipeline
|
||
|
||
router = APIRouter(tags=["chat"])
|
||
|
||
|
||
class SessionIn(BaseModel):
|
||
mode: str = "roleplay"
|
||
title: str = "新会话"
|
||
character_id: int | None = None
|
||
novel_setting: str | None = None
|
||
channel_id: int | None = None
|
||
|
||
|
||
class SendIn(BaseModel):
|
||
content: str
|
||
auto_extract: bool = True # 小说模式:自动抽角色
|
||
auto_avatar: bool = True
|
||
reply_to_id: int | None = None # 引用回复
|
||
|
||
|
||
class MessageIn(BaseModel):
|
||
content: str
|
||
|
||
|
||
def _key(user):
|
||
return security.key_cache.get(user.id)
|
||
|
||
|
||
def _enc(user, text):
|
||
return repos.enc(_key(user), text)
|
||
|
||
|
||
def _dec(user, text):
|
||
return repos.dec(_key(user), text)
|
||
|
||
|
||
async def _own_session(db, user, sid) -> ChatSession:
|
||
s = await db.get(ChatSession, sid)
|
||
if not s or s.user_id != user.id:
|
||
raise HTTPException(404, "会话不存在")
|
||
return s
|
||
|
||
|
||
async def _channel_for(db, user, session) -> tuple[LLMClient, dict]:
|
||
cid = session.channel_id
|
||
if not cid:
|
||
rows = await repos.ChannelRepo.visible_to(db, user)
|
||
if not rows:
|
||
raise HTTPException(400, "没有可用渠道,请先到渠道页配置 API")
|
||
c = rows[0]
|
||
else:
|
||
c = await repos.ChannelRepo.can_use(db, user, cid)
|
||
if not c:
|
||
raise HTTPException(403, "无权使用该渠道")
|
||
return LLMClient(c.base_url, c.api_key_enc), (c.models or {})
|
||
|
||
|
||
async def build_context(db, user, session, history) -> list[dict]:
|
||
"""拼装上下文:人设 + 记忆 + 世界书命中 + 全量最近对话。"""
|
||
msgs = []
|
||
if session.mode == "roleplay":
|
||
ch = await db.get(Character, session.character_id)
|
||
persona = f"你扮演角色「{ch.name}」。人设:\n{_dec(user, ch.persona)}\n始终以该角色的口吻回复,不要出戏。"
|
||
mems = await repos.MemoryRepo.list_for(db, user.id, ch.id)
|
||
key = _key(user)
|
||
mem_text = "\n".join(f"- [{m.kind}] {_dec(user, m.content_enc)}" for m in mems)
|
||
if mem_text:
|
||
persona += "\n\n你已知的记忆:\n" + mem_text
|
||
msgs.append({"role": "system", "content": persona})
|
||
scope_hits = []
|
||
else:
|
||
setting = _dec(user, session.novel_setting_enc or "")
|
||
msgs.append({"role": "system",
|
||
"content": ("你是小说编剧,与用户共创一部小说。用户可以控制主角行动,"
|
||
"你负责推进剧情、描写场景与其他角色的言行。剧情需要时,"
|
||
"你可以自主引入新的配角,给他们完整的性格与名字。\n"
|
||
f"小说设定:\n{setting}")})
|
||
scope_hits = []
|
||
# 世界书:角色模式查 character scope,小说模式查 novel scope
|
||
scope = "character" if session.mode == "roleplay" else "novel"
|
||
scope_id = session.character_id or session.id
|
||
entries = (await db.execute(select(WorldbookEntry).where(
|
||
WorldbookEntry.user_id == user.id, WorldbookEntry.scope == scope,
|
||
WorldbookEntry.enabled == True))).scalars().all() # noqa: E712
|
||
last_text = history[-1].content_enc if history else ""
|
||
hits = novel_pipeline.match_worldbook(entries, _dec(user, last_text or ""), _key(user))
|
||
for e in entries:
|
||
if e.constant:
|
||
h = novel_pipeline.match_worldbook([e], "", _key(user))
|
||
if h:
|
||
hits.append(h[0])
|
||
if hits:
|
||
msgs.append({"role": "system", "content": "【世界观设定】\n" + "\n".join(hits)})
|
||
for m in history:
|
||
role = "user" if m.role == "user" else "assistant"
|
||
msgs.append({"role": role, "content": _dec(user, m.content_enc)})
|
||
return msgs
|
||
|
||
|
||
@router.post("/sessions")
|
||
async def create_session(body: SessionIn, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
s = ChatSession(user_id=user.id, mode=body.mode, title=body.title,
|
||
character_id=body.character_id,
|
||
novel_setting_enc=_enc(user, body.novel_setting or "") if body.novel_setting else None,
|
||
channel_id=body.channel_id)
|
||
db.add(s)
|
||
await db.commit()
|
||
# 角色模式自动塞开场白
|
||
if body.character_id:
|
||
ch = await db.get(Character, body.character_id)
|
||
if ch and ch.greeting:
|
||
db.add(Message(session_id=s.id, user_id=user.id, role="assistant",
|
||
speaker=ch.name, content_enc=_enc(user, _dec(user, ch.greeting))))
|
||
await db.commit()
|
||
return {"id": s.id}
|
||
|
||
|
||
@router.get("/sessions")
|
||
async def list_sessions(user: User = Depends(current_user), db=Depends(get_db)):
|
||
rows = await repos.SessionRepo.list_for(db, user.id)
|
||
return {"sessions": [{"id": s.id, "mode": s.mode, "title": s.title,
|
||
"character_id": s.character_id} for s in rows]}
|
||
|
||
|
||
@router.get("/sessions/{sid}/messages")
|
||
async def get_messages(sid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
await _own_session(db, user, sid)
|
||
rows = await repos.MessageRepo.history(db, user.id, sid, limit=500)
|
||
out = []
|
||
for m in rows:
|
||
d = {"id": m.id, "role": m.role, "speaker": m.speaker, "starred": m.starred,
|
||
"active_swipe": m.active_swipe,
|
||
"created_at": m.created_at.isoformat() if m.created_at else None,
|
||
"content": _dec(user, m.content_enc)}
|
||
if m.reply_to_id:
|
||
q = await db.get(Message, m.reply_to_id)
|
||
if q:
|
||
d["quote"] = f"{q.speaker or ''}:{_dec(user, q.content_enc)[:60]}"
|
||
if m.swipes_enc:
|
||
sw = json.loads(_dec(user, m.swipes_enc))
|
||
d["content"] = sw[m.active_swipe] if sw else d["content"]
|
||
d["swipe_count"] = len(sw)
|
||
out.append(d)
|
||
return {"messages": out}
|
||
|
||
|
||
@router.post("/sessions/{sid}/send")
|
||
async def send(sid: int, body: SendIn, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
client, models = await _channel_for(db, user, s)
|
||
narrative_model = models.get("narrative") or "step-3.5-flash"
|
||
|
||
db.add(Message(session_id=sid, user_id=user.id, role="user",
|
||
content_enc=_enc(user, body.content),
|
||
reply_to_id=body.reply_to_id))
|
||
await db.commit()
|
||
|
||
history = await repos.MessageRepo.history(db, user.id, sid, limit=80)
|
||
msgs = await build_context(db, user, s, history)
|
||
reply = await client.chat(narrative_model, msgs, temperature=0.9, max_tokens=4096)
|
||
|
||
reply_row = Message(session_id=sid, user_id=user.id,
|
||
role="assistant" if s.mode == "roleplay" else "narrator",
|
||
content_enc=_enc(user, reply))
|
||
db.add(reply_row)
|
||
await db.commit()
|
||
|
||
new_chars = []
|
||
if s.mode == "novel" and body.auto_extract:
|
||
new_chars = await _run_extraction(db, user, s, client, models,
|
||
body.auto_avatar, reply)
|
||
return {"reply": reply, "message_id": reply_row.id, "new_characters": new_chars}
|
||
|
||
|
||
async def _run_extraction(db, user, session, client, models, auto_avatar, story_text):
|
||
"""动态小说灵魂:抽取新角色 → 建档 → 生图 → 世界书注册"""
|
||
extract_model = models.get("extract") or "step-3.5-flash"
|
||
found = await novel_pipeline.extract_new_characters(
|
||
client, extract_model, story_text)
|
||
existing = {c.name for c in await repos.CharacterRepo.list_for(db, user.id)}
|
||
image_model = models.get("image") or ""
|
||
out = []
|
||
for d in found:
|
||
if d["name"] in existing:
|
||
continue
|
||
data = novel_pipeline.build_character(user.id, session.id, d)
|
||
if auto_avatar and image_model:
|
||
data["avatar_url"] = await novel_pipeline.gen_avatar(
|
||
client, image_model, d.get("appearance", ""))
|
||
ch = Character(**data)
|
||
await _enc_persona(user, ch)
|
||
db.add(ch)
|
||
await db.flush()
|
||
# 自动记忆
|
||
key = _key(user)
|
||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||
db.add(Memory(character_id=ch.id, user_id=user.id, kind="fact",
|
||
content_enc=repos.enc(None if visible else key,
|
||
data["persona"])))
|
||
# 自动注册世界书
|
||
db.add(WorldbookEntry(
|
||
user_id=user.id, scope="novel", scope_id=session.id,
|
||
keywords=d["name"], constant=False, enabled=True,
|
||
content_enc=repos.enc(None if visible else key,
|
||
f"{d['name']}:{d.get('identity','')}。"
|
||
f"{d.get('personality','')} 与主角关系:{d.get('relation','')}")))
|
||
out.append({"id": ch.id, "name": ch.name, "persona": _dec(user, ch.persona),
|
||
"avatar_url": ch.avatar_url, "voice": ch.voice})
|
||
await db.commit()
|
||
return out
|
||
|
||
|
||
@router.patch("/messages/{mid}")
|
||
async def edit_message(mid: int, body: MessageIn, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
m = await db.get(Message, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "消息不存在")
|
||
m.content_enc = _enc(user, body.content)
|
||
await db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.delete("/messages/{mid}")
|
||
async def delete_message(mid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
m = await db.get(Message, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "消息不存在")
|
||
await db.delete(m)
|
||
await db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.delete("/sessions/{sid}")
|
||
async def delete_session(sid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
await db.execute(delete(Message).where(Message.session_id == sid))
|
||
await db.delete(s)
|
||
await db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.post("/sessions/{sid}/tts/{mid}")
|
||
async def tts(sid: int, mid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
m = await db.get(Message, mid)
|
||
if not m or m.user_id != user.id or m.session_id != sid:
|
||
raise HTTPException(404, "消息不存在")
|
||
client, models = await _channel_for(db, user, s)
|
||
model = models.get("tts") or "stepaudio-2.5-tts"
|
||
voice = "tongtong"
|
||
if s.character_id:
|
||
ch = await db.get(Character, s.character_id)
|
||
if ch:
|
||
voice = ch.voice
|
||
try:
|
||
audio = await client.tts(model, _dec(user, m.content_enc), voice)
|
||
except Exception as e:
|
||
raise HTTPException(502, f"TTS 失败: {e}")
|
||
return Response(content=audio, media_type="audio/wav")
|