162 lines
5.1 KiB
Go
162 lines
5.1 KiB
Go
package workflow
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
|
|
"github.com/samcharles93/archie-core/internal/agentexec"
|
|
"github.com/samcharles93/archie-core/internal/config"
|
|
)
|
|
|
|
// AgentStage is the reusable bridge from a workflow stage to an
|
|
// agentloop run. Every LLM-driven stage in any workflow (implement's
|
|
// planner/builder, tdd's test-writer/fixer, feasibility's analyst)
|
|
// is an AgentStage with a different mission, gate, and result handler —
|
|
// never a new engine.
|
|
type AgentStage struct {
|
|
Name string
|
|
// Role selects the model via cfg.Models[Role]; falls back to
|
|
// cfg.Models["builder"].
|
|
Role string
|
|
ReadOnly bool
|
|
// Mission produces the task statement from the current context.
|
|
Mission func(*TaskContext) string
|
|
// Gate returns the stage's quality gate; nil means ungated (e.g.
|
|
// read-only analysis stages).
|
|
Gate func(*TaskContext) agentexec.Gate
|
|
// ExtraRules is appended to the system prompt.
|
|
ExtraRules string
|
|
// MaxSteps overrides the configured step budget when > 0 (planner
|
|
// stages are cheaper than builder stages).
|
|
MaxSteps int
|
|
// ProtectGlobs blocks write/edit on matching paths for this stage —
|
|
// an environmental constraint, not a prompt rule (TDD's fix stage
|
|
// protects the committed repro tests; every builder stage protects
|
|
// the repo's generated files). The returned globs are combined
|
|
// with the repo's configured protected suffixes.
|
|
ProtectGlobs func(*TaskContext) []string
|
|
// CaptureTools adds structured-output tools whose calls are returned
|
|
// as data rather than receiving callbacks into daemon state.
|
|
CaptureTools func(*TaskContext) []agentexec.CaptureTool
|
|
// OnResult consumes a successful (passed) result. Parked and idle
|
|
// results park the workflow before OnResult is called.
|
|
OnResult func(*TaskContext, agentexec.Result) error
|
|
}
|
|
|
|
// Stage adapts the AgentStage to the engine.
|
|
func (a AgentStage) Stage() Stage {
|
|
return Stage{Name: a.Name, Run: func(ctx context.Context, tc *TaskContext) error {
|
|
if tc.Agent == nil {
|
|
return fmt.Errorf("no LLM runtime configured (missing [providers] in config?)")
|
|
}
|
|
modelRef := tc.Cfg.Models[a.Role]
|
|
if modelRef == "" {
|
|
modelRef = tc.Cfg.Models["builder"]
|
|
}
|
|
if modelRef == "" {
|
|
return fmt.Errorf("no model configured for role %q (set [models] in config)", a.Role)
|
|
}
|
|
|
|
budget := agentexec.Budget{
|
|
MaxSteps: tc.Cfg.Budgets.MaxSteps,
|
|
MaxTokens: tc.Cfg.Budgets.MaxTokens,
|
|
WallClock: tc.Cfg.Budgets.WallClock.Std(),
|
|
}
|
|
if a.MaxSteps > 0 {
|
|
budget.MaxSteps = a.MaxSteps
|
|
}
|
|
|
|
var gate agentexec.Gate
|
|
if a.Gate != nil {
|
|
gate = a.Gate(tc)
|
|
}
|
|
var captureTools []agentexec.CaptureTool
|
|
if a.CaptureTools != nil {
|
|
captureTools = a.CaptureTools(tc)
|
|
}
|
|
|
|
protection := agentexec.Protection{Suffixes: append([]string(nil), tc.Repo.Protect...)}
|
|
if a.ProtectGlobs != nil {
|
|
protection.Globs = a.ProtectGlobs(tc)
|
|
}
|
|
if a.ReadOnly {
|
|
protection = agentexec.Protection{}
|
|
}
|
|
|
|
var preflight []agentexec.Command
|
|
for _, argv := range tc.Repo.ResolvedPreflight() {
|
|
if len(argv) == 0 {
|
|
continue
|
|
}
|
|
preflight = append(preflight, agentexec.Command{Name: argv[0], Argv: argv})
|
|
}
|
|
|
|
req := agentexec.Request{
|
|
Version: agentexec.ProtocolVersion,
|
|
TaskID: tc.Task.ID,
|
|
Attempt: tc.Task.Attempt,
|
|
Stage: a.Name,
|
|
Model: modelRef,
|
|
Mission: a.Mission(tc),
|
|
ExtraRules: a.ExtraRules,
|
|
ReadOnly: a.ReadOnly,
|
|
Budget: budget,
|
|
Gate: gate,
|
|
Preflight: preflight,
|
|
Protection: protection,
|
|
Notes: tc.Task.Notes,
|
|
CaptureTools: captureTools,
|
|
}
|
|
res, err := tc.Agent.Run(ctx, tc.Dir, req)
|
|
if err != nil && res.Version == 0 {
|
|
return fmt.Errorf("agent run: %w", err)
|
|
}
|
|
if validateErr := res.ValidateFor(req); validateErr != nil {
|
|
return fmt.Errorf("validate agent result: %w", validateErr)
|
|
}
|
|
if len(res.AppendedNotes) > 0 {
|
|
for _, note := range res.AppendedNotes {
|
|
tc.Task.Notes += "- " + note + "\n"
|
|
}
|
|
if saveErr := tc.Store.Update(ctx, tc.Task); saveErr != nil {
|
|
return fmt.Errorf("persist agent notes: %w", saveErr)
|
|
}
|
|
}
|
|
if err != nil {
|
|
return fmt.Errorf("agent run: %w", err)
|
|
}
|
|
|
|
tc.Task.TokensUsed += res.TokensUsed
|
|
tc.Task.Iterations += res.Iterations
|
|
tc.Emit("agent_finish", a.Name, res.Summary, map[string]any{
|
|
"status": string(res.Status), "stop_reason": res.StopReason,
|
|
"tokens": res.TokensUsed, "iterations": res.Iterations, "model": modelRef,
|
|
})
|
|
|
|
if res.Status != agentexec.StatusPassed {
|
|
detail := res.Detail
|
|
if detail == "" {
|
|
detail = res.Summary
|
|
}
|
|
return fmt.Errorf("agent %s (%s): %s", res.Status, res.StopReason, clip(detail, 2000))
|
|
}
|
|
if a.OnResult != nil {
|
|
return a.OnResult(tc, res)
|
|
}
|
|
return nil
|
|
}}
|
|
}
|
|
|
|
// GateFromRepo converts the repo's configured command lists into an
|
|
// agent execution gate.
|
|
func GateFromRepo(repo config.Repo, budgets config.Budgets) agentexec.Gate {
|
|
cmds := make([]agentexec.Command, 0, len(repo.Gate))
|
|
for _, argv := range repo.Gate {
|
|
if len(argv) == 0 {
|
|
continue
|
|
}
|
|
cmds = append(cmds, agentexec.Command{Name: argv[0], Argv: argv})
|
|
}
|
|
return agentexec.Gate{Commands: cmds, MaxConsecutiveFailures: budgets.GateMaxFailures}
|
|
}
|