feat(workflow): declared workflow outputs for wait:true callers

A workflow declares named, typed outputs beside its inputs
(task.WorkflowInterface.Outputs). A run writes each one once through a
capture tool named after the output, or from a deterministic Go stage via
TaskContext.WriteOutput; the finish write persists them on tasks.outputs
before the outcome transition. A wait:true caller receives its successful
callee's outputs through WorkflowCallStatus and publishes one as its own
through a call step's outputs assignment.

Build authority: docs/prds/workflow-call-outputs.md.

- save time: WorkflowInterface.Validate checks output names and types;
  checkCallOutputs checks a call's assignment against both declarations
  and refuses outputs over a wait:false call.
- run time: undeclared, mistyped and required-but-missing values park the
  run; published callee values are re-checked against the caller's type.
- storage/wire: tasks.outputs (goose 0024), reset by each claim so the set
  is attempt-scoped; an encoded set past the structured-payload bound is
  refused, not clipped. Task.outputs_json and
  WorkflowCallStatusResponse.outputs_json carry it; task.Caller keeps its
  two methods.
- examples: firewall-contain calls firewall-investigate and publishes its
  summary as its own output.
This commit is contained in:
sam committed 2026-10-02 02:09:03 +10:00
1 parent e190e58c3d
commit 4afefe087e
29 files changed
+1381 -82

No files matched your search

+28
View File
@@ -0,0 +1,28 @@
# The containment workflow a firewall-investigate run calls:
# firewall-investigate (workflow.call, wait: true) hands its findings upward
# from its declared summary, and this workflow's own agent stage decides and
# records the containment as its own declared outputs. Paste it into the
# dashboard's workflow definitions alongside firewall-investigate
# (docs/prds/workflow-call-outputs.md).
id: firewall-contain
repository: none
profile: network-investigator
inputs:
src_ip: { type: string, required: true }
outputs:
contained: { type: bool, required: true }
summary: { type: string }
steps:
- type: workflow.call
settings:
workflow: firewall-investigate
wait: true
inputs: { src_ip: "inputs.src_ip" }
outputs: { summary: "outputs.summary" }
- type: agent.run
settings:
mission: >-
Using the investigation summary the called workflow returned, decide
whether the source address in the inputs should be contained. Write
your decision with the contained tool, and a one-line rationale with
the summary tool.
+8 -1
View File
@@ -2,17 +2,24 @@
# src_ip from a mapped parameter and runs one agent mission in a scratch
# workspace under the network-investigator profile. Paste it into the
# dashboard's workflow definitions.
#
# Its declared output (summary) is offered to the agent stages as a capture
# tool named after it; a wait:true caller publishes it as one of its own
# outputs (docs/prds/workflow-call-outputs.md).
id: firewall-investigate
repository: none
profile: network-investigator
inputs:
src_ip: { type: string, required: true }
severity: { type: string }
outputs:
summary: { type: string }
steps:
- type: agent.run
settings:
mission: >-
Investigate the source address in the inputs: who owns it, what it
resolves to, and whether it is reachable. Report what you found and
how serious it looks given the severity.
how serious it looks given the severity, and write your one-line
conclusion with the summary tool.
read_only: true
+34 -7
View File
@@ -1336,8 +1336,14 @@ type Task struct {
// writer reads as a depth-0 root run.
CallParentTaskId int64 `protobuf:"varint,36,opt,name=call_parent_task_id,json=callParentTaskId,proto3" json:"call_parent_task_id,omitempty"`
CallDepth int32 `protobuf:"varint,37,opt,name=call_depth,json=callDepth,proto3" json:"call_depth,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
// outputs_json is the JSON object of declared-output values this run wrote
// (task.EncodeOutputs), empty for a run that wrote none. The container's
// Update sends the whole row, so a column the message cannot carry is a
// column that write drops (docs/prds/workflow-call-outputs.md, "Storage and
// wire").
OutputsJson string `protobuf:"bytes,38,opt,name=outputs_json,json=outputsJson,proto3" json:"outputs_json,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Task) Reset() {
@@ -1630,6 +1636,13 @@ func (x *Task) GetCallDepth() int32 {
return 0
}
func (x *Task) GetOutputsJson() string {
if x != nil {
return x.OutputsJson
}
return ""
}
// Event mirrors internal/events.Event. Data is carried as a JSON object
// string (matching the store's own on-disk representation) rather than
// google.protobuf.Struct, to stay a direct mirror of the existing column.
@@ -10221,9 +10234,13 @@ func (x *WorkflowCallStatusRequest) GetCallTaskId() int64 {
type WorkflowCallStatusResponse struct {
state protoimpl.MessageState `protogen:"open.v1"`
// status is the callee's task status and detail its latest transition
// detail (empty before the callee first moves).
// detail (empty before the callee first moves). outputs_json is the
// callee's written outputs (task.EncodeOutputs), so a wait:true caller can
// publish one as its own (docs/prds/workflow-call-outputs.md, "Storage and
// wire").
Status string `protobuf:"bytes,1,opt,name=status,proto3" json:"status,omitempty"`
Detail string `protobuf:"bytes,2,opt,name=detail,proto3" json:"detail,omitempty"`
OutputsJson string `protobuf:"bytes,3,opt,name=outputs_json,json=outputsJson,proto3" json:"outputs_json,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
@@ -10272,6 +10289,13 @@ func (x *WorkflowCallStatusResponse) GetDetail() string {
return ""
}
func (x *WorkflowCallStatusResponse) GetOutputsJson() string {
if x != nil {
return x.OutputsJson
}
return ""
}
type InstalledPackage struct {
state protoimpl.MessageState `protogen:"open.v1"`
OrgId string `protobuf:"bytes,1,opt,name=org_id,json=orgId,proto3" json:"org_id,omitempty"`
@@ -11939,7 +11963,8 @@ const file_state_v1_state_proto_rawDesc = "" +
"\asubject\x18\x03 \x01(\tR\asubject\x12-\n" +
"\x05audit\x18\x04 \x01(\v2\x17.state.v1.IdentityAuditR\x05audit\"M\n" +
"\x1bBindIdentitySubjectResponse\x12.\n" +
"\bidentity\x18\x01 \x01(\v2\x12.state.v1.IdentityR\bidentity\"\xde\t\n" +
"\bidentity\x18\x01 \x01(\v2\x12.state.v1.IdentityR\bidentity\"\x81\n" +
"\n" +
"\x04Task\x12\x0e\n" +
"\x02id\x18\x01 \x01(\x03R\x02id\x12\x14\n" +
"\x05owner\x18\x02 \x01(\tR\x05owner\x12\x12\n" +
@@ -11989,7 +12014,8 @@ const file_state_v1_state_proto_rawDesc = "" +
"\x03org\x18# \x01(\tR\x03org\x12-\n" +
"\x13call_parent_task_id\x18$ \x01(\x03R\x10callParentTaskId\x12\x1d\n" +
"\n" +
"call_depth\x18% \x01(\x05R\tcallDepth\"\xf8\x02\n" +
"call_depth\x18% \x01(\x05R\tcallDepth\x12!\n" +
"\foutputs_json\x18& \x01(\tR\voutputsJson\"\xf8\x02\n" +
"\x05Event\x12\x0e\n" +
"\x02id\x18\x01 \x01(\x03R\x02id\x12*\n" +
"\x02at\x18\x02 \x01(\v2\x1a.google.protobuf.TimestampR\x02at\x12\x12\n" +
@@ -12541,10 +12567,11 @@ const file_state_v1_state_proto_rawDesc = "" +
"\x19WorkflowCallStatusRequest\x12$\n" +
"\x0ecaller_task_id\x18\x01 \x01(\x03R\fcallerTaskId\x12 \n" +
"\fcall_task_id\x18\x02 \x01(\x03R\n" +
"callTaskId\"L\n" +
"callTaskId\"o\n" +
"\x1aWorkflowCallStatusResponse\x12\x16\n" +
"\x06status\x18\x01 \x01(\tR\x06status\x12\x16\n" +
"\x06detail\x18\x02 \x01(\tR\x06detail\"\xa2\x02\n" +
"\x06detail\x18\x02 \x01(\tR\x06detail\x12!\n" +
"\foutputs_json\x18\x03 \x01(\tR\voutputsJson\"\xa2\x02\n" +
"\x10InstalledPackage\x12\x15\n" +
"\x06org_id\x18\x01 \x01(\tR\x05orgId\x12\x12\n" +
"\x04name\x18\x02 \x01(\tR\x04name\x12\x1c\n" +
+13 -3
View File
@@ -70,7 +70,10 @@ func (a AgentStage) Stage() Stage {
if err != nil {
return err
}
req := a.buildRequest(tc, modelRef)
req, buildErr := a.buildRequest(tc, modelRef)
if buildErr != nil {
return buildErr
}
// The agent call is a child of the stage's recorded step: the store
// says what the stage's runtime did, not just what the stage did.
res, runErr := tc.RunAgentChild(ctx, a.Name, func() (agentexec.Result, error) {
@@ -94,7 +97,7 @@ func (a AgentStage) resolveModel(tc *TaskContext) (string, error) {
}
// buildRequest assembles the agentexec.Request for this stage's run.
func (a AgentStage) buildRequest(tc *TaskContext, modelRef string) agentexec.Request {
func (a AgentStage) buildRequest(tc *TaskContext, modelRef string) (agentexec.Request, error) {
budget := agentexec.Budget{
MaxSteps: tc.Cfg.Budgets.MaxSteps,
WallClock: tc.Cfg.Budgets.WallClock.Std(),
@@ -111,6 +114,10 @@ func (a AgentStage) buildRequest(tc *TaskContext, modelRef string) agentexec.Req
if a.CaptureTools != nil {
captureTools = a.CaptureTools(tc)
}
captureTools, err := tc.appendOutputTools(captureTools)
if err != nil {
return agentexec.Request{}, err
}
protection := agentexec.Protection{Suffixes: append([]string(nil), tc.Repo.Protect...)}
if a.ProtectGlobs != nil {
@@ -146,7 +153,7 @@ func (a AgentStage) buildRequest(tc *TaskContext, modelRef string) agentexec.Req
Notes: tc.Task.Notes,
CaptureTools: captureTools,
Plugins: pluginSpecs(tc.SkillPlugins),
}
}, nil
}
// buildExtraRules prepends memory context, if the daemon wired a memory
@@ -236,6 +243,9 @@ func (a AgentStage) deliverResult(tc *TaskContext, res agentexec.Result) error {
return fmt.Errorf("review: %w", err)
}
}
if err := tc.applyOutputCaptures(res); err != nil {
return err
}
if a.OnResult != nil {
return a.OnResult(tc, res)
}
+13 -1
View File
@@ -5,6 +5,7 @@ import (
"encoding/json"
"fmt"
"log/slog"
"maps"
"os"
"path/filepath"
"strings"
@@ -25,6 +26,8 @@ type recordingStore struct {
transitions []transition
steps []StepStart
finishes []StepFinish
updates []Task
sequence []string
insertEr error
stepEr error
finishEr error
@@ -37,10 +40,19 @@ type recordingStore struct {
// never parks the task" a test rather than a reading of the code.
type transition struct{ from, to, detail string }
func (s *recordingStore) Update(context.Context, *Task) error { return nil }
func (s *recordingStore) Update(_ context.Context, t *Task) error {
clone := *t
outputs := make(map[string]any, len(t.Outputs))
maps.Copy(outputs, t.Outputs)
clone.Outputs = outputs
s.updates = append(s.updates, clone)
s.sequence = append(s.sequence, "update")
return nil
}
func (s *recordingStore) Transition(_ context.Context, _ int64, from, to, detail string) error {
s.transitions = append(s.transitions, transition{from: from, to: to, detail: detail})
s.sequence = append(s.sequence, "transition:"+to)
return nil
}
+1 -1
View File
@@ -87,7 +87,7 @@ func Compile(definition YAMLDefinition, registry StepRegistry) (Workflow, error)
}
stages = append(stages, stage)
}
return Workflow{Name: definition.ID, Stages: stages}, nil
return Workflow{Name: definition.ID, Stages: stages, Interface: definition.WorkflowInterface}, nil
}
// ParseAndCompile validates and compiles one definition in a single operation.
+226
View File
@@ -0,0 +1,226 @@
package workflow
import (
"encoding/json"
"fmt"
"maps"
"slices"
"strings"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
)
// Declared workflow outputs: how a run writes one and how a wait:true caller
// publishes one (docs/prds/workflow-call-outputs.md). A run's only structured
// results are capture calls, so declared outputs ride the capture path: each
// is offered to the run's agent stages as a capture tool named after it, and
// the engine applies, validates, publishes and persists the accepted values.
// workflowInterface is the declaration the run's compiled workflow carries
// (Workflow.Interface, set by Run); a stage body invoked outside Run falls
// back to the pinned definition's YAML, which the pin guarantees matches the
// compile the request came from.
func (tc *TaskContext) workflowInterface() task.WorkflowInterface {
if tc.runInterfaceSet {
return tc.runInterface
}
if tc.ifaceParsed == nil {
parsed, err := task.ParseWorkflowInterface(tc.Task.WorkflowDefinitionYAML)
if err != nil {
// The pinned YAML was validated when the definition was saved, so
// a parse failure here cannot be a definition the engine accepts;
// an empty interface keeps such a run output-less.
parsed = task.WorkflowInterface{}
tc.Log.Warn("pinned workflow definition does not parse for outputs; ignoring declared outputs", "err", err)
}
tc.ifaceParsed = &parsed
}
return *tc.ifaceParsed
}
// WriteOutput records one declared output's value for this attempt: the path
// a deterministic Go stage takes. An undeclared key, a mistyped value or a
// second write is refused, and the refusing error parks the run before its
// outcome transition.
func (tc *TaskContext) WriteOutput(name string, value any) error {
spec, ok := tc.workflowInterface().Outputs[name]
if !ok {
return fmt.Errorf("output %q is not declared by the workflow", name)
}
if _, written := tc.Task.Outputs[name]; written {
return fmt.Errorf("output %q has already been written; each output is written once per attempt", name)
}
if value != nil {
if got := task.ValueType(value); !task.TypeAccepts(spec.Type, got) {
return fmt.Errorf("output %q is %s, want %s", name, got, spec.Type)
}
}
if tc.Task.Outputs == nil {
tc.Task.Outputs = map[string]any{}
}
tc.Task.Outputs[name] = value
return nil
}
// outputCaptureTool builds the capture tool one declared output is offered
// as: named after the output, whose arguments are {"value": ...}, with the
// declared type as the value's schema. The schema guides the agent; the
// run-time re-check is what enforces.
func outputCaptureTool(name string, spec task.OutputSpec) agentexec.CaptureTool {
value := map[string]any{"description": fmt.Sprintf("The value of the %q output.", name)}
if typ := jsonSchemaType(spec.Type); typ != "" {
value["type"] = typ
}
params, err := json.Marshal(map[string]any{
"type": "object",
"properties": map[string]any{"value": value},
"required": []string{"value"},
})
if err != nil {
// A fixed-shape map cannot fail to marshal. Keep the call acceptable
// through RequiredFields alone if it ever did.
params = []byte(`{"type":"object"}`)
}
return agentexec.CaptureTool{
Name: name,
Description: fmt.Sprintf("Write the workflow output %q. Call exactly once, with the value as the value argument.", name),
Parameters: params,
// The value member is required, but a null value counts as not written
// (there is nothing to reject: the run simply does not write it).
RequiredFields: []string{"value"},
MaxCalls: 1,
}
}
// jsonSchemaType maps the workflow value vocabulary onto JSON Schema's type
// names. "any" has no constraint, so it yields no type at all -- an empty
// string, never a null that is not a valid JSON Schema type.
func jsonSchemaType(vocab string) string {
switch vocab {
case "string", "number", "object", "array":
return vocab
case "bool":
return "boolean"
default: // "any"
return ""
}
}
// appendOutputTools offers the declared outputs the run has not written yet
// to this stage as capture tools, refusing a stage capture tool that shares a
// declared output's name: the value would otherwise be ambiguous.
func (tc *TaskContext) appendOutputTools(tools []agentexec.CaptureTool) ([]agentexec.CaptureTool, error) {
iface := tc.workflowInterface()
for _, tool := range tools {
if _, clash := iface.Outputs[tool.Name]; clash {
return nil, fmt.Errorf("output %q is also a stage capture tool's name; a declared output is written through its own tool", tool.Name)
}
}
for _, name := range slices.Sorted(maps.Keys(iface.Outputs)) {
// A stage is not offered an output the run has written.
if _, already := tc.Task.Outputs[name]; already {
continue
}
tools = append(tools, outputCaptureTool(name, iface.Outputs[name]))
}
return tools, nil
}
// applyOutputCaptures applies the declared-output capture calls a passed
// agent result carries: the accepted call's value member is the output's
// value, re-validated against the declared type the way readCaptures
// re-checks every record, before it enters the run's set.
func (tc *TaskContext) applyOutputCaptures(res agentexec.Result) error {
iface := tc.workflowInterface()
for name, calls := range res.Captures {
spec, ok := iface.Outputs[name]
if !ok {
// Every other capture tool is the stage's own; its OnResult owns
// its records.
continue
}
for _, call := range calls {
value, written, err := decodeCapturedOutput(call)
if err != nil {
return fmt.Errorf("output %q: %w", name, err)
}
if !written {
continue
}
if got := task.ValueType(value); !task.TypeAccepts(spec.Type, got) {
return fmt.Errorf("output %q is %s, want %s", name, got, spec.Type)
}
if _, written := tc.Task.Outputs[name]; written {
return fmt.Errorf("output %q has already been written; each output is written once per attempt", name)
}
if tc.Task.Outputs == nil {
tc.Task.Outputs = map[string]any{}
}
tc.Task.Outputs[name] = value
}
}
return nil
}
// decodeCapturedOutput reads one accepted capture call's value member. A call
// with no value, or a null value, counts as not written, as CheckInputs
// treats a null input.
func decodeCapturedOutput(call json.RawMessage) (value any, written bool, err error) {
var args struct {
Value json.RawMessage `json:"value"`
}
if err := json.Unmarshal(call, &args); err != nil {
return nil, false, err
}
if len(args.Value) == 0 || string(args.Value) == "null" {
return nil, false, nil
}
decoder := json.NewDecoder(strings.NewReader(string(args.Value)))
decoder.UseNumber()
if err := decoder.Decode(&value); err != nil {
return nil, false, err
}
return value, true, nil
}
// validateFinishOutputs checks the attempt's written outputs before the
// outcome transition: required, undeclared and mistyped values park here, so
// no caller observes a terminal state that breaks the run's own promise.
func (tc *TaskContext) validateFinishOutputs() error {
return tc.workflowInterface().CheckOutputs(tc.Task.Outputs)
}
// publishCalleeOutputs publishes a successful callee's outputs the call step
// assigns into the caller's own set. An output the callee never wrote leaves
// the caller's output absent -- the caller's own required judgment decides; a
// written null counts as not written; a value whose type the caller's declared
// output cannot accept is refused, naming the output.
func (tc *TaskContext) publishCalleeOutputs(assignments map[string]string, calleeOutputs map[string]any) error {
if len(assignments) == 0 {
return nil
}
iface := tc.workflowInterface()
for _, calleeName := range slices.Sorted(maps.Keys(assignments)) {
ref := assignments[calleeName]
callerName := strings.TrimPrefix(ref, outputReference)
spec, ok := iface.Outputs[callerName]
if !ok {
// The save check refuses an undeclared reference; this re-check
// keeps a swapped callee from publishing into nothing.
return fmt.Errorf("output %q references %q, which this workflow does not declare", calleeName, ref)
}
value, ok := calleeOutputs[calleeName]
if !ok || value == nil {
// Declared but never written: the caller's output stays absent.
continue
}
if got := task.ValueType(value); !task.TypeAccepts(spec.Type, got) {
return fmt.Errorf("callee output %q is %s, which this workflow's output %q (%s) cannot accept", calleeName, got, callerName, spec.Type)
}
if err := tc.WriteOutput(callerName, value); err != nil {
return err
}
}
return nil
}
+269
View File
@@ -0,0 +1,269 @@
package workflow
import (
"context"
"encoding/json"
"log/slog"
"slices"
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/agentexec"
"github.com/samcharles93/archie-core/internal/config"
"github.com/samcharles93/archie-core/internal/domain/workflow/task"
)
// outputsRunYAML is the smallest workflow with a declared output: one agent
// stage under repository none.
const outputsRunYAML = "id: w\nrepository: none\noutputs:\n verdict: {type: bool, required: true}\n summary: {type: string}\nsteps:\n - type: agent.run\n settings:\n mission: m\n"
// outputsTC returns a TaskContext wired like the runtime tests, with the
// workflow's own YAML pinned on the task row.
func outputsTC(t *testing.T, yaml string, store Store, agent agentexec.Runner) *TaskContext {
t.Helper()
return &TaskContext{
Task: &Task{ID: 3, Attempt: 1, WorkflowDefinitionYAML: yaml},
Store: store, Trees: &fakeTrees{dir: "/scratch/3"}, Agent: agent,
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
Log: slog.New(slog.DiscardHandler),
}
}
// outputCaptureResult builds a passed agent result carrying one accepted capture
// call for the output tool named name.
func outputCaptureResult(name string, args ...string) agentexec.Result {
captures := map[string][]json.RawMessage{}
for _, raw := range args {
captures[name] = append(captures[name], json.RawMessage(raw))
}
return agentexec.Result{Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, Summary: "done", Captures: captures}
}
// TestRunOffersOutputsAsCaptureToolsAndAppliesThem pins the agent write path
// (docs/prds/workflow-call-outputs.md, "How a run writes one"): each declared
// output is a capture tool named after it with a {"value": ...} argument, and
// an accepted call enters the run's output set, which the finish write
// persists into the row before the outcome transition.
func TestRunOffersOutputsAsCaptureToolsAndAppliesThem(t *testing.T) {
wf := compileCaller(t, outputsRunYAML)
runner := &fakeAgentRunner{result: outputCaptureResult("verdict", `{"value": true}`)}
store := &recordingStore{}
tc := outputsTC(t, outputsRunYAML, store, runner)
Run(context.Background(), wf, tc)
var offered bool
for _, tool := range runner.request.CaptureTools {
if tool.Name == "verdict" {
offered = true
if tool.MaxCalls != 1 {
t.Errorf("verdict tool MaxCalls = %d, want 1: each output is written once per attempt", tool.MaxCalls)
}
if !slicesContains(tool.RequiredFields, "value") {
t.Errorf("verdict tool RequiredFields = %v, want [value]", tool.RequiredFields)
}
if !strings.Contains(string(tool.Parameters), `"value"`) {
t.Errorf("verdict tool parameters = %s, want a value argument", tool.Parameters)
}
}
}
if !offered {
t.Fatalf("CaptureTools = %+v, want a tool named for the declared output", runner.request.CaptureTools)
}
if got := tc.Task.Outputs["verdict"]; got != true {
t.Fatalf("run outputs = %+v, want {verdict: true} with bool restored", tc.Task.Outputs)
}
// The finish write replaces the row's set wholesale before the outcome
// transition carries the value to any caller.
if len(store.updates) == 0 {
t.Fatal("the run never persisted its row")
}
lastUpdate := store.updates[len(store.updates)-1]
if lastUpdate.Outputs["verdict"] != true {
t.Fatalf("row outputs = %+v, want the written verdict", lastUpdate.Outputs)
}
if seq := updatesBeforeTransition(store.sequence, "completed"); seq == -1 {
t.Fatalf("sequence = %v, want an update before the completed transition", store.sequence)
} else if store.updates[seq].Outputs["verdict"] != true {
t.Fatalf("update %d outputs = %+v, want the written verdict persisted before the transition", seq, store.updates[seq].Outputs)
}
}
// TestWrittenOutputIsNotOfferedToALaterStage pins the once-per-attempt rule:
// a stage is not offered an output the run has written, so a later stage
// cannot overwrite a value.
func TestWrittenOutputIsNotOfferedToALaterStage(t *testing.T) {
yaml := string(append([]byte("id: w\nrepository: none\noutputs:\n verdict: {type: bool}\nsteps:\n"), []byte(" - type: agent.run\n settings:\n mission: first\n - type: agent.run\n settings:\n mission: second\n")...))
wf := compileCaller(t, yaml)
var offered []bool
agent := agentRunnerFunc(func(_ context.Context, _ string, req agentexec.Request, _ agentexec.ToolCallReporter) (agentexec.Result, error) {
for _, tool := range req.CaptureTools {
if tool.Name == "verdict" {
offered = append(offered, true)
}
}
return agentexec.Result{Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, Summary: "ok"}, nil
})
tc := outputsTC(t, yaml, &recordingStore{}, agent)
Run(context.Background(), wf, tc)
if len(offered) != 1 {
t.Fatalf("verdict tool offered %d times (%v), want exactly once across the run's stages", len(offered), offered)
}
}
// TestCapturedOutputIsReValidated pins the run-time type check: a captured
// value is re-validated against the declared type when the run reads it
// back, and a null counts as not written.
func TestCapturedOutputIsReValidated(t *testing.T) {
t.Run("mistyped capture parks naming the output", func(t *testing.T) {
wf := compileCaller(t, outputsRunYAML)
store := &recordingStore{}
agent := &fakeAgentRunner{result: outputCaptureResult("verdict", `{"value": "yes"}`)}
tc := outputsTC(t, outputsRunYAML, store, agent)
Run(context.Background(), wf, tc)
if tc.Outcome.Status == StatusCompleted && !strings.Contains(tc.Task.ParkReason, `output "verdict" is string, want bool`) {
t.Fatalf("park reason %q, want the mistyped output named; outcome %+v", tc.Task.ParkReason, tc.Outcome)
}
})
t.Run("null capture counts as not written", func(t *testing.T) {
yaml := "id: w\nrepository: none\noutputs:\n summary: {type: string}\nsteps:\n - type: agent.run\n settings:\n mission: m\n"
wf := compileCaller(t, yaml)
store := &recordingStore{}
agent := &fakeAgentRunner{result: outputCaptureResult("summary", `{"value": null}`)}
tc := outputsTC(t, yaml, store, agent)
Run(context.Background(), wf, tc)
if tc.Outcome.Status != StatusCompleted {
t.Fatalf("outcome = %+v, want completed (the optional output stayed absent)", tc.Outcome)
}
if _, written := tc.Task.Outputs["summary"]; written {
t.Fatalf("run outputs = %+v, want the null write to count as not written", tc.Task.Outputs)
}
})
}
// TestRequiredOutputNeverWrittenParks pins the promise rule: a run whose
// required output is never written parks naming the output, reaching no
// successful terminal state (docs/prds/workflow-call-outputs.md, "Failure
// rules").
func TestRequiredOutputNeverWrittenParks(t *testing.T) {
wf := compileCaller(t, outputsRunYAML)
store := &recordingStore{}
agent := &fakeAgentRunner{result: agentexec.Result{Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, Summary: "done"}}
tc := outputsTC(t, outputsRunYAML, store, agent)
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, `output "verdict" is required`) {
t.Fatalf("park reason %q, want the missing required output named", tc.Task.ParkReason)
}
if len(store.transitions) == 0 || store.transitions[len(store.transitions)-1].to != StatusParked {
t.Fatalf("transitions = %+v, want the run parked rather than reaching a terminal state", store.transitions)
}
}
// TestGoStageOutputRules pins the deterministic Go path: a stage sets the
// same values through WriteOutput, which refuses an undeclared key, a
// mistyped value and a second write; a key a stage bypasses it with parks at
// the finish check, identically to a captured one.
func TestGoStageOutputRules(t *testing.T) {
iface := task.WorkflowInterface{Outputs: map[string]task.OutputSpec{
"verdict": {Type: "bool"},
"note": {Type: "string"},
}}
tc := &TaskContext{Task: &Task{ID: 1, WorkflowDefinitionYAML: "id: w\noutputs:\n verdict: {type: bool}\n"}}
tc.runInterface, tc.runInterfaceSet = iface, true
if err := tc.WriteOutput("verdict", true); err != nil {
t.Fatalf("WriteOutput(verdict) = %v, want nil", err)
}
if got := tc.Task.Outputs["verdict"]; got != true {
t.Fatalf("outputs = %+v, want the written value", got)
}
if err := tc.WriteOutput("verdict", false); err == nil || !strings.Contains(err.Error(), "verdict") {
t.Fatalf("second WriteOutput(verdict) = %v, want a refusal naming the output", err)
}
if err := tc.WriteOutput("bogus", 7); err == nil || !strings.Contains(err.Error(), "not declared") {
t.Fatalf("WriteOutput(bogus) = %v, want an undeclared-output refusal", err)
}
if err := tc.WriteOutput("note", json.Number("3")); err == nil || !strings.Contains(err.Error(), `is number, want string`) {
t.Fatalf("WriteOutput(note, number) = %v, want a type refusal", err)
}
// A value set around WriteOutput is judged at finish, so a bypass cannot
// smuggle an undeclared key into the row.
wf := Workflow{Name: "w", Stages: []Stage{{Name: "set", Run: func(_ context.Context, tc *TaskContext) error {
tc.Task.Outputs = map[string]any{"bogus": 7}
tc.Outcome = Outcome{Status: StatusCompleted, Detail: "done"}
return nil
}}}, Interface: iface}
store := &recordingStore{}
tc = &TaskContext{Task: &Task{ID: 9, WorkflowDefinitionYAML: "id: w\n"}, Store: store, Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler)}
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, `"bogus" is not declared`) {
t.Fatalf("park reason %q, want the undeclared key named; outcome %+v", tc.Task.ParkReason, tc.Outcome)
}
}
// TestStageCaptureToolSharingOutputNameRefused pins the ambiguity refusal: a
// stage's own capture tool may not share a declared output's name, because
// the value would otherwise be ambiguous
// (docs/prds/workflow-call-outputs.md, "Failure rules").
func TestStageCaptureToolSharingOutputNameRefused(t *testing.T) {
stage := AgentStage{
Name: "decide",
Role: "builder",
Mission: func(*TaskContext) string { return "m" },
CaptureTools: func(*TaskContext) []agentexec.CaptureTool {
return []agentexec.CaptureTool{{Name: "verdict", MaxCalls: 1}}
},
}.Stage()
tc := &TaskContext{
Task: &Task{ID: 3, WorkflowDefinitionYAML: outputsRunYAML},
Agent: &fakeAgentRunner{result: outputCaptureResult("verdict", `{"value": true}`)},
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
Log: slog.New(slog.DiscardHandler),
}
err := stage.Run(context.Background(), tc)
if err == nil || !strings.Contains(err.Error(), "verdict") {
t.Fatalf("stage error = %v, want a refusal naming the shared tool name", err)
}
}
func slicesContains(list []string, want string) bool {
return slices.Contains(list, want)
}
// updatesBeforeTransition returns the index of the last update recorded
// before the transition to to_ was asked for, or -1 when there is none.
func updatesBeforeTransition(sequence []string, to string) int {
last := -1
for i, entry := range sequence {
if entry == "update" {
last = i
continue
}
if entry == "transition:"+to {
return last
}
}
return -1
}
// TestOutputCaptureToolSchemaOmitsUnconstrainedType pins the "any" output's
// tool schema: no valid JSON Schema type exists for an unconstrained value, so
// the property carries none (a null type is not a valid schema, and would
// misguide a strict adapter).
func TestOutputCaptureToolSchemaOmitsUnconstrainedType(t *testing.T) {
for _, test := range []struct {
spec task.OutputSpec
want string
}{
{spec: task.OutputSpec{Type: "bool"}, want: `"type":"boolean"`},
{spec: task.OutputSpec{Type: "any"}, want: ""},
} {
tool := outputCaptureTool("out", test.spec)
if strings.Contains(string(tool.Parameters), `"type":null`) {
t.Fatalf("output type %q parameters = %s, want no null schema type", test.spec.Type, tool.Parameters)
}
if test.want != "" && !strings.Contains(string(tool.Parameters), test.want) {
t.Fatalf("output type %q parameters = %s, want containing %s", test.spec.Type, tool.Parameters, test.want)
}
}
}
+7 -4
View File
@@ -14,8 +14,11 @@ type Caller interface {
// and the callee's depth is the caller's + 1. The store refuses a
// caller that is not running and a call past the depth limit.
StartCall(ctx context.Context, callerTaskID int64, workflow string, inputs map[string]any) (*Task, error)
// CallStatus reads one call's callee: its status and latest transition
// detail. A store only answers for a task whose call_parent_task_id is
// callerTaskID, so a caller reads only its own callees.
CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (status, detail string, err error)
// CallStatus reads one call's callee: its status, latest transition
// detail and written outputs (decoded from the callee's row;
// docs/prds/workflow-call-outputs.md, "Storage and wire" — the callee
// writes them and the caller only receives them). A store only answers
// for a task whose call_parent_task_id is callerTaskID, so a caller
// reads only its own callees.
CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (status, detail string, outputs map[string]any, err error)
}
+77 -2
View File
@@ -32,6 +32,15 @@ type InputSpec struct {
Required bool `yaml:"required,omitempty" json:"required,omitempty"`
}
// OutputSpec declares one workflow output: the same type vocabulary an
// input uses. A required output the run never writes parks it before any
// terminal state (docs/prds/workflow-call-outputs.md, "Failure rules");
// required defaults to false.
type OutputSpec struct {
Type string `yaml:"type" json:"type"`
Required bool `yaml:"required,omitempty" json:"required,omitempty"`
}
// WorkflowInterface is what a workflow declares to whatever starts it: the
// inputs it takes, whether it works on a repository, and the agent profile it
// runs under. It lives beside the definition entry so a process that does not
@@ -39,6 +48,11 @@ type InputSpec struct {
type WorkflowInterface struct {
Inputs map[string]InputSpec `yaml:"inputs,omitempty" json:"inputs,omitempty"`
Repository RepositoryMode `yaml:"repository,omitempty" json:"repository,omitempty"`
// Outputs declares the named, typed structured results a run writes
// once each (docs/prds/workflow-call-outputs.md). A wait:true caller
// reads them through WorkflowCallStatus; a call step publishes one as
// one of the caller's own outputs.
Outputs map[string]OutputSpec `yaml:"outputs,omitempty" json:"outputs,omitempty"`
// Profile names a [containers.profiles] entry. It is resolved when a task
// is dispatched, not when the workflow is saved.
Profile string `yaml:"profile,omitempty" json:"profile,omitempty"`
@@ -78,8 +92,8 @@ func ParseWorkflowInterface(src string) (WorkflowInterface, error) {
return w, w.Validate()
}
// Validate rejects an unknown repository mode, a malformed input name and an
// unknown input type.
// Validate rejects an unknown repository mode, a malformed input or output
// name and an unknown input or output type.
func (w WorkflowInterface) Validate() error {
switch w.Repository {
case "", RepositoryRequired, RepositoryOptional, RepositoryNone:
@@ -94,6 +108,14 @@ func (w WorkflowInterface) Validate() error {
return fmt.Errorf("workflow input %q type %q must be one of %s", name, spec.Type, strings.Join(inputTypes, ", "))
}
}
for name, spec := range w.Outputs {
if !inputName.MatchString(name) {
return fmt.Errorf("workflow output %q must be a letter or underscore followed by letters, digits or underscores", name)
}
if !slices.Contains(inputTypes, spec.Type) {
return fmt.Errorf("workflow output %q type %q must be one of %s", name, spec.Type, strings.Join(inputTypes, ", "))
}
}
if w.Needs.GateRetries < 0 {
return fmt.Errorf("workflow needs.gate_retries must not be negative")
}
@@ -130,6 +152,31 @@ func (w WorkflowInterface) CheckInputs(values map[string]any) error {
return nil
}
// CheckOutputs rejects declared-output values that do not satisfy the
// declared outputs: the same rules CheckInputs applies to inputs (required,
// undeclared, wrong type), read from the other side of the interface
// (docs/prds/workflow-call-outputs.md, "Failure rules"). A written null
// counts as not written, as CheckInputs treats a null input; an unwritten
// optional output leaves its key absent rather than null.
func (w WorkflowInterface) CheckOutputs(values map[string]any) error {
for name, spec := range w.Outputs {
v, ok := values[name]
if spec.Required && (!ok || v == nil) {
return fmt.Errorf("output %q is required", name)
}
}
for name, v := range values {
spec, ok := w.Outputs[name]
if !ok {
return fmt.Errorf("output %q is not declared by the workflow", name)
}
if got := ValueType(v); v != nil && !TypeAccepts(spec.Type, got) {
return fmt.Errorf("output %q is %s, want %s", name, got, spec.Type)
}
}
return nil
}
// TypeAccepts reports whether a value or parameter of type got may feed an
// input declared as want.
func TypeAccepts(want, got string) bool {
@@ -183,3 +230,31 @@ func DecodeInputs(s string) (map[string]any, error) {
}
return inputs, nil
}
// EncodeOutputs is the stored and wire form of a task's written outputs: a
// JSON object, or empty for none (docs/prds/workflow-call-outputs.md,
// "Storage and wire").
func EncodeOutputs(outputs map[string]any) (string, error) {
if len(outputs) == 0 {
return "", nil
}
data, err := json.Marshal(outputs)
if err != nil {
return "", fmt.Errorf("encode task outputs: %w", err)
}
return string(data), nil
}
// DecodeOutputs reverses EncodeOutputs, keeping numbers exact.
func DecodeOutputs(s string) (map[string]any, error) {
if s == "" {
return nil, nil
}
decoder := json.NewDecoder(strings.NewReader(s))
decoder.UseNumber()
var outputs map[string]any
if err := decoder.Decode(&outputs); err != nil {
return nil, fmt.Errorf("decode task outputs: %w", err)
}
return outputs, nil
}
@@ -86,3 +86,112 @@ func TestCheckInputs(t *testing.T) {
})
}
}
// TestParseWorkflowInterfaceOutputs pins the declared-output grammar beside
// the declared-input grammar (docs/prds/workflow-call-outputs.md, "Where
// outputs are declared"): the same identifier shape, the same type
// vocabulary, the same Validate both ParseDefinition and
// ParseWorkflowInterface call.
func TestParseWorkflowInterfaceOutputs(t *testing.T) {
tests := []struct {
name string
src string
wantErr string
}{
{
name: "outputs parse beside inputs",
src: "id: a\ninputs:\n src_ip: {type: string}\noutputs:\n contained: {type: bool, required: true}\n summary: {type: string}\n",
},
{name: "unknown output type", src: "id: a\noutputs:\n contained: {type: boolean}\n", wantErr: `output "contained" type "boolean" must be one of`},
{name: "malformed output name", src: "id: a\noutputs:\n con-tained: {type: bool}\n", wantErr: `output "con-tained" must be a letter or underscore`},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
w, err := ParseWorkflowInterface(tt.src)
if tt.wantErr != "" {
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
t.Fatalf("err = %v, want containing %q", err, tt.wantErr)
}
return
}
if err != nil {
t.Fatal(err)
}
contained := w.Outputs["contained"]
if contained.Type != "bool" || !contained.Required {
t.Errorf("outputs.contained = %+v, want {bool required}", contained)
}
// required defaults to false.
if summary := w.Outputs["summary"]; summary.Type != "string" || summary.Required {
t.Errorf("outputs.summary = %+v, want {string not required}", summary)
}
})
}
}
// TestCheckOutputs pins the run-time and finish-time refusal the engine
// applies to a written output set: required, undeclared, wrong type -- with
// a written null counting as not written, exactly as CheckInputs judges a
// null input (docs/prds/workflow-call-outputs.md, "Failure rules").
func TestCheckOutputs(t *testing.T) {
w := WorkflowInterface{Outputs: map[string]OutputSpec{
"contained": {Type: "bool", Required: true},
"summary": {Type: "string"},
"extra": {Type: "any"},
}}
tests := []struct {
name string
values map[string]any
wantErr string
}{
{name: "required and typed", values: map[string]any{"contained": true, "summary": "done"}},
{name: "optional null is absent", values: map[string]any{"contained": true, "summary": nil}},
{name: "any takes an object", values: map[string]any{"contained": true, "extra": map[string]any{"a": 1.0}}},
{name: "missing required", values: map[string]any{"summary": "done"}, wantErr: `"contained" is required`},
{name: "null required", values: map[string]any{"contained": nil}, wantErr: `"contained" is required`},
{name: "undeclared", values: map[string]any{"contained": true, "port": 22}, wantErr: `"port" is not declared`},
{name: "wrong type", values: map[string]any{"contained": true, "summary": json.Number("3")}, wantErr: `"summary" is number, want string`},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
err := w.CheckOutputs(tt.values)
if tt.wantErr == "" {
if err != nil {
t.Fatalf("CheckOutputs() = %v", err)
}
return
}
if err == nil || !strings.Contains(err.Error(), tt.wantErr) {
t.Fatalf("CheckOutputs() = %v, want containing %q", err, tt.wantErr)
}
})
}
}
// TestEncodeDecodeOutputs pins outputs' stored form: the shape EncodeInputs
// already has, with numbers exact across the round trip and empty for none.
func TestEncodeDecodeOutputs(t *testing.T) {
if s, err := EncodeOutputs(nil); err != nil || s != "" {
t.Fatalf("EncodeOutputs(nil) = (%q, %v), want (\"\", nil)", s, err)
}
encoded, err := EncodeOutputs(map[string]any{"contained": true, "n": json.Number("3")})
if err != nil {
t.Fatal(err)
}
decoded, err := DecodeOutputs(encoded)
if err != nil {
t.Fatal(err)
}
if decoded["contained"] != true {
t.Errorf("contained = %v, want true", decoded["contained"])
}
if _, ok := decoded["n"].(json.Number); !ok {
t.Errorf("n = %T, want json.Number", decoded["n"])
}
if outputs, err := DecodeOutputs(""); err != nil || outputs != nil {
t.Fatalf("DecodeOutputs(\"\") = (%+v, %v), want (nil, nil)", outputs, err)
}
if _, err := DecodeOutputs("{"); err == nil {
t.Fatal("DecodeOutputs({) = nil, want an error")
}
}
+6
View File
@@ -102,6 +102,12 @@ type Task struct {
// the workflow's declared inputs at dispatch. They reach the agent as
// structured data, never as body text.
Inputs map[string]any `json:"inputs,omitempty"`
// Outputs are the structured results this run wrote to the workflow's
// declared outputs (docs/prds/workflow-call-outputs.md). The set is
// attempt-scoped: a claim starts the next attempt with an empty set and
// the finish write replaces the row's set wholesale. Callers read these
// only from a successful terminal state, through WorkflowCallStatus.
Outputs map[string]any `json:"outputs,omitempty"`
// ReviewPayload is the JSON-encoded review unit (the forge review's
// actionable comments) the remediate workflow's current run must
// address. The daemon's reaction consumer injects it before queuing a
+22
View File
@@ -161,6 +161,15 @@ type TaskContext struct {
// Outcome describes where the task ended up; the engine applies it.
Outcome Outcome
// runInterface is the declaration the run's compiled workflow carries
// (Workflow.Interface, set by Run), so the declared-outputs pieces
// (outputs.go) read one source: the engine's own compile of the pinned
// YAML. A stage body invoked outside Run falls back to parsing the
// pinned YAML once, memoized here.
runInterface task.WorkflowInterface
runInterfaceSet bool
ifaceParsed *task.WorkflowInterface
// SystemPrompt, when non-nil, returns additional context to inject
// before the agent's mission in every agent stage request. Wired by
// the composition root (cmd/archied) from the MemoryManager.
@@ -320,6 +329,10 @@ func Route(t *Task, reg Registry) Workflow {
func Run(ctx context.Context, wf Workflow, tc *TaskContext) {
t := tc.Task
t.Workflow = wf.Name
// The run's declared interface (outputs.go) is the compiled definition's
// own, so every write/publish/finish check judges the YAML the task row
// pinned.
tc.runInterface, tc.runInterfaceSet = wf.Interface, true
log := tc.Log.With("workflow", wf.Name, "repo", tc.Repo.FullName(), "issue", t.IssueNumber)
for _, stage := range wf.Stages {
@@ -437,6 +450,15 @@ func finish(ctx context.Context, tc *TaskContext, log *slog.Logger) {
park(ctx, tc, tc.Outcome.Detail)
return
}
// The attempt's declared outputs are validated before the outcome
// transition: an undeclared, mistyped or required-but-missing value
// parks the run here, so no caller observes a terminal state that
// breaks the workflow's own promise
// (docs/prds/workflow-call-outputs.md, "Failure rules").
if err := tc.validateFinishOutputs(); err != nil {
park(ctx, tc, err.Error())
return
}
if err := tc.Store.Update(ctx, t); err != nil {
park(ctx, tc, fmt.Sprintf("persist workflow outcome: %v", err))
return
+68 -9
View File
@@ -40,12 +40,23 @@ type workflowCallSettings struct {
Workflow string `yaml:"workflow"`
Inputs map[string]any `yaml:"inputs,omitempty"`
Wait bool `yaml:"wait,omitempty"`
// Outputs publishes a callee output as one of the caller's own: the key
// names the callee's declared output, the value an outputs.<name>
// reference naming the caller's declared output
// (docs/prds/workflow-call-outputs.md, "How a caller receives one").
Outputs map[string]string `yaml:"outputs,omitempty"`
}
// callReference is the prefix an inputs value must carry to be read as a
// reference to the calling workflow's declared input.
const callReference = "inputs."
// outputReference is the prefix a call step's outputs value must carry to be
// read as a reference to the caller's own declared output (the mirror image
// of callReference: there the prefixed side is the caller's, here the map
// key is the callee's).
const outputReference = "outputs."
// refName is the identifier grammar a reference suffix must match, shared
// with the workflow interface's input names.
var refName = regexp.MustCompile(`^[A-Za-z_][A-Za-z0-9_]*$`)
@@ -74,6 +85,14 @@ func newWorkflowCallStage(settings yaml.Node) (Stage, error) {
return Stage{}, fmt.Errorf("%s: input %q reference %q must name an input as inputs.<name>", WorkflowCallStepName, name, ref)
}
}
for name, ref := range s.Outputs {
if !strings.HasPrefix(ref, outputReference) || !refName.MatchString(strings.TrimPrefix(ref, outputReference)) {
return Stage{}, fmt.Errorf("%s: output %q must name a declared output as outputs.<name>", WorkflowCallStepName, name)
}
}
if !s.Wait && len(s.Outputs) > 0 {
return Stage{}, fmt.Errorf("%s: outputs on a wait:false call can never be read: nothing has finished when the caller moves on", WorkflowCallStepName)
}
return Stage{Name: WorkflowCallStepName, Run: func(ctx context.Context, tc *TaskContext) error {
return runWorkflowCall(ctx, s, tc)
}}, nil
@@ -126,7 +145,7 @@ func runWorkflowCall(ctx context.Context, s workflowCallSettings, tc *TaskContex
// caller itself being cancelled -- its CancelExecution already swept this
// step with the other non-terminal ones, so a late write here must not
// pretend the wait is still the caller's business.
waitErr := awaitCallee(ctx, s, tc, callee.ID)
calleeOutputs, waitErr := awaitCallee(ctx, s, tc, callee.ID)
if waitErr != nil {
if ctx.Err() == nil {
if ferr := tc.finishChildStep(ctx, callStep, taskstate.StepFailed, waitErr.Error(), 0); ferr != nil {
@@ -135,6 +154,16 @@ func runWorkflowCall(ctx context.Context, s workflowCallSettings, tc *TaskContex
}
return waitErr
}
// The callee succeeded: the outputs its finished run wrote are what
// this call publishes into the caller's own output set. A publish
// failure is the caller's failure, not the call's, so the call step
// closes failed and the run parks naming the output.
if err := tc.publishCalleeOutputs(s.Outputs, calleeOutputs); err != nil {
if ferr := tc.finishChildStep(ctx, callStep, taskstate.StepFailed, err.Error(), 0); ferr != nil {
return fmt.Errorf("%s: could not be closed: %w", WorkflowCallStepName, ferr)
}
return err
}
if err := tc.finishChildStep(ctx, callStep, taskstate.StepSucceeded,
fmt.Sprintf("%q (task %d) finished", s.Workflow, callee.ID), 0); err != nil {
return fmt.Errorf("%s: could not be closed: %w", WorkflowCallStepName, err)
@@ -199,14 +228,17 @@ func callEnded(status string) bool {
}
// awaitCallee polls the callee until it is terminal, failing the stage with
// the callee's detail when the callee did not succeed. The caller's own wall
// clock bounds the wait.
func awaitCallee(ctx context.Context, s workflowCallSettings, tc *TaskContext, callTaskID int64) error {
// the callee's detail when the callee did not succeed, and returning the
// callee's written outputs when it did. The caller's own wall clock bounds
// the wait.
func awaitCallee(ctx context.Context, s workflowCallSettings, tc *TaskContext, callTaskID int64) (map[string]any, error) {
var outputs map[string]any
for {
status, detail, err := tc.Calls.CallStatus(ctx, tc.Task.ID, callTaskID)
status, detail, latestOutputs, err := tc.Calls.CallStatus(ctx, tc.Task.ID, callTaskID)
if err != nil {
return fmt.Errorf("%s: read task %d: %w", WorkflowCallStepName, callTaskID, err)
return nil, fmt.Errorf("%s: read task %d: %w", WorkflowCallStepName, callTaskID, err)
}
outputs = latestOutputs
if callEnded(status) {
if callSucceeded(status) {
if err := tc.EmitDurable(ctx, events.KindWorkflowCallFinished, WorkflowCallStepName,
@@ -214,13 +246,13 @@ func awaitCallee(ctx context.Context, s workflowCallSettings, tc *TaskContext, c
map[string]any{"callee_task_id": callTaskID, "workflow": s.Workflow, "status": status, "detail": detail}); err != nil {
tc.Log.Warn("workflow call finish not persisted", "err", err)
}
return nil
return outputs, nil
}
return fmt.Errorf("%s: callee %q (task %d) ended %s: %s", WorkflowCallStepName, s.Workflow, callTaskID, status, detail)
return nil, fmt.Errorf("%s: callee %q (task %d) ended %s: %s", WorkflowCallStepName, s.Workflow, callTaskID, status, detail)
}
select {
case <-ctx.Done():
return ctx.Err()
return nil, ctx.Err()
case <-time.After(callPollInterval):
}
}
@@ -260,6 +292,9 @@ func validateWorkflowCalls(parsed map[string]YAMLDefinition) error {
if err := checkCallInputs(id, i, d.WorkflowInterface, callee, s.Inputs); err != nil {
return err
}
if err := checkCallOutputs(id, i, d.WorkflowInterface, callee, s.Outputs); err != nil {
return err
}
calls[id] = append(calls[id], s.Workflow)
}
}
@@ -304,6 +339,30 @@ func checkCallInputs(callerID string, index int, caller task.WorkflowInterface,
return nil
}
// checkCallOutputs validates one call's saved outputs assignment: the key
// must be declared by the callee, the reference must name an output the
// caller declares, and the callee's declared type must satisfy the caller's
// (docs/prds/workflow-call-outputs.md, "Save time"). The shape of the value
// (a well-formed outputs.<name> reference) is the factory's refusal; only
// the declarations are the collection's to judge, exactly as for inputs.
func checkCallOutputs(callerID string, index int, caller task.WorkflowInterface, callee YAMLDefinition, outputs map[string]string) error {
for calleeName, ref := range outputs {
calleeSpec, ok := callee.Outputs[calleeName]
if !ok {
return fmt.Errorf("workflow %q step %d: output %q is not declared by %q", callerID, index+1, calleeName, callee.ID)
}
callerName := strings.TrimPrefix(ref, outputReference)
callerSpec, ok := caller.Outputs[callerName]
if !ok {
return fmt.Errorf("workflow %q step %d: output %q references %q, which the calling workflow does not declare", callerID, index+1, calleeName, ref)
}
if !task.TypeAccepts(callerSpec.Type, calleeSpec.Type) {
return fmt.Errorf("workflow %q step %d: output %q is %s, want %s", callerID, index+1, calleeName, calleeSpec.Type, callerSpec.Type)
}
}
return nil
}
// callInputType names the type a saved call value carries at run time: a
// reference carries the calling workflow's declared input type, a literal its
// own JSON type. An error means the reference names an input the caller does
+192 -8
View File
@@ -37,8 +37,9 @@ type startCall struct {
}
type statusAt struct {
status string
detail string
status string
detail string
outputs map[string]any
}
func (f *fakeCaller) StartCall(_ context.Context, callerID int64, workflow string, inputs map[string]any) (*task.Task, error) {
@@ -50,19 +51,19 @@ func (f *fakeCaller) StartCall(_ context.Context, callerID int64, workflow strin
return callee, nil
}
func (f *fakeCaller) CallStatus(_ context.Context, callerID, callID int64) (string, string, error) {
func (f *fakeCaller) CallStatus(_ context.Context, callerID, callID int64) (string, string, map[string]any, error) {
if f.statusErr != nil {
return "", "", f.statusErr
return "", "", nil, f.statusErr
}
seq := f.statuses[callID]
if len(seq) == 0 {
return "", "", nil
return "", "", nil, nil
}
at := seq[0]
if len(seq) > 1 {
f.statuses[callID] = seq[1:]
}
return at.status, at.detail, nil
return at.status, at.detail, at.outputs, nil
}
func callerYAML(callee string, extra ...string) string {
@@ -252,7 +253,7 @@ func TestWorkflowCallWaitFalseStartsAndContinues(t *testing.T) {
func TestWorkflowCallWaitTrueWaitsForTerminalCallee(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n - type: agent.run\n settings:\n mission: report\n")
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{StatusQueued, ""}, {StatusRunning, ""}, {StatusCompleted, "contained 10.0.0.9"}},
101: {{status: StatusQueued}, {status: StatusRunning}, {status: StatusCompleted, detail: "contained 10.0.0.9"}},
}}
store := &recordingStore{}
tc := &TaskContext{
@@ -276,7 +277,7 @@ func TestWorkflowCallWaitTrueWaitsForTerminalCallee(t *testing.T) {
func TestWorkflowCallWaitTrueFailsWhenCalleeFails(t *testing.T) {
wf := compileCaller(t, "id: caller\nrepository: none\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n")
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{StatusParked, "needs an operator"}},
101: {{status: StatusParked, detail: "needs an operator"}},
}}
store := &recordingStore{}
tc := &TaskContext{
@@ -327,3 +328,186 @@ func TestWorkflowCallSettingsValidation(t *testing.T) {
})
}
}
// ---- Save-time: declared outputs ----
// TestValidateCollectionWorkflowCallOutputs pins checkCallOutputs beside
// checkCallInputs (docs/prds/workflow-call-outputs.md, "Save time"): the key
// must be declared by the callee, the value must name an output the caller
// declares, and the callee's declared type must satisfy the caller's.
func TestValidateCollectionWorkflowCallOutputs(t *testing.T) {
const callee = "id: callee\noutputs:\n contained: {type: bool, required: true}\n summary: {type: string}\nsteps:\n - type: agent.run\n settings:\n mission: m\n"
tests := []struct {
name string
yamls []string
want string
notViaCall bool // the refusal is the definition's own, not a call check
}{
{
name: "callee does not declare the published output",
yamls: []string{
"id: caller\noutputs:\n contained: {type: bool}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n outputs: {contained: \"outputs.contained\"}\n",
"id: callee\nsteps:\n - type: agent.run\n settings:\n mission: m\n",
},
want: `output "contained" is not declared by "callee"`,
},
{
name: "caller does not declare the referenced output",
yamls: []string{
"id: caller\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n outputs: {contained: \"outputs.contained\"}\n",
callee,
},
want: `output "contained" references "outputs.contained", which the calling workflow does not declare`,
},
{
name: "callee type cannot satisfy the caller's",
yamls: []string{
"id: caller\noutputs:\n contained: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n outputs: {contained: \"outputs.contained\"}\n",
callee,
},
want: `output "contained" is bool, want string`,
},
{
name: "outputs over a wait:false call",
yamls: []string{"id: caller\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n outputs: {contained: \"outputs.contained\"}\n", callee},
want: "outputs on a wait:false call",
notViaCall: true,
},
{
name: "output value is not an outputs.<name> reference",
yamls: []string{"id: caller\noutputs:\n contained: {type: bool}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n outputs: {contained: \"inputs.src_ip\"}\n", callee},
want: `must name a declared output as outputs.<name>`,
notViaCall: true,
},
{
name: "output reference is malformed",
yamls: []string{"id: caller\noutputs:\n contained: {type: bool}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n outputs: {contained: \"outputs.con-tained\"}\n", callee},
want: `must name a declared output as outputs.<name>`,
notViaCall: true,
},
}
for _, test := range tests {
t.Run(test.name, func(t *testing.T) {
if test.notViaCall {
_, err := ParseDefinition(test.yamls[0], callRegistry())
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("ParseDefinition() error = %v, want containing %q", err, test.want)
}
return
}
err := ValidateDefinitionCollection(collectionOf(append([]string{test.yamls[0]}, test.yamls[1:]...)...), callRegistry())
if err == nil || !strings.Contains(err.Error(), test.want) {
t.Fatalf("ValidateDefinitionCollection() error = %v, want containing %q", err, test.want)
}
})
}
// The valid publication: both sides declare, the types agree.
valid := collectionOf(
"id: caller\nrepository: none\noutputs:\n contained: {type: bool}\n summary: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n inputs: {}\n outputs: {contained: \"outputs.contained\", summary: \"outputs.summary\"}\n",
callee,
)
if err := ValidateDefinitionCollection(valid, callRegistry()); err != nil {
t.Fatalf("ValidateDefinitionCollection(matching publication) = %v, want nil", err)
}
}
// outputsCallerYAML declares the caller's own outputs and publishes a
// callee output as one of them (docs/prds/workflow-call-outputs.md, "How a
// caller receives one"). The trailing agent.run gives the caller an outcome
// of its own, so its finish check judges its declared outputs.
const outputsCallerYAML = "id: caller\nrepository: none\ninputs:\n src_ip: {type: string}\noutputs:\n contained: {type: bool, required: true}\n summary: {type: string}\nsteps:\n - type: workflow.call\n settings:\n workflow: callee\n wait: true\n inputs: {src_ip: \"inputs.src_ip\"}\n outputs: {contained: \"outputs.contained\", summary: \"outputs.summary\"}\n - type: agent.run\n settings:\n mission: report\n"
// TestWorkflowCallWaitTruePublishesCalleeOutputs pins the receive-and-publish
// path: a wait:true caller reads the outputs its successful callee wrote
// through CallStatus, the published ones enter the caller's own set, and the
// caller's finish write persists them into the caller's row before its own
// outcome transition.
func TestWorkflowCallWaitTruePublishesCalleeOutputs(t *testing.T) {
wf := compileCaller(t, outputsCallerYAML)
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{status: StatusCompleted, detail: "contained 10.0.0.9", outputs: map[string]any{
"contained": true, "summary": "blocked the address", "extra": "not assigned",
}}},
}}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1, WorkflowDefinitionYAML: outputsCallerYAML, Inputs: map[string]any{"src_ip": "10.0.0.9"}},
Calls: caller, Store: store, Trees: &fakeTrees{dir: "/scratch/3"}, Log: slog.New(slog.DiscardHandler),
Agent: &fakeAgentRunner{result: agentexec.Result{Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, Summary: "reported"}},
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
}
Run(context.Background(), wf, tc)
if tc.Outcome.Status != StatusCompleted {
t.Fatalf("outcome = %+v, want completed after the callee succeeded", tc.Outcome)
}
if tc.Task.Outputs["contained"] != true {
t.Fatalf("caller outputs = %+v, want the callee's bool restored as its own", tc.Task.Outputs)
}
if got := tc.Task.Outputs["summary"]; got != "blocked the address" {
t.Fatalf("caller outputs.summary = %v, want the callee's value", got)
}
if _, undeclared := tc.Task.Outputs["extra"]; undeclared {
t.Fatalf("caller outputs = %+v, want the assignment only, not the callee's whole set", tc.Task.Outputs)
}
// The caller's row carries the published values before its outcome
// transition, so the status its own caller sees when its wait ends
// already carries them.
if len(store.updates) == 0 || store.updates[len(store.updates)-1].Outputs["contained"] != true {
t.Fatalf("row updates = %+v, want the published outputs written", store.updates)
}
if seq := updatesBeforeTransition(store.sequence, "completed"); seq == -1 {
t.Fatalf("sequence = %v, want an update before the completed transition", store.sequence)
} else if store.updates[seq].Outputs["contained"] != true {
t.Fatal("the row write carrying the outputs did not precede the outcome transition")
}
}
// TestCallPublishSkipsUnwrittenOutputAndRequiredParks pins both halves of
// "declared but never written" on the caller side: a callee output the
// callee never wrote leaves the caller's output absent, and the caller's own
// required judgment then parks it naming the output.
func TestCallPublishSkipsUnwrittenOutputAndRequiredParks(t *testing.T) {
wf := compileCaller(t, outputsCallerYAML)
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{status: StatusCompleted, detail: "done", outputs: map[string]any{"summary": "x"}}},
}}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1, WorkflowDefinitionYAML: outputsCallerYAML, Inputs: map[string]any{"src_ip": "10.0.0.9"}},
Calls: caller, Store: store, Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler),
Agent: &fakeAgentRunner{result: agentexec.Result{Version: agentexec.ProtocolVersion, Status: agentexec.StatusPassed, Summary: "reported"}},
Cfg: config.Config{Models: map[string]string{"builder": "p/m"}},
}
Run(context.Background(), wf, tc)
if got := tc.Task.Outputs["summary"]; got != "x" {
t.Fatalf("caller outputs.summary = %v, want the one value the callee wrote", got)
}
if _, absent := tc.Task.Outputs["contained"]; absent {
t.Fatal("the unwritten callee output was published anyway")
}
if !strings.Contains(tc.Task.ParkReason, `output "contained" is required`) {
t.Fatalf("park reason %q, want the caller's missing required output named", tc.Task.ParkReason)
}
if len(store.transitions) == 0 || store.transitions[len(store.transitions)-1].to != StatusParked {
t.Fatalf("transitions = %+v, want the caller parked rather than reaching a terminal state", store.transitions)
}
}
// TestCallPublishTypeMismatchParks pins the run-time re-check: a published
// callee value is re-checked against the caller's declared type before it
// enters the caller's set; a mismatch parks the caller naming the output.
func TestCallPublishTypeMismatchParks(t *testing.T) {
wf := compileCaller(t, outputsCallerYAML)
caller := &fakeCaller{statuses: map[int64][]statusAt{
101: {{status: StatusCompleted, detail: "done", outputs: map[string]any{"contained": "yes"}}},
}}
store := &recordingStore{}
tc := &TaskContext{
Task: &Task{ID: 3, Attempt: 1, WorkflowDefinitionYAML: outputsCallerYAML, Inputs: map[string]any{"src_ip": "10.0.0.9"}},
Calls: caller, Store: store, Trees: &fakeTrees{}, Log: slog.New(slog.DiscardHandler),
}
Run(context.Background(), wf, tc)
if !strings.Contains(tc.Task.ParkReason, "contained") {
t.Fatalf("park reason %q, want the mismatched output named", tc.Task.ParkReason)
}
}
@@ -182,7 +182,7 @@ func (d deadlineCaller) StartCall(ctx context.Context, callerTaskID int64, wf st
return d.Caller.StartCall(ctx, callerTaskID, wf, inputs)
}
func (d deadlineCaller) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, error) {
func (d deadlineCaller) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, map[string]any, error) {
ctx, cancel := d.withDeadline(ctx)
defer cancel()
return d.Caller.CallStatus(ctx, callerTaskID, callTaskID)
@@ -0,0 +1,17 @@
-- Declared workflow outputs on the task row
-- (docs/prds/workflow-call-outputs.md, "Storage and wire").
--
-- tasks.outputs is the JSON object of declared-output values a run wrote,
-- written by the run's own row write exactly as tasks.inputs is. The column
-- defaults to the empty string, so every existing row and writer reads as a
-- run that wrote nothing (the empty set). It is attempt-scoped: the claim
-- statements reset it alongside the attempt increment, so nothing a previous
-- attempt wrote survives into the next.
-- +goose Up
ALTER TABLE tasks ADD COLUMN outputs text NOT NULL DEFAULT '';
-- +goose Down
ALTER TABLE tasks DROP COLUMN outputs;
@@ -24,7 +24,7 @@ func (q *Queries) CallStatusDetail(ctx context.Context, taskID int64) (string, e
const enqueueCallTask = `-- name: EnqueueCallTask :one
WITH caller AS (
SELECT t.id, t.owner, t.repo, t.issue_number, t.title, t.body, t.labels, t.status, t.workflow, t.branch, t.plan, t.notes, t.pr_number, t.tokens_used, t.iterations, t.attempt, t.park_reason, t.watch_comment_id, t.park_class, t.remediation_rounds, t.retry_count, t.source, t.identity, t.binding_id, t.binding_version, t.review_payload, t.workflow_definition_version, t.workflow_definition_digest, t.workflow_definition_yaml, t.created_at, t.updated_at, t.review_cursor, t.inputs, t.org_id, t.workspace_id, t.call_parent_task_id, t.call_depth FROM tasks t WHERE t.id = $1 FOR UPDATE
SELECT t.id, t.owner, t.repo, t.issue_number, t.title, t.body, t.labels, t.status, t.workflow, t.branch, t.plan, t.notes, t.pr_number, t.tokens_used, t.iterations, t.attempt, t.park_reason, t.watch_comment_id, t.park_class, t.remediation_rounds, t.retry_count, t.source, t.identity, t.binding_id, t.binding_version, t.review_payload, t.workflow_definition_version, t.workflow_definition_digest, t.workflow_definition_yaml, t.created_at, t.updated_at, t.review_cursor, t.inputs, t.org_id, t.workspace_id, t.call_parent_task_id, t.call_depth, t.outputs FROM tasks t WHERE t.id = $1 FOR UPDATE
)
INSERT INTO tasks (owner, repo, issue_number, title, body, labels, workflow, source, identity, org_id, workspace_id, inputs, call_parent_task_id, call_depth)
SELECT
@@ -41,7 +41,7 @@ SELECT
caller.id, caller.call_depth + 1
FROM caller
WHERE caller.status = 'running' AND caller.call_depth + 1 <= $7::int
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs
`
type EnqueueCallTaskParams struct {
@@ -112,6 +112,7 @@ func (q *Queries) EnqueueCallTask(ctx context.Context, arg EnqueueCallTaskParams
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
@@ -392,6 +392,7 @@ type Task struct {
WorkspaceID string
CallParentTaskID int64
CallDepth int32
Outputs string
}
type ToolCall struct {
@@ -46,9 +46,9 @@ func (q *Queries) BeginRemediationTask(ctx context.Context, arg BeginRemediation
}
const claimByIssue = `-- name: ClaimByIssue :one
UPDATE tasks SET status = 'running', attempt = attempt + 1, updated_at = now()
UPDATE tasks SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
WHERE owner = $1 AND repo = $2 AND issue_number = $3 AND status = 'queued'
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs
`
type ClaimByIssueParams struct {
@@ -57,6 +57,8 @@ type ClaimByIssueParams struct {
IssueNumber int64
}
// The claim starts the attempt's output set empty, as ClaimNextTask does:
// outputs is attempt-scoped (docs/prds/workflow-call-outputs.md).
func (q *Queries) ClaimByIssue(ctx context.Context, arg ClaimByIssueParams) (Task, error) {
row := q.db.QueryRow(ctx, claimByIssue, arg.Owner, arg.Repo, arg.IssueNumber)
var i Task
@@ -98,13 +100,14 @@ func (q *Queries) ClaimByIssue(ctx context.Context, arg ClaimByIssueParams) (Tas
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
const claimNextTask = `-- name: ClaimNextTask :one
UPDATE tasks
SET status = 'running', attempt = attempt + 1, updated_at = now()
SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
WHERE id = (
SELECT id FROM tasks
WHERE status = 'queued'
@@ -112,12 +115,15 @@ WHERE id = (
FOR UPDATE SKIP LOCKED
LIMIT 1
)
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs
`
// FOR UPDATE SKIP LOCKED replaces the SQLite single-writer assumption: two
// claimers running at once take different rows instead of blocking, so the
// daemon no longer depends on holding the only connection to the file.
// The claim also starts the attempt's output set empty: outputs is
// attempt-scoped, so nothing the previous attempt wrote survives
// (docs/prds/workflow-call-outputs.md).
func (q *Queries) ClaimNextTask(ctx context.Context) (Task, error) {
row := q.db.QueryRow(ctx, claimNextTask)
var i Task
@@ -159,6 +165,7 @@ func (q *Queries) ClaimNextTask(ctx context.Context) (Task, error) {
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
@@ -269,7 +276,7 @@ VALUES (
),
$8
)
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth
RETURNING id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs
`
type InsertChatTaskParams struct {
@@ -340,6 +347,7 @@ func (q *Queries) InsertChatTask(ctx context.Context, arg InsertChatTaskParams)
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
@@ -367,7 +375,7 @@ func (q *Queries) InsertTransition(ctx context.Context, arg InsertTransitionPara
}
const listOpenPRs = `-- name: ListOpenPRs :many
SELECT id, owner, repo, issue_number, pr_number, status, source, identity, attempt, review_cursor, watch_comment_id
SELECT id, owner, repo, issue_number, pr_number, status, source, identity, attempt, review_cursor, watch_comment_id, outputs
FROM tasks WHERE status = 'pr_open'
`
@@ -383,6 +391,7 @@ type ListOpenPRsRow struct {
Attempt int64
ReviewCursor int64
WatchCommentID int64
Outputs string
}
func (q *Queries) ListOpenPRs(ctx context.Context) ([]ListOpenPRsRow, error) {
@@ -406,6 +415,7 @@ func (q *Queries) ListOpenPRs(ctx context.Context) ([]ListOpenPRsRow, error) {
&i.Attempt,
&i.ReviewCursor,
&i.WatchCommentID,
&i.Outputs,
); err != nil {
return nil, err
}
@@ -420,7 +430,8 @@ func (q *Queries) ListOpenPRs(ctx context.Context) ([]ListOpenPRsRow, error) {
const listTaskSummaries = `-- name: ListTaskSummaries :many
SELECT id, owner, repo, issue_number, title, status, workflow,
pr_number, tokens_used, iterations, attempt, park_reason, retry_count,
created_at, updated_at, plan, source, identity, binding_id, binding_version
created_at, updated_at, plan, source, identity, binding_id, binding_version,
outputs
FROM tasks ORDER BY updated_at DESC LIMIT $1
`
@@ -445,11 +456,14 @@ type ListTaskSummariesRow struct {
Identity string
BindingID string
BindingVersion int64
Outputs string
}
// The dashboard's list. This projection is deliberately narrow: Plan gates
// the "Decision required" panel and Source labels the row, and widening it
// back would send rows without them.
// back would send rows without them. outputs rides it because the task row's
// own structured result is part of the summary a caller or the dashboard
// reads (docs/prds/workflow-call-outputs.md, "Storage and wire").
func (q *Queries) ListTaskSummaries(ctx context.Context, limit int32) ([]ListTaskSummariesRow, error) {
rows, err := q.db.Query(ctx, listTaskSummaries, limit)
if err != nil {
@@ -480,6 +494,7 @@ func (q *Queries) ListTaskSummaries(ctx context.Context, limit int32) ([]ListTas
&i.Identity,
&i.BindingID,
&i.BindingVersion,
&i.Outputs,
); err != nil {
return nil, err
}
@@ -620,7 +635,7 @@ func (q *Queries) StampTaskBinding(ctx context.Context, arg StampTaskBindingPara
}
const taskByID = `-- name: TaskByID :one
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth FROM tasks WHERE id = $1
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs FROM tasks WHERE id = $1
`
func (q *Queries) TaskByID(ctx context.Context, id int64) (Task, error) {
@@ -664,12 +679,13 @@ func (q *Queries) TaskByID(ctx context.Context, id int64) (Task, error) {
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
const taskByIssue = `-- name: TaskByIssue :one
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth FROM tasks WHERE owner = $1 AND repo = $2 AND issue_number = $3
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs FROM tasks WHERE owner = $1 AND repo = $2 AND issue_number = $3
`
type TaskByIssueParams struct {
@@ -719,12 +735,13 @@ func (q *Queries) TaskByIssue(ctx context.Context, arg TaskByIssueParams) (Task,
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
const taskByPR = `-- name: TaskByPR :one
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth FROM tasks WHERE owner = $1 AND repo = $2 AND pr_number = $3 AND status = $4
SELECT id, owner, repo, issue_number, title, body, labels, status, workflow, branch, plan, notes, pr_number, tokens_used, iterations, attempt, park_reason, watch_comment_id, park_class, remediation_rounds, retry_count, source, identity, binding_id, binding_version, review_payload, workflow_definition_version, workflow_definition_digest, workflow_definition_yaml, created_at, updated_at, review_cursor, inputs, org_id, workspace_id, call_parent_task_id, call_depth, outputs FROM tasks WHERE owner = $1 AND repo = $2 AND pr_number = $3 AND status = $4
`
type TaskByPRParams struct {
@@ -783,6 +800,7 @@ func (q *Queries) TaskByPR(ctx context.Context, arg TaskByPRParams) (Task, error
&i.WorkspaceID,
&i.CallParentTaskID,
&i.CallDepth,
&i.Outputs,
)
return i, err
}
@@ -844,6 +862,7 @@ UPDATE tasks SET workflow = $2, branch = $3, plan = $4, notes = $5,
watch_comment_id = $10, retry_count = $11, remediation_rounds = $12,
review_payload = $13, workflow_definition_version = $14,
workflow_definition_digest = $15, workflow_definition_yaml = $16,
outputs = $17,
updated_at = now()
WHERE id = $1
`
@@ -865,6 +884,7 @@ type UpdateTaskParams struct {
WorkflowDefinitionVersion int64
WorkflowDefinitionDigest string
WorkflowDefinitionYaml string
Outputs string
}
func (q *Queries) UpdateTask(ctx context.Context, arg UpdateTaskParams) error {
@@ -885,6 +905,7 @@ func (q *Queries) UpdateTask(ctx context.Context, arg UpdateTaskParams) error {
arg.WorkflowDefinitionVersion,
arg.WorkflowDefinitionDigest,
arg.WorkflowDefinitionYaml,
arg.Outputs,
)
return err
}
@@ -2,8 +2,11 @@
-- FOR UPDATE SKIP LOCKED replaces the SQLite single-writer assumption: two
-- claimers running at once take different rows instead of blocking, so the
-- daemon no longer depends on holding the only connection to the file.
-- The claim also starts the attempt's output set empty: outputs is
-- attempt-scoped, so nothing the previous attempt wrote survives
-- (docs/prds/workflow-call-outputs.md).
UPDATE tasks
SET status = 'running', attempt = attempt + 1, updated_at = now()
SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
WHERE id = (
SELECT id FROM tasks
WHERE status = 'queued'
@@ -28,10 +31,13 @@ SELECT * FROM tasks WHERE owner = $1 AND repo = $2 AND pr_number = $3 AND status
-- name: ListTaskSummaries :many
-- The dashboard's list. This projection is deliberately narrow: Plan gates
-- the "Decision required" panel and Source labels the row, and widening it
-- back would send rows without them.
-- back would send rows without them. outputs rides it because the task row's
-- own structured result is part of the summary a caller or the dashboard
-- reads (docs/prds/workflow-call-outputs.md, "Storage and wire").
SELECT id, owner, repo, issue_number, title, status, workflow,
pr_number, tokens_used, iterations, attempt, park_reason, retry_count,
created_at, updated_at, plan, source, identity, binding_id, binding_version
created_at, updated_at, plan, source, identity, binding_id, binding_version,
outputs
FROM tasks ORDER BY updated_at DESC LIMIT $1;
-- name: CountTasksByStatus :many
@@ -74,6 +80,7 @@ UPDATE tasks SET workflow = $2, branch = $3, plan = $4, notes = $5,
watch_comment_id = $10, retry_count = $11, remediation_rounds = $12,
review_payload = $13, workflow_definition_version = $14,
workflow_definition_digest = $15, workflow_definition_yaml = $16,
outputs = $17,
updated_at = now()
WHERE id = $1;
@@ -128,7 +135,9 @@ VALUES (
ON CONFLICT (org_id, identity, owner, repo, issue_number) DO NOTHING;
-- name: ClaimByIssue :one
UPDATE tasks SET status = 'running', attempt = attempt + 1, updated_at = now()
-- The claim starts the attempt's output set empty, as ClaimNextTask does:
-- outputs is attempt-scoped (docs/prds/workflow-call-outputs.md).
UPDATE tasks SET status = 'running', attempt = attempt + 1, outputs = '', updated_at = now()
WHERE owner = $1 AND repo = $2 AND issue_number = $3 AND status = 'queued'
RETURNING *;
@@ -160,5 +169,5 @@ WHERE id = @id AND status = @from_status;
DELETE FROM tasks WHERE id = $1 AND status = $2;
-- name: ListOpenPRs :many
SELECT id, owner, repo, issue_number, pr_number, status, source, identity, attempt, review_cursor, watch_comment_id
SELECT id, owner, repo, issue_number, pr_number, status, source, identity, attempt, review_cursor, watch_comment_id, outputs
FROM tasks WHERE status = 'pr_open';
+45 -12
View File
@@ -74,12 +74,21 @@ func (s *Store) Close() error { return nil }
// JSON-safe floor that keeps synthetic issue numbers clear of real ones.
const syntheticIssueNumberBase = 1_000_000_000_000_000
// structuredPayloadBytes is the write-side bound the store applies to a
// structured payload (review_payload today, task outputs now). A value that
// would exceed it is refused for outputs -- clipped JSON does not parse, and a
// caller must receive an object or nothing -- where the legacy review payload
// is still clipped (docs/prds/workflow-call-outputs.md, "Storage and wire").
const structuredPayloadBytes = 4000
// taskFromRow maps the generated task row to the workflow.Task the daemon and
// webui consume.
func taskFromRow(t postgresdb.Task) *workflow.Task {
// The inputs column is only ever written by EncodeInputs, so a decode
// failure cannot arise from stored data this package produced.
// The inputs and outputs columns are only ever written by EncodeInputs and
// EncodeOutputs, so a decode failure cannot arise from stored data this
// package produced.
inputs, _ := task.DecodeInputs(t.Inputs)
outputs, _ := task.DecodeOutputs(t.Outputs)
return &workflow.Task{
ID: t.ID,
Owner: t.Owner,
@@ -110,6 +119,7 @@ func taskFromRow(t postgresdb.Task) *workflow.Task {
BindingID: t.BindingID,
BindingVersion: int(t.BindingVersion),
Inputs: inputs,
Outputs: outputs,
ReviewPayload: t.ReviewPayload,
ParkClass: t.ParkClass,
RemediationRounds: int(t.RemediationRounds),
@@ -282,6 +292,18 @@ func (s *Store) ParkTask(ctx context.Context, taskID int64, from, detail, class
// Update persists mutable task fields written by workflows.
func (s *Store) Update(ctx context.Context, t *workflow.Task) error {
// The row write is where a run's outputs land (docs/prds/workflow-call-outputs.md).
// An encoded set past the bound the store applies to a structured payload
// is refused rather than clipped: clipped JSON does not parse, and a caller
// would receive a broken object as a value. The engine turns the refusal
// into a park, so nothing silently loses its structured result.
outputs, err := task.EncodeOutputs(t.Outputs)
if err != nil {
return fmt.Errorf("store: encode task %d outputs: %w", t.ID, err)
}
if len(outputs) > structuredPayloadBytes {
return fmt.Errorf("store: task %d outputs are %d bytes, past the %d-byte structured-payload bound; refuse rather than clip", t.ID, len(outputs), structuredPayloadBytes)
}
return s.queries().UpdateTask(ctx, postgresdb.UpdateTaskParams{
ID: t.ID,
Workflow: t.Workflow,
@@ -299,6 +321,7 @@ func (s *Store) Update(ctx context.Context, t *workflow.Task) error {
WorkflowDefinitionVersion: t.WorkflowDefinitionVersion,
WorkflowDefinitionDigest: t.WorkflowDefinitionDigest,
WorkflowDefinitionYaml: t.WorkflowDefinitionYAML,
Outputs: outputs,
})
}
@@ -504,11 +527,13 @@ func (s *Store) OpenPRs(ctx context.Context) ([]workflow.Task, error) {
}
tasks := make([]workflow.Task, 0, len(rows))
for _, r := range rows {
outputs, _ := task.DecodeOutputs(r.Outputs)
tasks = append(tasks, workflow.Task{
ID: r.ID, Owner: r.Owner, Repo: r.Repo, IssueNumber: int(r.IssueNumber),
PRNumber: int(r.PrNumber), Status: r.Status, Source: r.Source,
Identity: r.Identity, Attempt: int(r.Attempt),
ReviewCursor: r.ReviewCursor, WatchCommentID: r.WatchCommentID,
Outputs: outputs,
})
}
return tasks, nil
@@ -527,6 +552,7 @@ func (s *Store) Tasks(ctx context.Context, limit int) ([]workflow.Task, error) {
}
tasks := make([]workflow.Task, 0, len(rows))
for _, r := range rows {
outputs, _ := task.DecodeOutputs(r.Outputs)
tasks = append(tasks, workflow.Task{
ID: r.ID, Owner: r.Owner, Repo: r.Repo, IssueNumber: int(r.IssueNumber),
Title: r.Title, Status: r.Status, Workflow: r.Workflow,
@@ -534,6 +560,7 @@ func (s *Store) Tasks(ctx context.Context, limit int) ([]workflow.Task, error) {
Attempt: int(r.Attempt), ParkReason: r.ParkReason, RetryCount: int(r.RetryCount),
CreatedAt: r.CreatedAt, UpdatedAt: r.UpdatedAt, Plan: r.Plan, Source: r.Source,
Identity: r.Identity, BindingID: r.BindingID, BindingVersion: int(r.BindingVersion),
Outputs: outputs,
})
}
return tasks, nil
@@ -643,28 +670,34 @@ func (s *Store) callRefusal(ctx context.Context, callerTaskID int64) error {
return fmt.Errorf("store: workflow.call from task %d at depth %d: %w", callerTaskID, caller.CallDepth, storecontract.ErrCallDepthExceeded)
}
// CallStatus reads one call's callee for a waiting caller: its status and
// latest transition detail. The parent check is the row check the wire grant
// cannot do: a caller reads only the tasks it started.
func (s *Store) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, error) {
// CallStatus reads one call's callee for a waiting caller: its status, its
// latest transition detail and the outputs its finished run wrote. The parent
// check is the row check the wire grant cannot do: a caller reads only the
// tasks it started.
func (s *Store) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, map[string]any, error) {
callee, err := s.queries().TaskByID(ctx, callTaskID)
if errors.Is(err, pgx.ErrNoRows) {
return "", "", storecontract.ErrCallNotYours
return "", "", nil, storecontract.ErrCallNotYours
}
if err != nil {
return "", "", err
return "", "", nil, err
}
if callee.CallParentTaskID != callerTaskID {
return "", "", storecontract.ErrCallNotYours
return "", "", nil, storecontract.ErrCallNotYours
}
// The row is the callee's own; its outputs travel beside status and detail
// (docs/prds/workflow-call-outputs.md, "Storage and wire"). The caller
// decides whether to use them -- only a successful terminal state's values
// reach it.
outputs, _ := task.DecodeOutputs(callee.Outputs)
// A callee that has not moved yet has no transition row; its queue
// status is the whole answer, and the empty detail says so.
detail, err := s.queries().CallStatusDetail(ctx, callTaskID)
if errors.Is(err, pgx.ErrNoRows) {
return callee.Status, "", nil
return callee.Status, "", outputs, nil
}
if err != nil {
return "", "", err
return "", "", nil, err
}
return callee.Status, detail, nil
return callee.Status, detail, outputs, nil
}
@@ -0,0 +1,129 @@
// Declared workflow outputs on the task row: the attempt-scoped structured
// results a run writes (docs/prds/workflow-call-outputs.md, "Storage and
// wire").
package postgres
import (
"strings"
"testing"
"github.com/samcharles93/archie-core/internal/domain/workflow"
)
// newStoreForOutputs is a migrated pool with the Store built over it.
func newStoreForOutputs(t *testing.T) *Store {
t.Helper()
pool, _ := migrated(t)
return New(pool)
}
// TestTaskOutputs pins the task row half of the outputs model:
//
// - Update persists the run's written set, decoded exactly on the way out;
// - an encoded set past the structured-payload bound is refused, not
// clipped (clipped JSON does not parse);
// - a claim starts the next attempt with an empty set, so nothing a
// retried attempt does not rewrite survives.
func TestTaskOutputs(t *testing.T) {
t.Run("Update persists the run's outputs and TaskByID reads them back", func(t *testing.T) {
st := newStoreForOutputs(t)
ctx := t.Context()
task, err := st.EnqueueChatTask(ctx, "acme", "widget", "callee", "body", "w", "", nil)
if err != nil {
t.Fatal(err)
}
if _, err := st.ClaimNext(ctx); err != nil {
t.Fatal(err)
}
row, err := st.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
row.Outputs = map[string]any{"contained": true, "n": "3"}
if err := st.Update(ctx, row); err != nil {
t.Fatalf("Update: %v", err)
}
back, err := st.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
if back.Outputs["contained"] != true || back.Outputs["n"] != "3" {
t.Fatalf("row outputs = %+v, want the written set read back", back.Outputs)
}
})
t.Run("an encoded set past the structured-payload bound is refused", func(t *testing.T) {
st := newStoreForOutputs(t)
ctx := t.Context()
task, err := st.EnqueueChatTask(ctx, "acme", "widget", "callee", "body", "w", "", nil)
if err != nil {
t.Fatal(err)
}
if _, err := st.ClaimNext(ctx); err != nil {
t.Fatal(err)
}
row, err := st.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
row.Outputs = map[string]any{"summary": strings.Repeat("x", 5000)}
err = st.Update(ctx, row)
if err == nil {
t.Fatal("Update accepted a set past the structured-payload bound; it must be refused, not clipped")
}
if !strings.Contains(err.Error(), "outputs") {
t.Fatalf("refusal = %v, want it to name the outputs", err)
}
})
t.Run("a retried attempt starts with an empty set", func(t *testing.T) {
st := newStoreForOutputs(t)
ctx := t.Context()
task, err := st.EnqueueChatTask(ctx, "acme", "widget", "callee", "body", "w", "", nil)
if err != nil {
t.Fatal(err)
}
first, err := st.ClaimNext(ctx)
if err != nil || first == nil {
t.Fatalf("first claim: (%+v, %v)", first, err)
}
if first.Outputs != nil {
t.Fatalf("first claim outputs = %+v, want the empty set the fresh attempt starts with", first.Outputs)
}
row, err := st.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
row.Outputs = map[string]any{"contained": true}
if err := st.Update(ctx, row); err != nil {
t.Fatalf("Update: %v", err)
}
back, err := st.TaskByID(ctx, task.ID)
if err != nil || back.Outputs["contained"] != true {
t.Fatalf("setup: the attempt's outputs did not reach the row: (%+v, %v)", back.Outputs, err)
}
if err := st.Transition(ctx, task.ID, workflow.StatusRunning, workflow.StatusParked, "needs a look"); err != nil {
t.Fatal(err)
}
if err := st.RetryTask(ctx, task.ID, workflow.StatusParked, ""); err != nil {
t.Fatal(err)
}
second, err := st.ClaimNext(ctx)
if err != nil || second == nil {
t.Fatalf("retried claim: (%+v, %v)", second, err)
}
if task.ID != second.ID {
t.Skipf("another queued task claimed first; the idempotent queue handed out %d", second.ID)
}
if second.Outputs != nil {
t.Fatalf("retried attempt outputs = %+v, want the empty set", second.Outputs)
}
final, err := st.TaskByID(ctx, task.ID)
if err != nil {
t.Fatal(err)
}
if _, still := final.Outputs["contained"]; still {
t.Fatalf("row outputs = %+v, want the emptiness the new attempt starts with", final.Outputs)
}
})
}
+3 -3
View File
@@ -652,12 +652,12 @@ func (c *Client) StartCall(ctx context.Context, callerTaskID int64, wf string, i
return taskValue(r.Task), nil
}
func (c *Client) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, error) {
func (c *Client) CallStatus(ctx context.Context, callerTaskID, callTaskID int64) (string, string, map[string]any, error) {
r, err := c.client.WorkflowCallStatus(ctx, &pb.WorkflowCallStatusRequest{CallerTaskId: callerTaskID, CallTaskId: callTaskID})
if err != nil {
return "", "", unmapError(err)
return "", "", nil, unmapError(err)
}
return r.Status, r.Detail, nil
return r.Status, r.Detail, outputsValue(r.OutputsJson), nil
}
// Task log
+2 -2
View File
@@ -951,11 +951,11 @@ func (s *server) WorkflowCallStatus(ctx context.Context, r *pb.WorkflowCallStatu
if s.deps.WorkflowCalls == nil {
return nil, errWorkflowCallerUnavailable
}
status, detail, err := s.deps.WorkflowCalls.CallStatus(ctx, r.CallerTaskId, r.CallTaskId)
status, detail, outputs, err := s.deps.WorkflowCalls.CallStatus(ctx, r.CallerTaskId, r.CallTaskId)
if err != nil {
return nil, s.logErr("WorkflowCallStatus", err)
}
return &pb.WorkflowCallStatusResponse{Status: status, Detail: detail}, nil
return &pb.WorkflowCallStatusResponse{Status: status, Detail: detail, OutputsJson: outputsJSON(outputs)}, nil
}
// Task log
@@ -48,10 +48,10 @@ func TestTaskGrantAuthorizesTheWorkflowCallRPCs(t *testing.T) {
if callee.CallParentTaskID != caller.ID || callee.CallDepth != 1 {
t.Fatalf("callee = %+v, want the parent link and depth 1", callee)
}
if _, _, err := worker.CallStatus(ctx, caller.ID, callee.ID); err != nil {
if _, _, _, err := worker.CallStatus(ctx, caller.ID, callee.ID); err != nil {
t.Fatalf("task grant should authorize CallStatus on its own callees: %v", err)
}
if _, _, err := worker.CallStatus(ctx, caller.ID, other.ID); !errors.Is(err, storecontract.ErrCallNotYours) {
if _, _, _, err := worker.CallStatus(ctx, caller.ID, other.ID); !errors.Is(err, storecontract.ErrCallNotYours) {
t.Fatalf("CallStatus for a task that is not this caller's callee = %v, want ErrCallNotYours", err)
}
@@ -61,7 +61,7 @@ func TestTaskGrantAuthorizesTheWorkflowCallRPCs(t *testing.T) {
if _, err := worker.StartCall(ctx, other.ID, "callee", nil); status.Code(err) != codes.PermissionDenied {
t.Fatalf("StartCall for another task = %v, want PermissionDenied", err)
}
if _, _, err := worker.CallStatus(ctx, other.ID, callee.ID); status.Code(err) != codes.PermissionDenied {
if _, _, _, err := worker.CallStatus(ctx, other.ID, callee.ID); status.Code(err) != codes.PermissionDenied {
t.Fatalf("CallStatus for another task = %v, want PermissionDenied", err)
}
+16 -2
View File
@@ -73,8 +73,9 @@ func taskProto(t *task.Task) *pb.Task { //nolint:dupl // mirror-image field-by-f
Attempt: int64(t.Attempt), ParkReason: t.ParkReason, RetryCount: int64(t.RetryCount),
WatchCommentId: t.WatchCommentID, Source: t.Source, Identity: t.Identity,
BindingId: t.BindingID, BindingVersion: int64(t.BindingVersion),
InputsJson: inputsJSON(t.Inputs),
CreatedAt: timestamp(t.CreatedAt), UpdatedAt: timestamp(t.UpdatedAt),
InputsJson: inputsJSON(t.Inputs),
OutputsJson: outputsJSON(t.Outputs),
CreatedAt: timestamp(t.CreatedAt), UpdatedAt: timestamp(t.UpdatedAt),
ReviewPayload: t.ReviewPayload,
ReviewCursor: t.ReviewCursor,
ParkClass: t.ParkClass,
@@ -101,6 +102,7 @@ func taskValue(t *pb.Task) *task.Task { //nolint:dupl // see taskProto above
WatchCommentID: t.WatchCommentId, Source: t.Source, Identity: t.Identity,
BindingID: t.BindingId, BindingVersion: int(t.BindingVersion),
Inputs: inputsValue(t.InputsJson),
Outputs: outputsValue(t.OutputsJson),
CreatedAt: timeValue(t.CreatedAt), UpdatedAt: timeValue(t.UpdatedAt),
ReviewPayload: t.ReviewPayload,
ReviewCursor: t.ReviewCursor,
@@ -128,6 +130,18 @@ func inputsValue(s string) map[string]any {
return inputs
}
// outputsJSON and outputsValue carry a task's written outputs in
// task.EncodeOutputs form, exactly as inputsJSON/inputsValue carry inputs.
func outputsJSON(outputs map[string]any) string {
s, _ := task.EncodeOutputs(outputs)
return s
}
func outputsValue(s string) map[string]any {
outputs, _ := task.DecodeOutputs(s)
return outputs
}
// eventDataJSON and eventDataValue convert events.Event.Data (map[string]any)
// to/from a JSON object string, mirroring the store's own on-disk column.
func eventDataJSON(data map[string]any) string {
@@ -1,6 +1,7 @@
package staterpc
import (
"encoding/json"
"errors"
"testing"
@@ -59,27 +60,53 @@ func TestWorkflowCallerConformance(t *testing.T) {
// A callee that has not moved yet answers its queued status with
// no detail; after a transition the detail is the latest one.
status, detail, err := c.CallStatus(ctx, caller.ID, callee.ID)
status, detail, outputs, err := c.CallStatus(ctx, caller.ID, callee.ID)
if err != nil || status != workflow.StatusQueued || detail != "" {
t.Fatalf("CallStatus queued = (%q, %q, %v), want (queued, \"\", nil)", status, detail, err)
}
if outputs != nil {
t.Fatalf("CallStatus queued outputs = %+v, want none", outputs)
}
if err := local.Transition(ctx, callee.ID, callee.Status, workflow.StatusRunning, "started"); err != nil {
t.Fatalf("Transition callee to running: %v", err)
}
if err := local.Transition(ctx, callee.ID, workflow.StatusRunning, workflow.StatusCompleted, "contained 10.0.0.9"); err != nil {
t.Fatalf("Transition callee to completed: %v", err)
}
status, detail, err = c.CallStatus(ctx, caller.ID, callee.ID)
status, detail, _, err = c.CallStatus(ctx, caller.ID, callee.ID)
if err != nil || status != workflow.StatusCompleted || detail != "contained 10.0.0.9" {
t.Fatalf("CallStatus completed = (%q, %q, %v), want the terminal status and detail", status, detail, err)
}
// The callee's written outputs ride the same answer
// (docs/prds/workflow-call-outputs.md, "Storage and wire"):
// decoded from the callee's row, carried beside status and detail,
// over both adapters identically.
if row, err := local.TaskByID(ctx, callee.ID); err != nil {
t.Fatalf("TaskByID callee: %v", err)
} else {
row.Outputs = map[string]any{"contained": true, "detail_number": 3}
if err := local.Update(ctx, row); err != nil {
t.Fatalf("Update callee outputs: %v", err)
}
}
_, _, outputs, err = c.CallStatus(ctx, caller.ID, callee.ID)
if err != nil {
t.Fatalf("CallStatus with outputs: %v", err)
}
if outputs["contained"] != true {
t.Fatalf("CallStatus outputs = %+v, want the callee's written set", outputs)
}
if got, ok := outputs["detail_number"].(json.Number); !ok || got != "3" {
t.Fatalf("CallStatus outputs.detail_number = %v/%T, want the exact number", outputs["detail_number"], outputs["detail_number"])
}
// A caller reads only its own callees, over both adapters.
_, _, err = c.CallStatus(ctx, 99999, callee.ID)
_, _, _, err = c.CallStatus(ctx, 99999, callee.ID)
if !errors.Is(err, storecontract.ErrCallNotYours) {
t.Fatalf("CallStatus foreign caller = %v, want ErrCallNotYours", err)
}
_, _, err = c.CallStatus(ctx, caller.ID, 99999)
_, _, _, err = c.CallStatus(ctx, caller.ID, 99999)
if !errors.Is(err, storecontract.ErrCallNotYours) {
t.Fatalf("CallStatus missing callee = %v, want ErrCallNotYours", err)
}
+11 -1
View File
@@ -335,6 +335,12 @@ message Task {
// writer reads as a depth-0 root run.
int64 call_parent_task_id = 36;
int32 call_depth = 37;
// outputs_json is the JSON object of declared-output values this run wrote
// (task.EncodeOutputs), empty for a run that wrote none. The container's
// Update sends the whole row, so a column the message cannot carry is a
// column that write drops (docs/prds/workflow-call-outputs.md, "Storage and
// wire").
string outputs_json = 38;
}
// Event mirrors internal/events.Event. Data is carried as a JSON object
@@ -1041,9 +1047,13 @@ message WorkflowCallStatusRequest {
}
message WorkflowCallStatusResponse {
// status is the callee's task status and detail its latest transition
// detail (empty before the callee first moves).
// detail (empty before the callee first moves). outputs_json is the
// callee's written outputs (task.EncodeOutputs), so a wait:true caller can
// publish one as its own (docs/prds/workflow-call-outputs.md, "Storage and
// wire").
string status = 1;
string detail = 2;
string outputs_json = 3;
}
message InstalledPackage {