Coevolution extension

src/repo_registry/candidate_graph/generator.py

@@ -64,6 +64,10 @@ class CandidateGraphGenerator:
         manifests = self._facts(facts, "manifest")
         frameworks = self._facts(facts, "framework")
         languages = self._facts(facts, "language")
+        llm_providers = self._facts(facts, "llm_provider")
+        credential_configs = self._facts(facts, "credential_config")
+        provider_registries = self._facts(facts, "provider_registry")
+        fallback_policies = self._facts(facts, "fallback_policy")
 
         ability_sources = docs or manifests or languages
         ability = CandidateAbilityDraft(
@@ -86,6 +90,18 @@ class CandidateGraphGenerator:
             capabilities.append(
                 self._interface_capability(interfaces, tests, examples, docs, chunks)
             )
+        if llm_providers or provider_registries or fallback_policies:
+            capabilities.append(
+                self._llm_provider_capability(
+                    llm_providers,
+                    credential_configs,
+                    provider_registries,
+                    fallback_policies,
+                    tests,
+                    examples,
+                    docs,
+                )
+            )
         if manifests or frameworks or languages:
             capabilities.append(
                 CandidateCapabilityDraft(
@@ -142,6 +158,84 @@ class CandidateGraphGenerator:
             evidence=self._evidence(tests, examples, docs),
         )
 
+    def _llm_provider_capability(
+        self,
+        providers: list[ObservedFact],
+        credentials: list[ObservedFact],
+        registries: list[ObservedFact],
+        fallback_policies: list[ObservedFact],
+        tests: list[ObservedFact],
+        examples: list[ObservedFact],
+        docs: list[ObservedFact],
+    ) -> CandidateCapabilityDraft:
+        provider_names = sorted({fact.name for fact in providers})
+        provider_summary = ", ".join(provider_names) if provider_names else "LLM providers"
+        features = [
+            CandidateFeatureDraft(
+                name=f"Use {provider} Models",
+                type="integration",
+                location=self._grouped_location(
+                    [fact for fact in providers if fact.name == provider]
+                ),
+                confidence=0.75,
+                source_refs=self._source_refs(
+                    [fact for fact in providers if fact.name == provider]
+                ),
+            )
+            for provider in provider_names
+        ]
+        if credentials:
+            features.append(
+                CandidateFeatureDraft(
+                    name="Configure LLM Provider Credentials",
+                    type="configuration",
+                    location=self._grouped_location(credentials),
+                    confidence=0.7,
+                    source_refs=self._source_refs(credentials),
+                )
+            )
+        if registries:
+            features.append(
+                CandidateFeatureDraft(
+                    name="Maintain LLM Provider Registry",
+                    type="backend",
+                    location=self._grouped_location(registries),
+                    confidence=0.65,
+                    source_refs=self._source_refs(registries),
+                )
+            )
+        if fallback_policies:
+            features.append(
+                CandidateFeatureDraft(
+                    name="Apply LLM Provider Fallback Policy",
+                    type="backend",
+                    location=self._grouped_location(fallback_policies),
+                    confidence=0.6,
+                    source_refs=self._source_refs(fallback_policies),
+                )
+            )
+        return CandidateCapabilityDraft(
+            name="Route LLM Requests Across Providers",
+            description=(
+                "Expose or configure model-provider integrations detected from "
+                f"source-linked provider hints: {provider_summary}."
+            ),
+            inputs=["LLM request", "provider configuration"],
+            outputs=["provider-specific model response"],
+            confidence=self._llm_provider_confidence(
+                providers=providers,
+                credentials=credentials,
+                registries=registries,
+                fallback_policies=fallback_policies,
+                docs=docs,
+            ),
+            source_refs=self._source_refs(
+                providers + credentials + registries + fallback_policies
+            ),
+            features=features,
+            evidence=self._evidence(tests, examples, docs),
+        )
+
     def _interface_features(
         self,
         interfaces: list[ObservedFact],
@@ -378,6 +472,27 @@ class CandidateGraphGenerator:
             ],
         )
 
+    def _llm_provider_confidence(
+        self,
+        *,
+        providers: list[ObservedFact],
+        credentials: list[ObservedFact],
+        registries: list[ObservedFact],
+        fallback_policies: list[ObservedFact],
+        docs: list[ObservedFact],
+    ) -> float:
+        return self._confidence(
+            0.35,
+            [
+                (0.20, bool(providers)),
+                (0.10, len({fact.name for fact in providers}) > 1),
+                (0.10, bool(credentials)),
+                (0.10, bool(registries)),
+                (0.10, bool(fallback_policies)),
+                (0.05, bool(docs)),
+            ],
+        )
+
     def _confidence(
         self,
         base: float,