diff --git a/cmd/homed/main.go b/cmd/homed/main.go index 547985c..f279507 100644 --- a/cmd/homed/main.go +++ b/cmd/homed/main.go @@ -506,20 +506,23 @@ func main() { } agent := agentCore.New(agentCore.AgentConfig{ - ID: "main", - SystemPrompt: sysPrompt, - Provider: provider, - ProviderManager: providerMgr, - IO: iom, - Memory: memDB, - Indexer: memIdx, - Tracker: trk, - DocStore: docStore, - Knowledge: ks, - SocialStore: socialStore, - TextMemory: textMem, - MediaStore: mediaStore, - Personality: personality, + ID: "main", + SystemPrompt: sysPrompt, + Provider: provider, + ProviderManager: providerMgr, + IO: iom, + Memory: memDB, + Indexer: memIdx, + Tracker: trk, + DocStore: docStore, + Knowledge: ks, + SocialStore: socialStore, + TextMemory: textMem, + MediaStore: mediaStore, + Personality: personality, + // 人格落库面：首启门禁（任何通道都问一次）与 persona_set 工具用。 + // 与 WebUI 向导共用 internal/config 的同一份落库逻辑。 + PersonaStore: internalConfig.RegistryPersonaStore{Reg: cfgReg}, PluginReg: pluginReg, PluginDir: cfg.Plugin.Dir, DistillInterval: cfgReg.GetDuration("core.agent.distill_interval", 30*time.Minute), diff --git a/internal/agent/core/agent.go b/internal/agent/core/agent.go index fb4844c..bb7cc64 100644 --- a/internal/agent/core/agent.go +++ b/internal/agent/core/agent.go @@ -57,9 +57,13 @@ type Agent struct { // 由记忆系统本身决定。为 nil 时全部媒体接线静默跳过。 mediaStore *media.Store - // 人格设定 + // 人格设定（内容来自启动时载入的人格文件/配置项） personality *agentPkg.Personality + // 人格落库面：首启门禁与 persona_set 工具使用（见 persona.go）。 + // 为 nil 时门禁与工具都静默关闭（例如单测里不接配置的场景）。 + personaStore PersonaStore + // 插件注册表（用于 plgreload） pluginReg *plugin.Registry pluginDir string @@ -183,6 +187,7 @@ type AgentConfig struct { MultimodalSpace vector.MultimodalEmbedder FusionCfg CrossModalFusionConfig // 跨模态融合权重；零值用默认 Personality *agentPkg.Personality + PersonaStore PersonaStore // 人格设定的读写面（首启门禁 + persona_set 工具） PluginReg *plugin.Registry PluginDir string DistillInterval time.Duration @@ -269,6 +274,7 @@ func New(cfg AgentConfig) *Agent { textMem: cfg.TextMemory, mediaStore: cfg.MediaStore, personality: cfg.Personality, + personaStore: cfg.PersonaStore, pluginReg: cfg.PluginReg, pluginDir: cfg.PluginDir, distillInterval: cfg.DistillInterval, diff --git a/internal/agent/core/persona.go b/internal/agent/core/persona.go new file mode 100644 index 0000000..a6bdaa5 --- /dev/null +++ b/internal/agent/core/persona.go @@ -0,0 +1,54 @@ +package core + +import ( + "fmt" + "strings" + + agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api" +) + +// PersonaStore 是人格设定的读写面。 +// +// 首启门禁（buildSystemPrompt）与 persona_set 工具都通过它工作，实现在 cmd/homed： +// 读写配置项 core.agent.personal_prompt 与一次性标记 core.internal.persona_initialized +// （落库逻辑与 WebUI 向导共用 internal/config 的实现）。 +// +// 为什么放在内核而不是某个通道插件：人格是**任何通道都要问一次**的事。 +// 系统提示词每轮重建，门禁放在这里，WebUI / QQ / CLI / ACP / 邮件等全部通道自动覆盖。 +type PersonaStore interface { + // PersonaInitialized 报告人格是否已确认（向导或工具已问过）。 + PersonaInitialized() bool + // SetPersona 落库人格并打一次性标记，返回是否需要重启才生效。 + SetPersona(mode, content string) (restartRequired bool, err error) +} + +// executePersonaTool 落地首启人格设定。 +// +// 成功即打一次性标记 → 之后 buildSystemPrompt 不再要求模型询问人格。 +// custom 模式返回「需重启生效」：人格在 homed 启动时载入。 +func (a *Agent) executePersonaTool(tc agentAPI.ToolCall) string { + if a.personaStore == nil { + return "人格设定不可用：内核未接入配置" + } + mode, _ := tc.Arguments["mode"].(string) + content, _ := tc.Arguments["content"].(string) + mode = strings.TrimSpace(mode) + restart, err := a.personaStore.SetPersona(mode, content) + if err != nil { + return fmt.Sprintf("人格设定失败：%v", err) + } + switch mode { + case "custom": + msg := "已保存自定义人格" + if restart { + msg += "；**重启 homed 后生效**（人格在启动时载入）" + } + return msg + case "default": + return "已确认使用默认人格" + case "later": + return "已记为「以后再说」，继续使用默认人格" + default: + return "已保存人格设定" + } +} diff --git a/internal/agent/core/persona_test.go b/internal/agent/core/persona_test.go new file mode 100644 index 0000000..3db10cc --- /dev/null +++ b/internal/agent/core/persona_test.go @@ -0,0 +1,112 @@ +package core + +import ( + "strings" + "testing" + + agentAPI "gitcode.com/JianFeeeee/HomeAgent/internal/agent/api" + agentIO "gitcode.com/JianFeeeee/HomeAgent/internal/agent/io" +) + +// newTestAgent 造一个最小可用的 Agent（buildToolDefs 要求 io 非 nil）。 +func newTestAgent(st PersonaStore) *Agent { + return &Agent{io: agentIO.NewIOManager(), personaStore: st} +} + +// fakePersonaStore 记录调用并可控地报告「是否已确认」。 +type fakePersonaStore struct { + initialized bool + mode string + content string + calls int +} + +func (f *fakePersonaStore) PersonaInitialized() bool { return f.initialized } + +func (f *fakePersonaStore) SetPersona(mode, content string) (bool, error) { + f.calls++ + f.mode, f.content = mode, content + f.initialized = true + return mode == "custom", nil +} + +// 首启门禁：人格未确认时，**任何通道**的系统提示词都必须带上「去问用户」的指令； +// 确认后必须消失（否则会每轮反复追问）。 +func TestPersonaOnboardingGateInSystemPrompt(t *testing.T) { + st := &fakePersonaStore{} + a := newTestAgent(st) + + p := a.buildSystemPrompt("", "你好") + if !strings.Contains(p, "首启人格设定") || !strings.Contains(p, "persona_set") { + t.Fatalf("未确认人格时提示词应要求模型询问并调用 persona_set，实际缺少该段") + } + + // 模型落地后（标记置位）不再出现 + if out := a.executePersonaTool(agentAPI.ToolCall{Name: "persona_set", + Arguments: map[string]interface{}{"mode": "default"}}); !strings.Contains(out, "默认人格") { + t.Fatalf("persona_set(default) 回执不对: %s", out) + } + if !st.initialized { + t.Fatal("落库后应置位标记") + } + if p2 := a.buildSystemPrompt("", "你好"); strings.Contains(p2, "首启人格设定") { + t.Fatal("人格已确认后不应再要求询问") + } + + // 未接入配置（personaStore 为 nil）时，门禁与工具都必须静默关闭 + b := newTestAgent(nil) + if pb := b.buildSystemPrompt("", "你好"); strings.Contains(pb, "首启人格设定") { + t.Fatal("未接入配置时不应出现首启门禁") + } + if out := b.executePersonaTool(agentAPI.ToolCall{Name: "persona_set"}); !strings.Contains(out, "不可用") { + t.Fatalf("未接入配置时工具应回明确错误，实际: %s", out) + } +} + +// persona_set 的三选一语义与回执。 +func TestPersonaSetToolModes(t *testing.T) { + cases := []struct { + mode, content, want string + }{ + {"custom", "你是测试人格", "重启"}, + {"default", "", "默认人格"}, + {"later", "", "以后再说"}, + } + for _, c := range cases { + st := &fakePersonaStore{} + a := newTestAgent(st) + out := a.executePersonaTool(agentAPI.ToolCall{Name: "persona_set", + Arguments: map[string]interface{}{"mode": c.mode, "content": c.content}}) + if !strings.Contains(out, c.want) { + t.Errorf("mode=%s 回执应含 %q，实际: %s", c.mode, c.want, out) + } + if st.calls != 1 || st.mode != c.mode || st.content != c.content { + t.Errorf("mode=%s 落库参数不对: calls=%d mode=%s content=%q", c.mode, st.calls, st.mode, st.content) + } + } +} + +// 工具 schema 必须在 catalog 里出现（模型才可能调用）。 +func TestPersonaSetToolDefPresent(t *testing.T) { + a := newTestAgent(&fakePersonaStore{}) + found := false + for _, td := range a.buildToolDefs() { + if m, ok := td.(map[string]interface{}); ok { + if fn, ok := m["function"].(map[string]interface{}); ok && fn["name"] == "persona_set" { + found = true + } + } + } + if !found { + t.Fatal("buildToolDefs 未包含 persona_set") + } + // 未接入配置时不应暴露该工具 + b := newTestAgent(nil) + for _, td := range b.buildToolDefs() { + if m, ok := td.(map[string]interface{}); ok { + if fn, ok := m["function"].(map[string]interface{}); ok && fn["name"] == "persona_set" { + t.Fatal("未接入配置时不应暴露 persona_set") + } + } + } +} diff --git a/internal/agent/core/toolcall.go b/internal/agent/core/toolcall.go index e65a9e6..b39ee84 100644 --- a/internal/agent/core/toolcall.go +++ b/internal/agent/core/toolcall.go @@ -45,6 +45,8 @@ func (a *Agent) executeToolCall(tc agentAPI.ToolCall) (ret string) { func (a *Agent) executeToolCallInner(tc agentAPI.ToolCall) string { switch { + case tc.Name == "persona_set": + return a.executePersonaTool(tc) case strings.HasPrefix(tc.Name, "memory_"): return a.executeMemoryTool(tc) case strings.HasPrefix(tc.Name, "social_"): diff --git a/internal/agent/core/tooldefs.go b/internal/agent/core/tooldefs.go index 444d9d0..4037a4a 100644 --- a/internal/agent/core/tooldefs.go +++ b/internal/agent/core/tooldefs.go @@ -89,6 +89,16 @@ func (a *Agent) buildSystemPrompt(memContext string, userInput string) string { } } + // 首启人格门禁（跨通道唯一闸口）：人格未确认时，要求模型主动询问用户。 + // 系统提示词每轮重建，因此 WebUI / QQ / CLI / ACP / 邮件等所有通道都会带上它； + // 模型调用 persona_set（或用户在 WebUI 向导里选）落地后，标记置位，本段消失。 + if a.personaStore != nil && !a.personaStore.PersonaInitialized() { + prompt += "\n\n【首启人格设定】你的**人格设定尚未确认**。请在本轮回复里先问用户一句：" + + "要用默认人格，还是自定义一个？拿到明确答复后**必须调用 persona_set 工具**落库：" + + "用户选默认 → mode=default；自定义 → mode=custom 且把内容写进 content；" + + "用户说以后再说 → mode=later。用户答复前不要假设已设置，也不要反复追问同一件事。" + } + prompt += a.buildToolCatalog() return prompt @@ -197,6 +207,24 @@ func (a *Agent) buildToolDefs() []interface{} { } } + if a.personaStore != nil { + tools = append(tools, map[string]interface{}{ + "type": "function", + "function": map[string]interface{}{ + "name": "persona_set", + "description": "【首启人格】落地用户的人格选择并记录「已经问过」。仅在用户明确答复后调用：默认用 mode=default；自定义用 mode=custom 并把人格内容放进 content；用户说以后再说用 mode=later。", + "parameters": map[string]interface{}{ + "type": "object", + "properties": map[string]interface{}{ + "mode": map[string]interface{}{"type": "string", "description": "default | custom | later"}, + "content": map[string]interface{}{"type": "string", "description": "自定义人格内容（mode=custom 时必填）"}, + }, + "required": []string{"mode"}, + }, + }, + }) + } + if a.memory != nil { tools = append(tools, map[string]interface{}{ "type": "function", diff --git a/internal/config/persona.go b/internal/config/persona.go new file mode 100644 index 0000000..bb07316 --- /dev/null +++ b/internal/config/persona.go @@ -0,0 +1,139 @@ +package config + +import ( + "fmt" + "strings" +) + +// 人格设定的两个键：内容与「首启向导/工具已经问过」的一次性标记。 +// +// 为什么需要标记：人格曾经只有 /personal/personal.md 一个来源且无人维护， +// 里面写死的旧版本号反过来让实例自述旧版本（v1.2.0 压测发现）。 +// 现在人格是配置项（默认模板不含任何版本号），任何通道的第一次交互问一次，之后不再打扰。 +const ( + // PersonaPromptKey 是人格设定内容（【人格设定】块的正文）。 + PersonaPromptKey = "core.agent.personal_prompt" + // PersonaInitMarkerKey 是「已经问过/已确认」的一次性标记。 + PersonaInitMarkerKey = "core.internal.persona_initialized" +) + +// 三种落库方式，WebUI 首启向导与内核 persona_set 工具共用。 +const ( + PersonaModeDefault = "default" // 使用内置默认模板 + PersonaModeCustom = "custom" // 使用调用方提供的内容 + PersonaModeLater = "later" // 保留当前（默认）人格，只打标记不再问 +) + +// PersonaKV 是人格落库所需的最小读写面：GetCore/SetCore 的签名与 +// 公开 SDK 的 SettingsAPI 一致，因此插件侧（WebUI）可直接传入； +// 内核直连配置注册表时用 registryKV 适配（见文件末）。 +type PersonaKV interface { + GetCore(key string) (interface{}, error) + SetCore(key string, value interface{}) error +} + +// PersonaInitializedKV 报告人格是否已确认（向导或工具已问过）。 +func PersonaInitializedKV(kv PersonaKV) bool { + if kv == nil { + return false + } + v, err := kv.GetCore(PersonaInitMarkerKey) + if err != nil { + return false + } + s, _ := v.(string) + return strings.TrimSpace(s) != "" +} + +// CurrentPersonaKV 读当前人格内容；未设置时回落到内置默认模板。 +func CurrentPersonaKV(kv PersonaKV) string { + if kv == nil { + return DefaultPersonaPrompt + } + if v, err := kv.GetCore(PersonaPromptKey); err == nil { + if s, ok := v.(string); ok && strings.TrimSpace(s) != "" { + return s + } + } + return DefaultPersonaPrompt +} + +// SetPersonaKV 落库人格并打一次性标记，返回 restartRequired。 +// +// 生效时机：人格在 homed 启动时载入（拼成【人格设定】块进系统提示词）， +// 所以**自定义内容需重启**；default 与 later 都不改变当前已生效的人格，无需重启。 +// +// 非法输入一律在打标记之前拒绝——否则向导会被跳过，用户再也没机会设。 +func SetPersonaKV(kv PersonaKV, mode, content string) (restartRequired bool, err error) { + if kv == nil { + return false, fmt.Errorf("persona: settings unavailable") + } + switch mode { + case PersonaModeDefault: + if err := kv.SetCore(PersonaPromptKey, DefaultPersonaPrompt); err != nil { + return false, err + } + case PersonaModeCustom: + if strings.TrimSpace(content) == "" { + return false, fmt.Errorf("persona: content required for custom mode") + } + if err := kv.SetCore(PersonaPromptKey, content); err != nil { + return false, err + } + restartRequired = true + case PersonaModeLater: + // 保持当前人格（通常是默认模板），只打标记 + default: + return false, fmt.Errorf("persona: unknown mode %q (want default|custom|later)", mode) + } + if err := kv.SetCore(PersonaInitMarkerKey, "1"); err != nil { + return restartRequired, err + } + return restartRequired, nil +} + +// RegistryPersonaStore 把配置注册表暴露成内核的 core.PersonaStore 接口 +// （结构类型：方法集匹配即可，无需 import internal/agent/core）。 +type RegistryPersonaStore struct{ Reg *ConfigRegistry } + +func (p RegistryPersonaStore) PersonaInitialized() bool { return PersonaInitialized(p.Reg) } + +func (p RegistryPersonaStore) SetPersona(mode, content string) (bool, error) { + return SetPersona(p.Reg, mode, content) +} + +// registryKV 把内核直连的配置注册表适配成 PersonaKV。 +type registryKV struct{ reg *ConfigRegistry } + +func (r registryKV) GetCore(key string) (interface{}, error) { + v, err := r.reg.Get(key) + if err != nil || v == nil { + // 未设置的键对 PersonaKV 语义等同「没有」，不当作错误 + if s := r.reg.GetString(key, ""); s != "" { + return s, nil + } + return "", nil + } + return v, nil +} + +func (r registryKV) SetCore(key string, value interface{}) error { + s, ok := value.(string) + if !ok { + return fmt.Errorf("persona: value must be a string") + } + return r.reg.Set(key, s) +} + +// PersonaInitialized 报告人格是否已确认（内核直连注册表）。 +func PersonaInitialized(reg *ConfigRegistry) bool { + return reg != nil && PersonaInitializedKV(registryKV{reg}) +} + +// SetPersona 落库人格并打一次性标记（内核直连注册表）。 +func SetPersona(reg *ConfigRegistry, mode, content string) (bool, error) { + if reg == nil { + return false, fmt.Errorf("persona: config registry unavailable") + } + return SetPersonaKV(registryKV{reg}, mode, content) +} diff --git a/internal/config/persona_kv_test.go b/internal/config/persona_kv_test.go new file mode 100644 index 0000000..7cb12df --- /dev/null +++ b/internal/config/persona_kv_test.go @@ -0,0 +1,99 @@ +package config + +import ( + "strings" + "testing" +) + +// fakeKV 是 PersonaKV 的最小实现（模拟插件侧 SettingsAPI）。 +type fakeKV struct{ m map[string]string } + +func (f *fakeKV) GetCore(k string) (interface{}, error) { return f.m[k], nil } +func (f *fakeKV) SetCore(k string, v interface{}) error { + f.m[k] = v.(string) + return nil +} + +// 三选一语义 + 「只问一次」标记：这是首启向导与 persona_set 工具共用的同一份实现。 +func TestSetPersonaKV(t *testing.T) { + t.Run("custom 写入内容并要求重启", func(t *testing.T) { + kv := &fakeKV{m: map[string]string{}} + restart, err := SetPersonaKV(kv, PersonaModeCustom, "你是测试人格") + if err != nil || !restart { + t.Fatalf("custom 应成功且需重启: restart=%v err=%v", restart, err) + } + if kv.m[PersonaPromptKey] != "你是测试人格" || kv.m[PersonaInitMarkerKey] != "1" { + t.Fatalf("落库不对: %+v", kv.m) + } + if !PersonaInitializedKV(kv) { + t.Fatal("打过标记应报告已确认") + } + }) + + t.Run("default 写默认模板且无需重启", func(t *testing.T) { + kv := &fakeKV{m: map[string]string{}} + restart, err := SetPersonaKV(kv, PersonaModeDefault, "") + if err != nil || restart { + t.Fatalf("default 不应需重启: restart=%v err=%v", restart, err) + } + if kv.m[PersonaPromptKey] != DefaultPersonaPrompt { + t.Fatal("default 应写入内置默认模板") + } + }) + + t.Run("later 保持人格并打标记", func(t *testing.T) { + kv := &fakeKV{m: map[string]string{PersonaPromptKey: "原有人格"}} + if _, err := SetPersonaKV(kv, PersonaModeLater, ""); err != nil { + t.Fatal(err) + } + if kv.m[PersonaPromptKey] != "原有人格" { + t.Fatal("later 不应改动人格") + } + if kv.m[PersonaInitMarkerKey] != "1" { + t.Fatal("later 也必须打标记（否则每次启动都问）") + } + }) + + t.Run("非法输入必须拒绝且不打标记", func(t *testing.T) { + for _, c := range []struct{ mode, content string }{ + {PersonaModeCustom, " "}, // 空内容 + {"nope", ""}, // 未知 mode + } { + kv := &fakeKV{m: map[string]string{}} + if _, err := SetPersonaKV(kv, c.mode, c.content); err == nil { + t.Fatalf("mode=%q content=%q 应报错", c.mode, c.content) + } + if kv.m[PersonaInitMarkerKey] == "1" { + t.Fatalf("mode=%q 被拒时不得打标记（否则向导会被跳过）", c.mode) + } + } + }) + + t.Run("CurrentPersonaKV 未设置时回落默认", func(t *testing.T) { + kv := &fakeKV{m: map[string]string{}} + if got := CurrentPersonaKV(kv); got != DefaultPersonaPrompt { + t.Fatal("未设置应回落默认模板") + } + }) +} + +// 内核直连注册表的入口必须与 KV 版行为一致（同一份实现的两个薄入口）。 +func TestSetPersonaRegistryEntry(t *testing.T) { + dir := t.TempDir() + reg := NewConfigRegistry(dir + "/config.db") + reg.SeedDefaults(dir) + defer reg.Close() + + if PersonaInitialized(reg) { + t.Fatal("全新实例不应已确认人格") + } + if _, err := SetPersona(reg, PersonaModeCustom, "内核侧人格"); err != nil { + t.Fatal(err) + } + if !PersonaInitialized(reg) { + t.Fatal("内核侧落库后应报告已确认") + } + if got := reg.GetString(PersonaPromptKey, ""); !strings.Contains(got, "内核侧人格") { + t.Fatalf("注册表里没有人格内容: %q", got) + } +} diff --git a/internal/plugins/webui/handler.go b/internal/plugins/webui/handler.go index d0d37ea..835c841 100644 --- a/internal/plugins/webui/handler.go +++ b/internal/plugins/webui/handler.go @@ -981,12 +981,7 @@ func (h *Handler) handleKernel(w http.ResponseWriter, r *http.Request) { // 为什么需要向导：人格曾经只有 /personal/personal.md 一个来源且无人维护， // 里面写死的旧版本号反过来让实例自述旧版本（v1.2.0 压测发现）。 // 现在人格是配置项（默认模板不含任何版本号），首启问一次，之后不再打扰。 -const ( - personaPromptKey = "core.agent.personal_prompt" - personaInitMarker = "core.internal.persona_initialized" -) - -// handlePersona 是首启人格向导的后端。 +// handlePersona 是首启人格向导的后端（与内核 persona_set 工具共用 internal/config 的实现）。 // // GET → {initialized, current_prompt, file_override} // POST → {"mode":"default"|"custom"|"later","content":"..."} @@ -995,6 +990,9 @@ const ( // 生效时机：人格在 homed 启动时载入（以【人格设定】块拼进系统提示词）， // 所以**自定义内容需重启生效**；选「默认」或「稍后」（保持当前默认）无需重启。 // 不回答就是「稍后」：保留默认并打标记，不阻塞任何流程。 +// +// 跨通道：这里只是 WebUI 侧的入口；任何通道的消息到来时，内核都会检查同一枚标记， +// 未确认则在提示词里要求模型主动询问（见 internal/agent/core 的首启门禁）。 func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) { if h.settings == nil { writeJSON(w, http.StatusServiceUnavailable, map[string]string{"error": "settings not available"}) @@ -1002,24 +1000,9 @@ func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) { } switch r.Method { case http.MethodGet: - initialized := false - if v, err := h.settings.GetCore(personaInitMarker); err == nil { - if s, ok := v.(string); ok && strings.TrimSpace(s) != "" { - initialized = true - } - } - cur := "" - if v, err := h.settings.GetCore(personaPromptKey); err == nil { - if s, ok := v.(string); ok { - cur = s - } - } - if cur == "" { - cur = internalConfig.DefaultPersonaPrompt - } writeJSON(w, http.StatusOK, map[string]interface{}{ - "initialized": initialized, - "current_prompt": cur, + "initialized": internalConfig.PersonaInitializedKV(h.settings), + "current_prompt": internalConfig.CurrentPersonaKV(h.settings), "file_override": h.personaFileExists(), }) case http.MethodPost: @@ -1031,31 +1014,14 @@ func (h *Handler) handlePersona(w http.ResponseWriter, r *http.Request) { writeJSON(w, http.StatusBadRequest, map[string]string{"error": "invalid request"}) return } - restart := false - switch req.Mode { - case "default": - if err := h.settings.SetCore(personaPromptKey, internalConfig.DefaultPersonaPrompt); err != nil { - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()}) - return + restart, err := internalConfig.SetPersonaKV(h.settings, req.Mode, req.Content) + if err != nil { + // 非法 mode / 空内容 → 400；落库失败 → 500。两者都不打标记。 + code := http.StatusInternalServerError + if strings.Contains(err.Error(), "unknown mode") || strings.Contains(err.Error(), "content required") { + code = http.StatusBadRequest } - case "custom": - if strings.TrimSpace(req.Content) == "" { - writeJSON(w, http.StatusBadRequest, map[string]string{"error": "content required for custom mode"}) - return - } - if err := h.settings.SetCore(personaPromptKey, req.Content); err != nil { - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()}) - return - } - restart = true // 人格在启动时载入 - case "later": - // 保持当前（默认）人格，只打标记，不再问 - default: - writeJSON(w, http.StatusBadRequest, map[string]string{"error": "unknown mode"}) - return - } - if err := h.settings.SetCore(personaInitMarker, "1"); err != nil { - writeJSON(w, http.StatusInternalServerError, map[string]string{"error": err.Error()}) + writeJSON(w, code, map[string]string{"error": err.Error()}) return } writeJSON(w, http.StatusOK, map[string]interface{}{ diff --git a/internal/plugins/webui/handler_persona_test.go b/internal/plugins/webui/handler_persona_test.go index e28873a..5aa8a26 100644 --- a/internal/plugins/webui/handler_persona_test.go +++ b/internal/plugins/webui/handler_persona_test.go @@ -69,10 +69,10 @@ func TestPersonaWizardFlow(t *testing.T) { if w.Code != http.StatusOK { t.Fatalf("later 状态码 %d: %s", w.Code, w.Body.String()) } - if v := cfgReg.GetString(personaInitMarker, ""); v == "" { + if v := cfgReg.GetString(internalConfig.PersonaInitMarkerKey, ""); v == "" { t.Fatal("later 也必须打一次性标记（否则每次启动都问）") } - if v := cfgReg.GetString(personaPromptKey, ""); v != internalConfig.DefaultPersonaPrompt { + if v := cfgReg.GetString(internalConfig.PersonaPromptKey, ""); v != internalConfig.DefaultPersonaPrompt { t.Fatalf("later 不应改动人格，实际 %q", v) } @@ -97,7 +97,7 @@ func TestPersonaWizardFlow(t *testing.T) { if !pr.RestartRequired { t.Fatal("自定义人格应提示需要重启才生效") } - if v := cfgReg2.GetString(personaPromptKey, ""); v != "你是测试人格" { + if v := cfgReg2.GetString(internalConfig.PersonaPromptKey, ""); v != "你是测试人格" { t.Fatalf("自定义内容未写库: %q", v) } @@ -111,12 +111,12 @@ func TestPersonaWizardFlow(t *testing.T) { t.Fatalf("未知 mode 应 400，实际 %d", w.Code) } // 7. 被拒的请求不得打标记（否则向导会被跳过） - if v := cfgReg2.GetString(personaInitMarker, ""); v == "" { + if v := cfgReg2.GetString(internalConfig.PersonaInitMarkerKey, ""); v == "" { t.Fatal("前置条件：第 4 步已打标记") } h4, cfgReg4 := newPersonaHandler(t) _ = doPersona(t, h4, http.MethodPost, `{"mode":"nope"}`) - if v := cfgReg4.GetString(personaInitMarker, ""); v != "" { + if v := cfgReg4.GetString(internalConfig.PersonaInitMarkerKey, ""); v != "" { t.Fatal("被拒的请求不应打标记") } }