DMP游戏内AI聊天的想法

1
package aichat
2

3
import (
4
  "context"
5
  "dst-management-platform-api/database/dao"
6
  "dst-management-platform-api/database/models"
7
  "sync"
8
)
9

10
// ================================================================
11
// 导出类型
12
// ================================================================
13

14
// Manager AI 对话服务管理器，是 aichat 包的核心入口。
15
// 负责管理游戏内 AI 聊天的工作协程、Wiki 知识库搜索（关键词+向量）。
16
type Manager struct {
17
  roomAISettingDao *dao.RoomAISettingDAO
18
  client           *aiClient
19
  ctx              context.Context
20
  cancel           context.CancelFunc
21
  lifecycle        sync.Mutex
22
  mu               sync.Mutex
23
  workers          map[int]*roomWorker
24
  active           bool
25
  closed           bool
26

27
  keywordSearcher *keywordWikiSearcher
28
  embedSearcher   *embeddingWikiSearcher
29
  embedSearcherMu sync.Mutex
30
  lastEmbedConfig string
31
}
32

33
// EmbeddingConfig 向量嵌入模型配置
34
type EmbeddingConfig struct {
35
  APIURL     string
36
  APIKey     string
37
  Model      string
38
  Dimensions int
39
}
40

41
// EmbeddingStats 向量索引统计信息
42
type EmbeddingStats struct {
43
  TotalDocs       int            `json:"totalDocs"`
44
  TotalCategories int            `json:"totalCategories"`
45
  VectorDim       int            `json:"vectorDim"`
46
  Categories      map[string]int `json:"categories"`
47
}
48

49
// NewManager 创建 AI 对话服务管理器
50
func NewManager(roomAISettingDao *dao.RoomAISettingDAO, pluginDao *dao.PluginDAO) *Manager {
51
  return newManager(roomAISettingDao, pluginDao)
52
}
53

54
// Start 启动所有已启用房间的 AI 对话监听
55
func (m *Manager) Start() error {
56
  return m.start()
57
}
58

59
// StopAll 停止所有房间的 AI 对话监听
60
func (m *Manager) StopAll() {
61
  m.stopAll()
62
}
63

64
// StopRoom 停止指定房间的 AI 对话监听
65
func (m *Manager) StopRoom(roomID int) {
66
  m.lifecycle.Lock()
67
  defer m.lifecycle.Unlock()
68
  m.stopRoom(roomID)
69
}
70

71
// Reload 重新加载指定房间的 AI 配置并重启监听
72
func (m *Manager) Reload(roomID int) error {
73
  return m.reload(roomID)
74
}
75

76
// Close 关闭 AI 对话服务，释放所有资源
77
func (m *Manager) Close() {
78
  m.closeManager()
79
}
80

81
// BuildEmbeddingIndex 手动构建向量索引。config 指定 Embedding API 配置，force 为 true 时强制全量重建。
82
// 构建过程可能耗时较长。
83
func (m *Manager) BuildEmbeddingIndex(config EmbeddingConfig, force bool) error {
84
  return m.buildEmbeddingIndex(config, force)
85
}
86

87
// GetEmbeddingStats 获取向量索引统计信息
88
func (m *Manager) GetEmbeddingStats(config EmbeddingConfig) EmbeddingStats {
89
  return m.getEmbeddingStats(config)
90
}
91

92
// BuildKeywordIndex 手动构建关键词搜索索引。force 为 true 时强制重建。
93
func (m *Manager) BuildKeywordIndex(force bool) error {
94
  return m.buildKeywordIndex(force)
95
}
96

97
// UnloadKeywordIndex 释放关键词搜索索引占用的内存。下次 Search 时会自动从磁盘重新加载。
98
func (m *Manager) UnloadKeywordIndex() {
99
  m.unloadKeywordIndex()
100
}
101

102
// ValidateModelConfig 校验 AI 模型配置参数
103
func ValidateModelConfig(config *models.AIModelConfig) error {
104
  return validateModelConfig(config)
105
}
106

107
// ValidateRoomSetting 校验房间 AI 设置参数
108
func ValidateRoomSetting(setting *models.RoomAISetting) error {
109
  return validateRoomSetting(setting)
110
}

1
package aichat
2

3
import (
4
  "bytes"
5
  "context"
6
  "dst-management-platform-api/database/models"
7
  "dst-management-platform-api/utils"
8
  "encoding/json"
9
  "fmt"
10
  "io"
11
  "net/http"
12
  "net/url"
13
  "strings"
14
  "time"
15
)
16

17
type chatMessage struct {
18
  Role    string `json:"role"`
19
  Content string `json:"content"`
20
}
21

22
type chatCompletionRequest struct {
23
  Model       string        `json:"model"`
24
  Messages    []chatMessage `json:"messages"`
25
  Temperature float64       `json:"temperature"`
26
  MaxTokens   int           `json:"max_tokens"`
27
  Stream      bool          `json:"stream"`
28
}
29

30
type chatCompletionResponse struct {
31
  Choices []struct {
32
    Message chatMessage `json:"message"`
33
  } `json:"choices"`
34
  Error *struct {
35
    Message string `json:"message"`
36
  } `json:"error"`
37
}
38

39
type aiClient struct {
40
  httpClient *http.Client
41
}
42

43
func newClient() *aiClient {
44
  return &aiClient{
45
    httpClient: &http.Client{
46
      CheckRedirect: func(_ *http.Request, _ []*http.Request) error {
47
        return http.ErrUseLastResponse
48
      },
49
    },
50
  }
51
}
52

53
func (c *aiClient) complete(ctx context.Context, config models.AIModelConfig, messages []chatMessage) (string, error) {
54
  requestBody := chatCompletionRequest{
55
    Model:       config.ChatModel,
56
    Messages:    messages,
57
    Temperature: config.Temperature,
58
    MaxTokens:   config.MaxTokens,
59
    Stream:      false,
60
  }
61
  body, err := json.Marshal(requestBody)
62
  if err != nil {
63
    return "", fmt.Errorf("序列化大模型请求失败: %w", err)
64
  }
65

66
  endpoint, err := chatCompletionsEndpoint(config.ChatBaseURL)
67
  if err != nil {
68
    return "", err
69
  }
70
  requestCtx, cancel := context.WithTimeout(ctx, time.Duration(config.RequestTimeoutSeconds)*time.Second)
71
  defer cancel()
72

73
  req, err := http.NewRequestWithContext(requestCtx, http.MethodPost, endpoint, bytes.NewReader(body))
74
  if err != nil {
75
    return "", fmt.Errorf("创建大模型请求失败: %w", err)
76
  }
77
  req.Header.Set("Content-Type", "application/json")
78
  req.Header.Set("User-Agent", fmt.Sprintf("DMP-AI/%s", utils.Version))
79
  if config.ChatApiKey != "" {
80
    req.Header.Set("Authorization", "Bearer "+config.ChatApiKey)
81
  }
82

83
  resp, err := c.httpClient.Do(req)
84
  if err != nil {
85
    return "", fmt.Errorf("请求大模型失败: %w", err)
86
  }
87
  defer resp.Body.Close()
88

89
  responseBody, err := io.ReadAll(io.LimitReader(resp.Body, 2*1024*1024))
90
  if err != nil {
91
    return "", fmt.Errorf("读取大模型响应失败: %w", err)
92
  }
93

94
  var result chatCompletionResponse
95
  if len(responseBody) > 0 {
96
    if err = json.Unmarshal(responseBody, &result); err != nil {
97
      if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
98
        return "", fmt.Errorf("大模型响应异常 HTTP %d", resp.StatusCode)
99
      }
100
      return "", fmt.Errorf("解析大模型响应失败: %w", err)
101
    }
102
  }
103
  if resp.StatusCode < http.StatusOK || resp.StatusCode >= http.StatusMultipleChoices {
104
    if result.Error != nil && result.Error.Message != "" {
105
      return "", fmt.Errorf("大模型响应异常 HTTP %d: %s", resp.StatusCode, result.Error.Message)
106
    }
107
    return "", fmt.Errorf("大模型响应异常 HTTP %d", resp.StatusCode)
108
  }
109
  if result.Error != nil && result.Error.Message != "" {
110
    return "", fmt.Errorf("大模型响应异常: %s", result.Error.Message)
111
  }
112
  if len(result.Choices) == 0 {
113
    return "", fmt.Errorf("大模型响应中没有候选答案")
114
  }
115

116
  answer := strings.TrimSpace(result.Choices[0].Message.Content)
117
  if answer == "" {
118
    return "", fmt.Errorf("大模型返回了空答案")
119
  }
120
  return answer, nil
121
}
122

123
func chatCompletionsEndpoint(baseURL string) (string, error) {
124
  u, err := url.Parse(strings.TrimSpace(baseURL))
125
  if err != nil {
126
    return "", fmt.Errorf("解析大模型 Base URL 失败: %w", err)
127
  }
128

129
  path := strings.TrimRight(u.Path, "/")
130
  if !strings.HasSuffix(path, "/chat/completions") {
131
    if path == "" {
132
      path = "/chat/completions"
133
    } else {
134
      path += "/chat/completions"
135
    }
136
  }
137
  u.Path = path
138
  return u.String(), nil
139
}

1
package aichat
2

3
import (
4
  "dst-management-platform-api/database/models"
5
  "dst-management-platform-api/utils"
6
  "fmt"
7
  "strings"
8
  "unicode/utf8"
9
)
10

11
func validateModelConfig(config *models.AIModelConfig) error {
12
  config.ChatBaseURL = strings.TrimSpace(config.ChatBaseURL)
13
  config.ChatModel = strings.TrimSpace(config.ChatModel)
14
  config.EmbeddingModel = strings.TrimSpace(config.EmbeddingModel)
15

16
  if config.ChatBaseURL == "" || !utils.IsValidURL(config.ChatBaseURL) {
17
    return fmt.Errorf("大模型 Base URL 不合法")
18
  }
19
  if config.ChatModel == "" {
20
    return fmt.Errorf("大模型名称不能为空")
21
  }
22
  if utf8.RuneCountInString(config.ChatModel) > 256 {
23
    return fmt.Errorf("大模型名称过长")
24
  }
25
  if len(config.ChatApiKey) > 16*1024 {
26
    return fmt.Errorf("API Key 过长")
27
  }
28
  if config.EmbeddingModel != "" {
29
    if utf8.RuneCountInString(config.EmbeddingModel) > 256 {
30
      return fmt.Errorf("嵌入模型名称过长")
31
    }
32
    if len(config.EmbeddingApiKey) > 16*1024 {
33
      return fmt.Errorf("嵌入 API Key 过长")
34
    }
35
  }
36
  if utf8.RuneCountInString(config.EmbeddingBaseURL) > 8000 {
37
    return fmt.Errorf("系统提示词过长")
38
  }
39
  if config.Temperature < 0 || config.Temperature > 2 {
40
    return fmt.Errorf("temperature 必须在 0 到 2 之间")
41
  }
42
  if config.MaxTokens <= 0 || config.MaxTokens > 32768 {
43
    return fmt.Errorf("maxTokens 必须在 1 到 32768 之间")
44
  }
45
  if config.RequestTimeoutSeconds <= 0 || config.RequestTimeoutSeconds > 300 {
46
    return fmt.Errorf("请求超时时间必须在 1 到 300 秒之间")
47
  }
48

49
  return nil
50
}
51

52
func validateRoomSetting(setting *models.RoomAISetting) error {
53
  if setting.RoomID <= 0 {
54
    return fmt.Errorf("房间 ID 不合法")
55
  }
56
  if strings.ContainsAny(setting.Prefix, "\r\n") || utf8.RuneCountInString(setting.Prefix) > 64 {
57
    return fmt.Errorf("AI 对话前缀不合法")
58
  }
59
  if setting.ContextMaxMessages < 2 || setting.ContextMaxMessages > 100 {
60
    return fmt.Errorf("上下文消息数量必须在 2 到 100 之间")
61
  }
62
  if setting.ContextTTLMinutes <= 0 || setting.ContextTTLMinutes > 10080 {
63
    return fmt.Errorf("上下文有效期必须在 1 到 10080 分钟之间")
64
  }
65

66
  return ValidateModelConfig(&setting.AIModelConfig)
67
}

1
package aichat
2

3
import (
4
  "context"
5
  "dst-management-platform-api/database/dao"
6
  "dst-management-platform-api/database/models"
7
  "dst-management-platform-api/dst"
8
  "dst-management-platform-api/logger"
9
  "errors"
10
  "fmt"
11
  "os"
12
  "strings"
13
  "time"
14
  "unicode/utf8"
15

16
  "gorm.io/gorm"
17
)
18

19
const (
20
  chatLogBufferSize = 256
21
  maxQuestionRunes  = 2000
22
  maxReplyRunes     = 180
23
)
24

25
type chatSession struct {
26
  messages   []chatMessage
27
  lastActive time.Time
28
}
29

30
type roomWorker struct {
31
  cancel context.CancelFunc
32
}
33

34
func newManager(roomAISettingDao *dao.RoomAISettingDAO, pluginDao *dao.PluginDAO) *Manager {
35
  ctx, cancel := context.WithCancel(context.Background())
36

37
  aiManager := &Manager{
38
    roomAISettingDao: roomAISettingDao,
39
    client:           newClient(),
40
    ctx:              ctx,
41
    cancel:           cancel,
42
    workers:          make(map[int]*roomWorker),
43
    keywordSearcher:  newKeywordWikiSearcher(wikiPagesDir, wikiIndexFile),
44
  }
45

46
  chatPlugin, err := pluginDao.GetPluginByPluginName(models.PluginChat)
47
  if err != nil {
48
    logger.Logger.Errorf("获取 %s 插件状态失败, err: %v", models.PluginChat, err)
49
  } else if chatPlugin.Status {
50
    if err = aiManager.start(); err != nil {
51
      logger.Logger.Errorf("启动游戏内 AI 对话服务失败, err: %v", err)
52
    }
53
  }
54

55
  return aiManager
56
}
57

58
func (m *Manager) start() error {
59
  m.lifecycle.Lock()
60
  if m.closed {
61
    m.lifecycle.Unlock()
62
    return context.Canceled
63
  }
64
  m.active = true
65
  m.lifecycle.Unlock()
66

67
  settings, err := m.roomAISettingDao.ListEnabled()
68
  if err != nil {
69
    m.stopAll()
70
    return err
71
  }
72
  for _, setting := range settings {
73
    if err = m.reload(setting.RoomID); err != nil {
74
      logger.Logger.Errorf("启动房间 AI 对话监听失败, roomID: %d, err: %v", setting.RoomID, err)
75
    }
76
  }
77
  return nil
78
}
79

80
func (m *Manager) reload(roomID int) error {
81
  m.lifecycle.Lock()
82
  defer m.lifecycle.Unlock()
83
  m.stopRoom(roomID)
84
  if !m.active || m.closed {
85
    return nil
86
  }
87

88
  setting, err := m.roomAISettingDao.GetByRoomID(roomID)
89
  if errors.Is(err, gorm.ErrRecordNotFound) {
90
    return nil
91
  }
92
  if err != nil {
93
    return err
94
  }
95
  if !setting.Enabled {
96
    return nil
97
  }
98
  if err = validateRoomSetting(setting); err != nil {
99
    return err
100
  }
101

102
  room, worlds, roomSetting, err := dao.FetchGameInfo(roomID)
103
  if err != nil {
104
    return err
105
  }
106
  game := dst.NewGameController(room, worlds, roomSetting, "zh")
107
  workerCtx, cancel := context.WithCancel(m.ctx)
108

109
  m.mu.Lock()
110
  m.workers[roomID] = &roomWorker{cancel: cancel}
111
  m.mu.Unlock()
112

113
  settingCopy := *setting
114
  go m.runRoom(workerCtx, game, settingCopy)
115
  return nil
116
}
117

118
func (m *Manager) stopAll() {
119
  m.lifecycle.Lock()
120
  defer m.lifecycle.Unlock()
121
  m.active = false
122
  m.stopAllWorkers()
123
}
124

125
func (m *Manager) stopRoom(roomID int) {
126
  m.mu.Lock()
127
  worker, ok := m.workers[roomID]
128
  if ok {
129
    delete(m.workers, roomID)
130
  }
131
  m.mu.Unlock()
132

133
  if ok {
134
    worker.cancel()
135
  }
136
}
137

138
func (m *Manager) closeManager() {
139
  m.lifecycle.Lock()
140
  defer m.lifecycle.Unlock()
141
  m.active = false
142
  m.closed = true
143
  m.cancel()
144
  m.stopAllWorkers()
145
}
146

147
func (m *Manager) stopAllWorkers() {
148
  m.mu.Lock()
149
  workers := m.workers
150
  m.workers = make(map[int]*roomWorker)
151
  m.mu.Unlock()
152
  for _, worker := range workers {
153
    worker.cancel()
154
  }
155
}
156

157
func (m *Manager) runRoom(ctx context.Context, game *dst.Game, setting models.RoomAISetting) {
158
  lines := make(chan string, chatLogBufferSize)
159
  go m.watchChatLog(ctx, game, setting.RoomID, lines)
160

161
  sessions := make(map[string]*chatSession)
162
  cleanupTicker := time.NewTicker(time.Minute)
163
  defer cleanupTicker.Stop()
164

165
  for {
166
    select {
167
    case <-ctx.Done():
168
      return
169
    case <-cleanupTicker.C:
170
      cleanupSessions(sessions, time.Duration(setting.ContextTTLMinutes)*time.Minute)
171
    case line := <-lines:
172
      event, ok := parseChatEvent(line)
173
      if !ok {
174
        continue
175
      }
176
      question, ok := matchQuestion(setting.Prefix, event.Message)
177
      if !ok {
178
        continue
179
      }
180
      m.answer(ctx, game, setting, sessions, event, question)
181
    }
182
  }
183
}
184

185
func (m *Manager) watchChatLog(ctx context.Context, game *dst.Game, roomID int, lines chan<- string) {
186
  for {
187
    err := game.TailChatLog(ctx, 0, lines)
188
    if ctx.Err() != nil {
189
      return
190
    }
191
    logger.Logger.Errorf("房间聊天日志监听异常, roomID: %d, err: %v", roomID, err)
192

193
    timer := time.NewTimer(2 * time.Second)
194
    select {
195
    case <-ctx.Done():
196
      timer.Stop()
197
      return
198
    case <-timer.C:
199
    }
200
  }
201
}
202

203
// isEmbeddingConfigured 检查是否配置了嵌入模型
204
func (m *Manager) isEmbeddingConfigured(setting models.RoomAISetting) bool {
205
  return setting.EmbeddingModel != "" && setting.ChatBaseURL != ""
206
}
207

208
// getEmbeddingSearcher 获取或创建向量搜索引擎
209
// 仅创建 searcher 实例并缓存，不自动构建索引（构建需通过 BuildEmbeddingIndex 手动触发）
210
func (m *Manager) getEmbeddingSearcher(setting models.RoomAISetting) *embeddingWikiSearcher {
211
  // EmbeddingApiKey 如果单独配置了则优先使用，否则复用 ChatApiKey
212
  apiKey := setting.ChatApiKey
213
  if setting.EmbeddingApiKey != "" {
214
    apiKey = setting.EmbeddingApiKey
215
  }
216
  configKey := setting.ChatBaseURL + "|" + apiKey + "|" + setting.EmbeddingModel
217

218
  m.embedSearcherMu.Lock()
219
  defer m.embedSearcherMu.Unlock()
220

221
  // 配置未变，返回缓存的 searcher
222
  if m.embedSearcher != nil && m.lastEmbedConfig == configKey {
223
    return m.embedSearcher
224
  }
225

226
  // 配置变更或首次调用 — 创建新的 searcher（不自动构建索引）
227
  if m.embedSearcher != nil {
228
    m.embedSearcher.stopIdleTimer()
229
  }
230

231
  embedConfig := EmbeddingConfig{
232
    APIURL:     setting.ChatBaseURL,
233
    APIKey:     apiKey,
234
    Model:      setting.EmbeddingModel,
235
    Dimensions: 1024,
236
  }
237
  searcher := newEmbeddingWikiSearcher(wikiPagesDir, embedConfig)
238

239
  m.embedSearcher = searcher
240
  m.lastEmbedConfig = configKey
241
  return m.embedSearcher
242
}
243

244
// BuildEmbeddingIndex 手动构建向量索引。
245
// config 指定 Embedding API 配置，force 为 true 时强制全量重建。
246
// 构建过程可能耗时较长，建议在后台执行。
247
func (m *Manager) buildEmbeddingIndex(config EmbeddingConfig, force bool) error {
248
  searcher := newEmbeddingWikiSearcher(wikiPagesDir, config)
249

250
  if !force && !searcher.needsSetup() {
251
    logger.Logger.Infof("向量索引已存在，无需重建。使用 force=true 强制重建。")
252
    return nil
253
  }
254

255
  logger.Logger.Infof("开始手动构建向量索引 (force=%v)...", force)
256
  if err := searcher.buildIndex(force); err != nil {
257
    return fmt.Errorf("构建向量索引失败: %w", err)
258
  }
259

260
  // 更新缓存的 searcher
261
  m.embedSearcherMu.Lock()
262
  if m.embedSearcher != nil {
263
    m.embedSearcher.stopIdleTimer()
264
  }
265
  apiKey := config.APIKey
266
  configKey := config.APIURL + "|" + apiKey + "|" + config.Model
267
  m.embedSearcher = searcher
268
  m.lastEmbedConfig = configKey
269
  m.embedSearcherMu.Unlock()
270

271
  logger.Logger.Infof("向量索引构建完成")
272
  return nil
273
}
274

275
// GetEmbeddingStats 获取向量索引统计信息
276
func (m *Manager) getEmbeddingStats(config EmbeddingConfig) EmbeddingStats {
277
  searcher := newEmbeddingWikiSearcher(wikiPagesDir, config)
278
  defer searcher.stopIdleTimer()
279
  return searcher.getStats()
280
}
281

282
// BuildKeywordIndex 手动构建关键词搜索索引。
283
// force 为 true 时强制重建，否则索引已存在则跳过。
284
func (m *Manager) buildKeywordIndex(force bool) error {
285
  // 停止旧 searcher 的空闲计时器
286
  if m.keywordSearcher != nil {
287
    m.keywordSearcher.stopIdleTimer()
288
  }
289

290
  searcher := newKeywordWikiSearcher(wikiPagesDir, wikiIndexFile)
291

292
  if !force {
293
    if _, err := os.Stat(wikiIndexFile); err == nil {
294
      if loadErr := searcher.load(); loadErr == nil {
295
        logger.Logger.Infof("关键词索引已存在，无需重建。使用 force=true 强制重建。")
296
        m.keywordSearcher = searcher
297
        return nil
298
      }
299
    }
300
  }
301

302
  logger.Logger.Infof("开始构建关键词搜索索引 (force=%v)...", force)
303
  if err := searcher.buildIndex(force); err != nil {
304
    return fmt.Errorf("构建关键词索引失败: %w", err)
305
  }
306

307
  m.keywordSearcher = searcher
308
  logger.Logger.Infof("关键词搜索索引构建完成")
309
  return nil
310
}
311

312
// UnloadKeywordIndex 释放关键词搜索索引占用的内存。
313
// 下次 Search 时会自动从磁盘重新加载。
314
func (m *Manager) unloadKeywordIndex() {
315
  if m.keywordSearcher != nil {
316
    m.keywordSearcher.unload()
317
  }
318
}
319

320
// searchWiki 搜索 Wiki 知识库，返回格式化的参考上下文
321
func (m *Manager) searchWiki(setting models.RoomAISetting, question string) string {
322
  // 优先使用向量搜索
323
  if m.isEmbeddingConfigured(setting) {
324
    if searcher := m.getEmbeddingSearcher(setting); searcher != nil {
325
      results, err := searcher.search(question, nil, 3, 0.3)
326
      if err != nil {
327
        logger.Logger.Warnf("向量搜索 Wiki 失败: %v，回退到关键词搜索", err)
328
      } else if len(results) > 0 {
329
        return formatWikiContext(results, maxContextTokens)
330
      }
331
    }
332
  }
333

334
  // 回退到关键词搜索
335
  if m.keywordSearcher != nil {
336
    results, err := m.keywordSearcher.search(question, 3)
337
    if err != nil {
338
      logger.Logger.Warnf("关键词搜索 Wiki 失败: %v", err)
339
      return ""
340
    }
341
    if len(results) > 0 {
342
      return formatWikiContext(results, maxContextTokens)
343
    }
344
  }
345

346
  return ""
347
}
348

349
// buildSystemPrompt 构建系统提示词（Wiki 上下文 + 用户设定的提示词）
350
func buildSystemPrompt(setting models.RoomAISetting, wikiContext string) string {
351
  var parts []string
352

353
  // 默认提示词
354
  defaultPrompt := "你是饥荒联机版游戏内的 AI 助手。请根据以上参考文档，用中文回答玩家的问题。回答应简洁、准确，适合在游戏聊天框中显示，坚决不能使用使用 Markdown 格式，回答不能超过30个字。"
355

356
  // Wiki 参考文档
357
  if wikiContext != "" {
358
    parts = append(parts, wikiContext)
359
    parts = append(parts, "")
360
    parts = append(parts, defaultPrompt)
361
    return strings.Join(parts, "\n")
362
  }
363

364
  // 用户设定的系统提示词（存储在 EmbeddingBaseURL 字段中）
365
  systemPrompt := strings.TrimSpace(setting.EmbeddingBaseURL)
366
  if systemPrompt != "" {
367
    return systemPrompt
368
  }
369

370
  return defaultPrompt
371
}
372

373
func (m *Manager) answer(ctx context.Context, game *dst.Game, setting models.RoomAISetting, sessions map[string]*chatSession, event chatEvent, question string) {
374
  now := time.Now()
375
  ttl := time.Duration(setting.ContextTTLMinutes) * time.Minute
376
  session := sessions[event.UID]
377
  if session == nil || now.Sub(session.lastActive) >= ttl {
378
    session = &chatSession{}
379
    sessions[event.UID] = session
380
  }
381

382
  // 搜索 Wiki 知识库获取参考上下文
383
  wikiContext := m.searchWiki(setting, question)
384

385
  userMessage := chatMessage{Role: "user", Content: truncateRunes(question, maxQuestionRunes)}
386
  messages := make([]chatMessage, 0, len(session.messages)+3)
387

388
  // 构建系统提示词（Wiki 上下文 + 用户设定的提示词）
389
  systemContent := buildSystemPrompt(setting, wikiContext)
390
  if systemContent != "" {
391
    messages = append(messages, chatMessage{Role: "system", Content: systemContent})
392
  }
393
  messages = append(messages, session.messages...)
394
  messages = append(messages, userMessage)
395

396
  answer, err := m.client.complete(ctx, setting.AIModelConfig, messages)
397
  if err != nil {
398
    if ctx.Err() != nil {
399
      return
400
    }
401
    logger.Logger.Errorf("游戏内 AI 回答失败, roomID: %d, uid: %s, err: %v", setting.RoomID, event.UID, err)
402
    _ = sendGameReply(game, event.Nickname, "暂时无法回答，请稍后再试。")
403
    return
404
  }
405

406
  session.messages = append(session.messages, userMessage, chatMessage{Role: "assistant", Content: answer})
407
  maxMessages := setting.ContextMaxMessages
408
  if maxMessages%2 != 0 {
409
    maxMessages--
410
  }
411
  if len(session.messages) > maxMessages {
412
    session.messages = append([]chatMessage(nil), session.messages[len(session.messages)-maxMessages:]...)
413
  }
414
  session.lastActive = time.Now()
415

416
  if err = sendGameReply(game, event.Nickname, answer); err != nil {
417
    logger.Logger.Errorf("发送游戏内 AI 回答失败, roomID: %d, uid: %s, err: %v", setting.RoomID, event.UID, err)
418
  }
419
}
420

421
func cleanupSessions(sessions map[string]*chatSession, ttl time.Duration) {
422
  now := time.Now()
423
  for uid, session := range sessions {
424
    if now.Sub(session.lastActive) >= ttl {
425
      delete(sessions, uid)
426
    }
427
  }
428
}
429

430
func matchQuestion(prefix, message string) (string, bool) {
431
  message = strings.TrimSpace(message)
432
  if prefix != "" {
433
    if !strings.HasPrefix(message, prefix) {
434
      return "", false
435
    }
436
    message = strings.TrimSpace(strings.TrimPrefix(message, prefix))
437
  }
438
  return message, message != ""
439
}
440

441
func sendGameReply(game *dst.Game, nickname, answer string) error {
442
  answer = strings.Join(strings.Fields(answer), " ")
443
  if answer == "" {
444
    return fmt.Errorf("AI 回答为空")
445
  }
446

447
  prefix := fmt.Sprintf("[AI] %s: ", nickname)
448
  for _, part := range splitRunes(answer, maxReplyRunes-utf8.RuneCountInString(prefix)) {
449
    if err := game.SystemMsg(prefix + part); err != nil {
450
      return err
451
    }
452
  }
453
  return nil
454
}
455

456
func splitRunes(value string, size int) []string {
457
  if size <= 0 {
458
    size = maxReplyRunes
459
  }
460
  runes := []rune(value)
461
  parts := make([]string, 0, (len(runes)+size-1)/size)
462
  for len(runes) > 0 {
463
    n := size
464
    if len(runes) < n {
465
      n = len(runes)
466
    }
467
    parts = append(parts, string(runes[:n]))
468
    runes = runes[n:]
469
  }
470
  return parts
471
}
472

473
func truncateRunes(value string, size int) string {
474
  runes := []rune(value)
475
  if len(runes) <= size {
476
    return value
477
  }
478
  return string(runes[:size])
479
}