diff --git a/cmd/archie-agent/main.go b/cmd/archie-agent/main.go index 7732c77c1..c0275fe06 100644 --- a/cmd/archie-agent/main.go +++ b/cmd/archie-agent/main.go @@ -155,7 +155,7 @@ func handle(ctx context.Context, msg jetstream.Msg, nc *nats.Conn, log *slog.Log "reply_to", replyTo, ) - resp, err := agentexec.HandleMessage(ctx, req, log) + resp, err := agentexec.HandleMessage(ctx, req, log, agentexec.DefaultRunnerFactory) if err != nil { return fmt.Errorf("handle: %w", err) } diff --git a/internal/agentexec/nats.go b/internal/agentexec/nats.go index 297359984..50d05dd32 100644 --- a/internal/agentexec/nats.go +++ b/internal/agentexec/nats.go @@ -14,10 +14,8 @@ import ( ) // AgentRequestMessage is the NATS payload for an agent stage execution request. -// The Workflow field tells the agent which workflow to run (implement, tdd, -// feasibility, bootstrap) — the agent may execute multiple stages for one task. -// Channel selects the response routing: "response" (default, daemon-reviewed -// then forwarded to humans) or "system" (internal, never forwarded). PRD §2. +// When Workflow is set and Stages is populated, the agent runs all stages as a +// per-task batch rather than a single stage. PRD §1. type AgentRequestMessage struct { TaskID int64 `json:"task_id"` Attempt int `json:"attempt"` @@ -26,17 +24,17 @@ type AgentRequestMessage struct { Channel string `json:"channel,omitempty"` // "response" (default) or "system" Workspace string `json:"workspace"` Request Request `json:"request"` + Stages []Request `json:"stages,omitempty"` // batch: all agent stages for this task Providers map[string]Provider `json:"providers,omitempty"` } // AgentResponseEnvelope is the response payload published to the reply inbox. -// Channel distinguishes agent output for humans ("response") from internal -// messages the daemon never forwards ("system"). PRD §2. type AgentResponseEnvelope struct { - Version int `json:"version"` - Result Result `json:"result"` - Error string `json:"error,omitempty"` - Channel string `json:"channel,omitempty"` // "response" (default) or "system" + Version int `json:"version"` + Result Result `json:"result"` + Error string `json:"error,omitempty"` + Channel string `json:"channel,omitempty"` // "response" (default) or "system" + TaskCompleted bool `json:"task_completed,omitempty"` // true when all stages finished (per-task mode) } const defaultAgentTimeout = 30 * time.Minute diff --git a/internal/agentexec/nats_test.go b/internal/agentexec/nats_test.go index 3726231e4..2ccdb2276 100644 --- a/internal/agentexec/nats_test.go +++ b/internal/agentexec/nats_test.go @@ -15,53 +15,104 @@ import ( arnats "github.com/samcharles93/archie-core/internal/nats" ) +// ── helpers ────────────────────────────────────────────────────────── + +type mockRunner struct{} + +func (m *mockRunner) Run(_ context.Context, _ string, req Request) (Result, error) { + return Result{ + Version: ProtocolVersion, + TaskID: req.TaskID, + Attempt: req.Attempt, + Stage: req.Stage, + Status: StatusPassed, + Summary: "mock:" + req.Mission, + TokensUsed: 10, + Iterations: 1, + }, nil +} + +var mockFactory = func(providers map[string]Provider, log *slog.Logger) Runner { + return &mockRunner{} +} + // ── regression: Gap 1 — per-task agent ────────────────────────────── func TestHandleMessageReadsWorkflowField(t *testing.T) { // Gap 1: archie-agent is per-stage, not per-task. - // PRD section 1: the agent runs full multi-stage workflows, not - // individual stages. When HandleMessage receives a message with - // Workflow set, its behaviour must differ from a single-stage - // execution. Currently HandleMessage ignores the Workflow field. - msg := AgentRequestMessage{ + // PRD section 1: when the daemon sends a task-level message with + // Workflow="implement" and Stages populated, the agent must run all + // stages as a batch. Single-stage mode (Request only) is the + // backward-compatible fallback. + + ws := t.TempDir() + providers := map[string]Provider{"test": {Class: "openai", APIKeyEnv: "FAKE"}} + + // Single-stage mode: uses Request, no Workflow, no Stages. + singleMsg := AgentRequestMessage{ TaskID: 1, Attempt: 1, Stage: "plan", - Workspace: t.TempDir(), + Workspace: ws, Request: Request{ - Version: ProtocolVersion, - TaskID: 1, - Attempt: 1, - Stage: "plan", - Model: "test/model", - Mission: "test", - Budget: Budget{MaxSteps: 1, MaxTokens: 10}, + Version: ProtocolVersion, TaskID: 1, Attempt: 1, + Stage: "plan", Model: "test/model", Mission: "single", + Budget: Budget{MaxSteps: 1, MaxTokens: 10}, }, - Providers: map[string]Provider{"test": {Class: "openai", APIKeyEnv: "FAKE"}}, + Providers: providers, } - - // With Workflow empty: single-stage mode (current behaviour). - withoutWorkflow, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler)) + mockFactory := func(providers map[string]Provider, log *slog.Logger) Runner { + return &mockRunner{} + } + singleResp, err := HandleMessage(context.Background(), singleMsg, slog.New(slog.DiscardHandler), mockFactory) if err != nil { t.Fatal(err) } + if singleResp.TaskCompleted { + t.Error("single-stage mode set TaskCompleted=true — should be false") + } - // With Workflow set: should trigger per-task mode. - msg.Workflow = "implement" - withWorkflow, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler)) + // Per-task mode: Workflow set, Stages populated with two stages. + multiMsg := AgentRequestMessage{ + TaskID: 2, + Attempt: 1, + Stage: "plan", + Workflow: "implement", + Workspace: ws, + Request: Request{ + Version: ProtocolVersion, TaskID: 2, Attempt: 1, + Stage: "plan", Model: "test/model", Mission: "multi-1", + Budget: Budget{MaxSteps: 1, MaxTokens: 10}, + }, + Stages: []Request{ + { + Version: ProtocolVersion, TaskID: 2, Attempt: 1, + Stage: "plan", Model: "test/model", Mission: "multi-plan", + Budget: Budget{MaxSteps: 1, MaxTokens: 10}, + }, + { + Version: ProtocolVersion, TaskID: 2, Attempt: 1, + Stage: "build", Model: "test/model", Mission: "multi-build", + Budget: Budget{MaxSteps: 1, MaxTokens: 10}, + }, + }, + Providers: providers, + } + multiResp, err := HandleMessage(context.Background(), multiMsg, slog.New(slog.DiscardHandler), mockFactory) if err != nil { t.Fatal(err) } - - // The responses MUST differ when Workflow is set — the agent must - // process the full workflow, not just one stage. Currently both - // paths are identical (Workflow is ignored). - if withoutWorkflow.Result.Status == withWorkflow.Result.Status && - withoutWorkflow.Result.Summary == withWorkflow.Result.Summary { - t.Error("Gap 1: HandleMessage ignores the Workflow field. " + - "With and without Workflow produce identical results. " + - "The agent must run the full multi-stage workflow when Workflow is set, " + - "not just a single stage. See PRD section 1.") + if !multiResp.TaskCompleted { + t.Error("Gap 1: per-task mode did not set TaskCompleted=true. " + + "The agent must signal task completion when all stages in a " + + "workflow batch have been processed.") + } + // Batch results must aggregate from both stages. + if multiResp.Result.TokensUsed == singleResp.Result.TokensUsed && + multiResp.Result.Iterations == singleResp.Result.Iterations { + t.Error("Gap 1: per-task mode produced same token/iteration counts " + + "as single-stage mode. Multi-stage batch must accumulate " + + "results from all stages. See PRD section 1.") } } @@ -93,7 +144,7 @@ func TestHandleMessageRoutesSystemMessagesSeparately(t *testing.T) { } // Normal stage request — should route to response channel. - resp, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler)) + resp, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler), mockFactory) if err != nil { t.Fatal(err) } @@ -105,7 +156,7 @@ func TestHandleMessageRoutesSystemMessagesSeparately(t *testing.T) { // system channel. Currently HandleMessage always returns "response". // The daemon sets Channel on the request to indicate message type. msg.Channel = "system" - sysResp, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler)) + sysResp, err := HandleMessage(context.Background(), msg, slog.New(slog.DiscardHandler), mockFactory) if err != nil { t.Fatal(err) } diff --git a/internal/agentexec/worker.go b/internal/agentexec/worker.go index 406355f13..18446062f 100644 --- a/internal/agentexec/worker.go +++ b/internal/agentexec/worker.go @@ -7,15 +7,20 @@ import ( "fmt" "io" "log/slog" + "strings" ) const maxProtocolBytes = 8 << 20 -// ServeOne decodes and executes exactly one invocation. Stdout contains only -// the response envelope; callers should direct the supplied logger to stderr. +// DefaultRunnerFactory creates an InProcessRunner backed by the ai-sdk runtime. +func DefaultRunnerFactory(providers map[string]Provider, log *slog.Logger) Runner { + return NewInProcessRunner(NewRuntime(providers), log) +} + +// ServeOne decodes and executes exactly one invocation. func ServeOne(ctx context.Context, in io.Reader, out io.Writer, log *slog.Logger) error { return serveOne(ctx, in, out, func(invocation Invocation) Runner { - return NewInProcessRunner(NewRuntime(invocation.Providers), log) + return DefaultRunnerFactory(invocation.Providers, log) }) } @@ -45,24 +50,31 @@ func serveOne(ctx context.Context, in io.Reader, out io.Writer, newRunner func(I // ReplyFunc sends a response back to the daemon. type ReplyFunc func(data []byte) error -// HandleMessage processes one AgentRequestMessage by running the appropriate -// workflow stage. It exists so the agent's message processing is testable -// independently of NATS transport. -// -// Gap 1: currently runs ONE stage. Must be changed to run the full multi-stage -// workflow named in msg.Workflow. -func HandleMessage(ctx context.Context, msg AgentRequestMessage, log *slog.Logger) (*AgentResponseEnvelope, error) { - llm := NewRuntime(msg.Providers) - if llm == nil { +// RunnerFactory creates a Runner from provider config. In production this +// calls NewRuntime + NewInProcessRunner; tests inject a mock. +type RunnerFactory func(Providers map[string]Provider, log *slog.Logger) Runner + +// HandleMessage processes one AgentRequestMessage. When msg.Stages is +// populated and msg.Workflow is set, it runs all stages as a per-task +// batch. Otherwise it falls back to single-stage execution. +func HandleMessage(ctx context.Context, msg AgentRequestMessage, log *slog.Logger, newRunner RunnerFactory) (*AgentResponseEnvelope, error) { + runner := newRunner(msg.Providers, log) + if runner == nil { return nil, fmt.Errorf("no providers configured in request") } - runner := NewInProcessRunner(llm, log) - result, runErr := runner.Run(ctx, msg.Workspace, msg.Request) channel := msg.Channel if channel == "" { channel = "response" } + + // Per-task mode: run all stages for this workflow as a batch. + if msg.Workflow != "" && len(msg.Stages) > 0 { + return runStages(ctx, runner, msg, channel, log) + } + + // Single-stage mode (backward compatible). + result, runErr := runner.Run(ctx, msg.Workspace, msg.Request) resp := &AgentResponseEnvelope{ Version: msg.Request.Version, Result: result, @@ -74,6 +86,57 @@ func HandleMessage(ctx context.Context, msg AgentRequestMessage, log *slog.Logge return resp, nil } +// runStages executes every stage in msg.Stages sequentially, accumulating +// tokens, iterations, and notes. The first failure stops the batch and +// returns immediately. On success, TaskCompleted is set. +func runStages(ctx context.Context, runner Runner, msg AgentRequestMessage, channel string, log *slog.Logger) (*AgentResponseEnvelope, error) { + var ( + totalTokens int + totalIter int + lastResult Result + combinedNotes []string + combinedDetail []string + ) + + for i, stage := range msg.Stages { + log.Info("running stage", "stage", stage.Stage, "batch", fmt.Sprintf("%d/%d", i+1, len(msg.Stages))) + result, runErr := runner.Run(ctx, msg.Workspace, stage) + if runErr != nil { + resp := &AgentResponseEnvelope{ + Version: stage.Version, + Result: result, + Error: runErr.Error(), + Channel: channel, + } + return resp, nil + } + totalTokens += result.TokensUsed + totalIter += result.Iterations + combinedNotes = append(combinedNotes, result.AppendedNotes...) + if result.Summary != "" { + combinedDetail = append(combinedDetail, fmt.Sprintf("[%s] %s", stage.Stage, result.Summary)) + } + lastResult = result + if result.Status != StatusPassed { + break + } + } + + lastResult.TokensUsed = totalTokens + lastResult.Iterations = totalIter + lastResult.AppendedNotes = combinedNotes + if len(combinedDetail) > 0 { + lastResult.Summary = strings.Join(combinedDetail, "\n") + } + + return &AgentResponseEnvelope{ + Version: lastResult.Version, + Result: lastResult, + Channel: channel, + TaskCompleted: lastResult.Status == StatusPassed, + }, nil +} + func decodeOne(r io.Reader, value any) error { data, err := io.ReadAll(io.LimitReader(r, maxProtocolBytes+1)) if err != nil {