go-dispatch-stub-wiring

Answer

The repo wasn't checked out in this sandbox, so I reconstructed the described architecture 1:1 (workflow / router / framework + composition root) and applied the fix. The core changes are exactly the three the problem calls for:

1. Define NodeExecutor in the router package (router/router.go) — workflow.DefaultExecutor satisfies it (compile-time asserted):

// NodeExecutor executes a workflow node. workflow.DefaultExecutor satisfies it.
type NodeExecutor interface {
    Execute(ctx context.Context, kind workflow.NodeKind, ec workflow.ExecutionContext) (any, error)
}

// Compile-time assertion: the production executor is a NodeExecutor.
var _ NodeExecutor = (*workflow.DefaultExecutor)(nil)

type Router struct{ executor NodeExecutor }

// New returns a Router that runs nodes through the given executor.
func New(executor NodeExecutor) *Router { return &Router{executor: executor} }

2. Wire the executor at the composition root (cmd/server/main.go) — this is the line that was missing; router.New() previously received nothing, so /execute fell back to the Phase-1 stub echo:

r := router.New(framework.NewWorkflowExecutor())  // was: router.New()

framework.NewWorkflowExecutor() returns the executor built from the LLM provider (its llmWorkflowHandler adapts the provider into the workflow.LLMProvider surface; workflow.NewDefaultExecutor(...) wraps it).

3. dispatch() switches on handler type instead of echoing (router/router.go) — this replaces the stub:

func (r *Router) dispatch(ctx context.Context, req ExecuteRequest) (any, error) {
    switch workflow.NodeKind(req.HandlerType) {
    case workflow.NodeLLM:
        return r.executor.Execute(ctx, workflow.NodeLLM, workflow.ExecutionContext{
            AppID:  req.AppID,
            Inputs: req.Inputs,
        })
    case workflow.NodeJIT:
        // Phase-2: JIT backend not built yet. Typed error -> HTTP 501.
        return nil, &workflow.NotImplementedError{Kind: workflow.NodeJIT}
    default:
        return nil, fmt.Errorf("router: unknown handler type %q", req.HandlerType)
    }
}

The 501 mapping lives in the HTTP layer using errors.As against the typed error:

result, err := r.dispatch(req.Context(), body)
if err != nil {
    var nerr *workflow.NotImplementedError
    if errors.As(err, &nerr) {
        http.Error(w, nerr.Error(), http.StatusNotImplemented) // 501
        return
    }
    http.Error(w, err.Error(), http.StatusInternalServerError)
    return
}
writeJSON(w, http.StatusOK, result)

Supporting pieces: workflow.NodeKind (NodeLLM="llm", NodeJIT="jit"), ExecutionContext{AppID, Inputs}, and the typed NotImplementedError{Kind} — all in workflow/workflow.go.