AskaEth
0624d9ee36
按 DevDocs/design/22 批次 1 后端（§2/§3/§4.1-4.5/§4.7/§5 验收 1-6）。
- 迁移 0011：chat_sessions.persona_id + chat_messages.persona_id（均 DEFAULT ''，无回填 → 升级零风险）；同步包内幂等 DDL；**真实库升级验证**（拷贝 data/cyrene.db 到临时目录跑 MigrateUp：既有 1 会话/109 消息 persona 仍为 ''，原库未被触碰）
- history：SessionMeta/Message 加 PersonaID + SetSessionPersona；ListSessions/List/scan/Append 带上
- runtime：SessionEnv.PersonaID + loop.personaFor(ctx) 替换固定 l.personaID（memory/request/turn）+ **agent 池**（Options.Agents，按角色取 instructions，未命中回落）+ **提取器不再把 persona 烤死在构造期**（多角色下记忆不再永远记在 cyrene 名下）+ **thinking 旋钮改为按会话角色解析**（否则角色 Y 会用角色 X 的预算/展示）
- gateway：会话 DTO/POST/PATCH 支持 personaId；ws/rest/voice 的 OwnerEnv 硬编改为**按会话解析角色**（actor 元数据语义不变）；admin memories 搜索去掉硬编 cyrene
- Docs/api-client v0.42；**两处有意的行为收紧**已写明：POST /sessions body 非法 JSON → 400（原先完全忽略 body；空/null/{} 仍 201）；POST /admin/memories/search 省略 personaId 且无默认角色 → 400（原先默认查 cyrene）
- 测试：design/22 §5 验收 1-6（记忆隔离/提示词首条 system/情绪按角色/提取 persona 归属/迁移兼容）+ 进程内 e2e（断言 adapter 收到的 model.Request.Messages[0] 即该角色的 systemPrompt）
- **已知未做（留批次 2 / 待确认）**：① IM 与渠道级未做 → **§7-3「owner 私聊镜像随主会话角色」尚未生效**；② 请求级覆盖未实现（本批只做会话级）；③ **§7-5 的「上下文发送角色标记」只完成存储+DTO 半边**——消息 persona 已落库且 DTO 已带，但模型上下文不从 chat_messages 重建，「第 N 条是谁说的」尚未进上下文（需确认是否属批次 2）；④「切角色重建摘要」当前是空操作（压缩未接线）；⑤ thinking 旋钮仅在流式路径生效（非流式 agent.RunStep 不带，A 批次既有性质）
- 验收：go build/vet/test 全绿 + linux/amd64 与 darwin/arm64 交叉编译（既有 flake 本轮未触发；同批 session_orchestrator.go 一度 501 行 → 抽出 session_tail.go）
412 lines
16 KiB
Go
412 lines
16 KiB
Go
package gateway
|
||
|
||
import (
|
||
"encoding/json"
|
||
"errors"
|
||
"io"
|
||
"net/http"
|
||
"strconv"
|
||
"strings"
|
||
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/auth"
|
||
apperr "git.yeij.top/AskaEth/Cyrene_v2/internal/errors"
|
||
"git.yeij.top/AskaEth/Cyrene_v2/internal/runtime/history"
|
||
)
|
||
|
||
// historySessionSummary is the wire shape of one persistent session (main or sub) in the
|
||
// GET /api/v1/sessions response.
|
||
type historySessionSummary struct {
|
||
ID string `json:"id"`
|
||
Type string `json:"type"` // "main" | "sub"
|
||
Title string `json:"title,omitempty"`
|
||
CreatedAt int64 `json:"createdAt"`
|
||
// Pinned floats the session to the top of the list (D5). It is order metadata
|
||
// only and is always present so a client can render/sort without a second call.
|
||
Pinned bool `json:"pinned"`
|
||
// LastMessage is a display-only preview of the session's newest message, so the
|
||
// client can render a conversation row (e.g. the Android session list) without a
|
||
// per-session request. It is omitted for a session with no messages. Content is
|
||
// already truncated by the store.
|
||
LastMessage *historyLastMessage `json:"lastMessage,omitempty"`
|
||
// UnreadCount is the number of messages newer than the session's read cursor
|
||
// (D4), derived in the same list query. It is always returned (0 when nothing
|
||
// is unread) so a client can render/clear the badge without a second call. The
|
||
// cursor is session-scoped and single-owner: reading on any one end clears the
|
||
// badge for every end of the account.
|
||
UnreadCount int `json:"unreadCount"`
|
||
// PersonaID is the role this session belongs to (design/22 §2/§4.5). It is the
|
||
// single source of truth for which role answers in the conversation, and the
|
||
// client uses it to render the role's name/avatar for the active session.
|
||
// Omitted when empty, and empty means "inherit the global default role", so an
|
||
// old client that ignores the field keeps showing the default role's visuals.
|
||
PersonaID string `json:"personaId,omitempty"`
|
||
}
|
||
|
||
// historyLastMessage is the wire shape of the last-message preview in a session summary.
|
||
type historyLastMessage struct {
|
||
Role string `json:"role"` // "user" | "assistant"
|
||
Content string `json:"content"`
|
||
CreatedAt int64 `json:"createdAt"`
|
||
}
|
||
|
||
// historyMessage is the wire shape of one persisted chat message in the
|
||
// GET /api/v1/sessions/{id}/messages response. Mode is carried so the frontend renders
|
||
// the bubble without guessing (design/16 §5.1); thinking is stored and returned to the
|
||
// owner/admin (the messages route is owner/admin-only, so it never reaches a viewer).
|
||
type historyMessage struct {
|
||
ID string `json:"id"`
|
||
SessionID string `json:"sessionId"`
|
||
Role string `json:"role"`
|
||
Content string `json:"content"`
|
||
Mode string `json:"mode,omitempty"`
|
||
Mood string `json:"mood,omitempty"`
|
||
Image string `json:"image,omitempty"`
|
||
Thinking string `json:"thinking,omitempty"`
|
||
Platform string `json:"platform,omitempty"`
|
||
DeviceID string `json:"deviceId,omitempty"`
|
||
// SenderName is the human-readable sender display name of a third-party
|
||
// message (group/stranger, design/16 §4.6). It is blank for the owner's
|
||
// private chat on the main session, so empty means "labeled as the owner".
|
||
SenderName string `json:"senderName,omitempty"`
|
||
// AdapterID is the adapter (platform + account) registration name of the IM
|
||
// source that produced the message (e.g. "kook:3bef..."). It is blank for
|
||
// Web-originated messages.
|
||
AdapterID string `json:"adapterId,omitempty"`
|
||
// PersonaID is the role that SPOKE this message (design/22 §7-5). A session may
|
||
// switch roles while keeping its context, so the authoring role is stored and
|
||
// returned per message and the client renders the bubble with that role's
|
||
// name/avatar. Omitted when empty, and empty means "the global default role" —
|
||
// the pre-multi-character rows read exactly as before.
|
||
PersonaID string `json:"personaId,omitempty"`
|
||
CreatedAt int64 `json:"createdAt"`
|
||
}
|
||
|
||
// handleHistorySessions returns the main session first, then every sub session (oldest
|
||
// first). It is the chat-history session list for the frontend (design/16 §2.2).
|
||
func (s *Server) handleHistorySessions(w http.ResponseWriter, r *http.Request) {
|
||
meta, err := s.history.ListSessions(r.Context())
|
||
if err != nil {
|
||
s.log.Error("history list sessions", "err", err)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "sessions_failed", "failed to list sessions"))
|
||
return
|
||
}
|
||
out := make([]historySessionSummary, 0, len(meta))
|
||
for _, m := range meta {
|
||
out = append(out, historySessionSummary{
|
||
ID: m.ID,
|
||
Type: m.Type,
|
||
Title: m.Title,
|
||
CreatedAt: m.CreatedAt,
|
||
Pinned: m.Pinned,
|
||
PersonaID: m.PersonaID,
|
||
LastMessage: toHistoryLastMessage(m.LastMessage),
|
||
UnreadCount: m.UnreadCount,
|
||
})
|
||
}
|
||
writeJSON(w, http.StatusOK, out)
|
||
}
|
||
|
||
// toHistoryLastMessage maps a stored last-message preview to its wire shape, returning
|
||
// nil for a session that has no messages (so the field is omitted from the JSON).
|
||
func toHistoryLastMessage(m *history.MessageSummary) *historyLastMessage {
|
||
if m == nil {
|
||
return nil
|
||
}
|
||
return &historyLastMessage{Role: m.Role, Content: m.Content, CreatedAt: m.CreatedAt}
|
||
}
|
||
|
||
// createSubSessionRequest is the POST /api/v1/sessions body. The body itself is
|
||
// optional (a client that just wants a plain session sends none), and personaId is
|
||
// the optional role the new session is bound to (design/22 §4.5). It is the
|
||
// "seed the new session's role" half of the design's precedence: an explicit role
|
||
// here becomes the session-level binding (the single source of truth), while
|
||
// omitting it leaves persona_id = '' so the session inherits the global default.
|
||
type createSubSessionRequest struct {
|
||
PersonaID string `json:"personaId"`
|
||
}
|
||
|
||
// handleCreateSubSession creates a new sub session and returns its sessionId. It is a
|
||
// user-side write, so it is owner/admin-gated like /api/v1/chat. An optional
|
||
// {"personaId":"..."} body binds the new session to that role; an unknown id is
|
||
// rejected with 400 rather than creating a session that would silently answer as
|
||
// the default role.
|
||
func (s *Server) handleCreateSubSession(w http.ResponseWriter, r *http.Request) {
|
||
if s.history == nil {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话历史服务未配置（未注入 HistoryStore）", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
ownerID := ""
|
||
if claims, ok := auth.ClaimsFromContext(r.Context()); ok {
|
||
ownerID = claims.Sub
|
||
}
|
||
var req createSubSessionRequest
|
||
if err := json.NewDecoder(r.Body).Decode(&req); err != nil && !errors.Is(err, io.EOF) {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid request body"))
|
||
return
|
||
}
|
||
personaID := strings.TrimSpace(req.PersonaID)
|
||
if !s.requireKnownPersona(w, personaID) {
|
||
return
|
||
}
|
||
id, err := s.newSubSession(r.Context(), ownerID, personaID)
|
||
if err != nil {
|
||
if errors.Is(err, errPersonaBindingUnsupported) {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话角色绑定需要支持 personaId 的 HistoryStore", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
s.log.Error("history create sub session", "err", err)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "session_failed", "failed to create session"))
|
||
return
|
||
}
|
||
resp := map[string]any{"sessionId": id}
|
||
if personaID != "" {
|
||
resp["personaId"] = personaID
|
||
}
|
||
writeJSON(w, http.StatusCreated, resp)
|
||
}
|
||
|
||
// handleListMessages returns a page of messages for a session with cursor pagination.
|
||
// It is the hot-paging history endpoint (design/16 §2.2, §5.1). Two mutually exclusive
|
||
// cursors are supported:
|
||
// - before (millisecond createdAt): newest-first page of messages strictly older than
|
||
// before — the default, used to page backwards through history;
|
||
// - after (millisecond createdAt): oldest-first page of messages strictly newer than
|
||
// after — forward incremental catch-up, so a client that reconnected can pull
|
||
// everything it missed from the newest createdAt it already has, without the
|
||
// one-page limit of a backward walk.
|
||
//
|
||
// limit defaults to 50 (clamped to 200) for both directions. platform filters the page
|
||
// by source platform in either direction. An optional q switches the page to a
|
||
// session-scoped content search (newest first, still honoring before/limit); q is
|
||
// mutually exclusive with after, and an empty q is ignored so plain paging is
|
||
// unchanged. Supplying both before and after (both > 0) answers 400, as does a
|
||
// non-numeric/negative after or an invalid limit/before.
|
||
func (s *Server) handleListMessages(w http.ResponseWriter, r *http.Request) {
|
||
if s.history == nil {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话历史服务未配置（未注入 HistoryStore）", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
id := r.PathValue("id")
|
||
if id == "" {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "session id is required"))
|
||
return
|
||
}
|
||
limitStr := r.URL.Query().Get("limit")
|
||
limit := historyDefaultLimit
|
||
if limitStr != "" {
|
||
v, err := strconv.Atoi(limitStr)
|
||
if err != nil || v < 1 {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid limit"))
|
||
return
|
||
}
|
||
limit = v
|
||
}
|
||
var before int64
|
||
if b := r.URL.Query().Get("before"); b != "" {
|
||
v, err := strconv.ParseInt(b, 10, 64)
|
||
if err != nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid before"))
|
||
return
|
||
}
|
||
before = v
|
||
}
|
||
after, ok := parseAfterCursor(r)
|
||
if !ok {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid after"))
|
||
return
|
||
}
|
||
if before > 0 && after > 0 {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "before and after are mutually exclusive"))
|
||
return
|
||
}
|
||
platform := r.URL.Query().Get("platform")
|
||
query := strings.TrimSpace(r.URL.Query().Get("q"))
|
||
if query != "" && after > 0 {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "q and after are mutually exclusive"))
|
||
return
|
||
}
|
||
|
||
var msgs []history.Message
|
||
var err error
|
||
switch {
|
||
case query != "":
|
||
msgs, err = s.history.Search(r.Context(), id, query, before, limit)
|
||
case after > 0:
|
||
msgs, err = s.history.ListAfter(r.Context(), id, after, limit, platform)
|
||
default:
|
||
msgs, err = s.history.List(r.Context(), id, before, limit, platform)
|
||
}
|
||
if err != nil {
|
||
s.log.Error("history list messages", "err", err, "session", id)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "messages_failed", "failed to list messages"))
|
||
return
|
||
}
|
||
out := make([]historyMessage, 0, len(msgs))
|
||
for _, m := range msgs {
|
||
out = append(out, toHistoryMessage(m))
|
||
}
|
||
writeJSON(w, http.StatusOK, out)
|
||
}
|
||
|
||
// parseAfterCursor reads the non-negative "after" query param (a millisecond createdAt
|
||
// cursor). An absent/empty param yields (0, true) — no forward bound. A non-numeric or
|
||
// negative value yields (0, false) so the caller answers 400.
|
||
func parseAfterCursor(r *http.Request) (int64, bool) {
|
||
raw := r.URL.Query().Get("after")
|
||
if raw == "" {
|
||
return 0, true
|
||
}
|
||
v, err := strconv.ParseInt(raw, 10, 64)
|
||
if err != nil || v < 0 {
|
||
return 0, false
|
||
}
|
||
return v, true
|
||
}
|
||
|
||
// handleChannelPlatformLog returns up to limit messages for an IM platform across its
|
||
// isolated (group/stranger) sessions, newest first, for the admin adapter log page
|
||
// (design/16 §4.6 §4). It excludes the fixed main web session, so only the platform's
|
||
// non-owner message stream is surfaced; the owner-private mirror stays out of this view.
|
||
func (s *Server) handleChannelPlatformLog(w http.ResponseWriter, r *http.Request) {
|
||
if s.history == nil {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话历史服务未配置（未注入 HistoryStore）", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
platform := r.PathValue("platform")
|
||
if platform == "" {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "platform is required"))
|
||
return
|
||
}
|
||
limitStr := r.URL.Query().Get("limit")
|
||
limit := historyDefaultLimit
|
||
if limitStr != "" {
|
||
v, err := strconv.Atoi(limitStr)
|
||
if err != nil || v < 1 {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid limit"))
|
||
return
|
||
}
|
||
limit = v
|
||
}
|
||
var before int64
|
||
if b := r.URL.Query().Get("before"); b != "" {
|
||
v, err := strconv.ParseInt(b, 10, 64)
|
||
if err != nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid before"))
|
||
return
|
||
}
|
||
before = v
|
||
}
|
||
msgs, err := s.history.ListPlatformLog(r.Context(), platform, before, limit)
|
||
if err != nil {
|
||
s.log.Error("history platform log", "err", err, "platform", platform)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "platform_log_failed", "failed to list platform log"))
|
||
return
|
||
}
|
||
out := make([]historyMessage, 0, len(msgs))
|
||
for _, m := range msgs {
|
||
out = append(out, toHistoryMessage(m))
|
||
}
|
||
writeJSON(w, http.StatusOK, out)
|
||
}
|
||
|
||
// handleChannelMessages returns up to limit messages for the admin adapter log page,
|
||
// newest first, across one of three granularities (design/16 §4.6 §4): a single
|
||
// adapter config (?adapter=kook:3bef...), a whole platform (?platform=kook), or the
|
||
// full IM adapter overview (neither, so adapter_id != ''). before/limit reuse the
|
||
// standard cursor pagination. The owner-private mirror on the main web session is
|
||
// NOT excluded here because it carries the adapter_id; each granularity filters on
|
||
// adapter_id / platform directly.
|
||
func (s *Server) handleChannelMessages(w http.ResponseWriter, r *http.Request) {
|
||
if s.history == nil {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话历史服务未配置（未注入 HistoryStore）", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
limitStr := r.URL.Query().Get("limit")
|
||
limit := historyDefaultLimit
|
||
if limitStr != "" {
|
||
v, err := strconv.Atoi(limitStr)
|
||
if err != nil || v < 1 {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid limit"))
|
||
return
|
||
}
|
||
limit = v
|
||
}
|
||
var before int64
|
||
if b := r.URL.Query().Get("before"); b != "" {
|
||
v, err := strconv.ParseInt(b, 10, 64)
|
||
if err != nil {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "invalid before"))
|
||
return
|
||
}
|
||
before = v
|
||
}
|
||
|
||
adapter := r.URL.Query().Get("adapter")
|
||
platform := r.URL.Query().Get("platform")
|
||
|
||
var msgs []history.Message
|
||
var err error
|
||
switch {
|
||
case adapter != "":
|
||
msgs, err = s.history.ListAdapterLog(r.Context(), adapter, before, limit)
|
||
case platform != "":
|
||
msgs, err = s.history.ListPlatformLog(r.Context(), platform, before, limit)
|
||
default:
|
||
msgs, err = s.history.ListAllLog(r.Context(), before, limit)
|
||
}
|
||
if err != nil {
|
||
s.log.Error("history channel messages", "err", err, "adapter", adapter, "platform", platform)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "channel_messages_failed", "failed to list channel messages"))
|
||
return
|
||
}
|
||
out := make([]historyMessage, 0, len(msgs))
|
||
for _, m := range msgs {
|
||
out = append(out, toHistoryMessage(m))
|
||
}
|
||
writeJSON(w, http.StatusOK, out)
|
||
}
|
||
func (s *Server) handleDeleteSession(w http.ResponseWriter, r *http.Request) {
|
||
if s.history == nil {
|
||
writeError(w, &apperr.AppError{Code: "not_implemented", Message: "会话历史服务未配置（未注入 HistoryStore）", HTTPCode: http.StatusNotImplemented})
|
||
return
|
||
}
|
||
id := r.PathValue("id")
|
||
if id == "" {
|
||
writeError(w, apperr.Wrap(apperr.ErrBadRequest, "bad_request", "session id is required"))
|
||
return
|
||
}
|
||
if err := s.history.DeleteSession(r.Context(), id); err != nil {
|
||
if errors.Is(err, history.ErrImmutableMain) {
|
||
writeError(w, apperr.Wrap(apperr.ErrForbidden, "forbidden", "the main session cannot be deleted"))
|
||
return
|
||
}
|
||
s.log.Error("history delete session", "err", err, "session", id)
|
||
writeError(w, apperr.Wrap(apperr.ErrInternal, "session_failed", "failed to delete session"))
|
||
return
|
||
}
|
||
writeJSON(w, http.StatusOK, map[string]any{"deleted": id})
|
||
}
|
||
|
||
// toHistoryMessage maps a stored history.Message to its wire shape.
|
||
func toHistoryMessage(m history.Message) historyMessage {
|
||
return historyMessage{
|
||
ID: m.ID,
|
||
SessionID: m.SessionID,
|
||
Role: m.Role,
|
||
Content: m.Content,
|
||
Mode: m.Mode,
|
||
Mood: m.Mood,
|
||
Image: m.Image,
|
||
Thinking: m.Thinking,
|
||
Platform: m.Platform,
|
||
DeviceID: m.DeviceID,
|
||
SenderName: m.SenderName,
|
||
AdapterID: m.AdapterID,
|
||
PersonaID: m.PersonaID,
|
||
CreatedAt: m.CreatedAt,
|
||
}
|
||
}
|
||
|
||
// historyDefaultLimit is the page size used when the client omits the limit query param.
|
||
const historyDefaultLimit = 50
|