Merge branch 'main' into gcp-anthropic

hustxiayang · web-flow · commit 1249077085c7 · 2025-12-03T01:42:43.000-05:00
diff --git a/cmd/aigw/main.go b/cmd/aigw/main.go
@@ -41,12 +41,15 @@ type (
 	}
 	// cmdRun corresponds to `aigw run` command.
 	cmdRun struct {
-		Debug     bool                   `help:"Enable debug logging emitted to stderr."`
-		Path      string                 `arg:"" name:"path" optional:"" help:"Path to the AI Gateway configuration yaml file. Defaults to $AIGW_CONFIG_HOME/config.yaml if exists, otherwise optional when at least OPENAI_API_KEY, AZURE_OPENAI_API_KEY or ANTHROPIC_API_KEY is set." type:"path"`
-		AdminPort int                    `help:"HTTP port for the admin server (serves /metrics and /health endpoints)." default:"1064"`
-		McpConfig string                 `name:"mcp-config" help:"Path to MCP servers configuration file." type:"path"`
-		McpJSON   string                 `name:"mcp-json" help:"JSON string of MCP servers configuration."`
-		RunID     string                 `name:"run-id" env:"AIGW_RUN_ID" help:"Run identifier for this invocation. Defaults to timestamp-based ID or $AIGW_RUN_ID. Use '0' for Docker/Kubernetes."`
+		Debug     bool   `help:"Enable debug logging emitted to stderr."`
+		Path      string `arg:"" name:"path" optional:"" help:"Path to the AI Gateway configuration yaml file. Defaults to $AIGW_CONFIG_HOME/config.yaml if exists, otherwise optional when at least OPENAI_API_KEY, AZURE_OPENAI_API_KEY or ANTHROPIC_API_KEY is set." type:"path"`
+		AdminPort int    `help:"HTTP port for the admin server (serves /metrics and /health endpoints)." default:"1064"`
+		McpConfig string `name:"mcp-config" help:"Path to MCP servers configuration file." type:"path"`
+		McpJSON   string `name:"mcp-json" help:"JSON string of MCP servers configuration."`
+		RunID     string `name:"run-id" env:"AIGW_RUN_ID" help:"Run identifier for this invocation. Defaults to timestamp-based ID or $AIGW_RUN_ID. Use '0' for Docker/Kubernetes."`
+
+		MCPSessionEncryptionIterations int `name:"mcp-session-encryption-iterations" help:"Number of iterations for MCP session encryption key derivation." default:"100000"`
+
 		mcpConfig *autoconfig.MCPServers `kong:"-"` // Internal field: normalized MCP JSON data
 		dirs      *xdg.Directories       `kong:"-"` // Internal field: XDG directories, set by BeforeApply
 		runOpts   *runOpts               `kong:"-"` // Internal field: run options, set by Validate
diff --git a/cmd/aigw/main_test.go b/cmd/aigw/main_test.go
@@ -136,6 +136,9 @@ Flags:
       --run-id=STRING         Run identifier for this invocation. Defaults to
                               timestamp-based ID or $AIGW_RUN_ID. Use '0' for
                               Docker/Kubernetes ($AIGW_RUN_ID).
+      --mcp-session-encryption-iterations=100000
+                              Number of iterations for MCP session encryption
+                              key derivation.
 `,
 			expPanicCode: ptr.To(0),
 		},
diff --git a/cmd/aigw/run.go b/cmd/aigw/run.go
@@ -78,6 +78,8 @@ type runCmdContext struct {
 	// fakeClientSet is the fake client set for the k8s resources. The objects are written to this client set and updated
 	// during the translation.
 	fakeClientSet *fake.Clientset
+	// mcpSessionEncryptionIterations is the number of iterations for MCP session encryption key derivation.
+	mcpSessionEncryptionIterations int
 }
 
 // run starts the AI Gateway locally for a given configuration.
@@ -361,6 +363,7 @@ func (runCtx *runCmdContext) mustStartExtProc(
 		"--extProcAddr", fmt.Sprintf("unix://%s", runCtx.udsPath),
 		"--adminPort", fmt.Sprintf("%d", runCtx.adminPort),
 		"--mcpAddr", ":" + strconv.Itoa(internalapi.MCPProxyPort),
+		"--mcpSessionEncryptionIterations", strconv.Itoa(runCtx.mcpSessionEncryptionIterations),
 	}
 	if runCtx.isDebug {
 		args = append(args, "--logLevel", "debug")
diff --git a/cmd/extproc/mainlib/main.go b/cmd/extproc/mainlib/main.go
@@ -250,17 +250,17 @@ func Main(ctx context.Context, args []string, stderr io.Writer) (err error) {
 		return err
 	}
 
-	server, err := extproc.NewServer(l, tracing)
+	server, err := extproc.NewServer(l)
 	if err != nil {
 		return fmt.Errorf("failed to create external processor server: %w", err)
 	}
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/chat/completions"), extproc.ChatCompletionProcessorFactory(chatCompletionMetricsFactory))
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/completions"), extproc.CompletionsProcessorFactory(completionMetricsFactory))
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/embeddings"), extproc.EmbeddingsProcessorFactory(embeddingsMetricsFactory))
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/images/generations"), extproc.ImageGenerationProcessorFactory(imageGenerationMetricsFactory))
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.Cohere, "/v2/rerank"), extproc.RerankProcessorFactory(rerankMetricsFactory))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/chat/completions"), extproc.ChatCompletionProcessorFactory(chatCompletionMetricsFactory, tracing.ChatCompletionTracer()))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/completions"), extproc.CompletionsProcessorFactory(completionMetricsFactory, tracing.CompletionTracer()))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/embeddings"), extproc.EmbeddingsProcessorFactory(embeddingsMetricsFactory, tracing.EmbeddingsTracer()))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/images/generations"), extproc.ImageGenerationProcessorFactory(imageGenerationMetricsFactory, tracing.ImageGenerationTracer()))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.Cohere, "/v2/rerank"), extproc.RerankProcessorFactory(rerankMetricsFactory, tracing.RerankTracer()))
 	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.OpenAI, "/v1/models"), extproc.NewModelsProcessor)
-	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.Anthropic, "/v1/messages"), extproc.MessagesProcessorFactory(messagesMetricsFactory))
+	server.Register(path.Join(flags.rootPrefix, endpointPrefixes.Anthropic, "/v1/messages"), extproc.MessagesProcessorFactory(messagesMetricsFactory, tracing.MessageTracer()))
 
 	if watchErr := filterapi.StartConfigWatcher(ctx, flags.configPath, server, l, time.Second*5); watchErr != nil {
 		return fmt.Errorf("failed to start config watcher: %w", watchErr)
diff --git a/internal/extproc/chatcompletion_processor.go b/internal/extproc/chatcompletion_processor.go
@@ -31,13 +31,13 @@ import (
 )
 
 // ChatCompletionProcessorFactory returns a factory method to instantiate the chat completion processor.
-func ChatCompletionProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, tracing tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func ChatCompletionProcessorFactory(f metrics.Factory, tracer tracing.ChatCompletionTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "chat-completion", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &chatCompletionProcessorRouterFilter{
 				config:         config,
-				tracer:         tracing.ChatCompletionTracer(),
+				tracer:         tracer,
 				requestHeaders: requestHeaders,
 				logger:         logger,
 			}, nil
diff --git a/internal/extproc/chatcompletion_processor_test.go b/internal/extproc/chatcompletion_processor_test.go
@@ -33,14 +33,14 @@ import (
 func TestChatCompletion_Schema(t *testing.T) {
 	t.Run("supported openai / on route", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := ChatCompletionProcessorFactory(nil)(cfg, nil, slog.Default(), tracing.NoopTracing{}, false)
+		routeFilter, err := ChatCompletionProcessorFactory(nil, tracing.NoopChatCompletionTracer{})(cfg, nil, slog.Default(), false)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &chatCompletionProcessorRouterFilter{}, routeFilter)
 	})
 	t.Run("supported openai / on upstream", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := ChatCompletionProcessorFactory(&mockMetricsFactory{})(cfg, nil, slog.Default(), tracing.NoopTracing{}, true)
+		routeFilter, err := ChatCompletionProcessorFactory(&mockMetricsFactory{}, tracing.NoopChatCompletionTracer{})(cfg, nil, slog.Default(), true)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &chatCompletionProcessorUpstreamFilter{}, routeFilter)
diff --git a/internal/extproc/completions_processor.go b/internal/extproc/completions_processor.go
@@ -29,13 +29,13 @@ import (
 )
 
 // CompletionsProcessorFactory returns a factory method to instantiate the completions processor.
-func CompletionsProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, tracing tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func CompletionsProcessorFactory(f metrics.Factory, tracer tracing.CompletionTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "completions", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &completionsProcessorRouterFilter{
 				config:         config,
-				tracer:         tracing.CompletionTracer(),
+				tracer:         tracer,
 				requestHeaders: requestHeaders,
 				logger:         logger,
 			}, nil
diff --git a/internal/extproc/completions_processor_test.go b/internal/extproc/completions_processor_test.go
@@ -49,7 +49,7 @@ func TestCompletions_Schema(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			cfg := &filterapi.RuntimeConfig{}
-			filter, err := CompletionsProcessorFactory(&mockMetricsFactory{})(cfg, nil, slog.Default(), tracing.NoopTracing{}, tt.onUpstream)
+			filter, err := CompletionsProcessorFactory(&mockMetricsFactory{}, tracing.NoopCompletionTracer{})(cfg, nil, slog.Default(), tt.onUpstream)
 			require.NoError(t, err)
 			require.NotNil(t, filter)
 			require.IsType(t, tt.expectedType, filter)
diff --git a/internal/extproc/embeddings_processor.go b/internal/extproc/embeddings_processor.go
@@ -28,13 +28,13 @@ import (
 )
 
 // EmbeddingsProcessorFactory returns a factory method to instantiate the embeddings processor.
-func EmbeddingsProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, tracing tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func EmbeddingsProcessorFactory(f metrics.Factory, tracer tracing.EmbeddingsTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "embeddings", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &embeddingsProcessorRouterFilter{
 				config:         config,
-				tracer:         tracing.EmbeddingsTracer(),
+				tracer:         tracer,
 				requestHeaders: requestHeaders,
 				logger:         logger,
 			}, nil
diff --git a/internal/extproc/embeddings_processor_test.go b/internal/extproc/embeddings_processor_test.go
@@ -29,14 +29,14 @@ import (
 func TestEmbeddings_Schema(t *testing.T) {
 	t.Run("supported openai / on route", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := EmbeddingsProcessorFactory(nil)(cfg, nil, slog.Default(), tracing.NoopTracing{}, false)
+		routeFilter, err := EmbeddingsProcessorFactory(nil, tracing.NoopEmbeddingsTracer{})(cfg, nil, slog.Default(), false)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &embeddingsProcessorRouterFilter{}, routeFilter)
 	})
 	t.Run("supported openai / on upstream", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := EmbeddingsProcessorFactory(&mockMetricsFactory{})(cfg, nil, slog.Default(), tracing.NoopTracing{}, true)
+		routeFilter, err := EmbeddingsProcessorFactory(&mockMetricsFactory{}, tracing.NoopEmbeddingsTracer{})(cfg, nil, slog.Default(), true)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &embeddingsProcessorUpstreamFilter{}, routeFilter)
diff --git a/internal/extproc/imagegeneration_processor.go b/internal/extproc/imagegeneration_processor.go
@@ -29,13 +29,13 @@ import (
 )
 
 // ImageGenerationProcessorFactory returns a factory method to instantiate the image generation processor.
-func ImageGenerationProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, tracing tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func ImageGenerationProcessorFactory(f metrics.Factory, tracer tracing.ImageGenerationTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "image-generation", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &imageGenerationProcessorRouterFilter{
 				config:         config,
-				tracer:         tracing.ImageGenerationTracer(),
+				tracer:         tracer,
 				requestHeaders: requestHeaders,
 				logger:         logger,
 			}, nil
diff --git a/internal/extproc/imagegeneration_processor_test.go b/internal/extproc/imagegeneration_processor_test.go
@@ -32,14 +32,14 @@ import (
 func TestImageGeneration_Schema(t *testing.T) {
 	t.Run("supported openai / on route", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := ImageGenerationProcessorFactory(nil)(cfg, nil, slog.Default(), tracing.NoopTracing{}, false)
+		routeFilter, err := ImageGenerationProcessorFactory(nil, tracing.NoopImageGenerationTracer{})(cfg, nil, slog.Default(), false)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &imageGenerationProcessorRouterFilter{}, routeFilter)
 	})
 	t.Run("supported openai / on upstream", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		routeFilter, err := ImageGenerationProcessorFactory(&mockMetricsFactory{})(cfg, nil, slog.Default(), tracing.NoopTracing{}, true)
+		routeFilter, err := ImageGenerationProcessorFactory(&mockMetricsFactory{}, tracing.NoopImageGenerationTracer{})(cfg, nil, slog.Default(), true)
 		require.NoError(t, err)
 		require.NotNil(t, routeFilter)
 		require.IsType(t, &imageGenerationProcessorUpstreamFilter{}, routeFilter)
diff --git a/internal/extproc/messages_processor.go b/internal/extproc/messages_processor.go
@@ -31,8 +31,8 @@ import (
 //
 // Requests: Only accepts Anthropic format requests.
 // Responses: Returns Anthropic format responses.
-func MessagesProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, _ tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func MessagesProcessorFactory(f metrics.Factory, _ tracing.MessageTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "anthropic-messages", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &messagesProcessorRouterFilter{
diff --git a/internal/extproc/messages_processor_test.go b/internal/extproc/messages_processor_test.go
@@ -29,7 +29,7 @@ import (
 
 func TestMessagesProcessorFactory(t *testing.T) {
 	m := metrics.NewMetricsFactory(noop.NewMeterProvider().Meter("test"), map[string]string{}, metrics.GenAIOperationMessages)
-	factory := MessagesProcessorFactory(m)
+	factory := MessagesProcessorFactory(m, nil)
 	require.NotNil(t, factory, "MessagesProcessorFactory should return a non-nil factory")
 
 	// Test creating a router filter.
@@ -40,13 +40,13 @@ func TestMessagesProcessorFactory(t *testing.T) {
 	}
 	logger := slog.Default()
 
-	routerProcessor, err := factory(config, headers, logger, tracing.NoopTracing{}, false)
+	routerProcessor, err := factory(config, headers, logger, false)
 	require.NoError(t, err, "Factory should create router processor without error")
 	require.NotNil(t, routerProcessor, "Router processor should not be nil")
 	require.IsType(t, &messagesProcessorRouterFilter{}, routerProcessor, "Should return router filter type")
 
 	// Test creating an upstream filter.
-	upstreamProcessor, err := factory(config, headers, logger, tracing.NoopTracing{}, true)
+	upstreamProcessor, err := factory(config, headers, logger, true)
 	require.NoError(t, err, "Factory should create upstream processor without error")
 	require.NotNil(t, upstreamProcessor, "Upstream processor should not be nil")
 	require.IsType(t, &messagesProcessorUpstreamFilter{}, upstreamProcessor, "Should return upstream filter type")
diff --git a/internal/extproc/models_processor.go b/internal/extproc/models_processor.go
@@ -19,7 +19,6 @@ import (
 
 	"github.com/envoyproxy/ai-gateway/internal/apischema/openai"
 	"github.com/envoyproxy/ai-gateway/internal/filterapi"
-	tracing "github.com/envoyproxy/ai-gateway/internal/tracing/api"
 )
 
 // modelsProcessor implements [Processor] for the `/v1/models` endpoint.
@@ -36,7 +35,7 @@ type modelsProcessor struct {
 var _ Processor = (*modelsProcessor)(nil)
 
 // NewModelsProcessor creates a new processor that returns the list of declared models.
-func NewModelsProcessor(config *filterapi.RuntimeConfig, _ map[string]string, logger *slog.Logger, _ tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func NewModelsProcessor(config *filterapi.RuntimeConfig, _ map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 	if isUpstreamFilter {
 		return passThroughProcessor{}, nil
 	}
diff --git a/internal/extproc/models_processor_test.go b/internal/extproc/models_processor_test.go
@@ -18,7 +18,6 @@ import (
 
 	"github.com/envoyproxy/ai-gateway/internal/apischema/openai"
 	"github.com/envoyproxy/ai-gateway/internal/filterapi"
-	tracing "github.com/envoyproxy/ai-gateway/internal/tracing/api"
 )
 
 func TestModels_ProcessRequestHeaders(t *testing.T) {
@@ -35,7 +34,7 @@ func TestModels_ProcessRequestHeaders(t *testing.T) {
 			CreatedAt: now,
 		},
 	}}
-	p, err := NewModelsProcessor(cfg, nil, slog.Default(), tracing.NoopTracing{}, false)
+	p, err := NewModelsProcessor(cfg, nil, slog.Default(), false)
 	require.NoError(t, err)
 	res, err := p.ProcessRequestHeaders(t.Context(), &corev3.HeaderMap{
 		Headers: []*corev3.HeaderValue{{Key: "foo", Value: "bar"}},
diff --git a/internal/extproc/processor.go b/internal/extproc/processor.go
@@ -13,11 +13,10 @@ import (
 	extprocv3 "github.com/envoyproxy/go-control-plane/envoy/service/ext_proc/v3"
 
 	"github.com/envoyproxy/ai-gateway/internal/filterapi"
-	tracing "github.com/envoyproxy/ai-gateway/internal/tracing/api"
 )
 
 // ProcessorFactory is the factory function used to create new instances of a processor.
-type ProcessorFactory func(_ *filterapi.RuntimeConfig, _ map[string]string, _ *slog.Logger, _ tracing.Tracing, isUpstreamFilter bool) (Processor, error)
+type ProcessorFactory func(_ *filterapi.RuntimeConfig, _ map[string]string, _ *slog.Logger, isUpstreamFilter bool) (Processor, error)
 
 // Processor is the interface for the processor which corresponds to a single gRPC stream per the external processor filter.
 // This decouples the processor implementation detail from the server implementation.
diff --git a/internal/extproc/rerank_processor.go b/internal/extproc/rerank_processor.go
@@ -28,13 +28,13 @@ import (
 )
 
 // RerankProcessorFactory returns a factory method to instantiate the rerank processor.
-func RerankProcessorFactory(f metrics.Factory) ProcessorFactory {
-	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, tracing tracing.Tracing, isUpstreamFilter bool) (Processor, error) {
+func RerankProcessorFactory(f metrics.Factory, tracer tracing.RerankTracer) ProcessorFactory {
+	return func(config *filterapi.RuntimeConfig, requestHeaders map[string]string, logger *slog.Logger, isUpstreamFilter bool) (Processor, error) {
 		logger = logger.With("processor", "rerank", "isUpstreamFilter", fmt.Sprintf("%v", isUpstreamFilter))
 		if !isUpstreamFilter {
 			return &rerankProcessorRouterFilter{
 				config:         config,
-				tracer:         tracing.RerankTracer(),
+				tracer:         tracer,
 				requestHeaders: requestHeaders,
 				logger:         logger,
 			}, nil
diff --git a/internal/extproc/rerank_processor_test.go b/internal/extproc/rerank_processor_test.go
@@ -31,13 +31,13 @@ import (
 func TestRerank_Schema(t *testing.T) {
 	t.Run("on route", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		p, err := RerankProcessorFactory(nil)(cfg, nil, slog.Default(), tracing.NoopTracing{}, false)
+		p, err := RerankProcessorFactory(nil, tracing.NoopRerankTracer{})(cfg, nil, slog.Default(), false)
 		require.NoError(t, err)
 		require.IsType(t, &rerankProcessorRouterFilter{}, p)
 	})
 	t.Run("on upstream", func(t *testing.T) {
 		cfg := &filterapi.RuntimeConfig{}
-		p, err := RerankProcessorFactory(&mockMetricsFactory{})(cfg, nil, slog.Default(), tracing.NoopTracing{}, true)
+		p, err := RerankProcessorFactory(&mockMetricsFactory{}, tracing.NoopRerankTracer{})(cfg, nil, slog.Default(), true)
 		require.NoError(t, err)
 		require.IsType(t, &rerankProcessorUpstreamFilter{}, p)
 	})
diff --git a/internal/extproc/server.go b/internal/extproc/server.go
diff --git a/internal/extproc/server_test.go b/internal/extproc/server_test.go
diff --git a/internal/filterapi/filterconfig_test.go b/internal/filterapi/filterconfig_test.go
diff --git a/internal/tracing/api/api.go b/internal/tracing/api/api.go
diff --git a/internal/translator/gemini_helper.go b/internal/translator/gemini_helper.go
diff --git a/internal/translator/gemini_helper_test.go b/internal/translator/gemini_helper_test.go
diff --git a/site/package-lock.json b/site/package-lock.json
