chore: lint fixes part 5

pawbana · pawbana · commit 02b6daf13e32 · 2026-04-13T11:40:42.000Z
diff --git a/bridge.go b/bridge.go
@@ -276,7 +276,7 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC
 			log.Debug(ctx, "interception ended")
 		}
 
-		asyncRecorder.RecordInterceptionEnded(ctx, &recorder.InterceptionRecordEnded{ID: interceptor.ID().String()})
+		_ = asyncRecorder.RecordInterceptionEnded(ctx, &recorder.InterceptionRecordEnded{ID: interceptor.ID().String()})
 
 		// Ensure all recording have completed before completing request.
 		asyncRecorder.Wait()
diff --git a/intercept/chatcompletions/base.go b/intercept/chatcompletions/base.go
@@ -173,7 +173,7 @@ func (i *interceptionBase) unmarshalArgs(in string) (args recorder.ToolArgs) {
 }
 
 // writeUpstreamError marshals and writes a given error.
-func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr *errorResponse) {
+func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr *chatCompletionResponseError) {
 	if oaiErr == nil {
 		return
 	}
@@ -183,7 +183,7 @@ func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr *err
 
 	out, err := json.Marshal(oaiErr)
 	if err != nil {
-		i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", slog.F("%+v", oaiErr)))
+		i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", oaiErr))
 		// Response has to match expected format.
 		_, _ = w.Write([]byte(`{
 	"error": {
@@ -228,13 +228,13 @@ func calculateActualInputTokenUsage(in openai.CompletionUsage) int64 {
 		in.PromptTokensDetails.CachedTokens /* The aggregated number of text input tokens that has been cached from previous requests. */
 }
 
-func getErrorResponse(err error) *errorResponse {
+func getErrorResponse(err error) *chatCompletionResponseError {
 	var apiErr *openai.Error
 	if !errors.As(err, &apiErr) {
 		return nil
 	}
 
-	return &errorResponse{
+	return &chatCompletionResponseError{
 		ErrorObject: &shared.ErrorObject{
 			Code:    apiErr.Code,
 			Message: apiErr.Message,
@@ -244,15 +244,15 @@ func getErrorResponse(err error) *errorResponse {
 	}
 }
 
-var _ error = &errorResponse{}
+var _ error = &chatCompletionResponseError{}
 
-type errorResponse struct {
+type chatCompletionResponseError struct {
 	ErrorObject *shared.ErrorObject `json:"error"`
 	StatusCode  int                 `json:"-"`
 }
 
-func newErrorResponse(msg error) *errorResponse {
-	return &errorResponse{
+func newErrorResponse(msg error) *chatCompletionResponseError {
+	return &chatCompletionResponseError{
 		ErrorObject: &shared.ErrorObject{
 			Code:    "error",
 			Message: msg.Error(),
@@ -261,7 +261,7 @@ func newErrorResponse(msg error) *errorResponse {
 	}
 }
 
-func (a *errorResponse) Error() string {
+func (a *chatCompletionResponseError) Error() string {
 	if a.ErrorObject == nil {
 		return ""
 	}
diff --git a/intercept/chatcompletions/streaming.go b/intercept/chatcompletions/streaming.go
@@ -245,7 +245,7 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 				logger.Warn(ctx, "openai stream error", slog.Error(streamErr))
 				interceptionErr = oaiErr
 			} else {
-				logger.Warn(ctx, "unknown error", slog.Error(streamErr))
+				logger.Warn(ctx, "unknown stream error encountered", slog.Error(streamErr))
 				// Unfortunately, the OpenAI SDK does not support parsing errors received in the stream
 				// into known types (i.e. [shared.OverloadedError]).
 				// See https://github.com/openai/openai-go/blob/v2.7.0/packages/ssestream/ssestream.go#L171
@@ -254,14 +254,14 @@ func (i *StreamingInterception) ProcessRequest(w http.ResponseWriter, r *http.Re
 			}
 		} else if lastErr != nil {
 			// Otherwise check if any logical errors occurred during processing.
-			logger.Warn(ctx, "stream failed", slog.Error(lastErr))
+			logger.Warn(ctx, "stream processing failed", slog.Error(lastErr))
 			interceptionErr = newErrorResponse(xerrors.Errorf("processing error: %w", lastErr))
 		}
 
 		if interceptionErr != nil {
 			payload, err := i.marshalErr(interceptionErr)
 			if err != nil {
-				logger.Warn(ctx, "failed to marshal error", slog.Error(err), slog.F("error_payload", slog.F("%+v", interceptionErr)))
+				logger.Warn(ctx, "failed to marshal error", slog.Error(err), slog.F("error_payload", interceptionErr))
 			} else if err := events.Send(streamCtx, payload); err != nil {
 				logger.Warn(ctx, "failed to relay error", slog.Error(err), slog.F("payload", payload))
 			}
diff --git a/intercept/eventstream/eventstream.go b/intercept/eventstream/eventstream.go
@@ -132,7 +132,7 @@ func (s *EventStream) Start(w http.ResponseWriter, r *http.Request) {
 			return
 		}
 		if err := flush(w); err != nil {
-			s.logger.Warn(ctx, "failed to flush", slog.Error(err))
+			s.logger.Warn(ctx, "failed to flush event stream", slog.Error(err))
 			return
 		}
 
diff --git a/intercept/messages/base.go b/intercept/messages/base.go
@@ -405,7 +405,7 @@ func filterBedrockBetaFlags(headers http.Header, model string) {
 }
 
 // writeUpstreamError marshals and writes a given error.
-func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr *ErrorResponse) {
+func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr *messagesResponseError) {
 	if antErr == nil {
 		return
 	}
@@ -415,7 +415,7 @@ func (i *interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr *Err
 
 	out, err := json.Marshal(antErr)
 	if err != nil {
-		i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", slog.F("%+v", antErr)))
+		i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", antErr))
 		// Response has to match expected format.
 		// See https://docs.claude.com/en/api/errors#error-shapes.
 		_, _ = w.Write([]byte(fmt.Sprintf(`{
@@ -487,7 +487,7 @@ func accumulateUsage(dest, src any) {
 	}
 }
 
-func getErrorResponse(err error) *ErrorResponse {
+func getErrorResponse(err error) *messagesResponseError {
 	var apierr *anthropic.Error
 	if !errors.As(err, &apierr) {
 		return nil
@@ -505,7 +505,7 @@ func getErrorResponse(err error) *ErrorResponse {
 		typ = string(detail.Type)
 	}
 
-	return &ErrorResponse{
+	return &messagesResponseError{
 		ErrorResponse: &anthropic.ErrorResponse{
 			Error: anthropic.ErrorObjectUnion{
 				Message: msg,
@@ -517,16 +517,16 @@ func getErrorResponse(err error) *ErrorResponse {
 	}
 }
 
-var _ error = &ErrorResponse{}
+var _ error = &messagesResponseError{}
 
-type ErrorResponse struct {
+type messagesResponseError struct {
 	*anthropic.ErrorResponse
 
 	StatusCode int `json:"-"`
 }
 
-func newErrorResponse(msg error) *ErrorResponse {
-	return &ErrorResponse{
+func newErrorResponse(msg error) *messagesResponseError {
+	return &messagesResponseError{
 		ErrorResponse: &shared.ErrorResponse{
 			Error: shared.ErrorObjectUnion{
 				Message: msg.Error(),
@@ -536,7 +536,7 @@ func newErrorResponse(msg error) *ErrorResponse {
 	}
 }
 
-func (a *ErrorResponse) Error() string {
+func (a *messagesResponseError) Error() string {
 	if a.ErrorResponse == nil {
 		return ""
 	}
diff --git a/intercept/messages/streaming.go b/intercept/messages/streaming.go
@@ -157,7 +157,7 @@ newStream:
 	for {
 		// TODO add outer loop span (https://github.com/coder/aibridge/issues/67)
 		if err := streamCtx.Err(); err != nil {
-			lastErr = xerrors.Errorf("stream exit: %w", err)
+			interceptionErr = xerrors.Errorf("stream exit: %w", err)
 			break
 		}
 
@@ -474,8 +474,8 @@ newStream:
 				MsgID:          message.ID,
 				Prompt:         prompt,
 			})
-			prompt = ""
-			promptFound = false
+			prompt = ""         //nolint:ineffassign // reset to prevent double-recording across newStream iterations
+			promptFound = false //nolint:ineffassign // reset to prevent double-recording across newStream iterations
 		}
 
 		if events.IsStreaming() {
@@ -488,7 +488,7 @@ newStream:
 					logger.Warn(ctx, "anthropic stream error", slog.Error(streamErr))
 					interceptionErr = antErr
 				} else {
-					logger.Warn(ctx, "unknown error", slog.Error(streamErr))
+					logger.Warn(ctx, "unknown stream error encountered", slog.Error(streamErr))
 					// Unfortunately, the Anthropic SDK does not support parsing errors received in the stream
 					// into known types (i.e. [shared.OverloadedError]).
 					// See https://github.com/anthropics/anthropic-sdk-go/blob/v1.12.0/packages/ssestream/ssestream.go#L172-L174
@@ -497,14 +497,14 @@ newStream:
 				}
 			} else if lastErr != nil {
 				// Otherwise check if any logical errors occurred during processing.
-				logger.Warn(ctx, "stream failed", slog.Error(lastErr))
+				logger.Warn(ctx, "stream processing failed", slog.Error(lastErr))
 				interceptionErr = newErrorResponse(xerrors.Errorf("processing error: %w", lastErr))
 			}
 
 			if interceptionErr != nil {
 				payload, err := i.marshal(interceptionErr)
 				if err != nil {
-					logger.Warn(ctx, "failed to marshal error", slog.Error(err), slog.F("error_payload", slog.F("%+v", interceptionErr)))
+					logger.Warn(ctx, "failed to marshal error", slog.Error(err), slog.F("error_payload", interceptionErr))
 				} else if err := events.Send(streamCtx, payload); err != nil {
 					logger.Warn(ctx, "failed to relay error", slog.Error(err), slog.F("payload", payload))
 				}
diff --git a/internal/integrationtest/circuit_breaker_test.go b/internal/integrationtest/circuit_breaker_test.go
@@ -149,12 +149,14 @@ func TestCircuitBreaker_FullRecoveryCycle(t *testing.T) {
 				resp := doRequest()
 				assert.Equal(t, http.StatusTooManyRequests, resp.StatusCode)
 			}
+			//nolint:gosec // G115: test constant, no overflow risk
 			assert.Equal(t, int32(cbConfig.FailureThreshold), upstreamCalls.Load())
 
 			// Phase 2: Verify circuit is open
 			// Request should be blocked by circuit breaker (no upstream call)
 			resp := doRequest()
 			assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode)
+			//nolint:gosec // G115: test constant, no overflow risk
 			assert.Equal(t, int32(cbConfig.FailureThreshold), upstreamCalls.Load(), "No new upstream call when circuit is open")
 
 			// Verify metrics show circuit is open
@@ -570,11 +572,13 @@ func TestCircuitBreaker_PerModelIsolation(t *testing.T) {
 		resp := doRequest("claude-sonnet-4-20250514")
 		assert.Equal(t, http.StatusTooManyRequests, resp.StatusCode)
 	}
+	//nolint:gosec // G115: test constant, no overflow risk
 	assert.Equal(t, int32(cbConfig.FailureThreshold), sonnetCalls.Load())
 
 	// Verify sonnet circuit is open
 	resp := doRequest("claude-sonnet-4-20250514")
 	assert.Equal(t, http.StatusServiceUnavailable, resp.StatusCode, "Sonnet circuit should be open")
+	//nolint:gosec // G115: test constant, no overflow risk
 	assert.Equal(t, int32(cbConfig.FailureThreshold), sonnetCalls.Load(), "No new sonnet calls when circuit is open")
 
 	// Verify sonnet metrics show circuit is open
diff --git a/mcp/proxy_streamable_http.go b/mcp/proxy_streamable_http.go
@@ -87,7 +87,7 @@ func (p *StreamableHTTPServerProxy) Init(ctx context.Context) (outErr error) {
 		return xerrors.Errorf("MCP version negotiation failed; requested %q, accepts %q, received %q", version, strings.Join(mcp.ValidProtocolVersions, ","), result.ProtocolVersion)
 	}
 
-	p.logger.Debug(ctx, "MCP client initialized", slog.F("name", result.ServerInfo.Name), slog.F("server_version", result.ServerInfo.Version))
+	p.logger.Debug(ctx, "mcp client initialized", slog.F("name", result.ServerInfo.Name), slog.F("server_version", result.ServerInfo.Version))
 
 	tools, err := p.fetchTools(ctx)
 	if err != nil {
diff --git a/passthrough.go b/passthrough.go
@@ -44,7 +44,7 @@ func newPassthroughRouter(prov provider.Provider, logger slog.Logger, m *metrics
 		// Append the request path to the upstream base path.
 		reqPath, err := url.JoinPath(upURL.Path, r.URL.Path)
 		if err != nil {
-			logger.Warn(ctx, "failed to join upstream path", slog.Error(err), slog.F("upstreamPath", upURL.Path), slog.F("requestPath", r.URL.Path))
+			logger.Warn(ctx, "failed to join upstream path", slog.Error(err), slog.F("upstream_path", upURL.Path), slog.F("request_path", r.URL.Path))
 			http.Error(w, "failed to join upstream path", http.StatusInternalServerError)
 			span.SetStatus(codes.Error, "failed to join upstream path: "+err.Error())
 			return
diff --git a/provider/anthropic.go b/provider/anthropic.go
@@ -106,7 +106,7 @@ func (p *Anthropic) CreateInterceptor(_ http.ResponseWriter, r *http.Request, tr
 	path := strings.TrimPrefix(r.URL.Path, p.RoutePrefix())
 	if path != routeMessages {
 		span.SetStatus(codes.Error, "unknown route: "+r.URL.Path)
-		return nil, UnknownRoute
+		return nil, ErrUnknownRoute
 	}
 
 	payload, err := io.ReadAll(r.Body)
diff --git a/provider/anthropic_test.go b/provider/anthropic_test.go
@@ -147,7 +147,7 @@ func TestAnthropic_CreateInterceptor(t *testing.T) {
 		assert.Empty(t, receivedHeaders.Get("Authorization"), "client Authorization header must not reach upstream")
 	})
 
-	t.Run("UnknownRoute", func(t *testing.T) {
+	t.Run("ErrUnknownRoute", func(t *testing.T) {
 		t.Parallel()
 
 		body := `{"model": "claude-opus-4-5", "max_tokens": 1024, "messages": [{"role": "user", "content": "hello"}]}`
@@ -156,7 +156,7 @@ func TestAnthropic_CreateInterceptor(t *testing.T) {
 
 		interceptor, err := provider.CreateInterceptor(w, req, testTracer)
 
-		require.ErrorIs(t, err, UnknownRoute)
+		require.ErrorIs(t, err, ErrUnknownRoute)
 		require.Nil(t, interceptor)
 	})
 }
diff --git a/provider/copilot.go b/provider/copilot.go
@@ -183,7 +183,7 @@ func (p *Copilot) CreateInterceptor(_ http.ResponseWriter, r *http.Request, trac
 
 	default:
 		span.SetStatus(codes.Error, "unknown route: "+r.URL.Path)
-		return nil, UnknownRoute
+		return nil, ErrUnknownRoute
 	}
 
 	span.SetAttributes(interceptor.TraceAttributes(r)...)
diff --git a/provider/copilot_test.go b/provider/copilot_test.go
@@ -301,7 +301,7 @@ func TestCopilot_CreateInterceptor(t *testing.T) {
 		assert.Empty(t, receivedHeaders.Get("X-Api-Key"), "X-Api-Key must not be set upstream")
 	})
 
-	t.Run("UnknownRoute", func(t *testing.T) {
+	t.Run("ErrUnknownRoute", func(t *testing.T) {
 		t.Parallel()
 
 		body := `{"model": "gpt-4.1", "messages": [{"role": "user", "content": "hello"}]}`
@@ -311,7 +311,7 @@ func TestCopilot_CreateInterceptor(t *testing.T) {
 
 		interceptor, err := provider.CreateInterceptor(w, req, testTracer)
 
-		require.ErrorIs(t, err, UnknownRoute)
+		require.ErrorIs(t, err, ErrUnknownRoute)
 		require.Nil(t, interceptor)
 	})
 }
diff --git a/provider/openai.go b/provider/openai.go
@@ -153,7 +153,7 @@ func (p *OpenAI) CreateInterceptor(_ http.ResponseWriter, r *http.Request, trace
 
 	default:
 		span.SetStatus(codes.Error, "unknown route: "+r.URL.Path)
-		return nil, UnknownRoute
+		return nil, ErrUnknownRoute
 	}
 	span.SetAttributes(interceptor.TraceAttributes(r)...)
 	return interceptor, nil
diff --git a/provider/provider.go b/provider/provider.go
@@ -10,7 +10,7 @@ import (
 	"github.com/coder/aibridge/intercept"
 )
 
-var UnknownRoute = xerrors.New("unknown route")
+var ErrUnknownRoute = xerrors.New("unknown route")
 
 // Provider defines routes (bridged and passed through) for given provider.
 // Bridged routes are processed by dedicated interceptors.

Original file line number	Diff line number	Diff line change
`@@ -276,7 +276,7 @@ func newInterceptionProcessor(p provider.Provider, cbs *circuitbreaker.ProviderC`
`276`	`276`	`log.Debug(ctx, "interception ended")`
`277`	`277`	`}`
`278`	`278`
`279`		`- asyncRecorder.RecordInterceptionEnded(ctx, &recorder.InterceptionRecordEnded{ID: interceptor.ID().String()})`
	`279`	`+ _ = asyncRecorder.RecordInterceptionEnded(ctx, &recorder.InterceptionRecordEnded{ID: interceptor.ID().String()})`
`280`	`280`
`281`	`281`	`// Ensure all recording have completed before completing request.`
`282`	`282`	`asyncRecorder.Wait()`
Original file line number	Diff line number	Diff line change
`@@ -173,7 +173,7 @@ func (i *interceptionBase) unmarshalArgs(in string) (args recorder.ToolArgs) {`
`173`	`173`	`}`
`174`	`174`
`175`	`175`	`// writeUpstreamError marshals and writes a given error.`
`176`		`-func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr errorResponse) {`
	`176`	`+func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr chatCompletionResponseError) {`
`177`	`177`	`if oaiErr == nil {`
`178`	`178`	`return`
`179`	`179`	`}`
`@@ -183,7 +183,7 @@ func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, oaiErr err`
`183`	`183`
`184`	`184`	`out, err := json.Marshal(oaiErr)`
`185`	`185`	`if err != nil {`
`186`		`- i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", slog.F("%+v", oaiErr)))`
	`186`	`+ i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", oaiErr))`
`187`	`187`	`// Response has to match expected format.`
`188`	`188`	_, _ = w.Write([]byte(`{
`189`	`189`	`"error": {`
`@@ -228,13 +228,13 @@ func calculateActualInputTokenUsage(in openai.CompletionUsage) int64 {`
`228`	`228`	`in.PromptTokensDetails.CachedTokens /* The aggregated number of text input tokens that has been cached from previous requests. */`
`229`	`229`	`}`
`230`	`230`
`231`		`-func getErrorResponse(err error) *errorResponse {`
	`231`	`+func getErrorResponse(err error) *chatCompletionResponseError {`
`232`	`232`	`var apiErr *openai.Error`
`233`	`233`	`if !errors.As(err, &apiErr) {`
`234`	`234`	`return nil`
`235`	`235`	`}`
`236`	`236`
`237`		`- return &errorResponse{`
	`237`	`+ return &chatCompletionResponseError{`
`238`	`238`	`ErrorObject: &shared.ErrorObject{`
`239`	`239`	`Code: apiErr.Code,`
`240`	`240`	`Message: apiErr.Message,`
`@@ -244,15 +244,15 @@ func getErrorResponse(err error) *errorResponse {`
`244`	`244`	`}`
`245`	`245`	`}`
`246`	`246`
`247`		`-var _ error = &errorResponse{}`
	`247`	`+var _ error = &chatCompletionResponseError{}`
`248`	`248`
`249`		`-type errorResponse struct {`
	`249`	`+type chatCompletionResponseError struct {`
`250`	`250`	ErrorObject *shared.ErrorObject `json:"error"`
`251`	`251`	StatusCode int `json:"-"`
`252`	`252`	`}`
`253`	`253`
`254`		`-func newErrorResponse(msg error) *errorResponse {`
`255`		`- return &errorResponse{`
	`254`	`+func newErrorResponse(msg error) *chatCompletionResponseError {`
	`255`	`+ return &chatCompletionResponseError{`
`256`	`256`	`ErrorObject: &shared.ErrorObject{`
`257`	`257`	`Code: "error",`
`258`	`258`	`Message: msg.Error(),`
`@@ -261,7 +261,7 @@ func newErrorResponse(msg error) *errorResponse {`
`261`	`261`	`}`
`262`	`262`	`}`
`263`	`263`
`264`		`-func (a *errorResponse) Error() string {`
	`264`	`+func (a *chatCompletionResponseError) Error() string {`
`265`	`265`	`if a.ErrorObject == nil {`
`266`	`266`	`return ""`
`267`	`267`	`}`
Original file line number	Diff line number	Diff line change
`@@ -132,7 +132,7 @@ func (s EventStream) Start(w http.ResponseWriter, r http.Request) {`
`132`	`132`	`return`
`133`	`133`	`}`
`134`	`134`	`if err := flush(w); err != nil {`
`135`		`- s.logger.Warn(ctx, "failed to flush", slog.Error(err))`
	`135`	`+ s.logger.Warn(ctx, "failed to flush event stream", slog.Error(err))`
`136`	`136`	`return`
`137`	`137`	`}`
`138`	`138`
Original file line number	Diff line number	Diff line change
`@@ -405,7 +405,7 @@ func filterBedrockBetaFlags(headers http.Header, model string) {`
`405`	`405`	`}`
`406`	`406`
`407`	`407`	`// writeUpstreamError marshals and writes a given error.`
`408`		`-func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr ErrorResponse) {`
	`408`	`+func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr messagesResponseError) {`
`409`	`409`	`if antErr == nil {`
`410`	`410`	`return`
`411`	`411`	`}`
`@@ -415,7 +415,7 @@ func (i interceptionBase) writeUpstreamError(w http.ResponseWriter, antErr Err`
`415`	`415`
`416`	`416`	`out, err := json.Marshal(antErr)`
`417`	`417`	`if err != nil {`
`418`		`- i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", slog.F("%+v", antErr)))`
	`418`	`+ i.logger.Warn(context.Background(), "failed to marshal upstream error", slog.Error(err), slog.F("error_payload", antErr))`
`419`	`419`	`// Response has to match expected format.`
`420`	`420`	`// See https://docs.claude.com/en/api/errors#error-shapes.`
`421`	`421`	_, _ = w.Write([]byte(fmt.Sprintf(`{
`@@ -487,7 +487,7 @@ func accumulateUsage(dest, src any) {`
`487`	`487`	`}`
`488`	`488`	`}`
`489`	`489`
`490`		`-func getErrorResponse(err error) *ErrorResponse {`
	`490`	`+func getErrorResponse(err error) *messagesResponseError {`
`491`	`491`	`var apierr *anthropic.Error`
`492`	`492`	`if !errors.As(err, &apierr) {`
`493`	`493`	`return nil`
`@@ -505,7 +505,7 @@ func getErrorResponse(err error) *ErrorResponse {`
`505`	`505`	`typ = string(detail.Type)`
`506`	`506`	`}`
`507`	`507`
`508`		`- return &ErrorResponse{`
	`508`	`+ return &messagesResponseError{`
`509`	`509`	`ErrorResponse: &anthropic.ErrorResponse{`
`510`	`510`	`Error: anthropic.ErrorObjectUnion{`
`511`	`511`	`Message: msg,`
`@@ -517,16 +517,16 @@ func getErrorResponse(err error) *ErrorResponse {`
`517`	`517`	`}`
`518`	`518`	`}`
`519`	`519`
`520`		`-var _ error = &ErrorResponse{}`
	`520`	`+var _ error = &messagesResponseError{}`
`521`	`521`
`522`		`-type ErrorResponse struct {`
	`522`	`+type messagesResponseError struct {`
`523`	`523`	`*anthropic.ErrorResponse`
`524`	`524`
`525`	`525`	StatusCode int `json:"-"`
`526`	`526`	`}`
`527`	`527`
`528`		`-func newErrorResponse(msg error) *ErrorResponse {`
`529`		`- return &ErrorResponse{`
	`528`	`+func newErrorResponse(msg error) *messagesResponseError {`
	`529`	`+ return &messagesResponseError{`
`530`	`530`	`ErrorResponse: &shared.ErrorResponse{`
`531`	`531`	`Error: shared.ErrorObjectUnion{`
`532`	`532`	`Message: msg.Error(),`
`@@ -536,7 +536,7 @@ func newErrorResponse(msg error) *ErrorResponse {`
`536`	`536`	`}`
`537`	`537`	`}`
`538`	`538`
`539`		`-func (a *ErrorResponse) Error() string {`
	`539`	`+func (a *messagesResponseError) Error() string {`
`540`	`540`	`if a.ErrorResponse == nil {`
`541`	`541`	`return ""`
`542`	`542`	`}`
Original file line number	Diff line number	Diff line change
`@@ -87,7 +87,7 @@ func (p *StreamableHTTPServerProxy) Init(ctx context.Context) (outErr error) {`
`87`	`87`	`return xerrors.Errorf("MCP version negotiation failed; requested %q, accepts %q, received %q", version, strings.Join(mcp.ValidProtocolVersions, ","), result.ProtocolVersion)`
`88`	`88`	`}`
`89`	`89`
`90`		`- p.logger.Debug(ctx, "MCP client initialized", slog.F("name", result.ServerInfo.Name), slog.F("server_version", result.ServerInfo.Version))`
	`90`	`+ p.logger.Debug(ctx, "mcp client initialized", slog.F("name", result.ServerInfo.Name), slog.F("server_version", result.ServerInfo.Version))`
`91`	`91`
`92`	`92`	`tools, err := p.fetchTools(ctx)`
`93`	`93`	`if err != nil {`
Original file line number	Diff line number	Diff line change
`@@ -106,7 +106,7 @@ func (p Anthropic) CreateInterceptor(_ http.ResponseWriter, r http.Request, tr`
`106`	`106`	`path := strings.TrimPrefix(r.URL.Path, p.RoutePrefix())`
`107`	`107`	`if path != routeMessages {`
`108`	`108`	`span.SetStatus(codes.Error, "unknown route: "+r.URL.Path)`
`109`		`- return nil, UnknownRoute`
	`109`	`+ return nil, ErrUnknownRoute`
`110`	`110`	`}`
`111`	`111`
`112`	`112`	`payload, err := io.ReadAll(r.Body)`