Give each tracker agent its own config

The tracker-mapping, common-pattern enrichment, and third-party
disambiguation agents were all built from one shared
TrackerAgentsConfig fed by a single tracker-mapping config slot. That
forced a single AgentTimeout to be reused and patched per worker, and
two unrelated max-turns fields to share one struct.

Split the in-code config into TrackerMappingAgentConfig,
TrackerEnrichmentAgentConfig, and DisambiguationAgentConfig, each with
its own timeout and max-turns, and add dedicated tracker-enrichment and
third-party-disambiguation provider slots (the latter resolving next to
third-party-vetter). Enrichment and disambiguation fall back to the
tracker-mapping slot when their own provider is unset, preserving
single-config deployments.

Drop the shared pkg/agentsbuild package and duplicate its small wiring
into probod and proboctl so the two executables stay decoupled. Wire
the new env vars, builder test coverage, and Helm values.

Signed-off-by: Émile Ré <emile@probo.com>

pkg/probod/llm.go

@@ -15,17 +15,70 @@
 package probod
 
 import (
+	"fmt"
+
 	"github.com/prometheus/client_golang/prometheus"
+	"go.gearno.de/kit/httpclient"
 	"go.gearno.de/kit/log"
 	"go.opentelemetry.io/otel/trace"
-	"go.probo.inc/probo/pkg/agentsbuild"
 	"go.probo.inc/probo/pkg/llm"
+	llmanthropic "go.probo.inc/probo/pkg/llm/anthropic"
+	llmopenai "go.probo.inc/probo/pkg/llm/openai"
 )
 
+// buildLLMClient creates an LLM client for the given provider config.
+func (impl *Implm) buildLLMClient(
+	cfg LLMProviderConfig,
+	l *log.Logger,
+	tp trace.TracerProvider,
+	r prometheus.Registerer,
+) (*llm.Client, error) {
+	providerType := cfg.Type
+	if providerType == "" {
+		providerType = "openai"
+	}
+
+	httpClient := httpclient.DefaultPooledClient(
+		httpclient.WithLogger(l),
+		httpclient.WithTracerProvider(tp),
+		httpclient.WithRegisterer(r),
+	)
+
+	switch providerType {
+	case "openai":
+		p := llmopenai.NewProvider(
+			cfg.APIKey,
+			llmopenai.WithHTTPClient(httpClient),
+		)
+
+		return llm.NewClient(
+			p,
+			"openai",
+			llm.WithLogger(l),
+			llm.WithTracerProvider(tp),
+		), nil
+	case "anthropic":
+		p := llmanthropic.NewProvider(
+			cfg.APIKey,
+			llmanthropic.WithHTTPClient(httpClient),
+		)
+
+		return llm.NewClient(
+			p,
+			"anthropic",
+			llm.WithLogger(l),
+			llm.WithTracerProvider(tp),
+		), nil
+	case "bedrock":
+		return nil, fmt.Errorf("bedrock provider not yet wired; requires aws.Config")
+	default:
+		return nil, fmt.Errorf("unsupported LLM provider type: %q", providerType)
+	}
+}
+
 // resolveAgentClient resolves the agent's effective config from defaults and
 // builds an LLM client for it. The name parameter is used in the logger and
-// in error messages. It delegates to pkg/agentsbuild so probod and proboctl
-// wire LLM clients identically.
+// in error messages.
 func (impl *Implm) resolveAgentClient(
 	name string,
 	agent LLMAgentConfig,
@@ -33,5 +86,17 @@ func (impl *Implm) resolveAgentClient(
 	tp trace.TracerProvider,
 	r prometheus.Registerer,
 ) (LLMAgentConfig, *llm.Client, error) {
-	return agentsbuild.ResolveAgentClient(impl.cfg.Agents, name, agent, l, tp, r)
+	resolved := impl.cfg.Agents.ResolveAgent(agent)
+
+	providerCfg, ok := impl.cfg.Agents.Providers[resolved.Provider]
+	if !ok {
+		return LLMAgentConfig{}, nil, fmt.Errorf("unknown LLM provider %q for %s agent", resolved.Provider, name)
+	}
+
+	client, err := impl.buildLLMClient(providerCfg, l.Named("llm."+name), tp, r)
+	if err != nil {
+		return LLMAgentConfig{}, nil, fmt.Errorf("cannot create %s LLM client: %w", name, err)
+	}
+
+	return resolved, client, nil
 }

pkg/probod/probod.go

@@ -324,7 +324,7 @@ func (impl *Implm) Run(
 		return err
 	}
 
-	trackerAgentsCfg, thirdPartyDisambiguationCfg, err := impl.buildTrackerAgentsConfig(l, tp, r)
+	trackerMappingCfg, trackerEnrichmentCfg, thirdPartyDisambiguationCfg, err := impl.buildTrackerAgents(l, tp, r)
 	if err != nil {
 		return err
 	}
@@ -790,7 +790,7 @@ func (impl *Implm) Run(
 	trackerMappingWorker := cookiebanner.NewTrackerMappingWorker(
 		pgClient,
 		l,
-		trackerAgentsCfg,
+		trackerMappingCfg,
 		thirdPartyDisambiguationCfg,
 		time.Duration(impl.cfg.TrackerMappingWorker.StaleAfter)*time.Second,
 		worker.WithInterval(time.Duration(impl.cfg.TrackerMappingWorker.Interval)*time.Second),
@@ -811,14 +811,12 @@ func (impl *Implm) Run(
 	// the tracker agents are configured.
 	stopCommonPatternEnrichmentWorker := func() {}
 
-	if trackerAgentsCfg.LLMClient != nil {
-		enrichmentCfg := trackerAgentsCfg
-		enrichmentCfg.AgentTimeout = time.Duration(impl.cfg.CommonPatternEnrichmentWorker.AgentTimeout) * time.Second
-
+	if trackerEnrichmentCfg.LLMClient != nil {
 		commonPatternEnrichmentWorker := cookiebanner.NewCommonPatternEnrichmentWorker(
 			pgClient,
 			l,
-			enrichmentCfg,
+			trackerEnrichmentCfg,
+			trackerMappingCfg,
 			time.Duration(impl.cfg.CommonPatternEnrichmentWorker.StaleAfter)*time.Second,
 			worker.WithInterval(time.Duration(impl.cfg.CommonPatternEnrichmentWorker.Interval)*time.Second),
 			worker.WithMaxConcurrency(impl.cfg.CommonPatternEnrichmentWorker.MaxConcurrency),

pkg/probod/tracker_agents.go

@@ -15,22 +15,108 @@
 package probod
 
 import (
+	"fmt"
+	"time"
+
 	"github.com/prometheus/client_golang/prometheus"
 	"go.gearno.de/kit/log"
 	"go.opentelemetry.io/otel/trace"
-	"go.probo.inc/probo/pkg/agentsbuild"
 	"go.probo.inc/probo/pkg/cookiebanner"
 	"go.probo.inc/probo/pkg/thirdparty"
 )
 
-// buildTrackerAgentsConfig wires the tracker agents (mapping, enrichment,
-// disambiguation) from the probod config. It delegates to pkg/agentsbuild
-// so probod and proboctl build the same agent configuration; see that
-// package for the wiring rationale.
-func (impl *Implm) buildTrackerAgentsConfig(
+// buildTrackerAgents wires the three tracker agents from the probod
+// config, each with its own LLM client and tuning: the tracker-mapping
+// agent (catalog identification), the common-pattern enrichment agent
+// (description research), and the third-party disambiguation agent. All
+// are opt-in: when `llm.tracker-mapping.provider` is empty it returns
+// zero configs (nil LLM clients) so callers run without agent fallback.
+//
+// The enrichment and disambiguation agents fall back to the
+// tracker-mapping config when their own provider slot is empty, so a
+// deployment that configures only `tracker-mapping` keeps wiring all
+// three agents.
+func (impl *Implm) buildTrackerAgents(
 	l *log.Logger,
 	tp trace.TracerProvider,
 	r prometheus.Registerer,
-) (cookiebanner.TrackerAgentsConfig, thirdparty.DisambiguationConfig, error) {
-	return agentsbuild.BuildTrackerAgentsConfig(impl.cfg, l, tp, r)
+) (cookiebanner.TrackerMappingAgentConfig, cookiebanner.TrackerEnrichmentAgentConfig, thirdparty.DisambiguationAgentConfig, error) {
+	if impl.cfg.Agents.TrackerMapping.Provider == "" {
+		return cookiebanner.TrackerMappingAgentConfig{}, cookiebanner.TrackerEnrichmentAgentConfig{}, thirdparty.DisambiguationAgentConfig{}, nil
+	}
+
+	firecrawlAPIKey := impl.cfg.Agents.Tools.FirecrawlAPIKey
+
+	mappingAgentCfg, mappingClient, err := impl.resolveAgentClient(
+		"tracker-mapping",
+		impl.cfg.Agents.TrackerMapping,
+		l,
+		tp,
+		r,
+	)
+	if err != nil {
+		return cookiebanner.TrackerMappingAgentConfig{}, cookiebanner.TrackerEnrichmentAgentConfig{}, thirdparty.DisambiguationAgentConfig{}, fmt.Errorf("cannot resolve tracker mapping agent client: %w", err)
+	}
+
+	mappingCfg := cookiebanner.TrackerMappingAgentConfig{
+		LLMClient:       mappingClient,
+		Model:           mappingAgentCfg.ModelName,
+		FirecrawlAPIKey: firecrawlAPIKey,
+		MaxTokens:       mappingAgentCfg.MaxTokens,
+		Temperature:     mappingAgentCfg.Temperature,
+		Timeout:         time.Duration(impl.cfg.TrackerMappingWorker.AgentTimeout) * time.Second,
+		MaxTurns:        impl.cfg.TrackerMappingWorker.AgentMaxTurns,
+	}
+
+	enrichmentSlot := impl.cfg.Agents.TrackerEnrichment
+	if enrichmentSlot.Provider == "" {
+		enrichmentSlot = impl.cfg.Agents.TrackerMapping
+	}
+
+	enrichmentAgentCfg, enrichmentClient, err := impl.resolveAgentClient(
+		"tracker-enrichment",
+		enrichmentSlot,
+		l,
+		tp,
+		r,
+	)
+	if err != nil {
+		return cookiebanner.TrackerMappingAgentConfig{}, cookiebanner.TrackerEnrichmentAgentConfig{}, thirdparty.DisambiguationAgentConfig{}, fmt.Errorf("cannot resolve tracker enrichment agent client: %w", err)
+	}
+
+	enrichmentCfg := cookiebanner.TrackerEnrichmentAgentConfig{
+		LLMClient:       enrichmentClient,
+		Model:           enrichmentAgentCfg.ModelName,
+		FirecrawlAPIKey: firecrawlAPIKey,
+		MaxTokens:       enrichmentAgentCfg.MaxTokens,
+		Temperature:     enrichmentAgentCfg.Temperature,
+		Timeout:         time.Duration(impl.cfg.CommonPatternEnrichmentWorker.AgentTimeout) * time.Second,
+		MaxTurns:        impl.cfg.CommonPatternEnrichmentWorker.AgentMaxTurns,
+	}
+
+	disambiguationSlot := impl.cfg.Agents.ThirdPartyDisambiguation
+	if disambiguationSlot.Provider == "" {
+		disambiguationSlot = impl.cfg.Agents.TrackerMapping
+	}
+
+	disambiguationAgentCfg, disambiguationClient, err := impl.resolveAgentClient(
+		"third-party-disambiguation",
+		disambiguationSlot,
+		l,
+		tp,
+		r,
+	)
+	if err != nil {
+		return cookiebanner.TrackerMappingAgentConfig{}, cookiebanner.TrackerEnrichmentAgentConfig{}, thirdparty.DisambiguationAgentConfig{}, fmt.Errorf("cannot resolve third party disambiguation agent client: %w", err)
+	}
+
+	disambiguationCfg := thirdparty.DisambiguationAgentConfig{
+		LLMClient:   disambiguationClient,
+		Model:       disambiguationAgentCfg.ModelName,
+		MaxTokens:   disambiguationAgentCfg.MaxTokens,
+		Temperature: disambiguationAgentCfg.Temperature,
+		Timeout:     time.Duration(impl.cfg.TrackerMappingWorker.DisambiguationAgentTimeout) * time.Second,
+	}
+
+	return mappingCfg, enrichmentCfg, disambiguationCfg, nil
 }