1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
|
package executor
import (
"context"
"encoding/json"
"errors"
"fmt"
"github.com/thepeterstone/claudomator/internal/llm"
)
// agentToolDefs returns the four agent back-channel tools as OpenAI
// function-calling definitions, for runners that talk to an OpenAI-compatible
// endpoint (LocalRunner). They mirror the MCP tools the container runners expose.
func agentToolDefs() []llm.Tool {
strProp := func(desc string) map[string]any {
return map[string]any{"type": "string", "description": desc}
}
return []llm.Tool{
{Type: "function", Function: llm.ToolFunction{
Name: "ask_user",
Description: "Ask the user a question when you genuinely need a decision to proceed. The task pauses until the user answers; do not call other tools after this.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"question": strProp("the question to ask, phrased as a real question"),
"options": map[string]any{"type": "array", "items": map[string]any{"type": "string"}, "description": "optional suggested answer choices"},
},
"required": []string{"question"},
},
}},
{Type: "function", Function: llm.ToolFunction{
Name: "report_summary",
Description: "Record a concise 2-5 sentence summary of what you accomplished. Call this before finishing.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{"summary": strProp("the summary text")},
"required": []string{"summary"},
},
}},
{Type: "function", Function: llm.ToolFunction{
Name: "spawn_subtask",
Description: "Create a child task to be executed separately. Use this to break large work into focused pieces.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{
"name": strProp("short descriptive name for the subtask"),
"instructions": strProp("complete instructions for the subtask agent"),
"model": strProp("optional model override"),
"max_budget_usd": map[string]any{"type": "number", "description": "optional budget cap in USD"},
},
"required": []string{"name", "instructions"},
},
}},
{Type: "function", Function: llm.ToolFunction{
Name: "record_progress",
Description: "Record a short progress note that appears in the task timeline.",
Parameters: map[string]any{
"type": "object",
"properties": map[string]any{"message": strProp("a short progress note")},
"required": []string{"message"},
},
}},
}
}
// dispatchAgentTool invokes one model-requested tool against the AgentChannel.
// It returns the text to feed back to the model as the tool result, and a
// blocked flag set when ask_user could not be answered in-session (the run must
// stop and the task block).
func dispatchAgentTool(ctx context.Context, ch AgentChannel, name, argsJSON string) (result string, blocked bool, err error) {
switch name {
case "ask_user":
var a struct {
Question string `json:"question"`
Options []string `json:"options"`
}
_ = json.Unmarshal([]byte(argsJSON), &a)
q := map[string]any{"text": a.Question}
if len(a.Options) > 0 {
q["options"] = a.Options
}
payload, _ := json.Marshal(q)
ans, askErr := ch.AskUser(ctx, string(payload))
if errors.Is(askErr, ErrAgentBlocked) {
return "", true, nil
}
if askErr != nil {
return "", false, askErr
}
return ans, false, nil
case "report_summary":
var a struct {
Summary string `json:"summary"`
}
_ = json.Unmarshal([]byte(argsJSON), &a)
if rsErr := ch.ReportSummary(ctx, a.Summary); rsErr != nil {
return "", false, rsErr
}
return "Summary recorded.", false, nil
case "spawn_subtask":
var a struct {
Name string `json:"name"`
Instructions string `json:"instructions"`
Model string `json:"model"`
MaxBudgetUSD float64 `json:"max_budget_usd"`
}
_ = json.Unmarshal([]byte(argsJSON), &a)
id, ssErr := ch.SpawnSubtask(ctx, SubtaskSpec{
Name: a.Name,
Instructions: a.Instructions,
Model: a.Model,
MaxBudgetUSD: a.MaxBudgetUSD,
})
if ssErr != nil {
return "", false, ssErr
}
return "Created subtask " + id, false, nil
case "record_progress":
var a struct {
Message string `json:"message"`
}
_ = json.Unmarshal([]byte(argsJSON), &a)
if rpErr := ch.RecordProgress(ctx, a.Message); rpErr != nil {
return "", false, rpErr
}
return "Noted.", false, nil
default:
return "", false, fmt.Errorf("unknown tool %q", name)
}
}
|
