subagents works :-)

Author: rogeralsing

internal/core/runtime/command_executor_test.go

@@ -149,7 +149,7 @@ func TestCommandExecutorExecuteBuiltinApplyPatch(t *testing.T) {
 	}
 
 	executor := NewCommandExecutor()
-	if err := registerBuiltinInternalCommands(executor); err != nil {
+	if err := registerBuiltinInternalCommands(nil, executor); err != nil {
 		t.Fatalf("failed to register builtins: %v", err)
 	}
 

internal/core/runtime/internal_command_apply_patch.go

@@ -163,9 +163,12 @@ func parseApplyPatchOptions(commandLine, cwd string) (patch.FilesystemOptions, e
 	return opts, nil
 }
 
-func registerBuiltinInternalCommands(executor *CommandExecutor) error {
+func registerBuiltinInternalCommands(rt *Runtime, executor *CommandExecutor) error {
 	if executor == nil {
 		return errors.New("nil executor")
 	}
-	return executor.RegisterInternalCommand(applyPatchCommandName, newApplyPatchCommand())
+	if err := executor.RegisterInternalCommand(applyPatchCommandName, newApplyPatchCommand()); err != nil {
+		return err
+	}
+	return executor.RegisterInternalCommand(runResearchCommandName, newRunResearchCommand(rt))
 }

internal/core/runtime/internal_command_run_research.go

@@ -0,0 +1,83 @@
+package runtime
+
+import (
+	"context"
+	"encoding/json"
+	"errors"
+	"fmt"
+	"strings"
+)
+
+const runResearchCommandName = "run_research"
+
+func newRunResearchCommand(rt *Runtime) InternalCommandHandler {
+	return func(ctx context.Context, req InternalCommandRequest) (PlanObservationPayload, error) {
+		payload := PlanObservationPayload{}
+
+		// 1. Parse the research spec from the raw command
+		type researchSpec struct {
+			Goal  string `json:"goal"`
+			Turns int    `json:"turns"`
+		}
+		var rs researchSpec
+		jsonInput := strings.TrimSpace(strings.TrimPrefix(req.Raw, runResearchCommandName))
+		if err := json.Unmarshal([]byte(jsonInput), &rs); err != nil {
+			return failApplyPatch(&payload, "internal command: run_research invalid JSON"), err
+		}
+		rs.Goal = strings.TrimSpace(rs.Goal)
+		if rs.Goal == "" {
+			return failApplyPatch(&payload, "internal command: run_research requires non-empty goal"), errors.New("run_research: missing goal")
+		}
+		if rs.Turns <= 0 {
+			rs.Turns = 10 // Default to 10 turns if not specified or invalid
+		}
+
+		// 2. Configure new runtime options for the sub-agent
+		subOptions := rt.options
+		subOptions.HandsFree = true
+		subOptions.HandsFreeTopic = rs.Goal
+		subOptions.MaxPasses = rs.Turns
+		subOptions.HandsFreeAutoReply = fmt.Sprintf("Please continue to work on the set goal. No human available. Goal: %s", rs.Goal)
+		subOptions.DisableInputReader = true
+		subOptions.DisableOutputForwarding = true
+
+		// 3. Create and run the sub-agent
+		subAgent, err := NewRuntime(subOptions)
+		if err != nil {
+			return failApplyPatch(&payload, "failed to create sub-agent"), err
+		}
+
+		runCtx, cancel := context.WithCancel(ctx)
+		defer cancel()
+		go func() { _ = subAgent.Run(runCtx) }()
+
+		// 4. Capture the output of the sub-agent
+		var lastAssistant string
+		var success bool
+		for evt := range subAgent.Outputs() {
+			switch evt.Type {
+			case EventTypeAssistantMessage:
+				if m := strings.TrimSpace(evt.Message); m != "" {
+					lastAssistant = m
+				}
+			case EventTypeStatus:
+				if strings.Contains(evt.Message, "Hands-free session complete") {
+					success = true
+				}
+			}
+		}
+
+		// 5. Populate the payload with the result
+		if success {
+			payload.Stdout = lastAssistant
+			zero := 0
+			payload.ExitCode = &zero
+		} else {
+			payload.Stderr = lastAssistant
+			one := 1
+			payload.ExitCode = &one
+		}
+
+		return payload, nil
+	}
+}

internal/core/runtime/internal_command_run_research_test.go

@@ -0,0 +1,52 @@
+package runtime
+
+import (
+	"context"
+	"os"
+	"strconv"
+	"strings"
+	"testing"
+)
+
+func TestRunResearchCommand(t *testing.T) {
+	t.Skip("Skipping test that requires OpenAI API key")
+	t.Parallel()
+
+	// 1. Setup a mock runtime
+	options := RuntimeOptions{
+		APIKey:                  os.Getenv("OPENAI_API_KEY"),
+		Model:                   "gpt-4o",
+		DisableOutputForwarding: true,
+		UseStreaming:            true,
+	}
+	rt, err := NewRuntime(options)
+	if err != nil {
+		t.Fatalf("failed to create runtime: %v", err)
+	}
+
+	// 2. Create a request for the run_research command
+	researchGoal := "write a haiku about testing"
+	researchTurns := 5
+	rawCommand := `{"goal":"` + researchGoal + `","turns":` + strconv.Itoa(researchTurns) + `}`
+	req := InternalCommandRequest{
+		Name: runResearchCommandName,
+		Raw:  rawCommand,
+		Step: PlanStep{ID: "step-1", Command: CommandDraft{Shell: agentShell, Run: rawCommand}},
+	}
+
+	// 3. Execute the command
+
+	payload, err := newRunResearchCommand(rt)(context.Background(), req)
+	if err != nil {
+		t.Fatalf("handler returned error: %v", err)
+	}
+
+	// 4. Assert the results
+	if payload.ExitCode == nil || *payload.ExitCode != 0 {
+		t.Fatalf("expected exit code 0, got %+v", payload.ExitCode)
+	}
+
+	if !strings.Contains(payload.Stdout, "test") {
+		t.Fatalf("expected stdout to contain 'test', got %q", payload.Stdout)
+	}
+}

internal/core/runtime/runtime.go

@@ -57,23 +57,22 @@ func NewRuntime(options RuntimeOptions) (*Runtime, error) {
 		Pass:      0,
 	}}
 
-	executor := NewCommandExecutor()
-	if err := registerBuiltinInternalCommands(executor); err != nil {
-		return nil, err
-	}
-
 	rt := &Runtime{
 		options:       options,
 		inputs:        make(chan InputEvent, options.InputBuffer),
 		outputs:       make(chan RuntimeEvent, options.OutputBuffer),
 		closed:        make(chan struct{}),
 		plan:          NewPlanManager(),
 		client:        client,
-		executor:      executor,
 		history:       initialHistory,
 		agentName:     "main",
 		contextBudget: ContextBudget{MaxTokens: options.MaxContextTokens, CompactWhenPercent: options.CompactWhenPercent},
 	}
+	executor := NewCommandExecutor()
+	if err := registerBuiltinInternalCommands(rt, executor); err != nil {
+		return nil, err
+	}
+	rt.executor = executor
 
 	for name, handler := range options.InternalCommands {
 		if err := rt.executor.RegisterInternalCommand(name, handler); err != nil {
@@ -263,6 +262,20 @@ apply_patch [--respect-whitespace|--ignore-whitespace]
 '''
   The executor parses this JSON, notices the "openagent" shell, and forwards the run string to the apply_patch handler which consumes the embedded diff.
 
+### run_research
+Use this command to spawn a sub-agent to perform research. The sub-agent will run in a hands-free loop for a fixed number of turns.
+- Set the plan step's command shell to "openagent" so the runtime routes the request to the internal handler instead of the OS shell.
+- The payload sent in the plan step's "run" field must be a JSON object of the following shape:
+'''
+{"goal":"some goal","turns":20}
+'''
+- The 'goal' is the research topic for the sub-agent.
+- The 'turns' is the maximum number of passes the sub-agent will make.
+- Example plan step payload (escaped for this Go string literal):
+'''
+{"id":"step-42","command":{"shell":"openagent","cwd":"/workspace/project","run":"run_research {\"goal\":\"code review the last 2 commits in git, anything good? bad?\",\"turns\":20}"}}
+'''
+
 ## execution environment and sandbox
 You are not in a sandbox, you have full access to run any command.