chore: lint fixes part 3

pawbana · pawbana · commit 484f365e524d · 2026-04-10T12:29:57.000Z
diff --git a/intercept/apidump/apidump.go b/intercept/apidump/apidump.go
@@ -154,7 +154,7 @@ func (d *dumper) dumpResponse(resp *http.Response) error {
 // for deterministic output.
 // `sensitive` and `overrides` must both supply keys in canoncialized form.
 // See [textproto.MIMEHeader].
-func (d *dumper) writeRedactedHeaders(w io.Writer, headers http.Header, sensitive map[string]struct{}, overrides map[string]string) error {
+func (*dumper) writeRedactedHeaders(w io.Writer, headers http.Header, sensitive map[string]struct{}, overrides map[string]string) error {
 	// Collect all header keys including overrides.
 	headerKeys := make([]string, 0, len(headers)+len(overrides))
 	seen := make(map[string]struct{}, len(headers)+len(overrides))
diff --git a/intercept/chatcompletions/base.go b/intercept/chatcompletions/base.go
@@ -99,13 +99,13 @@ func (i *interceptionBase) CorrelatingToolCallID() *string {
 	return &msg.OfTool.ToolCallID
 }
 
-func (s *interceptionBase) baseTraceAttributes(r *http.Request, streaming bool) []attribute.KeyValue {
+func (i *interceptionBase) baseTraceAttributes(r *http.Request, streaming bool) []attribute.KeyValue {
 	return []attribute.KeyValue{
 		attribute.String(tracing.RequestPath, r.URL.Path),
-		attribute.String(tracing.InterceptionID, s.id.String()),
+		attribute.String(tracing.InterceptionID, i.id.String()),
 		attribute.String(tracing.InitiatorID, aibcontext.ActorIDFromContext(r.Context())),
-		attribute.String(tracing.Provider, s.providerName),
-		attribute.String(tracing.Model, s.Model()),
+		attribute.String(tracing.Provider, i.providerName),
+		attribute.String(tracing.Model, i.Model()),
 		attribute.Bool(tracing.Streaming, streaming),
 	}
 }
@@ -118,7 +118,7 @@ func (i *interceptionBase) Model() string {
 	return i.req.Model
 }
 
-func (i *interceptionBase) newErrorResponse(err error) map[string]any {
+func (*interceptionBase) newErrorResponse(err error) map[string]any {
 	return map[string]any{
 		"error":   true,
 		"message": err.Error(),
diff --git a/intercept/chatcompletions/blocking.go b/intercept/chatcompletions/blocking.go
@@ -51,16 +51,16 @@ func NewBlockingInterceptor(
 	}}
 }
 
-func (s *BlockingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {
-	s.interceptionBase.Setup(logger.Named("blocking"), recorder, mcpProxy)
+func (i *BlockingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {
+	i.interceptionBase.Setup(logger.Named("blocking"), recorder, mcpProxy)
 }
 
-func (s *BlockingInterception) Streaming() bool {
+func (*BlockingInterception) Streaming() bool {
 	return false
 }
 
-func (s *BlockingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
-	return s.interceptionBase.baseTraceAttributes(r, false)
+func (i *BlockingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
+	return i.interceptionBase.baseTraceAttributes(r, false)
 }
 
 func (i *BlockingInterception) ProcessRequest(w http.ResponseWriter, r *http.Request) (outErr error) {
diff --git a/intercept/chatcompletions/streaming.go b/intercept/chatcompletions/streaming.go
@@ -59,12 +59,12 @@ func (i *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Reco
 	i.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)
 }
 
-func (i *StreamingInterception) Streaming() bool {
+func (*StreamingInterception) Streaming() bool {
 	return true
 }
 
-func (s *StreamingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
-	return s.interceptionBase.baseTraceAttributes(r, true)
+func (i *StreamingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
+	return i.interceptionBase.baseTraceAttributes(r, true)
 }
 
 // ProcessRequest handles a request to /v1/chat/completions.
@@ -389,7 +389,7 @@ func (i *StreamingInterception) marshalErr(err error) ([]byte, error) {
 	return i.encodeForStream(data), nil
 }
 
-func (i *StreamingInterception) encodeForStream(payload []byte) []byte {
+func (*StreamingInterception) encodeForStream(payload []byte) []byte {
 	var buf bytes.Buffer
 	buf.WriteString("data: ")
 	buf.Write(payload)
diff --git a/intercept/eventstream/eventstream.go b/intercept/eventstream/eventstream.go
@@ -32,7 +32,6 @@ type EventStream struct {
 	initiated    atomic.Bool
 	initiateOnce sync.Once
 
-	closeOnce    sync.Once
 	shutdownOnce sync.Once
 	eventsCh     chan event
 
diff --git a/intercept/messages/base.go b/intercept/messages/base.go
@@ -118,15 +118,15 @@ func (i *interceptionBase) Model() string {
 	return i.reqPayload.model()
 }
 
-func (s *interceptionBase) baseTraceAttributes(r *http.Request, streaming bool) []attribute.KeyValue {
+func (i *interceptionBase) baseTraceAttributes(r *http.Request, streaming bool) []attribute.KeyValue {
 	return []attribute.KeyValue{
 		attribute.String(tracing.RequestPath, r.URL.Path),
-		attribute.String(tracing.InterceptionID, s.id.String()),
+		attribute.String(tracing.InterceptionID, i.id.String()),
 		attribute.String(tracing.InitiatorID, aibcontext.ActorIDFromContext(r.Context())),
-		attribute.String(tracing.Provider, s.providerName),
-		attribute.String(tracing.Model, s.Model()),
+		attribute.String(tracing.Provider, i.providerName),
+		attribute.String(tracing.Model, i.Model()),
 		attribute.Bool(tracing.Streaming, streaming),
-		attribute.Bool(tracing.IsBedrock, s.bedrockCfg != nil),
+		attribute.Bool(tracing.IsBedrock, i.bedrockCfg != nil),
 	}
 }
 
@@ -176,7 +176,7 @@ func (i *interceptionBase) disableParallelToolCalls() {
 }
 
 // extractModelThoughts returns any thinking blocks that were returned in the response.
-func (i *interceptionBase) extractModelThoughts(msg *anthropic.Message) []*recorder.ModelThoughtRecord {
+func (*interceptionBase) extractModelThoughts(msg *anthropic.Message) []*recorder.ModelThoughtRecord {
 	if msg == nil {
 		return nil
 	}
@@ -264,7 +264,7 @@ func (i *interceptionBase) withBody() option.RequestOption {
 	return option.WithRequestBody("application/json", []byte(i.reqPayload))
 }
 
-func (i *interceptionBase) withAWSBedrockOptions(ctx context.Context, cfg *aibconfig.AWSBedrock) ([]option.RequestOption, error) {
+func (*interceptionBase) withAWSBedrockOptions(ctx context.Context, cfg *aibconfig.AWSBedrock) ([]option.RequestOption, error) {
 	if cfg == nil {
 		return nil, xerrors.New("nil config given")
 	}
diff --git a/intercept/messages/base_test.go b/intercept/messages/base_test.go
@@ -777,11 +777,11 @@ type mockServerProxier struct {
 	tools []*mcp.Tool
 }
 
-func (m *mockServerProxier) Init(context.Context) error {
+func (*mockServerProxier) Init(context.Context) error {
 	return nil
 }
 
-func (m *mockServerProxier) Shutdown(context.Context) error {
+func (*mockServerProxier) Shutdown(context.Context) error {
 	return nil
 }
 
@@ -798,7 +798,7 @@ func (m *mockServerProxier) GetTool(id string) *mcp.Tool {
 	return nil
 }
 
-func (m *mockServerProxier) CallTool(context.Context, string, any) (*mcpgo.CallToolResult, error) {
+func (*mockServerProxier) CallTool(context.Context, string, any) (*mcpgo.CallToolResult, error) {
 	return nil, nil
 }
 
diff --git a/intercept/messages/blocking.go b/intercept/messages/blocking.go
@@ -62,7 +62,7 @@ func (i *BlockingInterception) TraceAttributes(r *http.Request) []attribute.KeyV
 	return i.interceptionBase.baseTraceAttributes(r, false)
 }
 
-func (s *BlockingInterception) Streaming() bool {
+func (*BlockingInterception) Streaming() bool {
 	return false
 }
 
diff --git a/intercept/messages/reqpayload.go b/intercept/messages/reqpayload.go
@@ -313,7 +313,7 @@ func (p MessagesRequestPayload) tools() ([]json.RawMessage, error) {
 	return p.resultToRawMessage(tools.Array()), nil
 }
 
-func (p MessagesRequestPayload) resultToRawMessage(items []gjson.Result) []json.RawMessage {
+func (MessagesRequestPayload) resultToRawMessage(items []gjson.Result) []json.RawMessage {
 	// gjson.Result conversion to json.RawMessage is needed because
 	// gjson.Result does not implement json.Marshaler — would
 	// serialize its struct fields instead of the raw JSON it represents.
diff --git a/intercept/messages/streaming.go b/intercept/messages/streaming.go
@@ -59,16 +59,16 @@ func NewStreamingInterceptor(
 	}}
 }
 
-func (s *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {
-	s.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)
+func (i *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {
+	i.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)
 }
 
-func (s *StreamingInterception) Streaming() bool {
+func (*StreamingInterception) Streaming() bool {
 	return true
 }
 
-func (s *StreamingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
-	return s.interceptionBase.baseTraceAttributes(r, true)
+func (i *StreamingInterception) TraceAttributes(r *http.Request) []attribute.KeyValue {
+	return i.interceptionBase.baseTraceAttributes(r, true)
 }
 
 // ProcessRequest handles a request to /v1/messages.
@@ -534,8 +534,8 @@ newStream:
 	return interceptionErr
 }
 
-func (s *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventUnion) ([]byte, error) {
-	sj, err := sjson.Set(event.RawJSON(), "message.id", s.ID().String())
+func (i *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventUnion) ([]byte, error) {
+	sj, err := sjson.Set(event.RawJSON(), "message.id", i.ID().String())
 	if err != nil {
 		return nil, xerrors.Errorf("marshal event id failed: %w", err)
 	}
@@ -545,10 +545,10 @@ func (s *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventU
 		return nil, xerrors.Errorf("marshal event usage failed: %w", err)
 	}
 
-	return s.encodeForStream([]byte(sj), event.Type), nil
+	return i.encodeForStream([]byte(sj), event.Type), nil
 }
 
-func (s *StreamingInterception) marshal(payload any) ([]byte, error) {
+func (i *StreamingInterception) marshal(payload any) ([]byte, error) {
 	data, err := json.Marshal(payload)
 	if err != nil {
 		return nil, xerrors.Errorf("marshal payload: %w", err)
@@ -564,15 +564,15 @@ func (s *StreamingInterception) marshal(payload any) ([]byte, error) {
 		return nil, xerrors.Errorf("could not determine type from payload %q", data)
 	}
 
-	return s.encodeForStream(data, eventType), nil
+	return i.encodeForStream(data, eventType), nil
 }
 
 // https://docs.anthropic.com/en/docs/build-with-claude/streaming#basic-streaming-request
-func (s *StreamingInterception) pingPayload() []byte {
-	return s.encodeForStream([]byte(`{"type": "ping"}`), "ping")
+func (i *StreamingInterception) pingPayload() []byte {
+	return i.encodeForStream([]byte(`{"type": "ping"}`), "ping")
 }
 
-func (s *StreamingInterception) encodeForStream(payload []byte, typ string) []byte {
+func (*StreamingInterception) encodeForStream(payload []byte, typ string) []byte {
 	var buf bytes.Buffer
 	buf.WriteString("event: ")
 	buf.WriteString(typ)
@@ -584,9 +584,9 @@ func (s *StreamingInterception) encodeForStream(payload []byte, typ string) []by
 }
 
 // newStream traces svc.NewStreaming() call.
-func (s *StreamingInterception) newStream(ctx context.Context, svc anthropic.MessageService) *ssestream.Stream[anthropic.MessageStreamEventUnion] {
-	_, span := s.tracer.Start(ctx, "Intercept.ProcessRequest.Upstream", trace.WithAttributes(tracing.InterceptionAttributesFromContext(ctx)...))
+func (i *StreamingInterception) newStream(ctx context.Context, svc anthropic.MessageService) *ssestream.Stream[anthropic.MessageStreamEventUnion] {
+	_, span := i.tracer.Start(ctx, "Intercept.ProcessRequest.Upstream", trace.WithAttributes(tracing.InterceptionAttributesFromContext(ctx)...))
 	defer span.End()
 
-	return svc.NewStreaming(ctx, anthropic.MessageNewParams{}, s.withBody())
+	return svc.NewStreaming(ctx, anthropic.MessageNewParams{}, i.withBody())
 }
diff --git a/intercept/responses/base.go b/intercept/responses/base.go
@@ -264,7 +264,7 @@ func (i *responsesInterceptionBase) recordTokenUsage(ctx context.Context, respon
 // extractModelThoughts extracts model thoughts from response output items.
 // It captures both reasoning summary items and commentary messages (message
 // output items with "phase": "commentary") as model thoughts.
-func (i *responsesInterceptionBase) extractModelThoughts(response *responses.Response) []*recorder.ModelThoughtRecord {
+func (*responsesInterceptionBase) extractModelThoughts(response *responses.Response) []*recorder.ModelThoughtRecord {
 	if response == nil {
 		return nil
 	}
diff --git a/intercept/responses/blocking.go b/intercept/responses/blocking.go
@@ -54,7 +54,7 @@ func (i *BlockingResponsesInterceptor) Setup(logger slog.Logger, recorder record
 	i.responsesInterceptionBase.Setup(logger.Named("blocking"), recorder, mcpProxy)
 }
 
-func (i *BlockingResponsesInterceptor) Streaming() bool {
+func (*BlockingResponsesInterceptor) Streaming() bool {
 	return false
 }
 
diff --git a/intercept/responses/streaming.go b/intercept/responses/streaming.go
@@ -61,7 +61,7 @@ func (i *StreamingResponsesInterceptor) Setup(logger slog.Logger, recorder recor
 	i.responsesInterceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)
 }
 
-func (i *StreamingResponsesInterceptor) Streaming() bool {
+func (*StreamingResponsesInterceptor) Streaming() bool {
 	return true
 }
 
diff --git a/internal/integrationtest/mockmcp.go b/internal/integrationtest/mockmcp.go
@@ -141,7 +141,7 @@ func createMockMCPSrv(t *testing.T) (http.Handler, *callAccumulator) {
 		tool := mcplib.NewTool(name,
 			mcplib.WithDescription(fmt.Sprintf("Mock of the %s tool", name)),
 		)
-		s.AddTool(tool, func(ctx context.Context, request mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
+		s.AddTool(tool, func(_ context.Context, request mcplib.CallToolRequest) (*mcplib.CallToolResult, error) {
 			acc.addCall(request.Params.Name, request.Params.Arguments)
 			if errMsg, ok := acc.getToolError(request.Params.Name); ok {
 				return nil, xerrors.New(errMsg)
diff --git a/internal/testutil/mock_recorder.go b/internal/testutil/mock_recorder.go
@@ -26,14 +26,14 @@ type MockRecorder struct {
 	interceptionsEnd map[string]*recorder.InterceptionRecordEnded
 }
 
-func (m *MockRecorder) RecordInterception(ctx context.Context, req *recorder.InterceptionRecord) error {
+func (m *MockRecorder) RecordInterception(_ context.Context, req *recorder.InterceptionRecord) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.interceptions = append(m.interceptions, req)
 	return nil
 }
 
-func (m *MockRecorder) RecordInterceptionEnded(ctx context.Context, req *recorder.InterceptionRecordEnded) error {
+func (m *MockRecorder) RecordInterceptionEnded(_ context.Context, req *recorder.InterceptionRecordEnded) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	if m.interceptionsEnd == nil {
@@ -46,28 +46,28 @@ func (m *MockRecorder) RecordInterceptionEnded(ctx context.Context, req *recorde
 	return nil
 }
 
-func (m *MockRecorder) RecordPromptUsage(ctx context.Context, req *recorder.PromptUsageRecord) error {
+func (m *MockRecorder) RecordPromptUsage(_ context.Context, req *recorder.PromptUsageRecord) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.userPrompts = append(m.userPrompts, req)
 	return nil
 }
 
-func (m *MockRecorder) RecordTokenUsage(ctx context.Context, req *recorder.TokenUsageRecord) error {
+func (m *MockRecorder) RecordTokenUsage(_ context.Context, req *recorder.TokenUsageRecord) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.tokenUsages = append(m.tokenUsages, req)
 	return nil
 }
 
-func (m *MockRecorder) RecordToolUsage(ctx context.Context, req *recorder.ToolUsageRecord) error {
+func (m *MockRecorder) RecordToolUsage(_ context.Context, req *recorder.ToolUsageRecord) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.toolUsages = append(m.toolUsages, req)
 	return nil
 }
 
-func (m *MockRecorder) RecordModelThought(ctx context.Context, req *recorder.ModelThoughtRecord) error {
+func (m *MockRecorder) RecordModelThought(_ context.Context, req *recorder.ModelThoughtRecord) error {
 	m.mu.Lock()
 	defer m.mu.Unlock()
 	m.modelThoughts = append(m.modelThoughts, req)
diff --git a/internal/testutil/mockprovider.go b/internal/testutil/mockprovider.go
@@ -24,10 +24,10 @@ func (m *MockProvider) BaseURL() string                              { return m.
 func (m *MockProvider) RoutePrefix() string                          { return fmt.Sprintf("/%s", m.NameStr) }
 func (m *MockProvider) BridgedRoutes() []string                      { return m.Bridged }
 func (m *MockProvider) PassthroughRoutes() []string                  { return m.Passthrough }
-func (m *MockProvider) AuthHeader() string                           { return "Authorization" }
-func (m *MockProvider) InjectAuthHeader(h *http.Header)              {}
-func (m *MockProvider) CircuitBreakerConfig() *config.CircuitBreaker { return nil }
-func (m *MockProvider) APIDumpDir() string                           { return "" }
+func (*MockProvider) AuthHeader() string                           { return "Authorization" }
+func (*MockProvider) InjectAuthHeader(_ *http.Header)              {}
+func (*MockProvider) CircuitBreakerConfig() *config.CircuitBreaker { return nil }
+func (*MockProvider) APIDumpDir() string                           { return "" }
 func (m *MockProvider) CreateInterceptor(w http.ResponseWriter, r *http.Request, tracer trace.Tracer) (intercept.Interceptor, error) {
 	if m.InterceptorFunc != nil {
 		return m.InterceptorFunc(w, r, tracer)
diff --git a/mcp/proxy_streamable_http.go b/mcp/proxy_streamable_http.go
@@ -161,7 +161,7 @@ func (p *StreamableHTTPServerProxy) fetchTools(ctx context.Context) (_ map[strin
 	return out, nil
 }
 
-func (p *StreamableHTTPServerProxy) Shutdown(ctx context.Context) error {
+func (p *StreamableHTTPServerProxy) Shutdown(_ context.Context) error {
 	if p.client == nil {
 		return nil
 	}
diff --git a/provider/anthropic.go b/provider/anthropic.go
diff --git a/provider/copilot.go b/provider/copilot.go
diff --git a/provider/openai.go b/provider/openai.go
diff --git a/recorder/recorder.go b/recorder/recorder.go
diff --git a/session_test.go b/session_test.go

Original file line number	Diff line number	Diff line change
`@@ -99,13 +99,13 @@ func (i interceptionBase) CorrelatingToolCallID() string {`
`99`	`99`	`return &msg.OfTool.ToolCallID`
`100`	`100`	`}`
`101`	`101`
`102`		`-func (s interceptionBase) baseTraceAttributes(r http.Request, streaming bool) []attribute.KeyValue {`
	`102`	`+func (i interceptionBase) baseTraceAttributes(r http.Request, streaming bool) []attribute.KeyValue {`
`103`	`103`	`return []attribute.KeyValue{`
`104`	`104`	`attribute.String(tracing.RequestPath, r.URL.Path),`
`105`		`- attribute.String(tracing.InterceptionID, s.id.String()),`
	`105`	`+ attribute.String(tracing.InterceptionID, i.id.String()),`
`106`	`106`	`attribute.String(tracing.InitiatorID, aibcontext.ActorIDFromContext(r.Context())),`
`107`		`- attribute.String(tracing.Provider, s.providerName),`
`108`		`- attribute.String(tracing.Model, s.Model()),`
	`107`	`+ attribute.String(tracing.Provider, i.providerName),`
	`108`	`+ attribute.String(tracing.Model, i.Model()),`
`109`	`109`	`attribute.Bool(tracing.Streaming, streaming),`
`110`	`110`	`}`
`111`	`111`	`}`
`@@ -118,7 +118,7 @@ func (i *interceptionBase) Model() string {`
`118`	`118`	`return i.req.Model`
`119`	`119`	`}`
`120`	`120`
`121`		`-func (i *interceptionBase) newErrorResponse(err error) map[string]any {`
	`121`	`+func (*interceptionBase) newErrorResponse(err error) map[string]any {`
`122`	`122`	`return map[string]any{`
`123`	`123`	`"error": true,`
`124`	`124`	`"message": err.Error(),`
Original file line number	Diff line number	Diff line change
`@@ -51,16 +51,16 @@ func NewBlockingInterceptor(`
`51`	`51`	`}}`
`52`	`52`	`}`
`53`	`53`
`54`		`-func (s *BlockingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {`
`55`		`- s.interceptionBase.Setup(logger.Named("blocking"), recorder, mcpProxy)`
	`54`	`+func (i *BlockingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {`
	`55`	`+ i.interceptionBase.Setup(logger.Named("blocking"), recorder, mcpProxy)`
`56`	`56`	`}`
`57`	`57`
`58`		`-func (s *BlockingInterception) Streaming() bool {`
	`58`	`+func (*BlockingInterception) Streaming() bool {`
`59`	`59`	`return false`
`60`	`60`	`}`
`61`	`61`
`62`		`-func (s BlockingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
`63`		`- return s.interceptionBase.baseTraceAttributes(r, false)`
	`62`	`+func (i BlockingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
	`63`	`+ return i.interceptionBase.baseTraceAttributes(r, false)`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`func (i BlockingInterception) ProcessRequest(w http.ResponseWriter, r http.Request) (outErr error) {`
Original file line number	Diff line number	Diff line change
`@@ -59,12 +59,12 @@ func (i *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Reco`
`59`	`59`	`i.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)`
`60`	`60`	`}`
`61`	`61`
`62`		`-func (i *StreamingInterception) Streaming() bool {`
	`62`	`+func (*StreamingInterception) Streaming() bool {`
`63`	`63`	`return true`
`64`	`64`	`}`
`65`	`65`
`66`		`-func (s StreamingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
`67`		`- return s.interceptionBase.baseTraceAttributes(r, true)`
	`66`	`+func (i StreamingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
	`67`	`+ return i.interceptionBase.baseTraceAttributes(r, true)`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`// ProcessRequest handles a request to /v1/chat/completions.`
`@@ -389,7 +389,7 @@ func (i *StreamingInterception) marshalErr(err error) ([]byte, error) {`
`389`	`389`	`return i.encodeForStream(data), nil`
`390`	`390`	`}`
`391`	`391`
`392`		`-func (i *StreamingInterception) encodeForStream(payload []byte) []byte {`
	`392`	`+func (*StreamingInterception) encodeForStream(payload []byte) []byte {`
`393`	`393`	`var buf bytes.Buffer`
`394`	`394`	`buf.WriteString("data: ")`
`395`	`395`	`buf.Write(payload)`
Original file line number	Diff line number	Diff line change
`@@ -118,15 +118,15 @@ func (i *interceptionBase) Model() string {`
`118`	`118`	`return i.reqPayload.model()`
`119`	`119`	`}`
`120`	`120`
`121`		`-func (s interceptionBase) baseTraceAttributes(r http.Request, streaming bool) []attribute.KeyValue {`
	`121`	`+func (i interceptionBase) baseTraceAttributes(r http.Request, streaming bool) []attribute.KeyValue {`
`122`	`122`	`return []attribute.KeyValue{`
`123`	`123`	`attribute.String(tracing.RequestPath, r.URL.Path),`
`124`		`- attribute.String(tracing.InterceptionID, s.id.String()),`
	`124`	`+ attribute.String(tracing.InterceptionID, i.id.String()),`
`125`	`125`	`attribute.String(tracing.InitiatorID, aibcontext.ActorIDFromContext(r.Context())),`
`126`		`- attribute.String(tracing.Provider, s.providerName),`
`127`		`- attribute.String(tracing.Model, s.Model()),`
	`126`	`+ attribute.String(tracing.Provider, i.providerName),`
	`127`	`+ attribute.String(tracing.Model, i.Model()),`
`128`	`128`	`attribute.Bool(tracing.Streaming, streaming),`
`129`		`- attribute.Bool(tracing.IsBedrock, s.bedrockCfg != nil),`
	`129`	`+ attribute.Bool(tracing.IsBedrock, i.bedrockCfg != nil),`
`130`	`130`	`}`
`131`	`131`	`}`
`132`	`132`
`@@ -176,7 +176,7 @@ func (i *interceptionBase) disableParallelToolCalls() {`
`176`	`176`	`}`
`177`	`177`
`178`	`178`	`// extractModelThoughts returns any thinking blocks that were returned in the response.`
`179`		`-func (i interceptionBase) extractModelThoughts(msg anthropic.Message) []*recorder.ModelThoughtRecord {`
	`179`	`+func (interceptionBase) extractModelThoughts(msg anthropic.Message) []*recorder.ModelThoughtRecord {`
`180`	`180`	`if msg == nil {`
`181`	`181`	`return nil`
`182`	`182`	`}`
`@@ -264,7 +264,7 @@ func (i *interceptionBase) withBody() option.RequestOption {`
`264`	`264`	`return option.WithRequestBody("application/json", []byte(i.reqPayload))`
`265`	`265`	`}`
`266`	`266`
`267`		`-func (i interceptionBase) withAWSBedrockOptions(ctx context.Context, cfg aibconfig.AWSBedrock) ([]option.RequestOption, error) {`
	`267`	`+func (interceptionBase) withAWSBedrockOptions(ctx context.Context, cfg aibconfig.AWSBedrock) ([]option.RequestOption, error) {`
`268`	`268`	`if cfg == nil {`
`269`	`269`	`return nil, xerrors.New("nil config given")`
`270`	`270`	`}`
Original file line number	Diff line number	Diff line change
`@@ -777,11 +777,11 @@ type mockServerProxier struct {`
`777`	`777`	`tools []*mcp.Tool`
`778`	`778`	`}`
`779`	`779`
`780`		`-func (m *mockServerProxier) Init(context.Context) error {`
	`780`	`+func (*mockServerProxier) Init(context.Context) error {`
`781`	`781`	`return nil`
`782`	`782`	`}`
`783`	`783`
`784`		`-func (m *mockServerProxier) Shutdown(context.Context) error {`
	`784`	`+func (*mockServerProxier) Shutdown(context.Context) error {`
`785`	`785`	`return nil`
`786`	`786`	`}`
`787`	`787`
`@@ -798,7 +798,7 @@ func (m mockServerProxier) GetTool(id string) mcp.Tool {`
`798`	`798`	`return nil`
`799`	`799`	`}`
`800`	`800`
`801`		`-func (m mockServerProxier) CallTool(context.Context, string, any) (mcpgo.CallToolResult, error) {`
	`801`	`+func (mockServerProxier) CallTool(context.Context, string, any) (mcpgo.CallToolResult, error) {`
`802`	`802`	`return nil, nil`
`803`	`803`	`}`
`804`	`804`
Original file line number	Diff line number	Diff line change
`@@ -62,7 +62,7 @@ func (i BlockingInterception) TraceAttributes(r http.Request) []attribute.KeyV`
`62`	`62`	`return i.interceptionBase.baseTraceAttributes(r, false)`
`63`	`63`	`}`
`64`	`64`
`65`		`-func (s *BlockingInterception) Streaming() bool {`
	`65`	`+func (*BlockingInterception) Streaming() bool {`
`66`	`66`	`return false`
`67`	`67`	`}`
`68`	`68`
Original file line number	Diff line number	Diff line change
`@@ -313,7 +313,7 @@ func (p MessagesRequestPayload) tools() ([]json.RawMessage, error) {`
`313`	`313`	`return p.resultToRawMessage(tools.Array()), nil`
`314`	`314`	`}`
`315`	`315`
`316`		`-func (p MessagesRequestPayload) resultToRawMessage(items []gjson.Result) []json.RawMessage {`
	`316`	`+func (MessagesRequestPayload) resultToRawMessage(items []gjson.Result) []json.RawMessage {`
`317`	`317`	`// gjson.Result conversion to json.RawMessage is needed because`
`318`	`318`	`// gjson.Result does not implement json.Marshaler — would`
`319`	`319`	`// serialize its struct fields instead of the raw JSON it represents.`
Original file line number	Diff line number	Diff line change
`@@ -59,16 +59,16 @@ func NewStreamingInterceptor(`
`59`	`59`	`}}`
`60`	`60`	`}`
`61`	`61`
`62`		`-func (s *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {`
`63`		`- s.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)`
	`62`	`+func (i *StreamingInterception) Setup(logger slog.Logger, recorder recorder.Recorder, mcpProxy mcp.ServerProxier) {`
	`63`	`+ i.interceptionBase.Setup(logger.Named("streaming"), recorder, mcpProxy)`
`64`	`64`	`}`
`65`	`65`
`66`		`-func (s *StreamingInterception) Streaming() bool {`
	`66`	`+func (*StreamingInterception) Streaming() bool {`
`67`	`67`	`return true`
`68`	`68`	`}`
`69`	`69`
`70`		`-func (s StreamingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
`71`		`- return s.interceptionBase.baseTraceAttributes(r, true)`
	`70`	`+func (i StreamingInterception) TraceAttributes(r http.Request) []attribute.KeyValue {`
	`71`	`+ return i.interceptionBase.baseTraceAttributes(r, true)`
`72`	`72`	`}`
`73`	`73`
`74`	`74`	`// ProcessRequest handles a request to /v1/messages.`
`@@ -534,8 +534,8 @@ newStream:`
`534`	`534`	`return interceptionErr`
`535`	`535`	`}`
`536`	`536`
`537`		`-func (s *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventUnion) ([]byte, error) {`
`538`		`- sj, err := sjson.Set(event.RawJSON(), "message.id", s.ID().String())`
	`537`	`+func (i *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventUnion) ([]byte, error) {`
	`538`	`+ sj, err := sjson.Set(event.RawJSON(), "message.id", i.ID().String())`
`539`	`539`	`if err != nil {`
`540`	`540`	`return nil, xerrors.Errorf("marshal event id failed: %w", err)`
`541`	`541`	`}`
`@@ -545,10 +545,10 @@ func (s *StreamingInterception) marshalEvent(event anthropic.MessageStreamEventU`
`545`	`545`	`return nil, xerrors.Errorf("marshal event usage failed: %w", err)`
`546`	`546`	`}`
`547`	`547`
`548`		`- return s.encodeForStream([]byte(sj), event.Type), nil`
	`548`	`+ return i.encodeForStream([]byte(sj), event.Type), nil`
`549`	`549`	`}`
`550`	`550`
`551`		`-func (s *StreamingInterception) marshal(payload any) ([]byte, error) {`
	`551`	`+func (i *StreamingInterception) marshal(payload any) ([]byte, error) {`
`552`	`552`	`data, err := json.Marshal(payload)`
`553`	`553`	`if err != nil {`
`554`	`554`	`return nil, xerrors.Errorf("marshal payload: %w", err)`
`@@ -564,15 +564,15 @@ func (s *StreamingInterception) marshal(payload any) ([]byte, error) {`
`564`	`564`	`return nil, xerrors.Errorf("could not determine type from payload %q", data)`
`565`	`565`	`}`
`566`	`566`
`567`		`- return s.encodeForStream(data, eventType), nil`
	`567`	`+ return i.encodeForStream(data, eventType), nil`
`568`	`568`	`}`
`569`	`569`
`570`	`570`	`// https://docs.anthropic.com/en/docs/build-with-claude/streaming#basic-streaming-request`
`571`		`-func (s *StreamingInterception) pingPayload() []byte {`
`572`		- return s.encodeForStream([]byte(`{"type": "ping"}`), "ping")
	`571`	`+func (i *StreamingInterception) pingPayload() []byte {`
	`572`	+ return i.encodeForStream([]byte(`{"type": "ping"}`), "ping")
`573`	`573`	`}`
`574`	`574`
`575`		`-func (s *StreamingInterception) encodeForStream(payload []byte, typ string) []byte {`
	`575`	`+func (*StreamingInterception) encodeForStream(payload []byte, typ string) []byte {`
`576`	`576`	`var buf bytes.Buffer`
`577`	`577`	`buf.WriteString("event: ")`
`578`	`578`	`buf.WriteString(typ)`
`@@ -584,9 +584,9 @@ func (s *StreamingInterception) encodeForStream(payload []byte, typ string) []by`
`584`	`584`	`}`
`585`	`585`
`586`	`586`	`// newStream traces svc.NewStreaming() call.`
`587`		`-func (s StreamingInterception) newStream(ctx context.Context, svc anthropic.MessageService) ssestream.Stream[anthropic.MessageStreamEventUnion] {`
`588`		`- _, span := s.tracer.Start(ctx, "Intercept.ProcessRequest.Upstream", trace.WithAttributes(tracing.InterceptionAttributesFromContext(ctx)...))`
	`587`	`+func (i StreamingInterception) newStream(ctx context.Context, svc anthropic.MessageService) ssestream.Stream[anthropic.MessageStreamEventUnion] {`
	`588`	`+ _, span := i.tracer.Start(ctx, "Intercept.ProcessRequest.Upstream", trace.WithAttributes(tracing.InterceptionAttributesFromContext(ctx)...))`
`589`	`589`	`defer span.End()`
`590`	`590`
`591`		`- return svc.NewStreaming(ctx, anthropic.MessageNewParams{}, s.withBody())`
	`591`	`+ return svc.NewStreaming(ctx, anthropic.MessageNewParams{}, i.withBody())`
`592`	`592`	`}`