1package agent
2
3import (
4 "context"
5 "encoding/json"
6 "errors"
7 "os"
8 "path/filepath"
9 "sync"
10 "sync/atomic"
11 "testing"
12 "time"
13
14 "github.com/bnema/zut/packages/agent/subagents"
15 "github.com/bnema/zut/packages/agent/tools"
16 "github.com/bnema/zut/packages/core"
17)
18
19type runtimeTestRunner struct {
20 started chan struct{}
21 startOne sync.Once
22 canceled atomic.Int32
23 block bool
24}
25
26type stubbornRuntimeTestRunner struct {
27 started chan struct{}
28 release chan struct{}
29}
30
31func (r *runtimeTestRunner) Run(ctx context.Context, _ subagents.Sink) error {
32 if r.started != nil {
33 r.startOne.Do(func() { close(r.started) })
34 }
35 if !r.block {
36 return nil
37 }
38 <-ctx.Done()
39 r.canceled.Add(1)
40 return ctx.Err()
41}
42
43func (r *stubbornRuntimeTestRunner) Run(context.Context, subagents.Sink) error {
44 close(r.started)
45 <-r.release
46 return nil
47}
48
49func newRuntimeTestConfig(root, repoRoot string, runner func(*subagents.Agent) subagents.Runner) subagentRuntimeConfig {
50 return subagentRuntimeConfig{
51 Context: context.Background(),
52 Root: root,
53 RepoRoot: repoRoot,
54 Provider: "parent-provider",
55 Model: "parent-model",
56 Reasoning: "high",
57 BaseURL: "https://parent.example/v1",
58 InsecureTLS: true,
59 FastMode: true,
60 Policy: subagents.SubagentPolicy{
61 MaxConcurrent: 2,
62 DefaultTimeout: time.Minute,
63 CancelGracePeriod: time.Second,
64 },
65 NewRunner: runner,
66 }
67}
68
69func TestSubagentRuntimeLaunchCredentialStaysWithLaunchProvider(t *testing.T) {
70 activeProvider := "parent-provider"
71 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner {
72 return &runtimeTestRunner{}
73 })
74 cfg.APIKey = "launch-key"
75 cfg.ActiveProvider = func() string { return activeProvider }
76 rt := newSubagentRuntime(cfg)
77 defer func() { _ = rt.Close(context.Background()) }()
78
79 credential, err := rt.resolveCredential(context.Background(), "parent-provider")
80 if err != nil {
81 t.Fatalf("launch provider credential: %v", err)
82 }
83 if credential.Value != "launch-key" {
84 t.Fatalf("launch provider credential = %q, want launch key", credential.Value)
85 }
86
87 activeProvider = "later-provider"
88 for _, providerID := range []string{"", "later-provider"} {
89 credential, err = rt.resolveCredential(context.Background(), providerID)
90 if err != nil {
91 t.Fatalf("later provider credential (%q): %v", providerID, err)
92 }
93 if credential.Value == "launch-key" {
94 t.Fatalf("launch API key leaked to provider selected after construction (%q)", providerID)
95 }
96 }
97}
98
99func TestSubagentRuntimeOwnsSupervisorConfigurationAndResolution(t *testing.T) {
100 root := t.TempDir()
101 repoRoot := t.TempDir()
102 var captured *subagents.Agent
103 runner := func(a *subagents.Agent) subagents.Runner {
104 captured = a
105 return &runtimeTestRunner{}
106 }
107 rt := newSubagentRuntime(newRuntimeTestConfig(root, repoRoot, runner))
108 if rt == nil || rt.Supervisor() == nil {
109 t.Fatal("runtime did not create a supervisor")
110 }
111 defer func() { _ = rt.Close(context.Background()) }()
112
113 registry := rt.InjectTools(core.NewRegistry())
114 tool, ok := registry["subagent_spawn"]
115 if !ok {
116 t.Fatal("runtime did not inject canonical spawn tool")
117 }
118 if _, err := tool.Execute(context.Background(), json.RawMessage(`{"task":"configure child"}`), nil); err != nil {
119 t.Fatalf("spawn tool: %v", err)
120 }
121 if captured == nil {
122 t.Fatal("runner did not receive an agent")
123 }
124 if captured.Provider != "parent-provider" || captured.Model != "parent-model" || captured.Reasoning != "high" {
125 t.Fatalf("child model settings = provider=%q model=%q reasoning=%q", captured.Provider, captured.Model, captured.Reasoning)
126 }
127 if captured.BaseURL != "https://parent.example/v1" || !captured.InsecureTLS || !captured.FastMode {
128 t.Fatalf("child connection/settings = base_url=%q insecure_tls=%v fast_mode=%v", captured.BaseURL, captured.InsecureTLS, captured.FastMode)
129 }
130 if captured.Dir != repoRoot {
131 t.Fatalf("child repo root = %q, want %q", captured.Dir, repoRoot)
132 }
133}
134
135func TestSubagentRuntimeConfigurationConcurrentAccess(t *testing.T) {
136 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner {
137 return &runtimeTestRunner{}
138 })
139 rt := newSubagentRuntime(cfg)
140 defer func() { _ = rt.Close(context.Background()) }()
141 repoRoot := t.TempDir()
142
143 var wg sync.WaitGroup
144 wg.Add(2)
145 go func() {
146 defer wg.Done()
147 for index := 0; index < 100; index++ {
148 rt.SetProvider("provider")
149 rt.SetModel("model")
150 rt.SetReasoning("medium")
151 rt.SetProviderSettings("https://provider.example/v1", index%2 == 0)
152 rt.SetFastMode(index%2 == 0)
153 rt.SetRepoRoot(repoRoot)
154 rt.SetWebSearchPolicy(subagents.WebSearchDeny)
155 }
156 }()
157 go func() {
158 defer wg.Done()
159 for index := 0; index < 100; index++ {
160 _ = rt.currentProvider()
161 _ = rt.currentModel()
162 _ = rt.currentReasoning()
163 _ = rt.snapshotConfiguration()
164 }
165 }()
166 wg.Wait()
167}
168
169func TestSubagentRuntimeResolvedWebSearchPolicyRefreshesSupervisor(t *testing.T) {
170 var captured []*subagents.Agent
171 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(a *subagents.Agent) subagents.Runner {
172 captured = append(captured, a)
173 return &runtimeTestRunner{}
174 })
175 cfg.WebSearchPolicy = subagents.WebSearchAllow
176 rt := newSubagentRuntime(cfg)
177 defer func() { _ = rt.Close(context.Background()) }()
178
179 allowedRegistry := core.Registry{"web_search": &recordingWebSearchTool{}}
180 rt.PrepareResolvedRegistry(allowedRegistry, subagents.WebSearchAllow)
181 if rt.Supervisor().WebSearchPolicy() != subagents.WebSearchAllow {
182 t.Fatal("resolved allow policy was not propagated to supervisor")
183 }
184 allowed, err := rt.Supervisor().SpawnReq(context.Background(), subagents.SpawnRequest{
185 Task: "allowed child",
186 Tools: []string{"web_search"},
187 })
188 if err != nil {
189 t.Fatalf("spawn allowed child: %v", err)
190 }
191 if allowed.WebSearchPolicy != subagents.WebSearchAllow {
192 t.Fatalf("allowed child policy = %v, want allow", allowed.WebSearchPolicy)
193 }
194
195 deniedRegistry := core.Registry{"web_search": &recordingWebSearchTool{}}
196 rt.PrepareResolvedRegistry(deniedRegistry, subagents.WebSearchDeny)
197 if _, ok := deniedRegistry["web_search"]; ok {
198 t.Fatal("resolved deny policy left web_search in parent registry")
199 }
200 if rt.Supervisor().WebSearchPolicy() != subagents.WebSearchDeny {
201 t.Fatal("resolved deny policy was not propagated to supervisor")
202 }
203 denied, err := rt.Supervisor().SpawnReq(context.Background(), subagents.SpawnRequest{
204 Task: "denied child",
205 Tools: []string{"web_search"},
206 })
207 if err != nil {
208 t.Fatalf("spawn denied child: %v", err)
209 }
210 if denied.WebSearchPolicy != subagents.WebSearchDeny {
211 t.Fatalf("denied child policy = %v, want deny", denied.WebSearchPolicy)
212 }
213 if len(captured) != 2 {
214 t.Fatalf("captured children = %d, want 2", len(captured))
215 }
216}
217
218func TestSubagentRuntimeInjectsCanonicalToolsAccordingToPolicy(t *testing.T) {
219 cases := []struct {
220 name string
221 args Args
222 want []string
223 }{
224 {name: "default", want: []string{"subagent_spawn", "subagent_status", "subagent_stop", "subagent_resume"}},
225 {name: "explicit spawn and status", args: Args{ToolsSet: true, Tools: []string{"subagent_spawn", "subagent_status"}}, want: []string{"subagent_spawn", "subagent_status"}},
226 {name: "no tools", args: Args{NoTools: true}},
227 {name: "permission set", args: Args{PermissionSet: &tools.PermissionSet{}}},
228 }
229 for _, tc := range cases {
230 t.Run(tc.name, func(t *testing.T) {
231 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner {
232 return &runtimeTestRunner{}
233 })
234 cfg.Args = tc.args
235 rt := newSubagentRuntime(cfg)
236 defer func() { _ = rt.Close(context.Background()) }()
237 got := rt.InjectTools(core.NewRegistry())
238 for _, name := range tc.want {
239 if _, ok := got[name]; !ok {
240 t.Errorf("missing injected tool %q in %#v", name, got)
241 }
242 }
243 if len(got) != len(tc.want) {
244 t.Errorf("injected tools = %#v, want exactly %v", got, tc.want)
245 }
246 })
247 }
248}
249
250func TestSubagentRuntimeFailedTransitionRestoresConfiguration(t *testing.T) {
251 rt := newSubagentRuntime(newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner {
252 return &runtimeTestRunner{}
253 }))
254 defer func() { _ = rt.Close(context.Background()) }()
255 before := rt.snapshotConfiguration()
256
257 if err := func() error {
258 rt.SetProvider("candidate-provider")
259 rt.SetProviderSettings("https://candidate.example/v1", false)
260 rt.SetFastMode(false)
261 rt.SetRepoRoot(t.TempDir())
262 rt.SetWebSearchPolicy(subagents.WebSearchDeny)
263 return errors.New("candidate transition failed")
264 }(); err != nil {
265 rt.restoreConfiguration(before)
266 }
267
268 if got := rt.snapshotConfiguration(); got != before {
269 t.Fatalf("runtime configuration after rollback = %+v, want %+v", got, before)
270 }
271 if got := rt.Supervisor().WebSearchPolicy(); got != before.webSearchPolicy {
272 t.Fatalf("supervisor web-search policy after rollback = %v, want %v", got, before.webSearchPolicy)
273 }
274}
275
276func TestSubagentRuntimeFreshShutdownContextCleansCanceledParent(t *testing.T) {
277 runner := &runtimeTestRunner{started: make(chan struct{}), block: true}
278 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner { return runner })
279 rt := newSubagentRuntime(cfg)
280 spawn := rt.InjectTools(core.NewRegistry())["subagent_spawn"]
281 if _, err := spawn.Execute(context.Background(), json.RawMessage(`{"task":"cancel me"}`), nil); err != nil {
282 t.Fatal(err)
283 }
284 select {
285 case <-runner.started:
286 case <-time.After(time.Second):
287 t.Fatal("runner did not start")
288 }
289 if err := closeSubagentRuntimeFresh(rt); err != nil {
290 t.Fatalf("fresh shutdown: %v", err)
291 }
292 if got := runner.canceled.Load(); got != 1 {
293 t.Fatalf("runner cancellation count = %d, want 1", got)
294 }
295}
296
297func TestSubagentRuntimeCloseRetriesAfterCanceledContext(t *testing.T) {
298 runner := &stubbornRuntimeTestRunner{started: make(chan struct{}), release: make(chan struct{})}
299 cfg := newRuntimeTestConfig(t.TempDir(), t.TempDir(), func(*subagents.Agent) subagents.Runner { return runner })
300 rt := newSubagentRuntime(cfg)
301 spawn := rt.InjectTools(core.NewRegistry())["subagent_spawn"]
302 if _, err := spawn.Execute(context.Background(), json.RawMessage(`{"task":"retry cleanup"}`), nil); err != nil {
303 t.Fatal(err)
304 }
305 select {
306 case <-runner.started:
307 case <-time.After(time.Second):
308 t.Fatal("runner did not start")
309 }
310
311 canceled, cancel := context.WithCancel(context.Background())
312 cancel()
313 if err := rt.Close(canceled); !errors.Is(err, context.Canceled) {
314 t.Fatalf("first Close error = %v, want context canceled", err)
315 }
316 close(runner.release)
317 if err := rt.Close(context.Background()); err != nil {
318 t.Fatalf("retry Close: %v", err)
319 }
320 if err := rt.Close(context.Background()); err != nil {
321 t.Fatalf("idempotent Close: %v", err)
322 }
323}
324
325func TestSubagentRuntimeCallbacksAndExactlyOnceClose(t *testing.T) {
326 root := t.TempDir()
327 runner := &runtimeTestRunner{started: make(chan struct{}), block: true}
328 var spawned atomic.Int32
329 var stopped atomic.Int32
330 cfg := newRuntimeTestConfig(root, t.TempDir(), func(*subagents.Agent) subagents.Runner { return runner })
331 cfg.OnSpawned = func(_ *subagents.Agent, _ string, required bool) {
332 if required {
333 t.Errorf("optional spawn callback required = true")
334 }
335 spawned.Add(1)
336 }
337 cfg.OnStopRequested = func(*subagents.Agent) { stopped.Add(1) }
338 rt := newSubagentRuntime(cfg)
339 registry := rt.InjectTools(core.NewRegistry())
340 spawn, ok := registry["subagent_spawn"]
341 if !ok {
342 t.Fatal("spawn tool was not injected")
343 }
344 if _, err := spawn.Execute(context.Background(), json.RawMessage(`{"task":"callback task"}`), nil); err != nil {
345 t.Fatalf("spawn tool: %v", err)
346 }
347 select {
348 case <-runner.started:
349 case <-time.After(time.Second):
350 t.Fatal("runner did not start")
351 }
352 if got := spawned.Load(); got != 1 {
353 t.Fatalf("OnSpawned calls = %d, want 1", got)
354 }
355
356 closeCtx, cancel := context.WithTimeout(context.Background(), time.Second)
357 defer cancel()
358 if err := rt.Close(closeCtx); err != nil {
359 t.Fatalf("first Close: %v", err)
360 }
361 if err := rt.Close(context.Background()); err != nil {
362 t.Fatalf("second Close: %v", err)
363 }
364 if got := runner.canceled.Load(); got != 1 {
365 t.Fatalf("runner cancellation count = %d, want exactly once", got)
366 }
367 if got := stopped.Load(); got != 0 {
368 t.Fatalf("unexpected stop callback count = %d", got)
369 }
370}
371
372func TestSubagentRuntimeInjectedSpawnProfileInheritsAndOverridesFrontmatter(t *testing.T) {
373 cwd := t.TempDir()
374 profilesDir := filepath.Join(cwd, ".agents")
375 if err := os.MkdirAll(profilesDir, 0o755); err != nil {
376 t.Fatal(err)
377 }
378 writeRuntimeProfile := func(name, frontmatter string) {
379 t.Helper()
380 contents := "---\nname: " + name + "\n" + frontmatter + "---\nDo the work.\n"
381 if err := os.WriteFile(filepath.Join(profilesDir, name+".md"), []byte(contents), 0o644); err != nil {
382 t.Fatal(err)
383 }
384 }
385 writeRuntimeProfile("inherited", "")
386 writeRuntimeProfile("overridden", "model: override-model\nprovider: override-provider\nthinking: low\n")
387 t.Setenv("ZUT_AGENT_PROFILES", profilesDir)
388
389 var captured []*subagents.Agent
390 cfg := newRuntimeTestConfig(t.TempDir(), cwd, func(a *subagents.Agent) subagents.Runner {
391 captured = append(captured, a)
392 return &runtimeTestRunner{}
393 })
394 cfg.Reasoning = "high"
395 rt := newSubagentRuntime(cfg)
396 // Change the host-owned setting after runtime construction. A child without
397 // a profile override must observe this new live value.
398 rt.SetReasoning("medium")
399 defer func() { _ = rt.Close(context.Background()) }()
400 spawn := rt.InjectTools(core.NewRegistry())["subagent_spawn"]
401
402 for _, name := range []string{"inherited", "overridden"} {
403 raw := []byte(`{"task":"` + name + ` task","agent":"` + name + `"}`)
404 result, err := spawn.Execute(context.Background(), raw, nil)
405 if err != nil {
406 t.Fatalf("spawn %s: %v", name, err)
407 }
408 if result.IsError {
409 t.Fatalf("spawn %s returned tool error: %#v", name, result)
410 }
411 }
412 if len(captured) != 2 {
413 t.Fatalf("captured agents = %d, want 2", len(captured))
414 }
415 inherited, overridden := captured[0], captured[1]
416 if inherited.Provider != "parent-provider" || inherited.Model != "parent-model" || inherited.Reasoning != "medium" {
417 t.Fatalf("inherited profile settings = provider=%q model=%q reasoning=%q", inherited.Provider, inherited.Model, inherited.Reasoning)
418 }
419 if overridden.Provider != "override-provider" || overridden.Model != "override-model" || overridden.Reasoning != "low" {
420 t.Fatalf("overridden profile settings = provider=%q model=%q reasoning=%q", overridden.Provider, overridden.Model, overridden.Reasoning)
421 }
422}