22353571065

Committed 24 Feb 2026 01:46PM UTC coverage: 4.3% (-0.02%) from 4.317%

Build # 22353571065

Build Type

push

github

Committed by

smallnest

Commit Message

improve agent

Coverage Stats

1 of 157 new or added lines in 8 files covered. (0.64%)

5 existing lines in 3 files now uncovered.

1058 of 24602 relevant lines covered (4.3%)

0.32 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

0.0

/agent/tools/subagent_spawn_tool.go

package tools

import (
        "context"
        "fmt"
        "strings"

        "github.com/google/uuid"
        "github.com/smallnest/goclaw/config"
        "github.com/smallnest/goclaw/internal/logger"
        "go.uber.org/zap"
)

// SubagentTypes - 分身相关类型定义（避免循环导入）

// DeliveryContext 传递上下文
type DeliveryContext struct {
        Channel   string `json:"channel,omitempty"`
        AccountID string `json:"account_id,omitempty"`
        To        string `json:"to,omitempty"`
        ThreadID  string `json:"thread_id,omitempty"`
}

// SubagentRunOutcome 分身运行结果
type SubagentRunOutcome struct {
        Status string `json:"status"` // ok, error, timeout, unknown
        Error  string `json:"error,omitempty"`
}

// SubagentRunParams 分身运行参数
type SubagentRunParams struct {
        RunID               string
        ChildSessionKey     string
        RequesterSessionKey string
        RequesterOrigin     *DeliveryContext
        RequesterDisplayKey string
        Task                string
        Cleanup             string
        Label               string
        ArchiveAfterMinutes int
}

// SubagentSystemPromptParams 系统提示词参数
type SubagentSystemPromptParams struct {
        RequesterSessionKey string
        RequesterOrigin     *DeliveryContext
        ChildSessionKey     string
        Label               string
        Task                string
}

// BuildSubagentSystemPrompt 构建分身系统提示词
func BuildSubagentSystemPrompt(params *SubagentSystemPromptParams) string {
        taskText := normalizeText(params.Task)
        if taskText == "" {
                taskText = "{{TASK_DESCRIPTION}}"
        }

        lines := []string{
                "# Subagent Context",
                "",
                "You are a **subagent** spawned by the main agent for a specific task.",
                "",
                "## Your Role",
                fmt.Sprintf("- You were created to handle: %s", taskText),
                "- Complete this task. That's your entire purpose.",
                "- You are NOT the main agent. Don't try to be.",
                "",
                "## Rules",
                "1. **Stay focused** - Do your assigned task, nothing else",
                "2. **Complete the task** - Your final message will be automatically reported to the main agent",
                "3. **Don't initiate** - No heartbeats, no proactive actions, no side quests",
                "4. **Be ephemeral** - You may be terminated after task completion. That's fine.",
                "",
                "## Output Format",
                "When complete, your final response should include:",
                "- What you accomplished or found",
                "- Any relevant details the main agent should know",
                "- Keep it concise but informative",
                "",
                "## What You DON'T Do",
                "- NO user conversations (that's main agent's job)",
                "- NO external messages (email, tweets, etc.) unless explicitly tasked",
                "- NO cron jobs or persistent state",
                "- NO pretending to be the main agent",
        }

        if params.Label != "" {
                lines = append(lines, "")
                lines = append(lines, fmt.Sprintf("- Label: %s", params.Label))
        }
        if params.RequesterSessionKey != "" {
                lines = append(lines, fmt.Sprintf("- Requester session: %s", params.RequesterSessionKey))
        }
        if params.RequesterOrigin != nil && params.RequesterOrigin.Channel != "" {
                lines = append(lines, fmt.Sprintf("- Requester channel: %s", params.RequesterOrigin.Channel))
        }
        lines = append(lines, fmt.Sprintf("- Your session: %s", params.ChildSessionKey))
        lines = append(lines, "")

        return joinLines(lines)
}

// normalizeText 规范化文本
func normalizeText(s string) string {
        inSpace := false
        var result []rune
        for _, r := range s {
                if r == ' ' || r == '\t' || r == '\n' {
                        if !inSpace {
                                result = append(result, ' ')
                                inSpace = true
                        }
                } else {
                        result = append(result, r)
                        inSpace = false
                }
        }
        return string(result)
}

// joinLines 连接行
func joinLines(lines []string) string {
        if len(lines) == 0 {
                return ""
        }
        result := lines[0]
        for i := 1; i < len(lines); i++ {
                result += "\n" + lines[i]
        }
        return result
}

// GenerateChildSessionKey 生成子会话密钥
func GenerateChildSessionKey(agentID string) string {
        u := uuid.New()
        return fmt.Sprintf("agent:%s:subagent:%s", agentID, u.String())
}

// GenerateRunID 生成运行ID
func GenerateRunID() string {
        return uuid.New().String()
}

// End SubagentTypes

// SubagentSpawnToolParams 分身生成工具参数
type SubagentSpawnToolParams struct {
        Task              string `json:"task"`                          // 任务描述（必填）
        Label             string `json:"label,omitempty"`               // 可选标签
        AgentID           string `json:"agent_id,omitempty"`            // 目标 Agent ID
        Model             string `json:"model,omitempty"`               // 模型覆盖
        Thinking          string `json:"thinking,omitempty"`            // 思考级别
        RunTimeoutSeconds int    `json:"run_timeout_seconds,omitempty"` // 超时时间
        Cleanup           string `json:"cleanup,omitempty"`             // 清理策略
}

// SubagentSpawnResult 分身生成结果
type SubagentSpawnResult struct {
        Status            string `json:"status"` // accepted, forbidden, error
        ChildSessionKey   string `json:"child_session_key,omitempty"`
        RunID             string `json:"run_id,omitempty"`
        Error             string `json:"error,omitempty"`
        ModelApplied      bool   `json:"model_applied,omitempty"`
        Warning           string `json:"warning,omitempty"`
        ChildSystemPrompt string `json:"child_system_prompt,omitempty"` // System prompt for the child agent
}

// SubagentRegistryInterface 分身注册表接口
type SubagentRegistryInterface interface {
        RegisterRun(params *SubagentRunParams) error
}

// SubagentSpawnTool 分身生成工具
type SubagentSpawnTool struct {
        registry         SubagentRegistryInterface
        getAgentConfig   func(agentID string) *config.AgentConfig
        getDefaultConfig func() *config.AgentDefaults
        getAgentID       func(sessionKey string) string
        onSpawn          func(spawnParams *SubagentSpawnResult) error
}

// NewSubagentSpawnTool 创建分身生成工具
func NewSubagentSpawnTool(registry SubagentRegistryInterface) *SubagentSpawnTool {
        return &SubagentSpawnTool{
                registry: registry,
        }
}

// SetAgentConfigGetter 设置 Agent 配置获取器
func (t *SubagentSpawnTool) SetAgentConfigGetter(getter func(agentID string) *config.AgentConfig) {
        t.getAgentConfig = getter
}

// SetDefaultConfigGetter 设置默认配置获取器
func (t *SubagentSpawnTool) SetDefaultConfigGetter(getter func() *config.AgentDefaults) {
        t.getDefaultConfig = getter
}

// SetAgentIDGetter 设置 Agent ID 获取器
func (t *SubagentSpawnTool) SetAgentIDGetter(getter func(sessionKey string) string) {
        t.getAgentID = getter
}

// SetOnSpawn 设置分身生成回调
func (t *SubagentSpawnTool) SetOnSpawn(fn func(spawnParams *SubagentSpawnResult) error) {
        t.onSpawn = fn
}

// Name 返回工具名称
func (t *SubagentSpawnTool) Name() string {
        return "sessions_spawn"
}

// Description 返回工具描述
func (t *SubagentSpawnTool) Description() string {
        return "Spawn a background sub-agent run in an isolated session and announce the result back to the requester chat."
}

// Parameters 返回工具参数定义
func (t *SubagentSpawnTool) Parameters() map[string]interface{} {
        return map[string]interface{}{
                "type": "object",
                "properties": map[string]interface{}{
                        "task": map[string]interface{}{
                                "type":        "string",
                                "description": "The task description for the sub-agent to complete.",
                        },
                        "label": map[string]interface{}{
                                "type":        "string",
                                "description": "Optional label for the sub-agent run.",
                        },
                        "agent_id": map[string]interface{}{
                                "type":        "string",
                                "description": "Optional target agent ID to spawn the sub-agent under.",
                        },
                        "model": map[string]interface{}{
                                "type":        "string",
                                "description": "Optional model override for the sub-agent.",
                        },
                        "thinking": map[string]interface{}{
                                "type":        "string",
                                "description": "Optional thinking level override (low, medium, high).",
                        },
                        "run_timeout_seconds": map[string]interface{}{
                                "type":        "integer",
                                "description": "Optional timeout in seconds for the sub-agent run.",
                        },
                        "cleanup": map[string]interface{}{
                                "type":        "string",
                                "description": "Cleanup strategy: 'delete' to remove immediately, 'keep' to archive after timeout.",
                                "enum":        []string{"delete", "keep"},
                        },
                },
                "required": []string{"task"},
        }
}

// Execute 执行工具
func (t *SubagentSpawnTool) Execute(ctx context.Context, params map[string]interface{}) (string, error) {
        // 解析参数
        spawnParams, err := t.parseParams(params)
        if err != nil {
                result := &SubagentSpawnResult{
                        Status: "error",
                        Error:  err.Error(),
                }
                return t.marshalResult(result), nil
        }

        // 验证任务不为空
        if strings.TrimSpace(spawnParams.Task) == "" {
                result := &SubagentSpawnResult{
                        Status: "error",
                        Error:  "task is required",
                }
                return t.marshalResult(result), nil
        }

        // 规范化清理策略
        if spawnParams.Cleanup != "delete" && spawnParams.Cleanup != "keep" {
                spawnParams.Cleanup = "keep"
        }

        // Get requester session info from context
        requesterSessionKey := "main" // default
        if sk := ctx.Value("session_key"); sk != nil {
                if key, ok := sk.(string); ok {
                        requesterSessionKey = key
                }
        }
        requesterAgentID := t.getAgentID(requesterSessionKey)
        if requesterAgentID == "" {
                requesterAgentID = "default"
        }

        // 确定目标 Agent ID
        targetAgentID := requesterAgentID
        if spawnParams.AgentID != "" {
                targetAgentID = spawnParams.AgentID
        }

        // 验证跨 Agent 创建权限
        if targetAgentID != requesterAgentID {
                if !t.checkCrossAgentPermission(requesterAgentID, targetAgentID) {
                        result := &SubagentSpawnResult{
                                Status: "forbidden",
                                Error:  fmt.Sprintf("agentId %s is not allowed for sessions_spawn", targetAgentID),
                        }
                        return t.marshalResult(result), nil
                }
        }

        // 解析请求者来源
        requesterOrigin := &DeliveryContext{
                Channel:   "cli", // 默认值
                AccountID: "default",
        }

        // 生成子会话密钥
        childSessionKey := GenerateChildSessionKey(targetAgentID)

        // 生成运行 ID
        runID := GenerateRunID()

        // 构建分身系统提示词
        childSystemPrompt := BuildSubagentSystemPrompt(&SubagentSystemPromptParams{
                RequesterSessionKey: requesterSessionKey,
                RequesterOrigin:     requesterOrigin,
                ChildSessionKey:     childSessionKey,
                Label:               spawnParams.Label,
                Task:                spawnParams.Task,
        })
        _ = childSystemPrompt // TODO: 传递给分身实例使用

        // 获取归档时间
        archiveAfterMinutes := 60 // 默认值
        if defCfg := t.getDefaultConfig(); defCfg != nil && defCfg.Subagents != nil {
                if defCfg.Subagents.ArchiveAfterMinutes > 0 {
                        archiveAfterMinutes = defCfg.Subagents.ArchiveAfterMinutes
                }
        }

        // 注册分身运行
        if err := t.registry.RegisterRun(&SubagentRunParams{
                RunID:               runID,
                ChildSessionKey:     childSessionKey,
                RequesterSessionKey: requesterSessionKey,
                RequesterOrigin:     requesterOrigin,
                RequesterDisplayKey: requesterSessionKey,
                Task:                spawnParams.Task,
                Cleanup:             spawnParams.Cleanup,
                Label:               spawnParams.Label,
                ArchiveAfterMinutes: archiveAfterMinutes,
        }); err != nil {
                result := &SubagentSpawnResult{
                        Status: "error",
                        Error:  fmt.Sprintf("failed to register subagent: %v", err),
                }
                return t.marshalResult(result), nil
        }

        // 调用生成回调
        if t.onSpawn != nil {
                spawnResult := &SubagentSpawnResult{
                        Status:            "accepted",
                        ChildSessionKey:   childSessionKey,
                        RunID:             runID,
                        ChildSystemPrompt: childSystemPrompt,
                }
                if err := t.onSpawn(spawnResult); err != nil {
                        logger.Error("Failed to handle subagent spawn",
                                zap.String("run_id", runID),
                                zap.Error(err))
                }
        }

        // 构建结果
        result := &SubagentSpawnResult{
                Status:            "accepted",
                ChildSessionKey:   childSessionKey,
                RunID:             runID,
                ChildSystemPrompt: childSystemPrompt,
        }

        logger.Info("Subagent spawned",
                zap.String("run_id", runID),
                zap.String("task", spawnParams.Task),
                zap.String("child_session_key", childSessionKey),
                zap.String("target_agent_id", targetAgentID))

        return t.marshalResult(result), nil
}

// parseParams 解析参数
func (t *SubagentSpawnTool) parseParams(params map[string]interface{}) (*SubagentSpawnToolParams, error) {
        result := &SubagentSpawnToolParams{
                Cleanup: "keep",
        }

        // 解析 task
        if val, ok := params["task"]; ok {
                if str, ok := val.(string); ok {
                        result.Task = str
                }
        }

        // 解析 label
        if val, ok := params["label"]; ok {
                if str, ok := val.(string); ok {
                        result.Label = str
                }
        }

        // 解析 agent_id
        if val, ok := params["agent_id"]; ok {
                if str, ok := val.(string); ok {
                        result.AgentID = str
                }
        }

        // 解析 model
        if val, ok := params["model"]; ok {
                if str, ok := val.(string); ok {
                        result.Model = str
                }
        }

        // 解析 thinking
        if val, ok := params["thinking"]; ok {
                if str, ok := val.(string); ok {
                        result.Thinking = str
                }
        }

        // 解析 run_timeout_seconds
        if val, ok := params["run_timeout_seconds"]; ok {
                switch v := val.(type) {
                case float64:
                        result.RunTimeoutSeconds = int(v)
                case int:
                        result.RunTimeoutSeconds = v
                }
        }

        // 解析 cleanup
        if val, ok := params["cleanup"]; ok {
                if str, ok := val.(string); ok {
                        result.Cleanup = str
                }
        }

        return result, nil
}

// marshalResult 序列化结果
func (t *SubagentSpawnTool) marshalResult(result *SubagentSpawnResult) string {
        // 简化输出
        switch result.Status {
        case "accepted":
                return fmt.Sprintf("Subagent spawned successfully. Run ID: %s, Session: %s",
                        result.RunID, result.ChildSessionKey)
        case "forbidden":
                return fmt.Sprintf("Forbidden: %s", result.Error)
        case "error":
                return fmt.Sprintf("Error: %s", result.Error)
        default:
                return fmt.Sprintf("Unknown status: %s", result.Status)
        }
}

// checkCrossAgentPermission 检查跨 Agent 创建权限
func (t *SubagentSpawnTool) checkCrossAgentPermission(requesterID, targetID string) bool {
        if t.getAgentConfig == nil {
                return false
        }

        agentCfg := t.getAgentConfig(requesterID)
        if agentCfg == nil || agentCfg.Subagents == nil {
                return false
        }

        // 检查是否允许所有
        allowAgents := agentCfg.Subagents.AllowAgents
        for _, agent := range allowAgents {
                if strings.TrimSpace(agent) == "*" {
                        return true
                }
        }

        // 检查是否包含目标 Agent
        for _, agent := range allowAgents {
                if strings.EqualFold(strings.TrimSpace(agent), targetID) {
                        return true
                }
        }

        return false
}

1	package tools
2
3	import (
4	"context"
5	"fmt"
6	"strings"
7
8	"github.com/google/uuid"
9	"github.com/smallnest/goclaw/config"
10	"github.com/smallnest/goclaw/internal/logger"
11	"go.uber.org/zap"
12	)
13
14	// SubagentTypes - 分身相关类型定义（避免循环导入）
15
16	// DeliveryContext 传递上下文
17	type DeliveryContext struct {
18	Channel string `json:"channel,omitempty"`
19	AccountID string `json:"account_id,omitempty"`
20	To string `json:"to,omitempty"`
21	ThreadID string `json:"thread_id,omitempty"`
22	}
23
24	// SubagentRunOutcome 分身运行结果
25	type SubagentRunOutcome struct {
26	Status string `json:"status"` // ok, error, timeout, unknown
27	Error string `json:"error,omitempty"`
28	}
29
30	// SubagentRunParams 分身运行参数
31	type SubagentRunParams struct {
32	RunID string
33	ChildSessionKey string
34	RequesterSessionKey string
35	RequesterOrigin *DeliveryContext
36	RequesterDisplayKey string
37	Task string
38	Cleanup string
39	Label string
40	ArchiveAfterMinutes int
41	}
42
43	// SubagentSystemPromptParams 系统提示词参数
44	type SubagentSystemPromptParams struct {
45	RequesterSessionKey string
46	RequesterOrigin *DeliveryContext
47	ChildSessionKey string
48	Label string
49	Task string
50	}
51
52	// BuildSubagentSystemPrompt 构建分身系统提示词
53	func BuildSubagentSystemPrompt(params *SubagentSystemPromptParams) string {	×
54	taskText := normalizeText(params.Task)	×
55	if taskText == "" {	×
56	taskText = "{{TASK_DESCRIPTION}}"	×
57	}	×
58
59	lines := []string{	×
60	"# Subagent Context",	×
61	"",	×
62	"You are a subagent spawned by the main agent for a specific task.",	×
63	"",	×
64	"## Your Role",	×
65	fmt.Sprintf("- You were created to handle: %s", taskText),	×
66	"- Complete this task. That's your entire purpose.",	×
67	"- You are NOT the main agent. Don't try to be.",	×
68	"",	×
69	"## Rules",	×
70	"1. Stay focused - Do your assigned task, nothing else",	×
71	"2. Complete the task - Your final message will be automatically reported to the main agent",	×
72	"3. Don't initiate - No heartbeats, no proactive actions, no side quests",	×
73	"4. Be ephemeral - You may be terminated after task completion. That's fine.",	×
74	"",	×
75	"## Output Format",	×
76	"When complete, your final response should include:",	×
77	"- What you accomplished or found",	×
78	"- Any relevant details the main agent should know",	×
79	"- Keep it concise but informative",	×
80	"",	×
81	"## What You DON'T Do",	×
82	"- NO user conversations (that's main agent's job)",	×
83	"- NO external messages (email, tweets, etc.) unless explicitly tasked",	×
84	"- NO cron jobs or persistent state",	×
85	"- NO pretending to be the main agent",	×
86	}	×
87		×
88	if params.Label != "" {	×
89	lines = append(lines, "")	×
90	lines = append(lines, fmt.Sprintf("- Label: %s", params.Label))	×
91	}	×
92	if params.RequesterSessionKey != "" {	×
93	lines = append(lines, fmt.Sprintf("- Requester session: %s", params.RequesterSessionKey))	×
94	}	×
95	if params.RequesterOrigin != nil && params.RequesterOrigin.Channel != "" {	×
96	lines = append(lines, fmt.Sprintf("- Requester channel: %s", params.RequesterOrigin.Channel))	×
97	}	×
98	lines = append(lines, fmt.Sprintf("- Your session: %s", params.ChildSessionKey))	×
99	lines = append(lines, "")	×
100		×
101	return joinLines(lines)	×
102	}
103
104	// normalizeText 规范化文本
105	func normalizeText(s string) string {	×
106	inSpace := false	×
107	var result []rune	×
108	for _, r := range s {	×
109	if r == ' ' \|\| r == '\t' \|\| r == '\n' {	×
110	if !inSpace {	×
111	result = append(result, ' ')	×
112	inSpace = true	×
113	}	×
114	} else {	×
115	result = append(result, r)	×
116	inSpace = false	×
117	}	×
118	}
119	return string(result)	×
120	}
121
122	// joinLines 连接行
123	func joinLines(lines []string) string {	×
124	if len(lines) == 0 {	×
125	return ""	×
126	}	×
127	result := lines[0]	×
128	for i := 1; i < len(lines); i++ {	×
129	result += "\n" + lines[i]	×
130	}	×
131	return result	×
132	}
133
134	// GenerateChildSessionKey 生成子会话密钥
135	func GenerateChildSessionKey(agentID string) string {	×
136	u := uuid.New()	×
137	return fmt.Sprintf("agent:%s:subagent:%s", agentID, u.String())	×
138	}	×
139
140	// GenerateRunID 生成运行ID
141	func GenerateRunID() string {	×
142	return uuid.New().String()	×
143	}	×
144
145	// End SubagentTypes
146
147	// SubagentSpawnToolParams 分身生成工具参数
148	type SubagentSpawnToolParams struct {
149	Task string `json:"task"` // 任务描述（必填）
150	Label string `json:"label,omitempty"` // 可选标签
151	AgentID string `json:"agent_id,omitempty"` // 目标 Agent ID
152	Model string `json:"model,omitempty"` // 模型覆盖
153	Thinking string `json:"thinking,omitempty"` // 思考级别
154	RunTimeoutSeconds int `json:"run_timeout_seconds,omitempty"` // 超时时间
155	Cleanup string `json:"cleanup,omitempty"` // 清理策略
156	}
157
158	// SubagentSpawnResult 分身生成结果
159	type SubagentSpawnResult struct {
160	Status string `json:"status"` // accepted, forbidden, error
161	ChildSessionKey string `json:"child_session_key,omitempty"`
162	RunID string `json:"run_id,omitempty"`
163	Error string `json:"error,omitempty"`
164	ModelApplied bool `json:"model_applied,omitempty"`
165	Warning string `json:"warning,omitempty"`
166	ChildSystemPrompt string `json:"child_system_prompt,omitempty"` // System prompt for the child agent
167	}
168
169	// SubagentRegistryInterface 分身注册表接口
170	type SubagentRegistryInterface interface {
171	RegisterRun(params *SubagentRunParams) error
172	}
173
174	// SubagentSpawnTool 分身生成工具
175	type SubagentSpawnTool struct {
176	registry SubagentRegistryInterface
177	getAgentConfig func(agentID string) *config.AgentConfig
178	getDefaultConfig func() *config.AgentDefaults
179	getAgentID func(sessionKey string) string
180	onSpawn func(spawnParams *SubagentSpawnResult) error
181	}
182
183	// NewSubagentSpawnTool 创建分身生成工具
184	func NewSubagentSpawnTool(registry SubagentRegistryInterface) *SubagentSpawnTool {	×
185	return &SubagentSpawnTool{	×
186	registry: registry,	×
187	}	×
188	}	×
189
190	// SetAgentConfigGetter 设置 Agent 配置获取器
191	func (t SubagentSpawnTool) SetAgentConfigGetter(getter func(agentID string) config.AgentConfig) {	×
192	t.getAgentConfig = getter	×
193	}	×
194
195	// SetDefaultConfigGetter 设置默认配置获取器
196	func (t SubagentSpawnTool) SetDefaultConfigGetter(getter func() config.AgentDefaults) {	×
197	t.getDefaultConfig = getter	×
198	}	×
199
200	// SetAgentIDGetter 设置 Agent ID 获取器
201	func (t *SubagentSpawnTool) SetAgentIDGetter(getter func(sessionKey string) string) {	×
202	t.getAgentID = getter	×
203	}	×
204
205	// SetOnSpawn 设置分身生成回调
206	func (t SubagentSpawnTool) SetOnSpawn(fn func(spawnParams SubagentSpawnResult) error) {	×
207	t.onSpawn = fn	×
208	}	×
209
210	// Name 返回工具名称
211	func (t *SubagentSpawnTool) Name() string {	×
212	return "sessions_spawn"	×
213	}	×
214
215	// Description 返回工具描述
216	func (t *SubagentSpawnTool) Description() string {	×
217	return "Spawn a background sub-agent run in an isolated session and announce the result back to the requester chat."	×
218	}	×
219
220	// Parameters 返回工具参数定义
221	func (t *SubagentSpawnTool) Parameters() map[string]interface{} {	×
222	return map[string]interface{}{	×
223	"type": "object",	×
224	"properties": map[string]interface{}{	×
225	"task": map[string]interface{}{	×
226	"type": "string",	×
227	"description": "The task description for the sub-agent to complete.",	×
228	},	×
229	"label": map[string]interface{}{	×
230	"type": "string",	×
231	"description": "Optional label for the sub-agent run.",	×
232	},	×
233	"agent_id": map[string]interface{}{	×
234	"type": "string",	×
235	"description": "Optional target agent ID to spawn the sub-agent under.",	×
236	},	×
237	"model": map[string]interface{}{	×
238	"type": "string",	×
239	"description": "Optional model override for the sub-agent.",	×
240	},	×
241	"thinking": map[string]interface{}{	×
242	"type": "string",	×
243	"description": "Optional thinking level override (low, medium, high).",	×
244	},	×
245	"run_timeout_seconds": map[string]interface{}{	×
246	"type": "integer",	×
247	"description": "Optional timeout in seconds for the sub-agent run.",	×
248	},	×
249	"cleanup": map[string]interface{}{	×
250	"type": "string",	×
251	"description": "Cleanup strategy: 'delete' to remove immediately, 'keep' to archive after timeout.",	×
252	"enum": []string{"delete", "keep"},	×
253	},	×
254	},	×
255	"required": []string{"task"},	×
256	}	×
257	}	×
258
259	// Execute 执行工具
260	func (t *SubagentSpawnTool) Execute(ctx context.Context, params map[string]interface{}) (string, error) {	×
261	// 解析参数	×
262	spawnParams, err := t.parseParams(params)	×
263	if err != nil {	×
264	result := &SubagentSpawnResult{	×
265	Status: "error",	×
266	Error: err.Error(),	×
267	}	×
268	return t.marshalResult(result), nil	×
269	}	×
270
271	// 验证任务不为空
272	if strings.TrimSpace(spawnParams.Task) == "" {	×
273	result := &SubagentSpawnResult{	×
274	Status: "error",	×
275	Error: "task is required",	×
276	}	×
277	return t.marshalResult(result), nil	×
278	}	×
279
280	// 规范化清理策略
281	if spawnParams.Cleanup != "delete" && spawnParams.Cleanup != "keep" {	×
282	spawnParams.Cleanup = "keep"	×
283	}	×
284
285	// Get requester session info from context
NEW 286	requesterSessionKey := "main" // default	×
NEW 287	if sk := ctx.Value("session_key"); sk != nil {	×
NEW 288	if key, ok := sk.(string); ok {	×
NEW 289	requesterSessionKey = key	×
NEW 290	}	×
291	}
292	requesterAgentID := t.getAgentID(requesterSessionKey)	×
293	if requesterAgentID == "" {	×
294	requesterAgentID = "default"	×
295	}	×
296
297	// 确定目标 Agent ID
298	targetAgentID := requesterAgentID	×
299	if spawnParams.AgentID != "" {	×
300	targetAgentID = spawnParams.AgentID	×
301	}	×
302
303	// 验证跨 Agent 创建权限
304	if targetAgentID != requesterAgentID {	×
305	if !t.checkCrossAgentPermission(requesterAgentID, targetAgentID) {	×
306	result := &SubagentSpawnResult{	×
307	Status: "forbidden",	×
308	Error: fmt.Sprintf("agentId %s is not allowed for sessions_spawn", targetAgentID),	×
309	}	×
310	return t.marshalResult(result), nil	×
311	}	×
312	}
313
314	// 解析请求者来源
315	requesterOrigin := &DeliveryContext{	×
316	Channel: "cli", // 默认值	×
317	AccountID: "default",	×
318	}	×
319		×
320	// 生成子会话密钥	×
321	childSessionKey := GenerateChildSessionKey(targetAgentID)	×
322		×
323	// 生成运行 ID	×
324	runID := GenerateRunID()	×
325		×
326	// 构建分身系统提示词	×
327	childSystemPrompt := BuildSubagentSystemPrompt(&SubagentSystemPromptParams{	×
328	RequesterSessionKey: requesterSessionKey,	×
329	RequesterOrigin: requesterOrigin,	×
330	ChildSessionKey: childSessionKey,	×
331	Label: spawnParams.Label,	×
332	Task: spawnParams.Task,	×
333	})	×
334	_ = childSystemPrompt // TODO: 传递给分身实例使用	×
335		×
336	// 获取归档时间	×
337	archiveAfterMinutes := 60 // 默认值	×
338	if defCfg := t.getDefaultConfig(); defCfg != nil && defCfg.Subagents != nil {	×
339	if defCfg.Subagents.ArchiveAfterMinutes > 0 {	×
340	archiveAfterMinutes = defCfg.Subagents.ArchiveAfterMinutes	×
341	}	×
342	}
343
344	// 注册分身运行
345	if err := t.registry.RegisterRun(&SubagentRunParams{	×
346	RunID: runID,	×
347	ChildSessionKey: childSessionKey,	×
348	RequesterSessionKey: requesterSessionKey,	×
349	RequesterOrigin: requesterOrigin,	×
350	RequesterDisplayKey: requesterSessionKey,	×
351	Task: spawnParams.Task,	×
352	Cleanup: spawnParams.Cleanup,	×
353	Label: spawnParams.Label,	×
354	ArchiveAfterMinutes: archiveAfterMinutes,	×
355	}); err != nil {	×
356	result := &SubagentSpawnResult{	×
357	Status: "error",	×
358	Error: fmt.Sprintf("failed to register subagent: %v", err),	×
359	}	×
360	return t.marshalResult(result), nil	×
361	}	×
362
363	// 调用生成回调
364	if t.onSpawn != nil {	×
365	spawnResult := &SubagentSpawnResult{	×
NEW 366	Status: "accepted",	×
NEW 367	ChildSessionKey: childSessionKey,	×
NEW 368	RunID: runID,	×
NEW 369	ChildSystemPrompt: childSystemPrompt,	×
370	}	×
371	if err := t.onSpawn(spawnResult); err != nil {	×
372	logger.Error("Failed to handle subagent spawn",	×
373	zap.String("run_id", runID),	×
374	zap.Error(err))	×
375	}	×
376	}
377
378	// 构建结果
379	result := &SubagentSpawnResult{	×
NEW 380	Status: "accepted",	×
NEW 381	ChildSessionKey: childSessionKey,	×
NEW 382	RunID: runID,	×
NEW 383	ChildSystemPrompt: childSystemPrompt,	×
384	}	×
385		×
386	logger.Info("Subagent spawned",	×
387	zap.String("run_id", runID),	×
388	zap.String("task", spawnParams.Task),	×
389	zap.String("child_session_key", childSessionKey),	×
390	zap.String("target_agent_id", targetAgentID))	×
391		×
392	return t.marshalResult(result), nil	×
393	}
394
395	// parseParams 解析参数
396	func (t SubagentSpawnTool) parseParams(params map[string]interface{}) (SubagentSpawnToolParams, error) {	×
397	result := &SubagentSpawnToolParams{	×
398	Cleanup: "keep",	×
399	}	×
400		×
401	// 解析 task	×
402	if val, ok := params["task"]; ok {	×
403	if str, ok := val.(string); ok {	×
404	result.Task = str	×
405	}	×
406	}
407
408	// 解析 label
409	if val, ok := params["label"]; ok {	×
410	if str, ok := val.(string); ok {	×
411	result.Label = str	×
412	}	×
413	}
414
415	// 解析 agent_id
416	if val, ok := params["agent_id"]; ok {	×
417	if str, ok := val.(string); ok {	×
418	result.AgentID = str	×
419	}	×
420	}
421
422	// 解析 model
423	if val, ok := params["model"]; ok {	×
424	if str, ok := val.(string); ok {	×
425	result.Model = str	×
426	}	×
427	}
428
429	// 解析 thinking
430	if val, ok := params["thinking"]; ok {	×
431	if str, ok := val.(string); ok {	×
432	result.Thinking = str	×
433	}	×
434	}
435
436	// 解析 run_timeout_seconds
437	if val, ok := params["run_timeout_seconds"]; ok {	×
438	switch v := val.(type) {	×
439	case float64:	×
440	result.RunTimeoutSeconds = int(v)	×
441	case int:	×
442	result.RunTimeoutSeconds = v	×
443	}
444	}
445
446	// 解析 cleanup
447	if val, ok := params["cleanup"]; ok {	×
448	if str, ok := val.(string); ok {	×
449	result.Cleanup = str	×
450	}	×
451	}
452
453	return result, nil	×
454	}
455
456	// marshalResult 序列化结果
457	func (t SubagentSpawnTool) marshalResult(result SubagentSpawnResult) string {	×
458	// 简化输出	×
459	switch result.Status {	×
460	case "accepted":	×
461	return fmt.Sprintf("Subagent spawned successfully. Run ID: %s, Session: %s",	×
462	result.RunID, result.ChildSessionKey)	×
463	case "forbidden":	×
464	return fmt.Sprintf("Forbidden: %s", result.Error)	×
465	case "error":	×
466	return fmt.Sprintf("Error: %s", result.Error)	×
467	default:	×
468	return fmt.Sprintf("Unknown status: %s", result.Status)	×
469	}
470	}
471
472	// checkCrossAgentPermission 检查跨 Agent 创建权限
473	func (t *SubagentSpawnTool) checkCrossAgentPermission(requesterID, targetID string) bool {	×
474	if t.getAgentConfig == nil {	×
475	return false	×
476	}	×
477
478	agentCfg := t.getAgentConfig(requesterID)	×
479	if agentCfg == nil \|\| agentCfg.Subagents == nil {	×
480	return false	×
481	}	×
482
483	// 检查是否允许所有
484	allowAgents := agentCfg.Subagents.AllowAgents	×
485	for _, agent := range allowAgents {	×
486	if strings.TrimSpace(agent) == "*" {	×
487	return true	×
488	}	×
489	}
490
491	// 检查是否包含目标 Agent
492	for _, agent := range allowAgents {	×
493	if strings.EqualFold(strings.TrimSpace(agent), targetID) {	×
494	return true	×
495	}	×
496	}
497
498	return false	×
499	}

smallnest / goclaw / 22353571065

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous