Refactor per-provider model lookup and restore catalog docs

src/llm-coding-tools-core/benches/model_catalog_builder.rs

@@ -3,19 +3,21 @@
 use core::hint::black_box;
 use criterion::{criterion_group, criterion_main, BenchmarkId, Criterion, Throughput};
 use llm_coding_tools_core::models::{
-    Modality, ModelCatalog, ModelInfo, ModelSourceRow, ProviderInfo, ProviderSourceRow,
+    Modality, ModelCatalog, ModelInfo, ProviderInfo, ProviderModelSource, ProviderSource,
     ProviderType,
 };
 
 struct Dataset {
-    providers: Vec<ProviderSourceRow>,
-    models: Vec<ModelSourceRow>,
+    providers: Vec<ProviderSource>,
+    provider_models: Vec<ProviderModelSource>,
 }
 
 fn make_dataset(provider_count: usize, model_count: usize) -> Dataset {
+    debug_assert!(provider_count > 0);
+
     let mut providers = Vec::with_capacity(provider_count);
     for i in 0..provider_count {
-        providers.push(ProviderSourceRow::new(
+        providers.push(ProviderSource::new(
             format!("provider-{i}"),
             ProviderInfo {
                 api_url: format!("https://provider-{i}.example/v1"),
@@ -29,12 +31,13 @@ fn make_dataset(provider_count: usize, model_count: usize) -> Dataset {
         ));
     }
 
-    let mut models = Vec::with_capacity(model_count);
+    let mut provider_models = Vec::with_capacity(model_count);
     let unique_cfg_count = (model_count / 5).max(1);
     for i in 0..model_count {
+        let provider_idx = i % provider_count;
         let cfg = i % unique_cfg_count;
         let temperature = if (cfg & 1) == 0 {
-            Some(1.0 + (cfg as f32 * 0.001))
+            Some(1.0 + ((cfg % 5000) as f32 * 0.001))
         } else {
             None
         };
@@ -44,7 +47,8 @@ fn make_dataset(provider_count: usize, model_count: usize) -> Dataset {
             None
         };
 
-        models.push(ModelSourceRow::new(
+        provider_models.push(ProviderModelSource::new(
+            format!("provider-{provider_idx}"),
             format!("org-{}/model-{i}", i % 17),
             ModelInfo {
                 modalities: Modality::TEXT,
@@ -56,28 +60,34 @@ fn make_dataset(provider_count: usize, model_count: usize) -> Dataset {
         ));
     }
 
-    Dataset { providers, models }
+    Dataset {
+        providers,
+        provider_models,
+    }
 }
 
 fn construct_batch(dataset: &Dataset) {
-    let catalog = ModelCatalog::build(&dataset.providers, &dataset.models).expect("batch build");
+    let catalog =
+        ModelCatalog::build(&dataset.providers, &dataset.provider_models).expect("batch build");
 
     black_box((
-        catalog.provider_len(),
-        catalog.model_len(),
-        catalog.model_config_len(),
+        catalog.provider_count(),
+        catalog.provider_model_count(),
+        catalog.model_config_count(),
     ));
 }
 
 fn benchmark_builder_construction(c: &mut Criterion) {
     let mut group = c.benchmark_group("model_catalog_builder_construct");
 
     for (name, provider_count, model_count) in [
-        ("models_dev_snapshot", 96usize, 1669usize),
+        ("models_dev_snapshot", 96usize, 3031usize),
         ("max", 16384usize, 65535usize),
     ] {
         let dataset = make_dataset(provider_count, model_count);
-        group.throughput(Throughput::Elements((provider_count + model_count) as u64));
+        group.throughput(Throughput::Elements(
+            (provider_count + dataset.provider_models.len()) as u64,
+        ));
 
         group.bench_with_input(BenchmarkId::new("batch", name), &dataset, |b, input| {
             b.iter(|| construct_batch(black_box(input)))