xonecas.io
62159
Sy

symb / files

symb / internal / mcptools / subagent.go

4.7 KB
1package mcptools
2
3import (
4	"context"
5	"encoding/json"
6	"fmt"
7	"sync/atomic"
8
9	"github.com/xonecas/symb/internal/delta"
10	"github.com/xonecas/symb/internal/lsp"
11	"github.com/xonecas/symb/internal/mcp"
12	"github.com/xonecas/symb/internal/provider"
13	"github.com/xonecas/symb/internal/shell"
14	"github.com/xonecas/symb/internal/subagent"
15)
16
17// SubAgentArgs represents arguments for the SubAgent tool.
18type SubAgentArgs struct {
19	Prompt        string `json:"prompt"`
20	Type          string `json:"type,omitempty"`
21	MaxIterations int    `json:"max_iterations,omitempty"`
22}
23
24// NewSubAgentTool creates the SubAgent tool definition.
25func NewSubAgentTool() mcp.Tool {
26	return mcp.Tool{
27		Name:        "SubAgent",
28		Description: `Spawn a sub-agent to handle a focused task. The sub-agent runs in isolated context with the same tools but cannot spawn further sub-agents. Use this to decompose complex tasks or delegate exploration — their tool usage doesn't consume your context window. The sub-agent's work is returned as a summary.`,
29		InputSchema: json.RawMessage(`{
30			"type": "object",
31			"properties": {
32				"prompt":         {"type": "string", "description": "Task description for the sub-agent. Be specific about what needs to be accomplished and the expected output format."},
33				"type":           {"type": "string", "enum": ["explore", "editor", "reviewer", "web"], "description": "Subagent type controls available tools and prompt. explore=read-only codebase search (Read, Grep, Shell); editor=surgical code changes (Read, Edit, Grep, Shell); reviewer=code review, read-only; web=documentation/API research (WebSearch, WebFetch). Omit for general tasks with all tools."},
34				"max_iterations": {"type": "integer", "description": "Maximum tool rounds for the sub-agent (default: 5)"}
35			},
36			"required": ["prompt"]
37		}`),
38	}
39}
40
41// SubAgentHandler handles SubAgent tool calls.
42type SubAgentHandler struct {
43	provider     *atomic.Pointer[provider.Provider]
44	lspManager   *lsp.Manager
45	deltaTracker *delta.Tracker
46	sh           *shell.Shell
47	allTools     []mcp.Tool
48	upstream     mcp.UpstreamClient
49}
50
51// NewSubAgentHandler creates a handler for the SubAgent tool.
52func NewSubAgentHandler(
53	prov *atomic.Pointer[provider.Provider],
54	lspManager *lsp.Manager,
55	deltaTracker *delta.Tracker,
56	sh *shell.Shell,
57	allTools []mcp.Tool,
58	upstream mcp.UpstreamClient,
59) *SubAgentHandler {
60	// Validate required dependencies
61	if prov == nil {
62		panic("SubAgentHandler: provider cannot be nil")
63	}
64	if sh == nil {
65		panic("SubAgentHandler: shell cannot be nil")
66	}
67
68	return &SubAgentHandler{
69		provider:     prov,
70		lspManager:   lspManager,
71		deltaTracker: deltaTracker,
72		sh:           sh,
73		allTools:     allTools,
74		upstream:     upstream,
75	}
76}
77
78// Handle implements the mcp.ToolHandler interface.
79func (h *SubAgentHandler) Handle(ctx context.Context, arguments json.RawMessage) (*mcp.ToolResult, error) {
80	if err := ctx.Err(); err != nil {
81		return toolError("Sub-agent cancelled: %v", err), nil
82	}
83
84	var args SubAgentArgs
85	if err := json.Unmarshal(arguments, &args); err != nil {
86		return toolError("Invalid arguments: %v", err), nil
87	}
88	if args.Prompt == "" {
89		return toolError("prompt is required"), nil
90	}
91
92	// Create isolated FileReadTracker for sub-agent
93	subTracker := NewFileReadTracker()
94
95	// Create fresh handlers with isolated tracker
96	subReadHandler := NewReadHandler(subTracker, h.lspManager)
97	subEditHandler := NewEditHandler(subTracker, h.lspManager, h.deltaTracker)
98	subShellHandler := NewShellHandler(h.sh)
99
100	// Create proxy with sub-agent tools (filtered - no nested SubAgent).
101	// Pass upstream so tools like web_search_exa can be dispatched.
102	subProxy := mcp.NewProxy(h.upstream)
103	filteredTools := subagent.FilterToolsForType(h.allTools, args.Type)
104
105	// Register tools with sub-agent proxy
106	for _, tool := range filteredTools {
107		switch tool.Name {
108		case "Read":
109			subProxy.RegisterTool(tool, subReadHandler.Handle)
110		case "Edit":
111			subProxy.RegisterTool(tool, subEditHandler.Handle)
112		case "Shell":
113			subProxy.RegisterTool(tool, subShellHandler.Handle)
114		case "Grep":
115			subProxy.RegisterTool(tool, MakeGrepHandler())
116		case "TodoWrite":
117			// Sub-agents get their own scratchpad
118			subPad := &Scratchpad{}
119			subProxy.RegisterTool(tool, MakeTodoWriteHandler(subPad))
120		}
121	}
122
123	subCtx, subCancel := context.WithCancel(context.Background())
124	defer subCancel()
125	result, err := subagent.Run(subCtx, subagent.Options{
126		Provider:      *h.provider.Load(),
127		Proxy:         subProxy,
128		Tools:         filteredTools,
129		Prompt:        args.Prompt,
130		Type:          args.Type,
131		MaxIterations: args.MaxIterations,
132	})
133	if err != nil {
134		return toolError("%v", err), nil
135	}
136
137	output := fmt.Sprintf("Sub-agent completed.\n\n%s\n\n---\nToken usage: %d in, %d out",
138		result.Content, result.InputTokens, result.OutputTokens)
139
140	return toolText(output), nil
141}