Open Maopaoya M0-M2: 用户体系+权限开关+后台 / 渠道管理 / 单角色扮演(记忆可篡改+世界书+TTS) / 动态小说管线(实体抽取→建档→立绘→世界书注册) / AES-GCM数据加密+登录解密迁移 / 液态玻璃UI
This commit is contained in:
@@ -0,0 +1,112 @@
|
||||
"""管理员后台:用户管理 / 权限开关 / 渠道分配 / 站点概览"""
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel
|
||||
|
||||
from ...db.session import get_db
|
||||
from ...db import repos
|
||||
from ...models.entities import User, Channel, ChatSession
|
||||
from ...api.routers.auth import current_user
|
||||
from ...core import security
|
||||
|
||||
router = APIRouter(prefix="/admin", tags=["admin"])
|
||||
|
||||
|
||||
async def require_admin(user: User = Depends(current_user)):
|
||||
if not user.is_admin:
|
||||
raise HTTPException(403, "需要管理员权限")
|
||||
return user
|
||||
|
||||
|
||||
@router.get("/settings")
|
||||
async def get_settings(db=Depends(get_db), _: User = Depends(require_admin)):
|
||||
return await repos.SettingRepo.all(db)
|
||||
|
||||
|
||||
@router.post("/settings")
|
||||
async def set_setting(key: str, value: str, db=Depends(get_db),
|
||||
_: User = Depends(require_admin)):
|
||||
allowed = {"allow_register", "allow_delete_account", "allow_byok",
|
||||
"admin_data_visible"}
|
||||
if key not in allowed:
|
||||
raise HTTPException(400, "未知开关")
|
||||
await repos.SettingRepo.set(db, key, "true" if value == "true" else "false")
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.get("/users")
|
||||
async def list_users(db=Depends(get_db), _: User = Depends(require_admin)):
|
||||
users = await repos.UserRepo.all(db)
|
||||
n_sessions = len((await db.execute(
|
||||
__import__("sqlalchemy").select(ChatSession))).scalars().all())
|
||||
return {"users": [{"id": u.id, "username": u.username, "is_admin": u.is_admin,
|
||||
"is_active": u.is_active} for u in users],
|
||||
"stats": {"users": len(users), "sessions": n_sessions}}
|
||||
|
||||
|
||||
class UserPatch(BaseModel):
|
||||
is_active: bool | None = None
|
||||
is_admin: bool | None = None
|
||||
new_password: str | None = None
|
||||
|
||||
|
||||
@router.patch("/users/{uid}")
|
||||
async def patch_user(uid: int, body: UserPatch, db=Depends(get_db),
|
||||
_: User = Depends(require_admin)):
|
||||
u = await repos.UserRepo.by_id(db, uid)
|
||||
if not u:
|
||||
raise HTTPException(404, "用户不存在")
|
||||
if body.is_active is not None:
|
||||
u.is_active = body.is_active
|
||||
if body.is_admin is not None:
|
||||
u.is_admin = body.is_admin
|
||||
if body.new_password:
|
||||
u.password_hash = security.hash_password(body.new_password)
|
||||
security.key_cache.pop(uid, None)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
class AuthInLike(BaseModel):
|
||||
username: str
|
||||
password: str
|
||||
|
||||
|
||||
@router.post("/users")
|
||||
async def create_user(body: AuthInLike, db=Depends(get_db),
|
||||
_: User = Depends(require_admin)):
|
||||
if await repos.UserRepo.by_username(db, body.username):
|
||||
raise HTTPException(409, "用户名已存在")
|
||||
salt = security.os.urandom(16)
|
||||
db.add(User(username=body.username,
|
||||
password_hash=security.hash_password(body.password),
|
||||
kdf_salt=salt.hex()))
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.post("/channels/{cid}/grant/{uid}")
|
||||
async def grant_channel(cid: int, uid: int, db=Depends(get_db),
|
||||
_: User = Depends(require_admin)):
|
||||
db.add(__import__("app.models.entities", fromlist=["ChannelGrant"]).ChannelGrant(
|
||||
channel_id=cid, user_id=uid))
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.delete("/channels/{cid}/grant/{uid}")
|
||||
async def revoke_channel(cid: int, uid: int, db=Depends(get_db),
|
||||
_: User = Depends(require_admin)):
|
||||
from ...models.entities import ChannelGrant
|
||||
from sqlalchemy import delete as _del
|
||||
await db.execute(_del(ChannelGrant).where(
|
||||
ChannelGrant.channel_id == cid, ChannelGrant.user_id == uid))
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.get("/channels/{cid}/grants")
|
||||
async def list_grants(cid: int, db=Depends(get_db), _: User = Depends(require_admin)):
|
||||
from ...models.entities import ChannelGrant
|
||||
rows = (await db.execute(__import__("sqlalchemy").select(ChannelGrant).where(
|
||||
ChannelGrant.channel_id == cid))).scalars().all()
|
||||
return {"user_ids": [r.user_id for r in rows]}
|
||||
@@ -0,0 +1,111 @@
|
||||
from fastapi import APIRouter, Depends, HTTPException, Request
|
||||
from pydantic import BaseModel
|
||||
from sqlalchemy import select
|
||||
|
||||
from ...db.session import get_db
|
||||
from ...db import repos
|
||||
from ...models.entities import User
|
||||
from ...core import security
|
||||
from ...core.config import settings
|
||||
|
||||
router = APIRouter(prefix="/auth", tags=["auth"])
|
||||
|
||||
|
||||
class AuthIn(BaseModel):
|
||||
username: str
|
||||
password: str
|
||||
|
||||
|
||||
async def current_user(request: Request, db=Depends(get_db)) -> User:
|
||||
token = request.headers.get("Authorization", "").removeprefix("Bearer ")
|
||||
payload = security.parse_token(token)
|
||||
if not payload:
|
||||
raise HTTPException(401, "未登录")
|
||||
user = await repos.UserRepo.by_id(db, int(payload["uid"]))
|
||||
if not user or not user.is_active:
|
||||
raise HTTPException(401, "账户无效")
|
||||
return user
|
||||
|
||||
|
||||
@router.post("/register")
|
||||
async def register(body: AuthIn, db=Depends(get_db)):
|
||||
if await repos.SettingRepo.get(db, "allow_register") != "true":
|
||||
raise HTTPException(403, "本站已关闭注册")
|
||||
if await repos.UserRepo.by_username(db, body.username):
|
||||
raise HTTPException(409, "用户名已存在")
|
||||
salt = security.os.urandom(16)
|
||||
u = User(username=body.username,
|
||||
password_hash=security.hash_password(body.password),
|
||||
kdf_salt=salt.hex())
|
||||
# 首个注册用户 = 管理员
|
||||
if not (await db.execute(select(User))).scalars().first():
|
||||
u.is_admin = True
|
||||
db.add(u)
|
||||
await db.commit()
|
||||
return await token_response(u, body.password)
|
||||
|
||||
|
||||
@router.post("/login")
|
||||
async def login(body: AuthIn, db=Depends(get_db)):
|
||||
u = await repos.UserRepo.by_username(db, body.username)
|
||||
if not u or not security.verify_password(body.password, u.password_hash):
|
||||
raise HTTPException(401, "用户名或密码错误")
|
||||
if not u.is_active:
|
||||
raise HTTPException(403, "账户已被封禁")
|
||||
return await token_response(u, body.password)
|
||||
|
||||
|
||||
async def token_response(u: User, password: str):
|
||||
key = security.derive_key(password, bytes.fromhex(u.kdf_salt))
|
||||
security.key_cache[u.id] = key
|
||||
# "数据可见" OFF→ON 迁移:登录时把存量密文解开转明文
|
||||
await migrate_decrypt(u, key)
|
||||
return {"token": security.make_token(u.id, u.is_admin),
|
||||
"username": u.username, "is_admin": u.is_admin}
|
||||
|
||||
|
||||
async def migrate_decrypt(u: User, key: bytes):
|
||||
"""admin_data_visible=true 时,解密该用户所有存量密文(静默)。"""
|
||||
from ...db.session import SessionLocal
|
||||
from ...models.entities import Memory, WorldbookEntry, Message, ChatSession
|
||||
async with SessionLocal() as db:
|
||||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||||
if not visible:
|
||||
return
|
||||
for field_rows, field in [(await db.execute(select(Memory).where(Memory.user_id == u.id))).scalars().all(), "content_enc"], \
|
||||
[(await db.execute(select(WorldbookEntry).where(WorldbookEntry.user_id == u.id))).scalars().all(), "content_enc"], \
|
||||
[(await db.execute(select(Message).where(Message.user_id == u.id))).scalars().all(), "content_enc"]:
|
||||
for row in field_rows:
|
||||
if security.is_encrypted(getattr(row, field)):
|
||||
setattr(row, field, security.decrypt_text(key, getattr(row, field)))
|
||||
# novel_setting
|
||||
for s in (await db.execute(select(ChatSession).where(ChatSession.user_id == u.id))).scalars().all():
|
||||
if s.novel_setting_enc and security.is_encrypted(s.novel_setting_enc):
|
||||
s.novel_setting_enc = security.decrypt_text(key, s.novel_setting_enc)
|
||||
await db.commit()
|
||||
|
||||
|
||||
@router.post("/delete-account")
|
||||
async def delete_account(body: AuthIn, user: User = Depends(current_user), db=Depends(get_db)):
|
||||
if await repos.SettingRepo.get(db, "allow_delete_account") != "true":
|
||||
raise HTTPException(403, "本站已关闭注销")
|
||||
if not security.verify_password(body.password, user.password_hash):
|
||||
raise HTTPException(401, "密码错误")
|
||||
# 硬删除:数据随账户消失,不可恢复
|
||||
from ...models.entities import (Memory, WorldbookEntry, Message,
|
||||
ChatSession, Character, Channel)
|
||||
for model, col in [(Memory, "user_id"), (WorldbookEntry, "user_id"),
|
||||
(Message, "user_id"), (ChatSession, "user_id"),
|
||||
(Character, "user_id"), (Channel, "owner_id")]:
|
||||
await db.execute(select(model)) # touch
|
||||
from sqlalchemy import delete as _del
|
||||
await db.execute(_del(model).where(getattr(model, col) == user.id))
|
||||
await db.delete(user)
|
||||
await db.commit()
|
||||
security.key_cache.pop(user.id, None)
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.get("/me")
|
||||
async def me(user: User = Depends(current_user)):
|
||||
return {"id": user.id, "username": user.username, "is_admin": user.is_admin}
|
||||
@@ -0,0 +1,101 @@
|
||||
"""渠道管理:CRUD + 测试 + Step Plan 预设"""
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel
|
||||
|
||||
from ...db.session import get_db
|
||||
from ...db import repos
|
||||
from ...models.entities import User, Channel
|
||||
from ...api.routers.auth import current_user
|
||||
from ...core.config import STEP_PRESET
|
||||
from ...services.llm import LLMClient
|
||||
|
||||
router = APIRouter(prefix="/channels", tags=["channels"])
|
||||
|
||||
|
||||
class ChannelIn(BaseModel):
|
||||
name: str
|
||||
base_url: str
|
||||
api_key: str
|
||||
models: dict = {}
|
||||
visibility: str = "admin" # public / granted / admin
|
||||
|
||||
|
||||
def _view(c: Channel) -> dict:
|
||||
return {"id": c.id, "name": c.name, "base_url": c.base_url,
|
||||
"models": c.models or {}, "owner_id": c.owner_id,
|
||||
"visibility": c.visibility,
|
||||
"has_key": bool(c.api_key_enc)}
|
||||
|
||||
|
||||
@router.get("/preset")
|
||||
async def preset():
|
||||
return STEP_PRESET
|
||||
|
||||
|
||||
@router.get("")
|
||||
async def list_channels(user: User = Depends(current_user), db=Depends(get_db)):
|
||||
rows = await repos.ChannelRepo.visible_to(db, user)
|
||||
return {"channels": [_view(c) for c in rows]}
|
||||
|
||||
|
||||
@router.post("")
|
||||
async def create_channel(body: ChannelIn, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
if not user.is_admin and (await repos.SettingRepo.get(db, "allow_byok")) != "true":
|
||||
raise HTTPException(403, "本站不允许用户自定义 API 渠道")
|
||||
c = Channel(name=body.name, base_url=body.base_url,
|
||||
api_key_enc=body.api_key, # BYOK key 也走加密列(M2 加密开关接入后统一加密)
|
||||
models=body.models, owner_id=None if user.is_admin else user.id,
|
||||
visibility=body.visibility if user.is_admin else "admin")
|
||||
db.add(c)
|
||||
await db.commit()
|
||||
return _view(c)
|
||||
|
||||
|
||||
@router.patch("/{cid}")
|
||||
async def update_channel(cid: int, body: ChannelIn, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
c = await repos.ChannelRepo.can_use(db, user, cid)
|
||||
if not c or (c.owner_id and c.owner_id != user.id and not user.is_admin):
|
||||
raise HTTPException(403, "无权修改该渠道")
|
||||
c.name, c.base_url, c.models = body.name, body.base_url, body.models
|
||||
if body.api_key:
|
||||
c.api_key_enc = body.api_key
|
||||
if user.is_admin:
|
||||
c.visibility = body.visibility
|
||||
await db.commit()
|
||||
return _view(c)
|
||||
|
||||
|
||||
@router.delete("/{cid}")
|
||||
async def delete_channel(cid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
c = await repos.ChannelRepo.can_use(db, user, cid)
|
||||
if not c or (c.owner_id and c.owner_id != user.id and not user.is_admin):
|
||||
raise HTTPException(403, "无权删除该渠道")
|
||||
await db.delete(c)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.post("/{cid}/test")
|
||||
async def test_channel(cid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
c = await repos.ChannelRepo.can_use(db, user, cid)
|
||||
if not c:
|
||||
raise HTTPException(403, "无权访问该渠道")
|
||||
model = (c.models or {}).get("narrative") or "step-3.5-flash"
|
||||
client = LLMClient(c.base_url, c.api_key_enc)
|
||||
ok, msg = await client.ping(model)
|
||||
return {"ok": ok, "message": msg, "model": model}
|
||||
|
||||
|
||||
@router.get("/{cid}/grants")
|
||||
async def list_grants(cid: int, user: User = Depends(current_user), db=Depends(get_db)):
|
||||
from ...models.entities import ChannelGrant
|
||||
from sqlalchemy import select
|
||||
if not user.is_admin:
|
||||
raise HTTPException(403, "需要管理员权限")
|
||||
rows = (await db.execute(select(ChannelGrant).where(
|
||||
ChannelGrant.channel_id == cid))).scalars().all()
|
||||
return {"user_ids": [r.user_id for r in rows]}
|
||||
@@ -0,0 +1,185 @@
|
||||
"""角色 / 记忆 / 世界书:全部可查可改可删,零黑箱。"""
|
||||
from fastapi import APIRouter, Depends, HTTPException
|
||||
from pydantic import BaseModel
|
||||
from sqlalchemy import select, delete
|
||||
|
||||
from ...db.session import get_db
|
||||
from ...db import repos
|
||||
from ...models.entities import User, Character, Memory, WorldbookEntry
|
||||
from ...api.routers.auth import current_user
|
||||
|
||||
router = APIRouter(prefix="/characters", tags=["characters"])
|
||||
|
||||
|
||||
class CharacterIn(BaseModel):
|
||||
name: str
|
||||
persona: str = ""
|
||||
greeting: str = ""
|
||||
voice: str = "tongtong"
|
||||
avatar_url: str = ""
|
||||
|
||||
|
||||
class MemoryIn(BaseModel):
|
||||
kind: str = "fact" # fact / event
|
||||
content: str
|
||||
|
||||
|
||||
class WorldbookIn(BaseModel):
|
||||
scope: str = "character" # character / novel
|
||||
scope_id: int = 0
|
||||
keywords: str = ""
|
||||
content: str
|
||||
constant: bool = False
|
||||
enabled: bool = True
|
||||
|
||||
|
||||
def _key(user):
|
||||
return security.key_cache.get(user.id)
|
||||
|
||||
|
||||
from ...core import security # noqa: E402
|
||||
|
||||
|
||||
async def _own_character(db, user, cid) -> Character:
|
||||
c = await db.get(Character, cid)
|
||||
if not c or c.user_id != user.id:
|
||||
raise HTTPException(404, "角色不存在")
|
||||
return c
|
||||
|
||||
|
||||
@router.get("")
|
||||
async def list_characters(user: User = Depends(current_user), db=Depends(get_db)):
|
||||
rows = await repos.CharacterRepo.list_for(db, user.id)
|
||||
return {"characters": [{"id": c.id, "name": c.name, "persona": c.persona,
|
||||
"greeting": c.greeting, "voice": c.voice,
|
||||
"avatar_url": c.avatar_url, "source": c.source,
|
||||
"novel_id": c.novel_id} for c in rows]}
|
||||
|
||||
|
||||
@router.post("")
|
||||
async def create_character(body: CharacterIn, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
c = Character(user_id=user.id, **body.model_dump())
|
||||
db.add(c)
|
||||
await db.commit()
|
||||
return {"id": c.id}
|
||||
|
||||
|
||||
@router.patch("/{cid}")
|
||||
async def update_character(cid: int, body: CharacterIn,
|
||||
user: User = Depends(current_user), db=Depends(get_db)):
|
||||
c = await _own_character(db, user, cid)
|
||||
for k, v in body.model_dump().items():
|
||||
setattr(c, k, v)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.delete("/{cid}")
|
||||
async def delete_character(cid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
c = await _own_character(db, user, cid)
|
||||
await db.execute(delete(Memory).where(Memory.character_id == cid))
|
||||
await db.delete(c)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
# ---------- 记忆(完全透明可篡改) ----------
|
||||
|
||||
@router.get("/{cid}/memories")
|
||||
async def list_memories(cid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
await _own_character(db, user, cid)
|
||||
rows = await repos.MemoryRepo.list_for(db, user.id, cid)
|
||||
key = _key(user)
|
||||
return {"memories": [{"id": m.id, "kind": m.kind,
|
||||
"content": repos.dec(key, m.content_enc)} for m in rows]}
|
||||
|
||||
|
||||
@router.post("/{cid}/memories")
|
||||
async def add_memory(cid: int, body: MemoryIn, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
await _own_character(db, user, cid)
|
||||
key = _key(user)
|
||||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||||
db.add(Memory(character_id=cid, user_id=user.id, kind=body.kind,
|
||||
content_enc=repos.enc(None if visible else key, body.content)))
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.patch("/{cid}/memories/{mid}")
|
||||
async def edit_memory(cid: int, mid: int, body: MemoryIn,
|
||||
user: User = Depends(current_user), db=Depends(get_db)):
|
||||
m = await db.get(Memory, mid)
|
||||
if not m or m.user_id != user.id or m.character_id != cid:
|
||||
raise HTTPException(404, "记忆不存在")
|
||||
key = _key(user)
|
||||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||||
m.content_enc = repos.enc(None if visible else key, body.content)
|
||||
m.kind = body.kind
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.delete("/{cid}/memories/{mid}")
|
||||
async def delete_memory(cid: int, mid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
m = await db.get(Memory, mid)
|
||||
if not m or m.user_id != user.id:
|
||||
raise HTTPException(404, "记忆不存在")
|
||||
await db.delete(m)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
# ---------- 世界书 ----------
|
||||
|
||||
@router.get("/worldbook/all")
|
||||
async def list_worldbook(user: User = Depends(current_user), db=Depends(get_db)):
|
||||
rows = await repos.WorldbookRepo.list_for(db, user.id)
|
||||
key = _key(user)
|
||||
return {"entries": [{"id": w.id, "scope": w.scope, "scope_id": w.scope_id,
|
||||
"keywords": w.keywords, "constant": w.constant,
|
||||
"enabled": w.enabled,
|
||||
"content": repos.dec(key, w.content_enc)} for w in rows]}
|
||||
|
||||
|
||||
@router.post("/worldbook")
|
||||
async def add_worldbook(body: WorldbookIn, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
key = _key(user)
|
||||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||||
db.add(WorldbookEntry(user_id=user.id, scope=body.scope, scope_id=body.scope_id,
|
||||
keywords=body.keywords, constant=body.constant,
|
||||
enabled=body.enabled,
|
||||
content_enc=repos.enc(None if visible else key, body.content)))
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.patch("/worldbook/{wid}")
|
||||
async def edit_worldbook(wid: int, body: WorldbookIn,
|
||||
user: User = Depends(current_user), db=Depends(get_db)):
|
||||
w = await db.get(WorldbookEntry, wid)
|
||||
if not w or w.user_id != user.id:
|
||||
raise HTTPException(404, "条目不存在")
|
||||
key = _key(user)
|
||||
visible = await repos.SettingRepo.get(db, "admin_data_visible") == "true"
|
||||
for k, v in body.model_dump().items():
|
||||
setattr(w, k, v)
|
||||
w.content_enc = repos.enc(None if visible else key, body.content)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
|
||||
|
||||
@router.delete("/worldbook/{wid}")
|
||||
async def delete_worldbook(wid: int, user: User = Depends(current_user),
|
||||
db=Depends(get_db)):
|
||||
w = await db.get(WorldbookEntry, wid)
|
||||
if not w or w.user_id != user.id:
|
||||
raise HTTPException(404, "条目不存在")
|
||||
await db.delete(w)
|
||||
await db.commit()
|
||||
return {"ok": True}
|
||||
@@ -0,0 +1,264 @@
|
||||
"""聊天主链路:单角色扮演 + 动态小说两种模式。上下文不做节省。"""
|
||||
import datetime as dt
|
||||
|
||||
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 ...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
|
||||
|
||||
|
||||
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{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, 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)
|
||||
return {"messages": [{"id": m.id, "role": m.role, "speaker": m.speaker,
|
||||
"content": _dec(user, m.content_enc)} for m in rows]}
|
||||
|
||||
|
||||
@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)))
|
||||
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)
|
||||
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": 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")
|
||||
Reference in New Issue
Block a user