refactor: migrate to connect-go v2 (#1325)

Migrates the runner to `connectrpc.com/connect/v2` by pinning actionslib v1.5.0, which carries https://gitea.com/gitea/actionslib/pulls/28. The wire behaviour towards Gitea is unchanged and works against Gitea servers on connect v1 and v2. The client keeps v1's unlimited response size, and the error codes and messages the runner checks stay the same.

Reviewed-on: https://gitea.com/gitea/runner/pulls/1325
Reviewed-by: bircni <[email protected]>
Co-authored-by: silverwind <[email protected]>

internal/pkg/client/client.go

@@ -8,17 +8,17 @@ import (
 	"errors"
 	"strings"
 
-	"connectrpc.com/connect"
-	"gitea.dev/actionslib/runner/v1"
+	"connectrpc.com/connect/v2"
+	runnerv1 "gitea.dev/actionslib/runner/v1"
 )
 
 // A Client manages communication with the runner.
 type Client interface {
 	Address() string
-	Declare(context.Context, *connect.Request[runnerv1.DeclareRequest]) (*connect.Response[runnerv1.DeclareResponse], error)
-	FetchTask(context.Context, *connect.Request[runnerv1.FetchTaskRequest]) (*connect.Response[runnerv1.FetchTaskResponse], error)
-	UpdateLog(context.Context, *connect.Request[runnerv1.UpdateLogRequest]) (*connect.Response[runnerv1.UpdateLogResponse], error)
-	UpdateTask(context.Context, *connect.Request[runnerv1.UpdateTaskRequest]) (*connect.Response[runnerv1.UpdateTaskResponse], error)
+	Declare(context.Context, *runnerv1.DeclareRequest) (*runnerv1.DeclareResponse, error)
+	FetchTask(context.Context, *runnerv1.FetchTaskRequest) (*runnerv1.FetchTaskResponse, error)
+	UpdateLog(context.Context, *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error)
+	UpdateTask(context.Context, *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error)
 }
 
 // IsRegistrationRejected reports whether Gitea itself answered "unregistered runner", unlike a proxy's 401.

internal/pkg/client/http.go

@@ -13,7 +13,8 @@ import (
 
 	"gitea.com/gitea/runner/internal/pkg/ver"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
+	"connectrpc.com/connect/v2/connecthttp"
 	"gitea.dev/actionslib/ping/v1/pingv1connect"
 	"gitea.dev/actionslib/pkg/protocol"
 	"gitea.dev/actionslib/runner/v1/runnerv1connect"
@@ -57,40 +58,33 @@ func getHTTPClient(endpoint string, tlsConfig *tls.Config, timeout time.Duration
 // New returns a new runner client. timeout bounds every RPC: without it a
 // stalled connection parks the reporter for the whole job context, so logs and
 // heartbeats stop together and the task is reaped as a zombie.
-func New(endpoint string, tlsConfig *tls.Config, uuid, token string, timeout time.Duration, extraHeaders map[string]string, opts ...connect.ClientOption) *HTTPClient {
+func New(endpoint string, tlsConfig *tls.Config, uuid, token string, timeout time.Duration, extraHeaders map[string]string, opts ...connecthttp.Option) *HTTPClient {
 	baseURL := strings.TrimRight(endpoint, "/") + "/api/actions"
 
-	opts = append(opts, connect.WithInterceptors(connect.UnaryInterceptorFunc(func(next connect.UnaryFunc) connect.UnaryFunc {
-		return func(ctx context.Context, req connect.AnyRequest) (connect.AnyResponse, error) {
+	opts = append([]connecthttp.Option{connecthttp.WithReadMaxBytes(0)}, opts...)
+	rpcClient := connect.NewClient(connecthttp.NewTransport(getHTTPClient(endpoint, tlsConfig, timeout, extraHeaders), baseURL, opts...), func(next connect.ClientFunc) connect.ClientFunc {
+		return func(ctx context.Context, spec connect.Spec) (connect.ClientStream, error) {
+			info, _ := connect.CallInfoForClientContext(ctx)
 			for name, value := range extraHeaders {
-				if req.Header().Get(name) == "" { // keep protocol headers such as Content-Type
-					req.Header().Set(name, value)
+				if info.RequestHeader().Get(name) == "" {
+					info.RequestHeader().Set(name, value)
 				}
 			}
-			req.Header().Set("User-Agent", "gitea-runner/"+ver.Version())
+			info.RequestHeader().Set("User-Agent", "gitea-runner/"+ver.Version())
 			if uuid != "" {
-				req.Header().Set(protocol.UUIDHeader, uuid)
+				info.RequestHeader().Set(protocol.UUIDHeader, uuid)
 			}
 			if token != "" {
-				req.Header().Set(protocol.TokenHeader, token)
+				info.RequestHeader().Set(protocol.TokenHeader, token)
 			}
-			return next(ctx, req)
+			return next(ctx, spec)
 		}
-	})))
+	})
 
-	httpClient := getHTTPClient(endpoint, tlsConfig, timeout, extraHeaders)
 	return &HTTPClient{
-		PingServiceClient: pingv1connect.NewPingServiceClient(
-			httpClient,
-			baseURL,
-			opts...,
-		),
-		RunnerServiceClient: runnerv1connect.NewRunnerServiceClient(
-			httpClient,
-			baseURL,
-			opts...,
-		),
-		endpoint: endpoint,
+		PingServiceClient:   pingv1connect.NewPingServiceClient(rpcClient),
+		RunnerServiceClient: runnerv1connect.NewRunnerServiceClient(rpcClient),
+		endpoint:            endpoint,
 	}
 }
 

internal/pkg/client/http_test.go

@@ -12,10 +12,12 @@ import (
 	"testing"
 	"time"
 
-	"connectrpc.com/connect"
+	"gitea.com/gitea/runner/internal/pkg/ver"
+
 	pingv1 "gitea.dev/actionslib/ping/v1"
 	"gitea.dev/actionslib/pkg/protocol"
 	"github.com/stretchr/testify/require"
+	"google.golang.org/protobuf/proto"
 )
 
 func TestGetHTTPClientUsesProxyFromEnvironment(t *testing.T) {
@@ -44,10 +46,14 @@ func TestGetHTTPClientAppliesTLSConfigOnlyToHTTPS(t *testing.T) {
 func TestNewSetsBaseURLAndHeaders(t *testing.T) {
 	var gotPath string
 	gotHeaders := make(http.Header)
+	data := strings.Repeat("x", 4<<20)
+	body, err := proto.Marshal(&pingv1.PingResponse{Data: data})
+	require.NoError(t, err)
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		gotPath = r.URL.Path
 		gotHeaders = r.Header.Clone()
-		w.WriteHeader(http.StatusInternalServerError)
+		w.Header().Set("Content-Type", "application/proto")
+		_, _ = w.Write(body)
 	}))
 	defer server.Close()
 
@@ -61,14 +67,19 @@ func TestNewSetsBaseURLAndHeaders(t *testing.T) {
 	// Address returns the endpoint as supplied (untrimmed)
 	require.Equal(t, server.URL+"/", c.Address())
 
-	// the call is expected to fail (server returns 500), we only assert what was sent
-	_, _ = c.Ping(t.Context(), connect.NewRequest(&pingv1.PingRequest{Data: "hi"}))
+	resp, err := c.Ping(t.Context(), &pingv1.PingRequest{Data: "hi"})
+	require.NoError(t, err)
+	require.Equal(t, data, resp.Data)
 
 	require.True(t, strings.HasPrefix(gotPath, "/api/actions/"), "unexpected path %q", gotPath)
 	require.Equal(t, "the-uuid", gotHeaders.Get(protocol.UUIDHeader))
 	require.Equal(t, "the-token", gotHeaders.Get(protocol.TokenHeader))
 	require.Equal(t, "proxy-token", gotHeaders.Get("X-Proxy-Token"))
 	require.Equal(t, "application/proto", gotHeaders.Get("Content-Type"))
+	require.Equal(t, "gitea-runner/"+ver.Version(), gotHeaders.Get("User-Agent"))
+	require.Equal(t, "1", gotHeaders.Get("Connect-Protocol-Version"))
+	require.Equal(t, "gzip", gotHeaders.Get("Accept-Encoding"))
+	require.Empty(t, gotHeaders.Get("Content-Encoding"))
 }
 
 func TestNewOmitsEmptyHeaders(t *testing.T) {
@@ -80,7 +91,7 @@ func TestNewOmitsEmptyHeaders(t *testing.T) {
 	defer server.Close()
 
 	c := New(server.URL, nil, "", "", time.Minute, nil)
-	_, _ = c.Ping(t.Context(), connect.NewRequest(&pingv1.PingRequest{Data: "hi"}))
+	_, _ = c.Ping(t.Context(), &pingv1.PingRequest{Data: "hi"})
 
 	require.Empty(t, gotHeaders.Get(protocol.UUIDHeader))
 	require.Empty(t, gotHeaders.Get(protocol.TokenHeader))
@@ -93,7 +104,7 @@ func TestNewStopsRedirectLoop(t *testing.T) {
 	defer server.Close()
 
 	c := New(server.URL, nil, "", "", time.Minute, nil)
-	_, err := c.Ping(t.Context(), connect.NewRequest(&pingv1.PingRequest{Data: "hi"}))
+	_, err := c.Ping(t.Context(), &pingv1.PingRequest{Data: "hi"})
 	require.ErrorContains(t, err, "stopped after 10 redirects")
 }
 
@@ -119,7 +130,7 @@ func TestNewRedirectKeepsExtraHeadersOnlyOnSameHost(t *testing.T) {
 		gotHeaders = nil
 		origin := tc.newOrigin(http.RedirectHandler("http://"+net.JoinHostPort(tc.host, port), http.StatusPermanentRedirect))
 		c := New(origin.URL, &tls.Config{InsecureSkipVerify: true}, "the-uuid", "the-token", time.Minute, map[string]string{"X-Proxy-Token": "proxy-token", "Content-Type": "text/plain"})
-		_, _ = c.Ping(t.Context(), connect.NewRequest(&pingv1.PingRequest{Data: "hi"}))
+		_, _ = c.Ping(t.Context(), &pingv1.PingRequest{Data: "hi"})
 		origin.Close()
 
 		require.NotNil(t, gotHeaders, origin.URL)

internal/pkg/client/mocks/Client.go

@@ -7,8 +7,7 @@ import (
 	"context"
 	"fmt"
 
-	"connectrpc.com/connect"
-	"gitea.dev/actionslib/runner/v1"
+	runnerv1 "gitea.dev/actionslib/runner/v1"
 	"github.com/stretchr/testify/mock"
 )
 
@@ -21,15 +20,15 @@ func (m *Client) Address() string {
 	return m.AddressValue
 }
 
-func call[Request, Response any](ctx context.Context, m *Client, method string, request *connect.Request[Request]) (*connect.Response[Response], error) {
+func call[Request, Response any](ctx context.Context, m *Client, method string, request *Request) (*Response, error) {
 	returns := m.MethodCalled(method, ctx, request)
-	if callback, ok := returns.Get(0).(func(context.Context, *connect.Request[Request]) (*connect.Response[Response], error)); ok {
+	if callback, ok := returns.Get(0).(func(context.Context, *Request) (*Response, error)); ok {
 		return callback(ctx, request)
 	}
-	var response *connect.Response[Response]
+	var response *Response
 	if value := returns.Get(0); value != nil {
 		var ok bool
-		response, ok = value.(*connect.Response[Response])
+		response, ok = value.(*Response)
 		if !ok {
 			panic(fmt.Sprintf("unexpected response type %T for %s", value, method))
 		}
@@ -37,19 +36,19 @@ func call[Request, Response any](ctx context.Context, m *Client, method string,
 	return response, returns.Error(1)
 }
 
-func (m *Client) Declare(ctx context.Context, request *connect.Request[runnerv1.DeclareRequest]) (*connect.Response[runnerv1.DeclareResponse], error) {
+func (m *Client) Declare(ctx context.Context, request *runnerv1.DeclareRequest) (*runnerv1.DeclareResponse, error) {
 	return call[runnerv1.DeclareRequest, runnerv1.DeclareResponse](ctx, m, "Declare", request)
 }
 
-func (m *Client) FetchTask(ctx context.Context, request *connect.Request[runnerv1.FetchTaskRequest]) (*connect.Response[runnerv1.FetchTaskResponse], error) {
+func (m *Client) FetchTask(ctx context.Context, request *runnerv1.FetchTaskRequest) (*runnerv1.FetchTaskResponse, error) {
 	return call[runnerv1.FetchTaskRequest, runnerv1.FetchTaskResponse](ctx, m, "FetchTask", request)
 }
 
-func (m *Client) UpdateLog(ctx context.Context, request *connect.Request[runnerv1.UpdateLogRequest]) (*connect.Response[runnerv1.UpdateLogResponse], error) {
+func (m *Client) UpdateLog(ctx context.Context, request *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
 	return call[runnerv1.UpdateLogRequest, runnerv1.UpdateLogResponse](ctx, m, "UpdateLog", request)
 }
 
-func (m *Client) UpdateTask(ctx context.Context, request *connect.Request[runnerv1.UpdateTaskRequest]) (*connect.Response[runnerv1.UpdateTaskResponse], error) {
+func (m *Client) UpdateTask(ctx context.Context, request *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 	return call[runnerv1.UpdateTaskRequest, runnerv1.UpdateTaskResponse](ctx, m, "UpdateTask", request)
 }
 

internal/pkg/report/joblog_test.go

@@ -15,7 +15,6 @@ import (
 	"gitea.com/gitea/runner/internal/pkg/client/mocks"
 	"gitea.com/gitea/runner/internal/pkg/config"
 
-	connect_go "connectrpc.com/connect"
 	runnerv1 "gitea.dev/actionslib/runner/v1"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/mock"
@@ -34,10 +33,10 @@ func readJobLog(t *testing.T, joblog *jobLog) string {
 
 func TestJobLog_MirrorsUploadedRows(t *testing.T) {
 	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateLogResponse{AckIndex: req.Msg.Index + int64(len(req.Msg.Rows))}), nil
+	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+		return &runnerv1.UpdateLogResponse{AckIndex: req.Index + int64(len(req.Rows))}, nil
 	})
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil)
+	client.On("UpdateTask", mock.Anything, mock.Anything).Return(&runnerv1.UpdateTaskResponse{}, nil)
 
 	cfg, err := config.LoadDefault("")
 	require.NoError(t, err)

internal/pkg/report/reporter.go

@@ -21,7 +21,7 @@ import (
 	"gitea.com/gitea/runner/internal/pkg/config"
 	"gitea.com/gitea/runner/internal/pkg/metrics"
 
-	"connectrpc.com/connect"
+	"connectrpc.com/connect/v2"
 	"gitea.dev/actionslib/pkg/model"
 	runnerv1 "gitea.dev/actionslib/runner/v1"
 	"google.golang.org/protobuf/proto"
@@ -823,12 +823,12 @@ func (r *Reporter) reportLog(noMore bool) (bool, error) {
 	defer rpcCancel()
 
 	start := time.Now()
-	resp, err := r.client.UpdateLog(rpcCtx, connect.NewRequest(&runnerv1.UpdateLogRequest{
+	resp, err := r.client.UpdateLog(rpcCtx, &runnerv1.UpdateLogRequest{
 		TaskId: r.state.Id,
 		Index:  int64(r.logOffset),
 		Rows:   rows,
 		NoMore: noMore,
-	}))
+	})
 	metrics.ReportLogDuration.Observe(time.Since(start).Seconds())
 	if err != nil {
 		metrics.ReportLogTotal.WithLabelValues(metrics.LabelResultError).Inc()
@@ -837,7 +837,7 @@ func (r *Reporter) reportLog(noMore bool) (bool, error) {
 	}
 	metrics.ReportLogTotal.WithLabelValues(metrics.LabelResultSuccess).Inc()
 
-	ack := int(resp.Msg.AckIndex)
+	ack := int(resp.AckIndex)
 	if ack < r.logOffset {
 		return false, errors.New("submitted logs are lost")
 	}
@@ -902,10 +902,10 @@ func (r *Reporter) ReportState(reportResult bool) error {
 	defer rpcCancel()
 
 	start := time.Now()
-	resp, err := r.client.UpdateTask(rpcCtx, connect.NewRequest(&runnerv1.UpdateTaskRequest{
+	resp, err := r.client.UpdateTask(rpcCtx, &runnerv1.UpdateTaskRequest{
 		State:   state,
 		Outputs: outputs,
-	}))
+	})
 	metrics.ReportStateDuration.Observe(time.Since(start).Seconds())
 	if err != nil {
 		metrics.ReportStateTotal.WithLabelValues(metrics.LabelResultError).Inc()
@@ -920,7 +920,7 @@ func (r *Reporter) ReportState(reportResult bool) error {
 
 	var noSent []string
 	r.outputsMu.Lock()
-	for _, k := range resp.Msg.SentOutputs {
+	for _, k := range resp.SentOutputs {
 		if _, ok := r.outputs[k]; ok {
 			r.outputs[k] = jobOutput{sent: true}
 		}
@@ -934,7 +934,7 @@ func (r *Reporter) ReportState(reportResult bool) error {
 
 	// A terminal result means the server is done with this task; keep running and
 	// the job holds a capacity slot until runner.timeout.
-	if state := resp.Msg.State; state != nil && state.Result != runnerv1.Result_RESULT_UNSPECIFIED {
+	if state := resp.State; state != nil && state.Result != runnerv1.Result_RESULT_UNSPECIFIED {
 		r.stateMu.Lock()
 		r.serverResult = state.Result
 		r.stateMu.Unlock()

internal/pkg/report/reporter_test.go

@@ -25,7 +25,6 @@ import (
 	"gitea.com/gitea/runner/internal/pkg/config"
 	"gitea.com/gitea/runner/internal/pkg/metrics"
 
-	connect_go "connectrpc.com/connect"
 	"gitea.dev/actionslib/pkg/model"
 	runnerv1 "gitea.dev/actionslib/runner/v1"
 	"github.com/stretchr/testify/assert"
@@ -57,13 +56,13 @@ func TestReporter_LogLevelFiltering(t *testing.T) {
 	defer logging.SetLevel(origLevel)
 
 	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-			AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-		}), nil
+	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+		return &runnerv1.UpdateLogResponse{
+			AckIndex: req.Index + int64(len(req.Rows)),
+		}, nil
 	})
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+		return &runnerv1.UpdateTaskResponse{}, nil
 	})
 
 	ctx, cancel := context.WithCancel(t.Context())
@@ -119,22 +118,22 @@ func TestReporter_EphemeralRunnerDeletion(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
 			if runnerDeleted {
 				return nil, errors.New("runner has been deleted")
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			// Server deletes ephemeral runner when it receives a completed state
-			if req.Msg.State != nil && req.Msg.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
+			if req.State != nil && req.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
 				runnerDeleted = true
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -191,15 +190,15 @@ func TestReporter_EphemeralRunnerDeletion(t *testing.T) {
 func TestReporter_RunDaemonClose_Race(t *testing.T) {
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -232,16 +231,16 @@ func TestReporter_MaxLatencyTimer(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
 			updateLogCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -283,16 +282,16 @@ func TestReporter_BatchSizeFlush(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
 			updateLogCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -338,14 +337,14 @@ func TestReporter_StateChangedNotLostDuringReport(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			n := updateTaskCalls.Add(1)
 			if n == 1 {
 				// Signal that the first UpdateTask is in flight, then block until released.
 				close(inFlight)
 				<-release
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -401,12 +400,12 @@ func TestReporter_StateChangedRestoredOnError(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			n := updateTaskCalls.Add(1)
 			if n == 1 {
 				return nil, errors.New("transient network error")
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -442,16 +441,16 @@ func TestReporter_StateNotifyFlush(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			updateTaskCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -496,19 +495,19 @@ func TestReporter_CloseAlwaysSendsRowsWithNoMore(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			lastReq.Store(req.Msg)
-			if req.Msg.NoMore {
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			lastReq.Store(req)
+			if req.NoMore {
 				noMoreCalls.Add(1)
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -557,9 +556,9 @@ func TestReporter_StateHeartbeat(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			updateTaskCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -605,13 +604,13 @@ func TestReporter_ServerCancelStillFlushesFinal(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			if req.Msg.NoMore {
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			if req.NoMore {
 				finalLogNoMoreSeen.Store(true)
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	// The first UpdateTask returns RESULT_CANCELLED — modelling a server-side
@@ -619,19 +618,19 @@ func TestReporter_ServerCancelStillFlushesFinal(t *testing.T) {
 	// UpdateTask issued by Close() must still arrive even though r.ctx is now
 	// cancelled.
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			n := updateTaskCalls.Add(1)
 			if n == 1 {
-				return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{
+				return &runnerv1.UpdateTaskResponse{
 					State: &runnerv1.TaskState{
 						Result: runnerv1.Result_RESULT_CANCELLED,
 					},
-				}), nil
+				}, nil
 			}
-			if req.Msg.State != nil && req.Msg.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
+			if req.State != nil && req.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
 				finalTaskStateSeen.Store(true)
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -685,22 +684,22 @@ func TestReporter_CloseReportsCancelledOnCanceledCtx(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			if req.Msg.NoMore {
-				rows := append([]*runnerv1.LogRow(nil), req.Msg.Rows...)
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			if req.NoMore {
+				rows := append([]*runnerv1.LogRow(nil), req.Rows...)
 				finalLogRows.Store(&rows)
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			if req.Msg.State != nil && req.Msg.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
-				finalState.Store(req.Msg.State)
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			if req.State != nil && req.State.Result != runnerv1.Result_RESULT_UNSPECIFIED {
+				finalState.Store(req.State)
 			}
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -750,16 +749,16 @@ func TestReporter_StopHeartbeats(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Maybe().Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
 			updateTaskCalls.Add(1)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -895,9 +894,9 @@ func TestReporter_OutputsSentOnce(t *testing.T) {
 	client := mocks.NewClient(t)
 	var reported []map[string]string
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			reported = append(reported, req.Msg.Outputs)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{SentOutputs: slices.Collect(maps.Keys(req.Msg.Outputs))}), nil
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			reported = append(reported, req.Outputs)
+			return &runnerv1.UpdateTaskResponse{SentOutputs: slices.Collect(maps.Keys(req.Outputs))}, nil
 		})
 
 	ctx, cancel := context.WithCancel(t.Context())
@@ -983,8 +982,8 @@ func TestReporter_masksEncodedSecrets(t *testing.T) {
 // process down with it.
 func TestReporter_AckIndexBeyondBuffer(t *testing.T) {
 	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateLogResponse{AckIndex: 1000}), nil
+	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, _ *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+		return &runnerv1.UpdateLogResponse{AckIndex: 1000}, nil
 	})
 
 	ctx, cancel := context.WithCancel(t.Context())
@@ -1011,17 +1010,17 @@ func TestReporter_CloseWithStuckDaemon(t *testing.T) {
 	var once sync.Once
 
 	client := mocks.NewClient(t)
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
+	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
 		once.Do(func() {
 			close(entered)
 			<-release
 		})
-		return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-			AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-		}), nil
+		return &runnerv1.UpdateLogResponse{
+			AckIndex: req.Index + int64(len(req.Rows)),
+		}, nil
 	})
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+		return &runnerv1.UpdateTaskResponse{}, nil
 	}).Maybe()
 
 	ctx, cancel := context.WithCancel(t.Context())
@@ -1059,16 +1058,16 @@ func TestReporter_CloseWithStuckDaemon(t *testing.T) {
 func TestReporter_ServerFailureResultIsReportedAsFailure(t *testing.T) {
 	var lastState *runnerv1.TaskState
 	client := mocks.NewClient(t)
-	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-		lastState = req.Msg.State
-		return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{
+	client.On("UpdateTask", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+		lastState = req.State
+		return &runnerv1.UpdateTaskResponse{
 			State: &runnerv1.TaskState{Result: runnerv1.Result_RESULT_FAILURE},
-		}), nil
+		}, nil
 	})
-	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-		return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-			AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-		}), nil
+	client.On("UpdateLog", mock.Anything, mock.Anything).Return(func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+		return &runnerv1.UpdateLogResponse{
+			AckIndex: req.Index + int64(len(req.Rows)),
+		}, nil
 	}).Maybe()
 
 	ctx, cancel := context.WithCancel(t.Context())
@@ -1115,16 +1114,16 @@ func TestReporter_CloseMasksLastWords(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			rows = append(rows, req.Msg.Rows...)
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: req.Msg.Index + int64(len(req.Msg.Rows)),
-			}), nil
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			rows = append(rows, req.Rows...)
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: req.Index + int64(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, _ *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -1184,16 +1183,16 @@ func TestReporter_StepRangeCoversAckedRows(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{
-				AckIndex: server.appendRows(len(req.Msg.Rows)),
-			}), nil
+		func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{
+				AckIndex: server.appendRows(len(req.Rows)),
+			}, nil
 		},
 	)
 	client.On("UpdateTask", mock.Anything, mock.Anything).Return(
-		func(_ context.Context, req *connect_go.Request[runnerv1.UpdateTaskRequest]) (*connect_go.Response[runnerv1.UpdateTaskResponse], error) {
-			server.applyState(req.Msg.State)
-			return connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil
+		func(_ context.Context, req *runnerv1.UpdateTaskRequest) (*runnerv1.UpdateTaskResponse, error) {
+			server.applyState(req.State)
+			return &runnerv1.UpdateTaskResponse{}, nil
 		},
 	)
 
@@ -1250,8 +1249,8 @@ func TestReporter_FlushWithoutAckedRowsSkipsState(t *testing.T) {
 
 	client := mocks.NewClient(t)
 	client.On("UpdateLog", mock.Anything, mock.Anything).Once().Return(
-		func(_ context.Context, _ *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{AckIndex: 0}), nil
+		func(_ context.Context, _ *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{AckIndex: 0}, nil
 		},
 	)
 
@@ -1277,10 +1276,10 @@ func newTestSteps(n int) []*model.Step {
 func TestReporter_ReportedSteps(t *testing.T) {
 	newReporter := func(t *testing.T, steps []*model.Step) (*Reporter, context.CancelFunc) {
 		client := mocks.NewClient(t)
-		client.On("UpdateLog", mock.Anything, mock.Anything).Maybe().Return(func(_ context.Context, req *connect_go.Request[runnerv1.UpdateLogRequest]) (*connect_go.Response[runnerv1.UpdateLogResponse], error) {
-			return connect_go.NewResponse(&runnerv1.UpdateLogResponse{AckIndex: req.Msg.Index + int64(len(req.Msg.Rows))}), nil
+		client.On("UpdateLog", mock.Anything, mock.Anything).Maybe().Return(func(_ context.Context, req *runnerv1.UpdateLogRequest) (*runnerv1.UpdateLogResponse, error) {
+			return &runnerv1.UpdateLogResponse{AckIndex: req.Index + int64(len(req.Rows))}, nil
 		})
-		client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(connect_go.NewResponse(&runnerv1.UpdateTaskResponse{}), nil)
+		client.On("UpdateTask", mock.Anything, mock.Anything).Maybe().Return(&runnerv1.UpdateTaskResponse{}, nil)
 		taskCtx, err := structpb.NewStruct(map[string]any{})
 		require.NoError(t, err)
 		cfg, _ := config.LoadDefault("")