881 lines
29 KiB
Go
881 lines
29 KiB
Go
package room
|
||
|
||
import (
|
||
"context"
|
||
"fmt"
|
||
"log"
|
||
"os"
|
||
"path/filepath"
|
||
"strings"
|
||
"time"
|
||
|
||
"github.com/sdaduanbilei/agent-team/internal/agent"
|
||
"github.com/sdaduanbilei/agent-team/internal/llm"
|
||
"github.com/sdaduanbilei/agent-team/internal/prompt"
|
||
"github.com/sdaduanbilei/agent-team/internal/room/tools"
|
||
"github.com/sdaduanbilei/agent-team/internal/skill"
|
||
"github.com/sdaduanbilei/agent-team/internal/store"
|
||
)
|
||
|
||
func Load(roomDir string, agentsDir string, skillsDir string, opts ...LoadOption) (*Room, error) {
|
||
var lo loadOptions
|
||
for _, opt := range opts {
|
||
opt(&lo)
|
||
}
|
||
|
||
data, err := os.ReadFile(filepath.Join(roomDir, "room.md"))
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
cfg, err := parseRoomConfig(data)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
|
||
r := &Room{Config: cfg, Dir: roomDir, members: make(map[string]*agent.Agent), Mode: "plan", Status: StatusPending}
|
||
|
||
r.ToolExecutor = tools.NewExecutor(filepath.Join(roomDir, "workspace"))
|
||
|
||
projectRoot := filepath.Dir(agentsDir)
|
||
if data, err := os.ReadFile(filepath.Join(projectRoot, "SYSTEM.md")); err == nil {
|
||
r.systemRules = string(data)
|
||
}
|
||
|
||
// 从 DB 预加载所有 agent 配置
|
||
var dbConfigs []store.AgentConfig
|
||
if lo.store != nil {
|
||
dbConfigs, _ = lo.store.GetRoomAgentConfigs(cfg.Name)
|
||
}
|
||
dbConfigMap := make(map[string]map[string]string) // agent_name -> file_type -> content
|
||
for _, c := range dbConfigs {
|
||
if dbConfigMap[c.AgentName] == nil {
|
||
dbConfigMap[c.AgentName] = make(map[string]string)
|
||
}
|
||
dbConfigMap[c.AgentName][c.FileType] = c.Content
|
||
}
|
||
|
||
if cfg.Master != "" {
|
||
var knowledgeDir string
|
||
if cfg.Team != "" {
|
||
kd := filepath.Join(agentsDir, cfg.Team, "knowledge")
|
||
if info, err := os.Stat(kd); err == nil && info.IsDir() {
|
||
knowledgeDir = kd
|
||
}
|
||
}
|
||
|
||
agentPath := resolveAgentPath(agentsDir, cfg.Team, cfg.Master)
|
||
r.master, err = agent.Load(agentPath)
|
||
if err != nil {
|
||
return nil, fmt.Errorf("load master %s: %w", cfg.Master, err)
|
||
}
|
||
r.master.KnowledgeDir = knowledgeDir
|
||
// DB 配置覆盖
|
||
if files, ok := dbConfigMap[cfg.Master]; ok {
|
||
if soul, ok := files["soul"]; ok {
|
||
r.master.Soul = soul
|
||
r.master.UseDBConfig = true
|
||
}
|
||
if agentDoc, ok := files["agent"]; ok {
|
||
r.master.AgentDoc = agentDoc
|
||
r.master.UseDBConfig = true
|
||
}
|
||
}
|
||
|
||
for _, name := range cfg.Members {
|
||
a, err := agent.Load(resolveAgentPath(agentsDir, cfg.Team, name))
|
||
if err != nil {
|
||
return nil, fmt.Errorf("load member %s: %w", name, err)
|
||
}
|
||
a.KnowledgeDir = knowledgeDir
|
||
// DB 配置覆盖
|
||
if files, ok := dbConfigMap[name]; ok {
|
||
if soul, ok := files["soul"]; ok {
|
||
a.Soul = soul
|
||
a.UseDBConfig = true
|
||
}
|
||
if agentDoc, ok := files["agent"]; ok {
|
||
a.AgentDoc = agentDoc
|
||
a.UseDBConfig = true
|
||
}
|
||
}
|
||
r.members[name] = a
|
||
}
|
||
}
|
||
|
||
// 加载 TEAM.md 项目模板：优先从 DB，降级到文件系统
|
||
teamMDBody := ""
|
||
if teamDoc, ok := dbConfigMap["__team__"]["team_doc"]; ok && teamDoc != "" {
|
||
teamMDBody = teamDoc
|
||
} else if cfg.Team != "" {
|
||
teamMDPath := filepath.Join(agentsDir, cfg.Team, "TEAM.md")
|
||
if teamData, err := os.ReadFile(teamMDPath); err == nil {
|
||
teamMDBody = string(teamData)
|
||
}
|
||
}
|
||
if teamMDBody != "" {
|
||
body := teamMDBody
|
||
if strings.HasPrefix(body, "---") {
|
||
parts := strings.SplitN(body, "---", 3)
|
||
if len(parts) >= 3 {
|
||
body = parts[2]
|
||
}
|
||
}
|
||
if pt := parseProjectTemplate(body); pt != nil {
|
||
r.projectTemplate = pt
|
||
log.Printf("[room %s] 已加载项目模板，包含 %d 个文件定义", cfg.Name, len(pt.Files))
|
||
}
|
||
if wf := extractTeamWorkflow(body); wf != "" {
|
||
r.teamWorkflow = wf
|
||
log.Printf("[room %s] 已加载团队工作流描述 (%d 字符)", cfg.Name, len(wf))
|
||
}
|
||
}
|
||
|
||
r.skillMeta, _ = skill.Discover(skillsDir)
|
||
|
||
// 初始化 prompt 模板引擎
|
||
r.Prompt = prompt.New()
|
||
// 加载 room 级模板覆盖（如果存在）
|
||
roomPromptDir := filepath.Join(roomDir, "prompts")
|
||
r.Prompt.LoadOverrides(roomPromptDir)
|
||
|
||
return r, nil
|
||
}
|
||
|
||
func (r *Room) emit(e Event) {
|
||
e.RoomID = r.Config.Name
|
||
if r.Broadcast != nil {
|
||
r.Broadcast(e)
|
||
}
|
||
if r.Store != nil && !e.NoStore {
|
||
gid := &r.currentGroupID
|
||
switch e.Type {
|
||
case EvtAgentMessage:
|
||
if !e.Streaming && e.Content != "" && e.Role != "tool_use" &&
|
||
!strings.HasPrefix(e.Content, "正在处理:") && !strings.HasPrefix(e.Content, "正在处理: ") {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: e.Agent, Role: e.Role,
|
||
Content: e.Content, GroupID: gid,
|
||
})
|
||
}
|
||
case EvtArtifact:
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: e.Agent, Role: "artifact",
|
||
Content: e.Title, Filename: e.Filename, Title: e.Title, GroupID: gid,
|
||
})
|
||
case EvtTaskAssign:
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: e.From, Role: "task_assign",
|
||
Content: e.Task, Title: e.To, GroupID: gid,
|
||
})
|
||
}
|
||
}
|
||
}
|
||
|
||
func (r *Room) emitUsage(agentName string, usage llm.Usage) {
|
||
if usage.TotalTokens > 0 {
|
||
r.emit(Event{
|
||
Type: EvtTokenUsage,
|
||
Agent: agentName,
|
||
PromptTokens: usage.PromptTokens,
|
||
CompletionTokens: usage.CompletionTokens,
|
||
TotalTokens: usage.TotalTokens,
|
||
})
|
||
if r.Store != nil {
|
||
r.Store.InsertTokenUsage(r.Config.Name, agentName, usage.PromptTokens, usage.CompletionTokens, usage.TotalTokens)
|
||
}
|
||
}
|
||
}
|
||
|
||
func (r *Room) setMode(mode string) {
|
||
r.Mode = mode
|
||
r.emit(Event{Type: EvtModeChange, Mode: mode})
|
||
}
|
||
|
||
func (r *Room) setStatus(s Status, activeAgent, action string) {
|
||
r.Status = s
|
||
r.ActiveAgent = activeAgent
|
||
r.emit(Event{Type: EvtRoomStatus, Status: s, ActiveAgent: activeAgent, Action: action})
|
||
}
|
||
|
||
func (r *Room) Stop() {
|
||
r.cancelMu.Lock()
|
||
defer r.cancelMu.Unlock()
|
||
if r.cancelFunc != nil {
|
||
r.cancelFunc()
|
||
r.cancelFunc = nil
|
||
}
|
||
r.setStatus(StatusPending, "", "")
|
||
}
|
||
|
||
// AppendHistory persists a message to today's history file.
|
||
func (r *Room) AppendHistory(role, agentName, content string) {
|
||
dir := filepath.Join(r.Dir, "history")
|
||
os.MkdirAll(dir, 0755)
|
||
filename := filepath.Join(dir, time.Now().Format("2006-01-02")+".md")
|
||
line := fmt.Sprintf("\n**[%s] %s** (%s)\n\n%s\n", time.Now().Format("15:04:05"), agentName, role, content)
|
||
f, err := os.OpenFile(filename, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
|
||
if err != nil {
|
||
return
|
||
}
|
||
defer f.Close()
|
||
f.WriteString(line)
|
||
}
|
||
|
||
// contextMaxTokens 是模型上下文窗口限制（留 8K 给输出）
|
||
const contextMaxTokens = 120000
|
||
|
||
// estimateTokens 估算消息列表的 token 数（中文约 1.5 token/字，英文约 0.75 token/word）
|
||
func estimateTokens(msgs []llm.Message) int {
|
||
total := 0
|
||
for _, m := range msgs {
|
||
// 粗略估算：每个字符约 1 token（中英混合取均值）
|
||
total += len([]rune(m.Content))
|
||
}
|
||
return total
|
||
}
|
||
|
||
// compressMessages 当 token 数超限时，保留 system prompt + 最近的消息，中间部分压缩为摘要
|
||
func compressMessages(msgs []llm.Message, maxTokens int) []llm.Message {
|
||
if len(msgs) <= 3 {
|
||
return msgs
|
||
}
|
||
est := estimateTokens(msgs)
|
||
if est <= maxTokens {
|
||
return msgs
|
||
}
|
||
|
||
log.Printf("[context] 当前 %d tokens (估算), 超过 %d 限制, 压缩历史", est, maxTokens)
|
||
|
||
// 保留: system(第0条) + 最近的消息
|
||
system := msgs[0]
|
||
middle := msgs[1:]
|
||
|
||
// 从后往前保留消息，直到 token 数在限制内
|
||
// 留 system 的 token + 安全余量
|
||
sysTokens := len([]rune(system.Content))
|
||
budget := maxTokens - sysTokens - 2000 // 留 2K 余量
|
||
|
||
var kept []llm.Message
|
||
keptTokens := 0
|
||
for i := len(middle) - 1; i >= 0; i-- {
|
||
msgTokens := len([]rune(middle[i].Content))
|
||
if keptTokens+msgTokens > budget {
|
||
break
|
||
}
|
||
kept = append([]llm.Message{middle[i]}, kept...)
|
||
keptTokens += msgTokens
|
||
}
|
||
|
||
// 被截掉的部分生成摘要提示
|
||
droppedCount := len(middle) - len(kept)
|
||
if droppedCount > 0 {
|
||
summary := llm.NewMsg("user", fmt.Sprintf("[系统提示] 之前有 %d 条对话消息因上下文长度限制已被压缩。请基于当前可见的消息继续工作。", droppedCount))
|
||
// NOTE: compressMessages 是无状态函数，无法访问 r.Prompt，保留 fmt 拼接
|
||
result := make([]llm.Message, 0, 2+len(kept))
|
||
result = append(result, system, summary)
|
||
result = append(result, kept...)
|
||
log.Printf("[context] 压缩完成: 保留 %d 条, 丢弃 %d 条, 估算 %d tokens", len(kept), droppedCount, estimateTokens(result))
|
||
return result
|
||
}
|
||
return msgs
|
||
}
|
||
|
||
// Handle processes a user message through master orchestration.
|
||
func (r *Room) Handle(ctx context.Context, userMsg string) error {
|
||
return r.HandleUserMessage(ctx, "user", userMsg)
|
||
}
|
||
|
||
// HandleUserMessage 处理用户消息。
|
||
func (r *Room) HandleUserMessage(ctx context.Context, userName, userMsg string) error {
|
||
if r.master == nil {
|
||
return fmt.Errorf("room has no master agent configured")
|
||
}
|
||
r.AppendHistory("user", userName, userMsg)
|
||
|
||
if r.Store != nil {
|
||
id, _ := r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: userName, Role: "user", Content: userMsg,
|
||
})
|
||
r.currentGroupID = id
|
||
}
|
||
|
||
ctx, cancel := context.WithCancel(ctx)
|
||
r.cancelMu.Lock()
|
||
r.cancelFunc = cancel
|
||
r.cancelMu.Unlock()
|
||
defer func() {
|
||
r.cancelMu.Lock()
|
||
r.cancelFunc = nil
|
||
r.cancelMu.Unlock()
|
||
}()
|
||
|
||
// 检测用户直接 @master：去掉前缀，作为普通对话处理
|
||
if r.master != nil {
|
||
masterName := r.master.Config.Name
|
||
prefix := "@" + masterName
|
||
trimmed := strings.TrimSpace(userMsg)
|
||
if strings.HasPrefix(trimmed, prefix) {
|
||
question := strings.TrimSpace(strings.TrimPrefix(trimmed, prefix))
|
||
if question != "" {
|
||
// 清除 lastActiveMember，确保消息发给 master 而非成员
|
||
r.lastActiveMember = ""
|
||
userMsg = question
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检测用户直接 @agent（成员）
|
||
userAssignments := parseUserMentions(userMsg, r.members)
|
||
if len(userAssignments) > 0 {
|
||
// 区分对话和任务分配：短消息/问候视为对话
|
||
if len(userAssignments) == 1 {
|
||
for name, task := range userAssignments {
|
||
if isConversational(task) {
|
||
r.lastActiveMember = name
|
||
return r.handleMemberConversation(ctx, userName, task)
|
||
}
|
||
}
|
||
}
|
||
return r.handleDirectAssign(ctx, userAssignments)
|
||
}
|
||
|
||
// Build 模式下执行暂存任务
|
||
if r.Mode == "build" && len(r.pendingAssignments) > 0 {
|
||
log.Printf("[room %s] build 模式，执行 %d 个暂存任务", r.Config.Name, len(r.pendingAssignments))
|
||
assignments := r.pendingAssignments
|
||
r.pendingAssignments = nil
|
||
r.pendingPlanReply = ""
|
||
|
||
skillXML := skill.ToXML(r.skillMeta)
|
||
board := &SharedBoard{}
|
||
r.setStatus(StatusWorking, "", "")
|
||
r.runMembersParallel(ctx, assignments, board, skillXML)
|
||
// 只在写作阶段（前置材料全部完成后）触发审读
|
||
if r.allStaticFilesDone() {
|
||
r.runChallengeRound(ctx, board, skillXML)
|
||
}
|
||
|
||
r.setStatus(StatusPending, "", "")
|
||
return nil
|
||
}
|
||
|
||
// Build 模式下成员对话续接
|
||
if r.Mode == "build" && r.lastActiveMember != "" {
|
||
return r.handleMemberConversation(ctx, userName, userMsg)
|
||
}
|
||
|
||
r.setStatus(StatusThinking, "", "")
|
||
|
||
// 构建 system prompt
|
||
teamXML := r.buildTeamXML()
|
||
skillXML := skill.ToXML(r.skillMeta)
|
||
skillSummary := r.buildSkillSummary()
|
||
var userXML string
|
||
if r.User != nil {
|
||
userXML = r.User.BuildUserXML()
|
||
}
|
||
extraContext := userXML + "\n\n" + teamXML + "\n\n" + skillSummary
|
||
if r.systemRules != "" {
|
||
extraContext = r.systemRules + "\n\n" + extraContext
|
||
}
|
||
if r.teamWorkflow != "" {
|
||
extraContext = extraContext + "\n\n<team_workflow>\n" + r.teamWorkflow + "\n</team_workflow>"
|
||
}
|
||
if projectCtx := r.buildProjectContext(r.master.Config.Name); projectCtx != "" {
|
||
extraContext = extraContext + "\n\n" + projectCtx
|
||
}
|
||
if wsCtx := r.buildWorkspaceContext(); wsCtx != "" {
|
||
extraContext = extraContext + "\n\n" + wsCtx
|
||
}
|
||
systemPrompt := r.master.BuildSystemPrompt(extraContext)
|
||
modeInfo := fmt.Sprintf("\n\n当前用户：%s\n当前模式：%s", userName, r.Mode)
|
||
if r.Mode == "build" {
|
||
modeInfo += "\n\n" + r.Prompt.R("mode_build_rule")
|
||
} else {
|
||
modeInfo += "\n\n" + r.Prompt.R("mode_plan_rule")
|
||
}
|
||
sysMsg := llm.NewMsg("system", systemPrompt+modeInfo)
|
||
|
||
r.historyMu.Lock()
|
||
if len(r.masterHistory) == 0 {
|
||
r.masterHistory = []llm.Message{sysMsg}
|
||
} else {
|
||
r.masterHistory[0] = sysMsg
|
||
}
|
||
r.masterHistory = append(r.masterHistory, llm.NewMsg("user", userMsg))
|
||
// token 感知的历史压缩（替代简单的消息数截断）
|
||
r.masterHistory = compressMessages(r.masterHistory, contextMaxTokens)
|
||
masterMsgs := make([]llm.Message, len(r.masterHistory))
|
||
copy(masterMsgs, r.masterHistory)
|
||
r.historyMu.Unlock()
|
||
|
||
// Master 规划循环：简化为最多 3 轮（安全上限），每次用户消息通常只跑 1 轮
|
||
const maxIterations = 3
|
||
for iteration := 0; iteration < maxIterations; iteration++ {
|
||
log.Printf("[room %s] master iteration %d, sending to LLM...", r.Config.Name, iteration)
|
||
|
||
if r.projectTemplate != nil {
|
||
if !r.masterCallerDecidedIteration(ctx, &masterMsgs, skillXML, iteration) {
|
||
break
|
||
}
|
||
} else {
|
||
if !r.masterLegacyIteration(ctx, &masterMsgs, skillXML, iteration) {
|
||
break
|
||
}
|
||
}
|
||
}
|
||
|
||
r.setStatus(StatusPending, "", "")
|
||
go r.updateMasterMemory(context.Background(), userMsg, masterMsgs)
|
||
return nil
|
||
}
|
||
|
||
// masterCallerDecidedIteration 执行一次 Caller-Decided 路径的 master 迭代。
|
||
// 返回 true 表示继续循环，false 表示 break。
|
||
func (r *Room) masterCallerDecidedIteration(ctx context.Context, masterMsgs *[]llm.Message, skillXML string, iteration int) bool {
|
||
if iteration > 0 {
|
||
r.setStatus(StatusThinking, r.master.Config.Name, "正在规划...")
|
||
}
|
||
|
||
// 调用前压缩 context
|
||
*masterMsgs = compressMessages(*masterMsgs, contextMaxTokens)
|
||
|
||
// CHAT CALL: 纯规划+分配
|
||
var masterReply strings.Builder
|
||
_, usage, err := r.master.ChatWithUsage(ctx, *masterMsgs, func(token string) {
|
||
masterReply.WriteString(token)
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: token, Streaming: true})
|
||
})
|
||
if err != nil {
|
||
log.Printf("[room %s] master chat error: %v", r.Config.Name, err)
|
||
return false
|
||
}
|
||
r.emitUsage(r.master.Config.Name, usage)
|
||
reply := masterReply.String()
|
||
log.Printf("[room %s] master chat reply (%d chars): %.100s...", r.Config.Name, len(reply), reply)
|
||
|
||
// 安全网：如果 master 的聊天回复中混入了文档正文，剥离并替换显示
|
||
persistContent := reply
|
||
if r.projectTemplate != nil && isDocument(reply) {
|
||
stripped := r.stripDocuments(reply)
|
||
if stripped != "" && stripped != reply {
|
||
persistContent = stripped
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: stripped, Streaming: false, Action: "replace"})
|
||
log.Printf("[room %s] master 聊天中混入文档内容，已剥离", r.Config.Name)
|
||
} else {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: "", Streaming: false})
|
||
}
|
||
} else {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: "", Streaming: false})
|
||
}
|
||
|
||
// 存为 text part
|
||
if r.Store != nil {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: r.master.Config.Name, Role: "master",
|
||
Content: persistContent, PartType: "text",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
assistantMsg := llm.NewMsg("assistant", reply)
|
||
*masterMsgs = append(*masterMsgs, assistantMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, assistantMsg)
|
||
r.historyMu.Unlock()
|
||
r.AppendHistory("master", r.master.Config.Name, reply)
|
||
|
||
// Plan 模式下：master 只允许聊天，禁止一切文件操作和任务分配
|
||
if r.Mode != "build" {
|
||
// 检查是否有 @分配 → 提醒用户切换模式
|
||
allMentions := parseAssignments(reply)
|
||
hasAssignment := false
|
||
for name := range allMentions {
|
||
if _, isMember := r.members[name]; isMember {
|
||
hasAssignment = true
|
||
break
|
||
}
|
||
}
|
||
if hasAssignment {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: "system", Role: "master",
|
||
Content: r.Prompt.R("plan_mode_blocked")})
|
||
}
|
||
return false // plan 模式下每次只回复一条，不循环
|
||
}
|
||
|
||
// 增量编辑（仅 build 模式）
|
||
if editFile, edited := r.applyDocumentEdit(reply); edited {
|
||
editTitle := strings.TrimSuffix(editFile, ".md")
|
||
r.emit(Event{Type: EvtArtifact, Agent: r.master.Config.Name, Filename: editFile, Title: editTitle})
|
||
if r.Store != nil {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: r.master.Config.Name, Role: "master",
|
||
Content: editTitle, Filename: editFile, PartType: "document",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
}
|
||
|
||
// 安全网：如果 master 在聊天中直接输出了文档内容，自动拦截保存
|
||
if isDocument(reply) && r.allStaticFilesDone() {
|
||
if dynDir, dynOwner, _ := r.getDynamicFileInfo(); dynDir != "" && dynOwner == r.master.Config.Name {
|
||
chapterFilename := r.extractChapterFilename(reply, dynDir)
|
||
content := strings.TrimSpace(reply)
|
||
if !strings.HasPrefix(content, "# ") {
|
||
content = "# " + strings.TrimSuffix(chapterFilename, ".md") + "\n\n" + content
|
||
}
|
||
r.saveWorkspace(chapterFilename, content)
|
||
docName := strings.TrimSuffix(chapterFilename, ".md")
|
||
r.emit(Event{Type: EvtArtifact, Agent: r.master.Config.Name, Filename: chapterFilename, Title: docName})
|
||
if r.Store != nil {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: r.master.Config.Name, Role: "master",
|
||
Content: docName, Filename: chapterFilename, PartType: "document",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
log.Printf("[room %s] 拦截 master 聊天中的章节内容，保存到 %s", r.Config.Name, chapterFilename)
|
||
}
|
||
}
|
||
|
||
// 解析 @ 分配
|
||
allMentions := parseAssignments(reply)
|
||
assignments := make(map[string]string)
|
||
for name, task := range allMentions {
|
||
if _, isMember := r.members[name]; isMember {
|
||
assignments[name] = task
|
||
}
|
||
}
|
||
|
||
// Phase 轻量校验：只在分配写手（phase:2 任务）时检查前置材料是否就绪
|
||
if len(assignments) > 0 && r.projectTemplate != nil {
|
||
blocked := r.validatePhaseAssignments(assignments)
|
||
if len(blocked) > 0 {
|
||
var blockedList strings.Builder
|
||
for name, reason := range blocked {
|
||
blockedList.WriteString(fmt.Sprintf("- @%s: %s\n", name, reason))
|
||
delete(assignments, name)
|
||
}
|
||
blockedContent := r.Prompt.Render("phase_blocked", map[string]string{
|
||
"BlockedList": blockedList.String(),
|
||
})
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: "system", Role: "master", Content: blockedContent})
|
||
log.Printf("[room %s] phase 校验阻止了 %d 个任务分配", r.Config.Name, len(blocked))
|
||
|
||
// 注入反馈让 master 知道被阻止了
|
||
phaseBlockMsg := llm.NewMsg("user", blockedContent)
|
||
*masterMsgs = append(*masterMsgs, phaseBlockMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, phaseBlockMsg)
|
||
r.historyMu.Unlock()
|
||
}
|
||
}
|
||
|
||
if len(assignments) > 0 && r.Mode != "build" {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master",
|
||
Content: r.Prompt.R("plan_mode_blocked")})
|
||
return false
|
||
}
|
||
|
||
// 执行成员任务
|
||
if len(assignments) > 0 && r.Mode == "build" {
|
||
board := &SharedBoard{}
|
||
results := r.runMembersParallel(ctx, assignments, board, skillXML)
|
||
// 只在写作阶段（前置材料全部完成后）触发审读
|
||
if r.allStaticFilesDone() {
|
||
r.runChallengeRound(ctx, board, skillXML)
|
||
}
|
||
|
||
r.setStatus(StatusThinking, r.master.Config.Name, "正在审阅成员结果...")
|
||
var resultsStr strings.Builder
|
||
for memberName, result := range results {
|
||
resultsStr.WriteString(fmt.Sprintf("[%s] %s\n", memberName, result))
|
||
}
|
||
feedbackMsg := r.Prompt.Render("feedback_results", map[string]string{
|
||
"Results": resultsStr.String(),
|
||
"BoardContext": board.ToContext(),
|
||
"WorkspaceContext": r.buildWorkspaceContext(),
|
||
"WorkflowStep": r.buildWorkflowStep(),
|
||
})
|
||
|
||
feedbackLLMMsg := llm.NewMsg("user", feedbackMsg)
|
||
*masterMsgs = append(*masterMsgs, feedbackLLMMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, feedbackLLMMsg)
|
||
r.historyMu.Unlock()
|
||
r.updateTasks(*masterMsgs)
|
||
}
|
||
|
||
// FILE UPDATE CALLS: master 提到要更新已存在的文件
|
||
if r.Mode == "build" {
|
||
updateFiles := r.parseMasterUpdateIntent(reply)
|
||
if len(updateFiles) > 0 {
|
||
for _, file := range updateFiles {
|
||
r.masterFileUpdateCall(ctx, masterMsgs, file, reply)
|
||
}
|
||
}
|
||
}
|
||
|
||
// FILE CALLS: master 负责的文件
|
||
pendingFiles := r.findPendingMasterFiles()
|
||
if len(pendingFiles) > 0 && r.Mode == "build" {
|
||
for _, file := range pendingFiles {
|
||
r.masterFileCall(ctx, masterMsgs, file)
|
||
}
|
||
} else if r.Mode == "build" && r.allStaticFilesDone() {
|
||
// 所有静态文件完成，检查是否有动态章节需要写
|
||
if dynDir, dynOwner, _ := r.getDynamicFileInfo(); dynDir != "" && dynOwner == r.master.Config.Name {
|
||
// 用 master 的聊天回复作为章节规划提示
|
||
r.masterChapterFileCall(ctx, masterMsgs, dynDir, reply)
|
||
}
|
||
}
|
||
|
||
// 每次用户消息最多执行一轮分配 + 一次 file call，然后停下等用户
|
||
return false
|
||
}
|
||
|
||
// masterLegacyIteration 执行一次旧路径的 master 迭代（无项目模板）。
|
||
func (r *Room) masterLegacyIteration(ctx context.Context, masterMsgs *[]llm.Message, skillXML string, iteration int) bool {
|
||
if iteration > 0 {
|
||
r.setStatus(StatusWorking, r.master.Config.Name, "正在编写文档...")
|
||
}
|
||
// 调用前压缩 context
|
||
*masterMsgs = compressMessages(*masterMsgs, contextMaxTokens)
|
||
|
||
var masterReply strings.Builder
|
||
_, usage, err := r.master.ChatWithUsage(ctx, *masterMsgs, func(token string) {
|
||
masterReply.WriteString(token)
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: token, Streaming: true})
|
||
})
|
||
if err != nil {
|
||
log.Printf("[room %s] master chat error: %v", r.Config.Name, err)
|
||
return false
|
||
}
|
||
r.emitUsage(r.master.Config.Name, usage)
|
||
reply := masterReply.String()
|
||
log.Printf("[room %s] master reply (%d chars): %.100s...", r.Config.Name, len(reply), reply)
|
||
|
||
// Plan 模式下：只聊天，禁止一切后续操作
|
||
if r.Mode != "build" {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: "", Streaming: false})
|
||
if r.Store != nil {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: r.master.Config.Name, Role: "master",
|
||
Content: reply, PartType: "text",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
assistantMsg := llm.NewMsg("assistant", reply)
|
||
*masterMsgs = append(*masterMsgs, assistantMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, assistantMsg)
|
||
r.historyMu.Unlock()
|
||
r.AppendHistory("master", r.master.Config.Name, reply)
|
||
|
||
// 检查是否尝试了分配或文档
|
||
allMentions := parseAssignments(reply)
|
||
hasAssignment := false
|
||
for name := range allMentions {
|
||
if _, isMember := r.members[name]; isMember {
|
||
hasAssignment = true
|
||
break
|
||
}
|
||
}
|
||
if hasAssignment {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: "system", Role: "master",
|
||
Content: r.Prompt.R("plan_mode_blocked")})
|
||
}
|
||
return false
|
||
}
|
||
|
||
var savedDocTitles []string
|
||
persistContent := reply
|
||
|
||
// Build 模式下执行文件产出
|
||
{
|
||
if editFile, edited := r.applyDocumentEdit(reply); edited {
|
||
persistContent = fmt.Sprintf("已更新《%s》", strings.TrimSuffix(editFile, ".md"))
|
||
savedDocTitles = append(savedDocTitles, strings.TrimSuffix(editFile, ".md"))
|
||
} else if docs := splitDocuments(reply); len(docs) > 0 {
|
||
for _, doc := range docs {
|
||
title := extractTitle(doc)
|
||
filename := titleToFilename(title, r.master.Config.Name)
|
||
r.saveWorkspace(filename, doc)
|
||
r.emit(Event{Type: EvtArtifact, Agent: r.master.Config.Name, Filename: filename, Title: title})
|
||
savedDocTitles = append(savedDocTitles, title)
|
||
}
|
||
}
|
||
}
|
||
|
||
if len(savedDocTitles) > 0 {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: persistContent, Streaming: false, Action: "replace"})
|
||
} else {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master", Content: "", Streaming: false})
|
||
}
|
||
|
||
if r.Store != nil && persistContent != "" {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: r.master.Config.Name, Role: "master",
|
||
Content: persistContent, PartType: "text",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
assistantMsg := llm.NewMsg("assistant", reply)
|
||
*masterMsgs = append(*masterMsgs, assistantMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, assistantMsg)
|
||
r.historyMu.Unlock()
|
||
r.AppendHistory("master", r.master.Config.Name, reply)
|
||
|
||
allMentions := parseAssignments(reply)
|
||
assignments := make(map[string]string)
|
||
for name, task := range allMentions {
|
||
if _, isMember := r.members[name]; isMember {
|
||
assignments[name] = task
|
||
}
|
||
}
|
||
|
||
if len(assignments) == 0 {
|
||
if len(savedDocTitles) > 0 && r.Mode == "build" {
|
||
continueMsg := r.Prompt.R("continue_legacy")
|
||
continueLLMMsg := llm.NewMsg("user", continueMsg)
|
||
*masterMsgs = append(*masterMsgs, continueLLMMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, continueLLMMsg)
|
||
r.historyMu.Unlock()
|
||
return true // continue
|
||
}
|
||
return false // break
|
||
}
|
||
|
||
if r.Mode != "build" {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: r.master.Config.Name, Role: "master",
|
||
Content: r.Prompt.R("plan_mode_blocked")})
|
||
return false
|
||
}
|
||
|
||
board := &SharedBoard{}
|
||
results := r.runMembersParallel(ctx, assignments, board, skillXML)
|
||
// 只在写作阶段（前置材料全部完成后）触发审读
|
||
if r.allStaticFilesDone() {
|
||
r.runChallengeRound(ctx, board, skillXML)
|
||
}
|
||
|
||
r.setStatus(StatusThinking, r.master.Config.Name, "正在审阅成员结果...")
|
||
var resultsStr strings.Builder
|
||
for memberName, result := range results {
|
||
resultsStr.WriteString(fmt.Sprintf("[%s] %s\n", memberName, result))
|
||
}
|
||
var wsFilesList string
|
||
if wsFiles := r.listWorkspaceFiles(); len(wsFiles) > 0 {
|
||
wsFilesList = "\n\n当前产出物文件：\n"
|
||
for _, f := range wsFiles {
|
||
wsFilesList += "- " + f + "\n"
|
||
}
|
||
}
|
||
feedbackMsg := r.Prompt.Render("feedback_legacy", map[string]string{
|
||
"Results": resultsStr.String(),
|
||
"WorkspaceFiles": wsFilesList,
|
||
})
|
||
feedbackLLMMsg := llm.NewMsg("user", feedbackMsg)
|
||
*masterMsgs = append(*masterMsgs, feedbackLLMMsg)
|
||
r.historyMu.Lock()
|
||
r.masterHistory = append(r.masterHistory, feedbackLLMMsg)
|
||
r.historyMu.Unlock()
|
||
r.updateTasks(*masterMsgs)
|
||
return true // continue
|
||
}
|
||
|
||
// handleMemberConversation 处理用户与成员的对话续接
|
||
func (r *Room) handleMemberConversation(ctx context.Context, userName, userMsg string) error {
|
||
memberName := r.lastActiveMember
|
||
member, ok := r.members[memberName]
|
||
if !ok {
|
||
return fmt.Errorf("member %s not found", memberName)
|
||
}
|
||
log.Printf("[room %s] 用户与 %s 对话", r.Config.Name, memberName)
|
||
r.setStatus(StatusWorking, member.Config.Name, "")
|
||
|
||
if r.memberConvos == nil {
|
||
r.memberConvos = make(map[string][]llm.Message)
|
||
}
|
||
|
||
// 如果该成员没有现有对话上下文，初始化系统提示
|
||
if len(r.memberConvos[memberName]) == 0 {
|
||
extraCtx := r.buildTeamXML()
|
||
if r.systemRules != "" {
|
||
extraCtx = r.systemRules + "\n\n" + extraCtx
|
||
}
|
||
if wsCtx := r.buildWorkspaceContext(); wsCtx != "" {
|
||
extraCtx += "\n\n" + wsCtx
|
||
}
|
||
systemPrompt := member.BuildSystemPrompt(extraCtx)
|
||
r.memberConvos[memberName] = []llm.Message{
|
||
llm.NewMsg("system", systemPrompt+"\n\n"+r.Prompt.R("member_conversation")),
|
||
}
|
||
}
|
||
|
||
r.memberConvos[memberName] = append(r.memberConvos[memberName], llm.NewMsg("user", userMsg))
|
||
|
||
var memberReply strings.Builder
|
||
_, usage, err := member.ChatWithUsage(ctx, r.memberConvos[memberName], func(token string) {
|
||
memberReply.WriteString(token)
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: memberName, Role: "member", Content: token, Streaming: true})
|
||
})
|
||
if err != nil {
|
||
r.setStatus(StatusPending, "", "")
|
||
return err
|
||
}
|
||
r.emitUsage(memberName, usage)
|
||
result := memberReply.String()
|
||
|
||
// 结束流式
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: memberName, Role: "member", Content: "", Streaming: false})
|
||
|
||
r.memberConvos[memberName] = append(r.memberConvos[memberName], llm.NewMsg("assistant", result))
|
||
r.AppendHistory("member", memberName, result)
|
||
|
||
// 存储到数据库
|
||
if r.Store != nil && strings.TrimSpace(result) != "" {
|
||
r.Store.InsertMessage(&store.Message{
|
||
RoomID: r.Config.Name, Agent: memberName, Role: "member",
|
||
Content: result, PartType: "text",
|
||
GroupID: &r.currentGroupID,
|
||
})
|
||
}
|
||
|
||
_, routed := r.saveAgentOutput(memberName, result, "")
|
||
if routed {
|
||
r.lastActiveMember = ""
|
||
} else if !isDocument(result) {
|
||
// lastActiveMember 保持不变，用户可继续对话
|
||
} else {
|
||
r.lastActiveMember = ""
|
||
}
|
||
|
||
r.setStatus(StatusPending, "", "")
|
||
return nil
|
||
}
|
||
|
||
// handleDirectAssign 处理用户直接 @agent 指派的任务
|
||
func (r *Room) handleDirectAssign(ctx context.Context, assignments map[string]string) error {
|
||
// Plan 模式下阻止任务执行
|
||
if r.Mode != "build" {
|
||
r.emit(Event{Type: EvtAgentMessage, Agent: "system", Role: "master",
|
||
Content: r.Prompt.R("plan_mode_blocked")})
|
||
r.setStatus(StatusPending, "", "")
|
||
return nil
|
||
}
|
||
|
||
skillXML := skill.ToXML(r.skillMeta)
|
||
board := &SharedBoard{}
|
||
|
||
r.runMembersParallel(ctx, assignments, board, skillXML)
|
||
// 只在写作阶段（前置材料全部完成后）触发审读
|
||
if r.allStaticFilesDone() {
|
||
r.runChallengeRound(ctx, board, skillXML)
|
||
}
|
||
|
||
r.setStatus(StatusPending, "", "")
|
||
return nil
|
||
}
|