diff --git a/internal/agentexec/inprocess.go b/internal/agentexec/inprocess.go index fa7755285..2a4b6f439 100644 --- a/internal/agentexec/inprocess.go +++ b/internal/agentexec/inprocess.go @@ -19,7 +19,10 @@ import ( // Runner executes one autonomous stage against an already prepared workspace. type Runner interface { - Run(ctx context.Context, workspace string, req Request) (Result, error) + // report, when non-nil, is notified once per completed tool call. Only + // a runner executing in the same process as its tools (InProcessRunner) + // can populate it; others accept and ignore it. + Run(ctx context.Context, workspace string, req Request, report ToolCallReporter) (Result, error) } type loopFunc func(context.Context, agentloop.Config) (agentloop.Result, error) @@ -62,7 +65,7 @@ func NewInProcessRunner( // it is not configurable. const workspaceToolset = "workspace" -func (r *InProcessRunner) Run(ctx context.Context, workspace string, req Request) (Result, error) { +func (r *InProcessRunner) Run(ctx context.Context, workspace string, req Request, report ToolCallReporter) (Result, error) { if err := req.Validate(); err != nil { return Result{}, err } @@ -75,7 +78,9 @@ func (r *InProcessRunner) Run(ctx context.Context, workspace string, req Request notes := &memoryNotes{initial: req.Notes} captures := make(map[string][]json.RawMessage) - centralTools, err := BuildToolSet(r.tools, r.Limits.Options(workspaceToolset)) + toolOpts := r.Limits.Options(workspaceToolset) + toolOpts.OnToolCall = report + centralTools, err := BuildToolSet(r.tools, toolOpts) if err != nil { return Result{}, fmt.Errorf("build central tool set: %w", err) } diff --git a/internal/agentexec/inprocess_test.go b/internal/agentexec/inprocess_test.go index 3503e1f22..87abce07c 100644 --- a/internal/agentexec/inprocess_test.go +++ b/internal/agentexec/inprocess_test.go @@ -39,7 +39,7 @@ func TestInProcessRunnerMapsRequestAndCapturesOutput(t *testing.T) { Protection: Protection{Suffixes: []string{"_templ.go"}, Globs: []string{"*_test.go"}}, CaptureTools: []CaptureTool{{Name: "decide", Parameters: json.RawMessage(`{"type":"object"}`), MaxCalls: 1}}, } - got, err := runner.Run(context.Background(), "/workspace", req) + got, err := runner.Run(context.Background(), "/workspace", req, nil) if err != nil { t.Fatal(err) } @@ -89,7 +89,7 @@ func TestInProcessRunnerIncludesAvailableCentralTools(t *testing.T) { Stage: "build", Model: "provider/model", Mission: "mission", - }) + }, nil) if err != nil { t.Fatal(err) } @@ -121,7 +121,7 @@ func TestInProcessRunnerRejectsInvalidCentralToolSchemas(t *testing.T) { Stage: "build", Model: "provider/model", Mission: "mission", - }) + }, nil) if err == nil { t.Fatal("Run() error = nil, want invalid central tool schema error") } @@ -242,7 +242,7 @@ func TestInProcessRunnerPreservesCallerCancellation(t *testing.T) { } _, err := runner.Run(ctx, "/workspace", Request{ Version: ProtocolVersion, TaskID: 1, Attempt: 1, Stage: "build", Model: "provider/model", Mission: "mission", - }) + }, nil) if !errors.Is(err, context.Canceled) { t.Fatalf("Run error = %v, want context.Canceled", err) } diff --git a/internal/agentexec/nats.go b/internal/agentexec/nats.go index 3120e4d31..6d6247c8d 100644 --- a/internal/agentexec/nats.go +++ b/internal/agentexec/nats.go @@ -67,7 +67,10 @@ type NATSRunner struct { // Run publishes a stage execution request to JetStream with an X-Archie-Reply // header, blocks on the sync inbox subscription, and returns the result. -func (r *NATSRunner) Run(ctx context.Context, workspace string, req Request) (Result, error) { +// +// report is ignored: execution happens on whatever remote worker answers the +// request, a different process with no way to call back here per tool call. +func (r *NATSRunner) Run(ctx context.Context, workspace string, req Request, _ ToolCallReporter) (Result, error) { if err := req.Validate(); err != nil { return Result{}, err } diff --git a/internal/agentexec/nats_test.go b/internal/agentexec/nats_test.go index e7382e53c..a886e0a7f 100644 --- a/internal/agentexec/nats_test.go +++ b/internal/agentexec/nats_test.go @@ -18,7 +18,7 @@ import ( type mockRunner struct{} -func (m *mockRunner) Run(_ context.Context, _ string, req Request) (Result, error) { +func (m *mockRunner) Run(_ context.Context, _ string, req Request, _ ToolCallReporter) (Result, error) { return Result{ Version: ProtocolVersion, TaskID: req.TaskID, @@ -269,7 +269,7 @@ func TestNATSRunnerRoundTrip(t *testing.T) { Budget: Budget{MaxSteps: 5, MaxTokens: 100}, } - result, err := runner.Run(ctx, "/tmp/test-workspace", req) + result, err := runner.Run(ctx, "/tmp/test-workspace", req, nil) if err != nil { t.Fatal(err) } diff --git a/internal/agentexec/skill_test.go b/internal/agentexec/skill_test.go index ec8ec6775..dd958551d 100644 --- a/internal/agentexec/skill_test.go +++ b/internal/agentexec/skill_test.go @@ -13,7 +13,7 @@ type captureRunner struct { callback func(Request) } -func (c *captureRunner) Run(_ context.Context, _ string, req Request) (Result, error) { +func (c *captureRunner) Run(_ context.Context, _ string, req Request, _ ToolCallReporter) (Result, error) { c.callback(req) return Result{ Version: ProtocolVersion, diff --git a/internal/agentexec/subprocess.go b/internal/agentexec/subprocess.go index 924d13d7d..e0dbb5232 100644 --- a/internal/agentexec/subprocess.go +++ b/internal/agentexec/subprocess.go @@ -26,7 +26,9 @@ type SubprocessRunner struct { Providers map[string]Provider } -func (r *SubprocessRunner) Run(ctx context.Context, workspace string, req Request) (Result, error) { +// Run ignores report: the subprocess executes tools in its own process, so +// there is nothing here to observe a call as it happens. +func (r *SubprocessRunner) Run(ctx context.Context, workspace string, req Request, _ ToolCallReporter) (Result, error) { providerName, _, ok := strings.Cut(req.Model, "/") if !ok || providerName == "" { return Result{}, fmt.Errorf("agent model %q must be provider/model", req.Model) diff --git a/internal/agentexec/subprocess_test.go b/internal/agentexec/subprocess_test.go index f0c152d6e..481db2649 100644 --- a/internal/agentexec/subprocess_test.go +++ b/internal/agentexec/subprocess_test.go @@ -15,7 +15,7 @@ import ( func TestSubprocessRunnerRoundTrip(t *testing.T) { req := testRequest() - result, err := helperRunner("success").Run(context.Background(), "/workspace", req) + result, err := helperRunner("success").Run(context.Background(), "/workspace", req, nil) if err != nil { t.Fatal(err) } @@ -26,7 +26,7 @@ func TestSubprocessRunnerRoundTrip(t *testing.T) { func TestSubprocessRunnerReturnsStampedWorkerError(t *testing.T) { req := testRequest() - result, err := helperRunner("worker-error").Run(context.Background(), "/workspace", req) + result, err := helperRunner("worker-error").Run(context.Background(), "/workspace", req, nil) if err == nil || err.Error() != "provider unavailable" { t.Fatalf("error = %v", err) } @@ -38,7 +38,7 @@ func TestSubprocessRunnerReturnsStampedWorkerError(t *testing.T) { func TestSubprocessRunnerRejectsMalformedAndOversizedOutput(t *testing.T) { for _, behavior := range []string{"malformed", "oversized", "multiple", "mismatched"} { t.Run(behavior, func(t *testing.T) { - _, err := helperRunner(behavior).Run(context.Background(), "/workspace", testRequest()) + _, err := helperRunner(behavior).Run(context.Background(), "/workspace", testRequest(), nil) if err == nil { t.Fatal("Run succeeded") } @@ -47,7 +47,7 @@ func TestSubprocessRunnerRejectsMalformedAndOversizedOutput(t *testing.T) { } func TestSubprocessRunnerReportsExitDiagnostics(t *testing.T) { - _, err := helperRunner("exit").Run(context.Background(), "/workspace", testRequest()) + _, err := helperRunner("exit").Run(context.Background(), "/workspace", testRequest(), nil) if err == nil || !strings.Contains(err.Error(), "child diagnostic") { t.Fatalf("error = %v", err) } @@ -56,7 +56,7 @@ func TestSubprocessRunnerReportsExitDiagnostics(t *testing.T) { func TestSubprocessRunnerCancelsChild(t *testing.T) { ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) defer cancel() - _, err := helperRunner("hang").Run(ctx, "/workspace", testRequest()) + _, err := helperRunner("hang").Run(ctx, "/workspace", testRequest(), nil) if !errors.Is(err, context.DeadlineExceeded) { t.Fatalf("error = %v, want deadline exceeded", err) } @@ -69,7 +69,7 @@ func TestSubprocessRunnerCancellationKillsGrandchildren(t *testing.T) { runner.AdditionalEnv = append(runner.AdditionalEnv, "AGENT_HELPER_MARKER") ctx, cancel := context.WithTimeout(context.Background(), 50*time.Millisecond) defer cancel() - _, err := runner.Run(ctx, "/workspace", testRequest()) + _, err := runner.Run(ctx, "/workspace", testRequest(), nil) if !errors.Is(err, context.DeadlineExceeded) { t.Fatalf("error = %v, want deadline exceeded", err) } @@ -83,7 +83,7 @@ func TestSubprocessRunnerForwardsOnlyRequestedProvider(t *testing.T) { runner := helperRunner("provider-scope") runner.Environ = append(runner.Environ, "OTHER_KEY=must-not-leak") runner.Providers["other"] = Provider{Class: "openai", APIKeyEnv: "OTHER_KEY"} - if _, err := runner.Run(context.Background(), "/workspace", testRequest()); err != nil { + if _, err := runner.Run(context.Background(), "/workspace", testRequest(), nil); err != nil { t.Fatal(err) } } @@ -137,7 +137,7 @@ func TestServeOneWritesStampedExecutionError(t *testing.T) { } var output strings.Builder err = serveOne(context.Background(), strings.NewReader(string(input)), &output, func(Invocation) Runner { - return runnerFunc(func(_ context.Context, _ string, req Request) (Result, error) { + return runnerFunc(func(_ context.Context, _ string, req Request, _ ToolCallReporter) (Result, error) { return Result{ Version: ProtocolVersion, TaskID: req.TaskID, Attempt: req.Attempt, Stage: req.Stage, Status: StatusPassed, @@ -176,10 +176,10 @@ func helperRunner(behavior string) *SubprocessRunner { } } -type runnerFunc func(context.Context, string, Request) (Result, error) +type runnerFunc func(context.Context, string, Request, ToolCallReporter) (Result, error) -func (f runnerFunc) Run(ctx context.Context, workspace string, req Request) (Result, error) { - return f(ctx, workspace, req) +func (f runnerFunc) Run(ctx context.Context, workspace string, req Request, report ToolCallReporter) (Result, error) { + return f(ctx, workspace, req, report) } func testRequest() Request { diff --git a/internal/agentexec/toolset.go b/internal/agentexec/toolset.go index bce630c93..472687e94 100644 --- a/internal/agentexec/toolset.go +++ b/internal/agentexec/toolset.go @@ -83,6 +83,56 @@ type ToolSetOptions struct { // Nil means no approver is configured — such tools are omitted from the // built set rather than failing at call time. Approval tools.ApprovalRequester + + // OnToolCall, when non-nil, is notified once per completed tool call. + // InProcessRunner populates it so a workflow stage can surface tool + // activity on the task timeline (archie-core-467's task-transcript + // counterpart). Nil means no one is listening. + OnToolCall ToolCallReporter +} + +// ToolCallReport is one completed tool invocation, reported through a +// ToolCallReporter. +type ToolCallReport struct { + Tool string + // Detail is a clipped one-line summary: the tool's result, or + // "error: " if it failed. + Detail string + Failed bool +} + +// ToolCallReporter receives one ToolCallReport per completed tool call. Only +// a runner that executes in the same process as its tools can populate this +// -- SubprocessRunner and NATSRunner dispatch to a different process and have +// no visibility into individual calls from here. A nil reporter is valid and +// reports nothing. +type ToolCallReporter func(ToolCallReport) + +// toolCallDetailBytes caps the summary ToolCallReport.Detail carries. This +// rides on every task's observability event stream, so one large file read +// must not dominate it the way baselineMissionBytes-sized content is allowed +// to dominate a builder's own context. +const toolCallDetailBytes = 300 + +func clipToolCallDetail(s string) string { + if len(s) <= toolCallDetailBytes { + return s + } + return s[:toolCallDetailBytes] + "…" +} + +// reportToolCallCompletion notifies opts.OnToolCall, if set, of one +// completed call. Factored out of toolExecute's closure so the branching +// here doesn't add to that function's own cognitive-complexity budget. +func reportToolCallCompletion(opts ToolSetOptions, entry tools.ToolEntry, result string, err error) { + if opts.OnToolCall == nil { + return + } + outcome := result + if err != nil { + outcome = "error: " + err.Error() + } + opts.OnToolCall(ToolCallReport{Tool: entry.Name, Detail: clipToolCallDetail(outcome), Failed: err != nil}) } // resultLimit returns the cap that applies to one entry. @@ -194,7 +244,9 @@ func safeResolvedSchema(entry tools.ToolEntry) (schema tools.JSONSchema, err err // value would bound the wrong string. func toolExecute(entry tools.ToolEntry, opts ToolSetOptions) func(context.Context, string) (string, error) { limit := opts.resultLimit(entry) - return func(ctx context.Context, input string) (string, error) { + return func(ctx context.Context, input string) (result string, err error) { + defer func() { reportToolCallCompletion(opts, entry, result, err) }() + // A turn that has spent its budget must say so. Returning an error // tells the model it has run out; returning an empty result would // read as "the tool found nothing" and invite it to try again. diff --git a/internal/agentexec/toolset_test.go b/internal/agentexec/toolset_test.go index e65519425..aca243a25 100644 --- a/internal/agentexec/toolset_test.go +++ b/internal/agentexec/toolset_test.go @@ -87,6 +87,61 @@ func TestToolSetHandlerPropagatesHandlerError(t *testing.T) { } } +// TestToolSetReportsCompletedToolCalls pins archie-core-467's task-transcript +// counterpart: every tool invocation built through BuildToolSet must notify +// ToolSetOptions.OnToolCall exactly once, on both the success and failure +// path, so a workflow stage can surface it on the task timeline. +func TestToolSetReportsCompletedToolCalls(t *testing.T) { + tests := []struct { + name string + handler tools.Handler + wantFailed bool + wantDetail string + }{ + { + name: "success", + handler: func(context.Context, map[string]any) (any, error) { return "wrote 3 lines", nil }, + wantFailed: false, + wantDetail: `"wrote 3 lines"`, + }, + { + name: "failure", + handler: func(context.Context, map[string]any) (any, error) { return nil, errors.New("permission denied") }, + wantFailed: true, + wantDetail: "error: permission denied", + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + reg := tools.NewRegistry() + if err := reg.Register(tools.ToolEntry{Name: "write_file", Handler: tt.handler}); err != nil { + t.Fatal(err) + } + + var reports []ToolCallReport + set := mustBuildToolSetWith(t, reg, ToolSetOptions{ + OnToolCall: func(rep ToolCallReport) { reports = append(reports, rep) }, + }) + _, _ = set["write_file"].Execute(context.Background(), `{}`) + + if len(reports) != 1 { + t.Fatalf("OnToolCall was called %d times, want 1: %+v", len(reports), reports) + } + got := reports[0] + if got.Tool != "write_file" { + t.Errorf("Tool = %q, want %q", got.Tool, "write_file") + } + if got.Failed != tt.wantFailed { + t.Errorf("Failed = %v, want %v", got.Failed, tt.wantFailed) + } + if got.Detail != tt.wantDetail { + t.Errorf("Detail = %q, want %q", got.Detail, tt.wantDetail) + } + }) + } +} + func TestToolSetHandlerRejectsMalformedInput(t *testing.T) { reg := tools.NewRegistry() if err := reg.Register(tools.ToolEntry{ diff --git a/internal/agentexec/worker.go b/internal/agentexec/worker.go index d4a7e6194..4b42f702d 100644 --- a/internal/agentexec/worker.go +++ b/internal/agentexec/worker.go @@ -36,7 +36,7 @@ func serveOne(ctx context.Context, in io.Reader, out io.Writer, newRunner func(I if runner == nil { return fmt.Errorf("agent runner is not configured") } - result, runErr := runner.Run(ctx, invocation.Workspace, invocation.Request) + result, runErr := runner.Run(ctx, invocation.Workspace, invocation.Request, nil) response := Response{Version: ProtocolVersion, Result: result} if runErr != nil { response.Error = runErr.Error() @@ -57,6 +57,12 @@ 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. +// +// It passes a nil ToolCallReporter to every Run call: this path has no +// TaskContext and therefore no events.Bus to report through. The workflow +// engine's own AgentStage.Stage().Run (agent.go) is what wires a real +// reporter into tc.Emit; this entry point predates that and is not reached +// by workflow.Run. func HandleMessage(ctx context.Context, msg AgentRequestMessage, log *slog.Logger, newRunner RunnerFactory) (*AgentResponseEnvelope, error) { runner := newRunner(msg.Providers, log) if runner == nil { @@ -74,7 +80,7 @@ func HandleMessage(ctx context.Context, msg AgentRequestMessage, log *slog.Logge } // Single-stage mode (backward compatible). - result, runErr := runner.Run(ctx, msg.Workspace, msg.Request) + result, runErr := runner.Run(ctx, msg.Workspace, msg.Request, nil) resp := &AgentResponseEnvelope{ Version: msg.Request.Version, Result: result, @@ -100,7 +106,7 @@ func runStages(ctx context.Context, runner Runner, msg AgentRequestMessage, chan 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) + result, runErr := runner.Run(ctx, msg.Workspace, stage, nil) if runErr != nil { resp := &AgentResponseEnvelope{ Version: stage.Version, diff --git a/internal/app/agentworker/task_execution_test.go b/internal/app/agentworker/task_execution_test.go index 2a196f547..92c4477ee 100644 --- a/internal/app/agentworker/task_execution_test.go +++ b/internal/app/agentworker/task_execution_test.go @@ -30,7 +30,7 @@ import ( type panicRunner struct{ t *testing.T } -func (r panicRunner) Run(context.Context, string, agentexec.Request) (agentexec.Result, error) { +func (r panicRunner) Run(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) { r.t.Fatal("bootstrap workflow must not invoke an LLM runner") return agentexec.Result{}, nil } diff --git a/internal/daemon/daemon_test.go b/internal/daemon/daemon_test.go index 2219d5ec7..3994155a7 100644 --- a/internal/daemon/daemon_test.go +++ b/internal/daemon/daemon_test.go @@ -34,7 +34,7 @@ type cleanupStorage struct { type identityRunnerStub struct{} -func (*identityRunnerStub) Run(context.Context, string, agentexec.Request) (agentexec.Result, error) { +func (*identityRunnerStub) Run(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) { return agentexec.Result{}, nil } diff --git a/internal/domain/workflow/agent.go b/internal/domain/workflow/agent.go index ebf1c6df7..ce392a7ad 100644 --- a/internal/domain/workflow/agent.go +++ b/internal/domain/workflow/agent.go @@ -138,7 +138,7 @@ func (a AgentStage) Stage() Stage { CaptureTools: captureTools, Plugins: pluginSpecs(tc.SkillPlugins), } - res, err := tc.Agent.Run(ctx, tc.Dir, req) + res, err := tc.Agent.Run(ctx, tc.Dir, req, tc.toolCallReporter(a.Name)) // Record guardrail state: on success the guardrail engine checks // no-progress thresholds; on failure it records the error pattern. diff --git a/internal/domain/workflow/agent_test.go b/internal/domain/workflow/agent_test.go index 5bed34e89..bc284d3ed 100644 --- a/internal/domain/workflow/agent_test.go +++ b/internal/domain/workflow/agent_test.go @@ -9,9 +9,11 @@ import ( "reflect" "strings" "testing" + "time" "github.com/samcharles93/archie-core/internal/agentexec" "github.com/samcharles93/archie-core/internal/config" + "github.com/samcharles93/archie-core/internal/events" "github.com/samcharles93/archie-core/internal/store" ) @@ -20,17 +22,25 @@ type fakeAgentRunner struct { request agentexec.Request result agentexec.Result err error + // report is the reporter the caller passed to Run, captured so a test + // can invoke it directly and assert on the resulting tc.Emit call. + report agentexec.ToolCallReporter } -type agentRunnerFunc func(context.Context, string, agentexec.Request) (agentexec.Result, error) +type agentRunnerFunc func(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) -func (f agentRunnerFunc) Run(ctx context.Context, workspace string, req agentexec.Request) (agentexec.Result, error) { - return f(ctx, workspace, req) +func (f agentRunnerFunc) Run( + ctx context.Context, workspace string, req agentexec.Request, report agentexec.ToolCallReporter, +) (agentexec.Result, error) { + return f(ctx, workspace, req, report) } -func (r *fakeAgentRunner) Run(_ context.Context, workspace string, req agentexec.Request) (agentexec.Result, error) { +func (r *fakeAgentRunner) Run( + _ context.Context, workspace string, req agentexec.Request, report agentexec.ToolCallReporter, +) (agentexec.Result, error) { r.workspace = workspace r.request = req + r.report = report if r.result.Version == 0 { r.result.Version = agentexec.ProtocolVersion } @@ -83,6 +93,61 @@ func TestAgentStageBuildsExecutionRequestAndAppliesResult(t *testing.T) { } } +// TestAgentStageReportsToolCallsOnTheTaskBus pins archie-core-467's +// task-transcript counterpart: the reporter AgentStage.Stage() passes into +// tc.Agent.Run must, when invoked, publish a tool_call event onto tc.Bus +// carrying the tool name and outcome -- otherwise a workflow task's own +// transcript never shows what its tools actually did, only the chat +// gateway's interactive turns do. +func TestAgentStageReportsToolCallsOnTheTaskBus(t *testing.T) { + runner := &fakeAgentRunner{result: agentexec.Result{ + Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, + }} + stage := AgentStage{ + Name: "build", + Role: "builder", + Mission: func(*TaskContext) string { return "implement the feature" }, + }.Stage() + + bus := events.NewBus() + sub := bus.Subscribe(8) + t.Cleanup(sub.Close) + + task := &store.Task{ID: 9, Owner: "acme", Repo: "widget", Attempt: 1} + tc := &TaskContext{ + Task: task, Agent: runner, Dir: "/tmp/workspace", Bus: bus, Log: slog.New(slog.DiscardHandler), + Cfg: config.Config{Models: map[string]string{"builder": "provider/model"}}, + } + if err := stage.Run(context.Background(), tc); err != nil { + t.Fatal(err) + } + + if runner.report == nil { + t.Fatal("AgentStage did not pass a ToolCallReporter to Run") + } + runner.report(agentexec.ToolCallReport{Tool: "read_file", Detail: `"package main"`, Failed: false}) + runner.report(agentexec.ToolCallReport{Tool: "shell", Detail: "error: exit status 1", Failed: true}) + + var got []events.Event + for len(got) < 2 { + select { + case e := <-sub.C: + if e.Kind == events.KindToolCall { + got = append(got, e) + } + case <-time.After(time.Second): + t.Fatalf("timed out waiting for tool_call events, got %d", len(got)) + } + } + + if got[0].Stage != "build" || got[0].Data["tool"] != "read_file" || got[0].Detail != `"package main"` || got[0].Data["failed"] != false { + t.Fatalf("first tool_call event = %#v", got[0]) + } + if got[1].Data["tool"] != "shell" || got[1].Detail != "error: exit status 1" || got[1].Data["failed"] != true { + t.Fatalf("second tool_call event = %#v", got[1]) + } +} + func TestAgentStagePersistsReturnedNotes(t *testing.T) { st, err := store.Open(t.Context(), filepath.Join(t.TempDir(), "archie.db")) if err != nil { @@ -122,7 +187,7 @@ func TestAgentStagePersistsReturnedNotes(t *testing.T) { func TestAgentStageDiscardsUnstampedErrorResult(t *testing.T) { task := &store.Task{ID: 1, Attempt: 1, Notes: "existing\n"} - runner := agentRunnerFunc(func(context.Context, string, agentexec.Request) (agentexec.Result, error) { + runner := agentRunnerFunc(func(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) { return agentexec.Result{AppendedNotes: []string{"untrusted"}}, errors.New("worker exited") }) stage := AgentStage{ diff --git a/internal/domain/workflow/implement.go b/internal/domain/workflow/implement.go index 18f308c5d..85997f8ce 100644 --- a/internal/domain/workflow/implement.go +++ b/internal/domain/workflow/implement.go @@ -81,7 +81,7 @@ func StageBaselineGate() Stage { Protection: agentexec.Protection{Suffixes: append([]string(nil), tc.Repo.Protect...)}, } - res, agentErr := tc.Agent.Run(ctx, tc.Dir, req) + res, agentErr := tc.Agent.Run(ctx, tc.Dir, req, tc.toolCallReporter("baseline-fix")) if agentErr != nil { return fmt.Errorf("baseline-fix agent run: %w", agentErr) } diff --git a/internal/domain/workflow/implement_test.go b/internal/domain/workflow/implement_test.go index 44bf691bb..aba68383d 100644 --- a/internal/domain/workflow/implement_test.go +++ b/internal/domain/workflow/implement_test.go @@ -163,7 +163,7 @@ func TestStageCommitPushDoesNotUseSyntheticIssueForChatNoOp(t *testing.T) { // alwaysFailingRunner reports the gate as unfixable, so StageBaselineGate // falls through to its terminal error without needing a real agent loop. -var alwaysFailingRunner = agentRunnerFunc(func(context.Context, string, agentexec.Request) (agentexec.Result, error) { +var alwaysFailingRunner = agentRunnerFunc(func(context.Context, string, agentexec.Request, agentexec.ToolCallReporter) (agentexec.Result, error) { return agentexec.Result{Status: "failed"}, nil }) diff --git a/internal/domain/workflow/workflow.go b/internal/domain/workflow/workflow.go index 57404501e..221a42df3 100644 --- a/internal/domain/workflow/workflow.go +++ b/internal/domain/workflow/workflow.go @@ -119,6 +119,20 @@ func (tc *TaskContext) Emit(kind, stage, detail string, data map[string]any) { }) } +// toolCallReporter builds the agentexec.ToolCallReporter an agent stage +// passes to tc.Agent.Run, so every completed tool call during that run +// surfaces as a tool_call event on the task timeline (archie-core-467's +// task-transcript counterpart -- the interactive chat gateway has its own, +// separate ToolCallEvent). Safe to call on a nil Bus: Emit no-ops. +func (tc *TaskContext) toolCallReporter(stage string) agentexec.ToolCallReporter { + return func(report agentexec.ToolCallReport) { + tc.Emit(events.KindToolCall, stage, report.Detail, map[string]any{ + "tool": report.Tool, + "failed": report.Failed, + }) + } +} + // Outcome is a stage's terminal decision for the whole workflow. Stages // that don't end the workflow leave it zero. type Outcome struct { diff --git a/internal/events/events.go b/internal/events/events.go index 8c3f4229f..daba60820 100644 --- a/internal/events/events.go +++ b/internal/events/events.go @@ -16,11 +16,17 @@ const ( KindStageStart = "stage_start" KindStageFinish = "stage_finish" // data: duration_ms, error KindAgentFinish = "agent_finish" // data: status, stop_reason, tokens, iterations, model - KindParked = "parked" // data: reason - KindOutcome = "outcome" // data: status, detail - KindPRMerged = "pr_merged" - KindPRRejected = "pr_rejected" - KindTaskDead = "task_dead" + // KindToolCall marks one completed tool invocation during an agent + // stage run (archie-core-467's task-transcript counterpart -- the + // interactive chat gateway surfaces its own tool calls separately via + // gateway.ToolCallEvent). Only emitted for runners that execute in the + // same process as their tools; see agentexec.ToolCallReporter. + KindToolCall = "tool_call" // data: tool, failed + KindParked = "parked" // data: reason + KindOutcome = "outcome" // data: status, detail + KindPRMerged = "pr_merged" + KindPRRejected = "pr_rejected" + KindTaskDead = "task_dead" // Operator actions taken from the dashboard. Without these an // intervention is recorded in the tasks table but invisible on the // timeline and the activity stream -- the one kind of event most worth