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