592 lines
25 KiB
Python
592 lines
25 KiB
Python
"""扩展功能:群聊 / 朋友圈 / 语音通话 / Swipe / 广场 / 搜索 / 偏好 / 导出"""
|
||
import json
|
||
import os
|
||
import secrets
|
||
|
||
from fastapi import APIRouter, Depends, HTTPException, Response
|
||
from fastapi.responses import FileResponse
|
||
from pydantic import BaseModel
|
||
from sqlalchemy import select, or_, delete
|
||
|
||
from ...db.session import get_db
|
||
from ...db import repos
|
||
from ...models.entities import (User, ChatSession, Message, Character, Memory,
|
||
Moment, MomentComment, UserPrefs)
|
||
from .auth import current_user
|
||
from .chat import _key, _own_session, _dec, _enc, _channel_for, build_context
|
||
from .characters import _enc_persona
|
||
from ...core import security
|
||
from ...services.llm import LLMClient
|
||
from ...services import novel_pipeline
|
||
|
||
router = APIRouter(tags=["extra"])
|
||
|
||
|
||
# ============ 1. 群聊(多角色同台) ============
|
||
|
||
class GroupIn(BaseModel):
|
||
title: str = "群聊"
|
||
character_ids: list[int]
|
||
channel_id: int | None = None
|
||
|
||
|
||
@router.post("/groups")
|
||
async def create_group(body: GroupIn, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
if len(body.character_ids) < 1:
|
||
raise HTTPException(400, "至少选择一个角色")
|
||
# 校验所有权
|
||
for cid in body.character_ids:
|
||
c = await db.get(Character, cid)
|
||
if not c or c.user_id != user.id:
|
||
raise HTTPException(404, f"角色 {cid} 不存在")
|
||
s = ChatSession(user_id=user.id, mode="group", title=body.title,
|
||
character_id=body.character_ids[0],
|
||
group_member_ids=",".join(map(str, body.character_ids)),
|
||
channel_id=body.channel_id)
|
||
db.add(s)
|
||
await db.commit()
|
||
# 每个角色来一段开场白
|
||
key = _key(user)
|
||
for cid in body.character_ids:
|
||
c = await db.get(Character, cid)
|
||
g = repos.dec(key, c.greeting)
|
||
if g:
|
||
db.add(Message(session_id=s.id, user_id=user.id, role="assistant",
|
||
speaker=c.name, content_enc=_enc(user, g)))
|
||
await db.commit()
|
||
return {"id": s.id}
|
||
|
||
|
||
GROUP_SYSTEM = """这是群聊场景。参与角色:{roster}。
|
||
你控制角色「{name}」发言。其他角色的话会以【角色名】标注。
|
||
只在轮到你说话或被@时发言,保持角色人设,不要替其他角色说话。回复保持简短口语化。"""
|
||
|
||
|
||
@router.post("/sessions/{sid}/send_group")
|
||
async def send_group(sid: int, body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
"""群聊发送:每个群成员依次发言(被@的优先)"""
|
||
s = await _own_session(db, user, sid)
|
||
if s.mode != "group":
|
||
raise HTTPException(400, "非群聊会话")
|
||
text = body.get("content", "")
|
||
at = body.get("at") # 指定发言角色名,可选
|
||
key = _key(user)
|
||
db.add(Message(session_id=sid, user_id=user.id, role="user",
|
||
content_enc=_enc(user, text)))
|
||
await db.commit()
|
||
|
||
member_ids = [int(x) for x in s.group_member_ids.split(",") if x]
|
||
client, models = await _channel_for(db, user, s)
|
||
history = await repos.MessageRepo.history(db, user.id, sid, limit=60)
|
||
msgs = [{"role": m.role,
|
||
"content": (f"【{m.speaker}】" if m.speaker else "") + _dec(user, m.content_enc)}
|
||
for m in history]
|
||
roster = []
|
||
for cid in member_ids:
|
||
c = await db.get(Character, cid)
|
||
roster.append(f"{c.name}(人设:{repos.dec(key, c.persona)[:200]})")
|
||
out = []
|
||
for cid in member_ids:
|
||
c = await db.get(Character, cid)
|
||
if at and c.name != at:
|
||
continue
|
||
sysmsg = GROUP_SYSTEM.format(roster=";".join(roster), name=c.name)
|
||
if s.prompt_suffix:
|
||
sysmsg += "\n" + s.prompt_suffix
|
||
wb = await repos.WorldbookRepo.list_for(db, user.id)
|
||
for hit in novel_pipeline.match_worldbook(wb, text, key):
|
||
sysmsg += "\n[设定]" + hit
|
||
reply = await client.chat(models.get("narrative") or "step-3.5-flash",
|
||
[{"role": "system", "content": sysmsg}] + msgs,
|
||
temperature=0.95)
|
||
m = Message(session_id=sid, user_id=user.id, role="assistant",
|
||
speaker=c.name, content_enc=_enc(user, reply),
|
||
swipes_enc=_enc(user, json.dumps([reply])))
|
||
db.add(m)
|
||
out.append({"speaker": c.name, "content": reply, "id": m.id})
|
||
await db.commit()
|
||
return {"messages": out}
|
||
|
||
|
||
@router.get("/sessions/{sid}/members")
|
||
async def group_members(sid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
ids = [int(x) for x in s.group_member_ids.split(",") if x]
|
||
out = []
|
||
for cid in ids:
|
||
c = await db.get(Character, cid)
|
||
if c:
|
||
out.append({"id": c.id, "name": c.name, "avatar_url": c.avatar_url,
|
||
"voice": c.voice})
|
||
return {"members": out}
|
||
|
||
|
||
# ============ 2. 角色朋友圈 ============
|
||
|
||
MOMENT_SYSTEM = """你扮演角色「{name}」(人设:{persona})。请以该角色的口吻发一条朋友圈动态,
|
||
内容符合人设与近期状态(可结合提供的世界观设定),50-120字,活泼自然,可带 emoji。
|
||
只输出动态正文。"""
|
||
|
||
|
||
@router.post("/moments/generate")
|
||
async def gen_moment(body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
cid = body.get("character_id")
|
||
c = await db.get(Character, cid)
|
||
if not c or c.user_id != user.id:
|
||
raise HTTPException(404, "角色不存在")
|
||
client, models = await _channel_for(db, user, None)
|
||
key = _key(user)
|
||
mems = await repos.MemoryRepo.list_for(db, user.id, cid)
|
||
mem_text = "\n".join(_dec(user, m.content_enc) for m in mems[:10])
|
||
prompt = MOMENT_SYSTEM.format(name=c.name, persona=repos.dec(key, c.persona))
|
||
if mem_text:
|
||
prompt += "\n你最近的经历/心情:\n" + mem_text
|
||
content = await client.chat(models.get("narrative") or "step-3.5-flash",
|
||
[{"role": "user", "content": prompt}], temperature=1.0)
|
||
m = Moment(user_id=user.id, character_id=cid, content_enc=_enc(user, content))
|
||
if body.get("with_image"):
|
||
img_model = models.get("image")
|
||
if img_model:
|
||
m.image_url = await novel_pipeline.gen_avatar(
|
||
client, img_model, repos.dec(key, c.persona)[:150])
|
||
db.add(m)
|
||
await db.commit()
|
||
return {"id": m.id, "content": content, "image_url": m.image_url}
|
||
|
||
|
||
@router.get("/moments")
|
||
async def list_moments(user: User = Depends(current_user), db=Depends(get_db)):
|
||
rows = (await db.execute(select(Moment).where(Moment.user_id == user.id)
|
||
.order_by(Moment.id.desc()))).scalars().all()
|
||
key = _key(user)
|
||
out = []
|
||
for m in rows:
|
||
c = await db.get(Character, m.character_id)
|
||
comments = (await db.execute(select(MomentComment).where(
|
||
MomentComment.moment_id == m.id))).scalars().all()
|
||
out.append({"id": m.id, "character": c.name if c else "?",
|
||
"avatar_url": c.avatar_url if c else "",
|
||
"content": _dec(user, m.content_enc), "image_url": m.image_url,
|
||
"liked_by_me": m.liked_by_me,
|
||
"comments": [{"author": x.author, "content": _dec(user, x.content_enc),
|
||
"id": x.id} for x in comments]})
|
||
return {"moments": out}
|
||
|
||
|
||
@router.post("/moments/{mid}/like")
|
||
async def like_moment(mid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
m = await db.get(Moment, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "动态不存在")
|
||
m.liked_by_me = not m.liked_by_me
|
||
await db.commit()
|
||
return {"liked_by_me": m.liked_by_me}
|
||
|
||
|
||
@router.delete("/moments/{mid}")
|
||
async def del_moment(mid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
m = await db.get(Moment, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "动态不存在")
|
||
await db.execute(delete(MomentComment).where(MomentComment.moment_id == mid))
|
||
await db.delete(m)
|
||
await db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.post("/moments/{mid}/comment")
|
||
async def comment_moment(mid: int, body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
"""用户评论;body.reply=true 时让角色回评"""
|
||
m = await db.get(Moment, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "动态不存在")
|
||
c = await db.get(Character, m.character_id)
|
||
key = _key(user)
|
||
text = body.get("content", "")
|
||
db.add(MomentComment(moment_id=mid, user_id=user.id, author="me",
|
||
content_enc=_enc(user, text)))
|
||
reply = ""
|
||
if body.get("reply", True):
|
||
client, models = await _channel_for(db, user, None)
|
||
prompt = (f"你扮演「{c.name}」(人设:{repos.dec(key, c.persona)})。"
|
||
f"你发的朋友圈:「{_dec(user, m.content_enc)}」。用户评论:「{text}」。"
|
||
f"以角色口吻回一句评论,30字内,只输出评论。")
|
||
reply = await client.chat(models.get("narrative") or "step-3.5-flash",
|
||
[{"role": "user", "content": prompt}], temperature=1.0)
|
||
db.add(MomentComment(moment_id=mid, user_id=user.id, author=c.name,
|
||
content_enc=_enc(user, reply)))
|
||
await db.commit()
|
||
return {"reply": reply}
|
||
|
||
|
||
# ============ 3. 语音通话 ============
|
||
|
||
@router.post("/sessions/{sid}/call")
|
||
async def voice_call(sid: int, body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
"""语音通话一轮:用户文本(或语音转写)→ 角色回复 → TTS 音频"""
|
||
s = await _own_session(db, user, sid)
|
||
text = body.get("content", "")
|
||
if not text:
|
||
raise HTTPException(400, "缺少内容")
|
||
db.add(Message(session_id=sid, user_id=user.id, role="user",
|
||
content_enc=_enc(user, text)))
|
||
await db.commit()
|
||
history = await repos.MessageRepo.history(db, user.id, sid, limit=40)
|
||
msgs = await build_context(db, user, s, history)
|
||
client, models = await _channel_for(db, user, s)
|
||
reply = await client.chat(models.get("narrative") or "step-3.5-flash",
|
||
msgs, temperature=0.95, max_tokens=300)
|
||
db.add(Message(session_id=sid, user_id=user.id, role="assistant",
|
||
speaker=s.title, content_enc=_enc(user, reply)))
|
||
await db.commit()
|
||
try:
|
||
audio = await client.tts(models.get("tts") or "stepaudio-2.5-tts", reply)
|
||
import base64 as b64
|
||
audio_b64 = b64.b64encode(audio).decode()
|
||
except Exception:
|
||
audio_b64 = ""
|
||
return {"reply": reply, "audio_wav": audio_b64}
|
||
|
||
|
||
# ============ 4. Swipe 多版本 ============
|
||
|
||
@router.post("/messages/{mid}/swipe")
|
||
async def swipe_message(mid: int, body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
"""切换备选版本:delta ±1"""
|
||
m = await db.get(Message, mid)
|
||
if not m or m.user_id != user.id:
|
||
raise HTTPException(404, "消息不存在")
|
||
swipes = json.loads(_dec(user, m.swipes_enc)) if m.swipes_enc else [_dec(user, m.content_enc)]
|
||
idx = m.active_swipe + body.get("delta", 1)
|
||
if not 0 <= idx < len(swipes):
|
||
raise HTTPException(400, "没有更多版本")
|
||
m.active_swipe = idx
|
||
m.content_enc = _enc(user, swipes[idx])
|
||
await db.commit()
|
||
return {"active": idx, "content": swipes[idx], "count": len(swipes)}
|
||
|
||
|
||
@router.post("/messages/{mid}/regenerate")
|
||
async def regenerate_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, "消息不存在")
|
||
s = await db.get(ChatSession, m.session_id)
|
||
history = await repos.MessageRepo.history(db, user.id, m.session_id, limit=60)
|
||
history = [h for h in history if h.id <= mid and h.id != m.id]
|
||
msgs = await build_context(db, user, s, history)
|
||
client, models = await _channel_for(db, user, s)
|
||
reply = await client.chat(models.get("narrative") or "step-3.5-flash", msgs)
|
||
swipes = json.loads(_dec(user, m.swipes_enc)) if m.swipes_enc else [_dec(user, m.content_enc)]
|
||
swipes.append(reply)
|
||
m.swipes_enc = _enc(user, json.dumps(swipes))
|
||
m.active_swipe = len(swipes) - 1
|
||
m.content_enc = _enc(user, reply)
|
||
await db.commit()
|
||
return {"active": m.active_swipe, "count": len(swipes)}
|
||
|
||
|
||
@router.patch("/messages/{mid}/swipe")
|
||
async def pick_swipe(mid: int, body: dict, 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, "消息不存在")
|
||
swipes = json.loads(_dec(user, m.swipes_enc)) if m.swipes_enc else [_dec(user, m.content_enc)]
|
||
idx = body.get("active", 0)
|
||
if not 0 <= idx < len(swipes):
|
||
raise HTTPException(400, "下标越界")
|
||
m.active_swipe = idx
|
||
m.content_enc = _enc(user, swipes[idx])
|
||
await db.commit()
|
||
return {"active": idx, "content": swipes[idx]}
|
||
|
||
|
||
# ============ 5. 角色卡导入导出 / 广场 ============
|
||
|
||
@router.get("/characters/{cid}/export")
|
||
async def export_character(cid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
c = await db.get(Character, cid)
|
||
if not c or c.user_id != user.id:
|
||
raise HTTPException(404, "角色不存在")
|
||
key = _key(user)
|
||
mems = await repos.MemoryRepo.list_for(db, user.id, cid)
|
||
card = {"name": c.name, "description": repos.dec(key, c.persona),
|
||
"first_mes": repos.dec(key, c.greeting), "voice": c.voice,
|
||
"tags": c.tags, "source": "open-maopaoya"}
|
||
if not c.share_code:
|
||
c.share_code = secrets.token_urlsafe(8)
|
||
await db.commit()
|
||
return {"card": card, "memories": [_dec(user, m.content_enc) for m in mems],
|
||
"name": c.name, "share_code": c.share_code}
|
||
|
||
|
||
class CardIn(BaseModel):
|
||
name: str
|
||
description: str = ""
|
||
first_mes: str = ""
|
||
voice: str = "tongtong"
|
||
tags: str = ""
|
||
memories: list[str] = []
|
||
|
||
|
||
@router.post("/characters/import")
|
||
async def import_character(body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
# 两种入参:share_code 或完整 card JSON
|
||
if body.get("share_code"):
|
||
src = (await db.execute(select(Character).where(
|
||
Character.share_code == body["share_code"]))).scalar_one_or_none()
|
||
if not src:
|
||
raise HTTPException(404, "分享码无效")
|
||
key = _key(user)
|
||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||
ek = None if visible else key
|
||
c = Character(user_id=user.id, name=src.name, source="imported",
|
||
voice=src.voice, avatar_url=src.avatar_url, tags=src.tags)
|
||
c.persona = repos.enc(ek, repos.dec(key, src.persona))
|
||
c.greeting = repos.enc(ek, repos.dec(key, src.greeting))
|
||
db.add(c)
|
||
await db.commit()
|
||
return {"id": c.id}
|
||
card = body.get("card") or body
|
||
c = Character(user_id=user.id, name=card["name"], source="imported",
|
||
tags=card.get("tags", ""), voice=card.get("voice", "tongtong"))
|
||
key = _key(user)
|
||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||
ek = None if visible else key
|
||
c.persona = repos.enc(ek, card.get("description", ""))
|
||
c.greeting = repos.enc(ek, card.get("first_mes", ""))
|
||
db.add(c)
|
||
await db.flush()
|
||
for mem in (card.get("memories") or [])[:200]:
|
||
db.add(Memory(character_id=c.id, user_id=user.id, kind="fact",
|
||
content_enc=repos.enc(ek, mem)))
|
||
await db.commit()
|
||
return {"id": c.id}
|
||
|
||
|
||
@router.post("/characters/{cid}/publish")
|
||
async def publish_character(cid: int, body: dict, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
c = await db.get(Character, cid)
|
||
if not c or c.user_id != user.id:
|
||
raise HTTPException(404, "角色不存在")
|
||
c.is_public = bool(body.get("public", True))
|
||
if c.is_public:
|
||
key = _key(user)
|
||
if not key:
|
||
raise HTTPException(401, "请重新登录后再发布")
|
||
# 公开卡片属公开数据:人设/开场白存明文公开字段供广场展示与领养
|
||
c.public_persona = repos.dec(key, c.persona)
|
||
c.public_greeting = repos.dec(key, c.greeting)
|
||
c.tags = body.get("tags", c.tags)
|
||
if not c.share_code:
|
||
c.share_code = secrets.token_urlsafe(8)
|
||
await db.commit()
|
||
return {"is_public": c.is_public, "share_code": c.share_code}
|
||
|
||
|
||
@router.get("/plaza")
|
||
async def plaza(q: str = "", user: User = Depends(current_user), db=Depends(get_db)):
|
||
rows = (await db.execute(select(Character).where(Character.is_public == True)
|
||
.order_by(Character.usage_count.desc()))).scalars().all()
|
||
q = (q or "").strip()
|
||
if q:
|
||
rows = [c for c in rows if q.lower() in c.name.lower()
|
||
or q.lower() in (c.tags or "").lower()
|
||
or q.lower() in (c.public_persona or "").lower()]
|
||
return {"characters": [{"id": c.id, "name": c.name,
|
||
"persona": (c.public_persona or "")[:150],
|
||
"avatar_url": c.avatar_url, "tags": c.tags,
|
||
"usage_count": c.usage_count,
|
||
"share_code": c.share_code} for c in rows]}
|
||
|
||
|
||
@router.post("/plaza/{cid}/clone")
|
||
async def clone_character(cid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
c = await db.get(Character, cid)
|
||
if not c or not c.is_public:
|
||
raise HTTPException(404, "角色不存在或未公开")
|
||
n = Character(user_id=user.id, name=c.name, source="imported",
|
||
voice=c.voice, avatar_url=c.avatar_url, tags=c.tags)
|
||
# 优先取发布时的公开明文;作者本人克隆用自身密钥解密
|
||
if c.user_id == user.id:
|
||
key = _key(user)
|
||
n.persona = repos.dec(key, c.persona)
|
||
n.greeting = repos.dec(key, c.greeting)
|
||
else:
|
||
if not c.is_public:
|
||
raise HTTPException(403, "该角色未公开")
|
||
n.persona = c.public_persona or ""
|
||
n.greeting = c.public_greeting or ""
|
||
n.source = "imported"
|
||
db.add(n)
|
||
c.usage_count += 1
|
||
await db.commit()
|
||
return {"id": n.id}
|
||
|
||
|
||
# ============ 6. 搜索 / 收藏 / 导出 / 偏好 ============
|
||
|
||
@router.get("/search")
|
||
async def search(q: str, user: User = Depends(current_user), db=Depends(get_db)):
|
||
key = _key(user)
|
||
chars = (await db.execute(select(Character).where(
|
||
Character.user_id == user.id, or_(
|
||
Character.name.ilike(f"%{q}%"))))).scalars().all()
|
||
sessions = (await db.execute(select(ChatSession).where(
|
||
ChatSession.user_id == user.id, ChatSession.title.ilike(f"%{q}%")))).scalars().all()
|
||
msgs = (await db.execute(select(Message).where(
|
||
Message.user_id == user.id).order_by(Message.id.desc()).limit(500))).scalars().all()
|
||
hit_msgs = [{"id": m.id, "session_id": m.session_id,
|
||
"content": _dec(user, m.content_enc)[:120], "speaker": m.speaker}
|
||
for m in msgs if q.lower() in _dec(user, m.content_enc).lower()][:30]
|
||
return {"characters": [{"id": c.id, "name": c.name} for c in chars],
|
||
"sessions": [{"id": s.id, "title": s.title, "mode": s.mode} for s in sessions],
|
||
"messages": hit_msgs}
|
||
|
||
|
||
@router.patch("/messages/{mid}/star")
|
||
async def star_message(mid: int, body: dict, 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.starred = bool(body.get("starred", True))
|
||
await db.commit()
|
||
return {"starred": m.starred}
|
||
|
||
|
||
@router.get("/sessions/{sid}/export")
|
||
async def export_chat(sid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
msgs = await repos.MessageRepo.history(db, user.id, sid, limit=10000)
|
||
lines = [f"# {s.title}\n"]
|
||
for m in msgs:
|
||
who = m.speaker or ("我" if m.role == "user" else "AI")
|
||
lines.append(f"**{who}**: {_dec(user, m.content_enc)}\n")
|
||
return Response(content="\n".join(lines), media_type="text/markdown",
|
||
headers={"Content-Disposition":
|
||
f"attachment; filename=session-{sid}.md"})
|
||
|
||
|
||
@router.get("/prefs")
|
||
async def get_prefs(user: User = Depends(current_user), db=Depends(get_db)):
|
||
p = await db.get(UserPrefs, user.id)
|
||
return {"prefs": json.loads(p.data) if p else {}}
|
||
|
||
|
||
@router.post("/prefs")
|
||
async def set_prefs(body: dict, user: User = Depends(current_user), db=Depends(get_db)):
|
||
p = await db.get(UserPrefs, user.id)
|
||
if not p:
|
||
p = UserPrefs(user_id=user.id, data="{}")
|
||
db.add(p)
|
||
cur = json.loads(p.data)
|
||
cur.update(body)
|
||
p.data = json.dumps(cur)
|
||
await db.commit()
|
||
return {"prefs": cur}
|
||
|
||
|
||
@router.get("/me/export")
|
||
async def export_my_data(user: User = Depends(current_user), db=Depends(get_db)):
|
||
"""账号级全量备份(本人密钥可解 → 明文 JSON)"""
|
||
import datetime as _dt
|
||
key = _key(user)
|
||
chars = await repos.CharacterRepo.list_for(db, user.id)
|
||
sessions = await repos.SessionRepo.list_for(db, user.id)
|
||
data = {"version": 1, "exported_at": str(_dt.datetime.utcnow()),
|
||
"username": user.username,
|
||
"characters": [{"name": c.name, "persona": repos.dec(key, c.persona),
|
||
"greeting": repos.dec(key, c.greeting), "voice": c.voice,
|
||
"avatar_url": c.avatar_url, "tags": c.tags,
|
||
"source": c.source} for c in chars],
|
||
"sessions": [{"mode": s.mode, "title": s.title,
|
||
"novel_setting": _dec(user, s.novel_setting_enc or "")}
|
||
for s in sessions],
|
||
"memories": [], "worldbook": []}
|
||
for c in chars:
|
||
for m in await repos.MemoryRepo.list_for(db, user.id, c.id):
|
||
data["memories"].append({"character": c.name, "kind": m.kind,
|
||
"content": _dec(user, m.content_enc)})
|
||
for w in await repos.WorldbookRepo.list_for(db, user.id):
|
||
data["worldbook"].append({"keywords": w.keywords,
|
||
"content": _dec(user, w.content_enc),
|
||
"constant": w.constant})
|
||
return data
|
||
|
||
|
||
# ============ 补齐:别名/设置/摘要/统计 ============
|
||
|
||
@router.post("/characters/{cid}/clone")
|
||
async def clone_alias(cid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||
return await clone_character(cid, user, db)
|
||
|
||
|
||
class SessionSettingsIn(BaseModel):
|
||
title: str | None = None
|
||
prompt_suffix: str | None = None
|
||
bg_url: str | None = None
|
||
pinned: bool | None = None
|
||
archived: bool | None = None
|
||
|
||
|
||
@router.patch("/sessions/{sid}/settings")
|
||
async def session_settings(sid: int, body: SessionSettingsIn,
|
||
user: User = Depends(current_user), db=Depends(get_db)):
|
||
s = await _own_session(db, user, sid)
|
||
for k, v in body.model_dump(exclude_none=True).items():
|
||
setattr(s, k, v)
|
||
await db.commit()
|
||
return {"ok": True}
|
||
|
||
|
||
@router.post("/sessions/{sid}/summary")
|
||
async def summarize_session(sid: int, user: User = Depends(current_user),
|
||
db=Depends(get_db)):
|
||
"""自动摘要:把本会话剧情压缩成事件记忆(需要可用渠道)"""
|
||
s = await _own_session(db, user, sid)
|
||
msgs = await repos.MessageRepo.history(db, user.id, sid, limit=200)
|
||
text = "\n".join(_dec(user, m.content_enc) for m in msgs)
|
||
client, models = await _channel_for(db, user, s)
|
||
summary = await client.chat(models.get("extract") or "step-3.5-flash", [
|
||
{"role": "system", "content": "把以下对话/剧情压缩成简明的事件要点列表,"
|
||
"每条一行,保留关键事实与人物关系。只输出要点。"},
|
||
{"role": "user", "content": text[:12000]},
|
||
], temperature=0.2)
|
||
# 存成事件记忆
|
||
if s.character_id:
|
||
key = _key(user)
|
||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||
db.add(Memory(character_id=s.character_id, user_id=user.id, kind="event",
|
||
content_enc=repos.enc(None if visible else key, summary)))
|
||
await db.commit()
|
||
return {"summary": summary, "saved": bool(s.character_id)}
|
||
|
||
|
||
@router.get("/admin/stats")
|
||
async def admin_stats(user: User = Depends(current_user), db=Depends(get_db)):
|
||
if not user.is_admin:
|
||
raise HTTPException(403, "需要管理员权限")
|
||
users = (await db.execute(select(User))).scalars().all()
|
||
sessions = (await db.execute(select(ChatSession))).scalars().all()
|
||
msgs = (await db.execute(select(Message))).scalars().all()
|
||
chars = (await db.execute(select(Character))).scalars().all()
|
||
by_mode = {}
|
||
for s in sessions:
|
||
by_mode[s.mode] = by_mode.get(s.mode, 0) + 1
|
||
return {"users": len(users), "sessions": len(sessions),
|
||
"messages": len(msgs), "characters": len(chars),
|
||
"by_mode": by_mode}
|