Feat/rerank model (#2137)

* feat(provider): add rerank model management as a core model type

* feat(provider): add rerank support to existing requesters and new rerank providers

* feat(web): add rerank model management UI and pipeline config

* fix(provider): correct rerank support_type after verification

- Add rerank to OpenRouter (confirmed /api/v1/rerank endpoint)
- Remove rerank from Ollama (no native support, PR #7219 unmerged)
- Remove rerank from JiekouAI (no rerank docs found, URL path mismatch)

* fix(provider): remove alru_cache from model getters and add rerank param hints

* fix: resolve lint errors

- Remove unused alru_cache import from modelmgr.py
- Remove unused error_message variable in invoke_rerank
- Fix prettier formatting in frontend files

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix: remove unused exception variable

- Change `except Exception as e:` to `except Exception:` since e is not used
- Fix prettier formatting in ProviderCard.tsx

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix: apply ruff format

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* feat(template): add rerank config fields to default pipeline config

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* chore: remove PR.md

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

* fix(ui): remove duplicate rerank model form in AddModelPopover

The form was being rendered twice: once in TabsContent manual mode
and again in a separate conditional block for rerank tab.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 <noreply@anthropic.com>

src/langbot/pkg/provider/modelmgr/modelmgr.py

@@ -9,7 +9,6 @@ from ...discover import engine
 from . import token
 from ...entity.persistence import model as persistence_model
 from ...entity.errors import provider as provider_errors
-from async_lru import alru_cache
 
 
 class ModelManager:
@@ -24,6 +23,8 @@ class ModelManager:
 
     embedding_models: list[requester.RuntimeEmbeddingModel]
 
+    rerank_models: list[requester.RuntimeRerankModel]
+
     requester_components: list[engine.Component]
 
     requester_dict: dict[str, type[requester.ProviderAPIRequester]]
@@ -32,6 +33,7 @@ class ModelManager:
         self.ap = ap
         self.llm_models = []
         self.embedding_models = []
+        self.rerank_models = []
         self.requester_components = []
         self.requester_dict = {}
 
@@ -64,8 +66,7 @@ class ModelManager:
 
         self.llm_models = []
         self.embedding_models = []
-
-        # Load all providers first
+        self.rerank_models = []
         self.provider_dict = {}
         providers_result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(persistence_model.ModelProvider)
@@ -110,6 +111,22 @@ class ModelManager:
             except Exception as e:
                 self.ap.logger.error(f'Failed to load model {embedding_model.uuid}: {e}\n{traceback.format_exc()}')
 
+        # Load rerank models
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.RerankModel))
+        rerank_models = result.all()
+        for rerank_model in rerank_models:
+            try:
+                provider = self.provider_dict.get(rerank_model.provider_uuid)
+                if provider is None:
+                    self.ap.logger.warning(
+                        f'Provider {rerank_model.provider_uuid} not found for model {rerank_model.uuid}'
+                    )
+                    continue
+                runtime_rerank_model = await self.load_rerank_model_with_provider(rerank_model, provider)
+                self.rerank_models.append(runtime_rerank_model)
+            except Exception as e:
+                self.ap.logger.error(f'Failed to load model {rerank_model.uuid}: {e}\n{traceback.format_exc()}')
+
     async def sync_new_models_from_space(self):
         """Sync models from Space"""
         space_model_provider = await self.ap.persistence_mgr.execute_async(
@@ -212,6 +229,26 @@ class ModelManager:
 
         return runtime_embedding_model
 
+    async def init_temporary_runtime_rerank_model(
+        self,
+        model_info: dict,
+    ) -> requester.RuntimeRerankModel:
+        """Initialize runtime rerank model from dict (for testing)"""
+        provider_info = model_info.get('provider', {})
+        runtime_provider = await self.load_provider(provider_info)
+
+        runtime_rerank_model = requester.RuntimeRerankModel(
+            model_entity=persistence_model.RerankModel(
+                uuid=model_info.get('uuid', ''),
+                name=model_info.get('name', ''),
+                provider_uuid='',
+                extra_args=model_info.get('extra_args', {}),
+            ),
+            provider=runtime_provider,
+        )
+
+        return runtime_rerank_model
+
     async def load_provider(
         self, provider_info: persistence_model.ModelProvider | sqlalchemy.Row | dict
     ) -> requester.RuntimeProvider:
@@ -269,6 +306,9 @@ class ModelManager:
         for model in self.embedding_models:
             if model.provider.provider_entity.uuid == provider_uuid:
                 model.provider = new_runtime_provider
+        for model in self.rerank_models:
+            if model.provider.provider_entity.uuid == provider_uuid:
+                model.provider = new_runtime_provider
 
         # update ref in provider dict
         self.provider_dict[provider_uuid] = new_runtime_provider
@@ -305,6 +345,22 @@ class ModelManager:
 
         return runtime_embedding_model
 
+    async def load_rerank_model_with_provider(
+        self,
+        model_info: persistence_model.RerankModel | sqlalchemy.Row,
+        provider: requester.RuntimeProvider,
+    ) -> requester.RuntimeRerankModel:
+        """Load rerank model with provider info"""
+        if isinstance(model_info, sqlalchemy.Row):
+            model_info = persistence_model.RerankModel(**model_info._mapping)
+
+        runtime_rerank_model = requester.RuntimeRerankModel(
+            model_entity=model_info,
+            provider=provider,
+        )
+
+        return runtime_rerank_model
+
     async def load_llm_model(self, model_info: dict):
         """Load LLM model from dict (with provider info)"""
         provider_info = model_info.get('provider', {})
@@ -352,7 +408,6 @@ class ModelManager:
 
         await self.load_embedding_model_with_provider(model_entity, provider_entity)
 
-    @alru_cache(ttl=60 * 5)
     async def get_model_by_uuid(self, uuid: str) -> requester.RuntimeLLMModel:
         """Get LLM model by uuid"""
         for model in self.llm_models:
@@ -360,7 +415,6 @@ class ModelManager:
                 return model
         raise ValueError(f'LLM model {uuid} not found')
 
-    @alru_cache(ttl=60 * 5)
     async def get_embedding_model_by_uuid(self, uuid: str) -> requester.RuntimeEmbeddingModel:
         """Get embedding model by uuid"""
         for model in self.embedding_models:
@@ -368,6 +422,13 @@ class ModelManager:
                 return model
         raise ValueError(f'Embedding model {uuid} not found')
 
+    async def get_rerank_model_by_uuid(self, uuid: str) -> requester.RuntimeRerankModel:
+        """Get rerank model by uuid"""
+        for model in self.rerank_models:
+            if model.model_entity.uuid == uuid:
+                return model
+        raise ValueError(f'Rerank model {uuid} not found')
+
     async def remove_llm_model(self, model_uuid: str):
         """Remove LLM model"""
         for model in self.llm_models:
@@ -382,6 +443,13 @@ class ModelManager:
                 self.embedding_models.remove(model)
                 return
 
+    async def remove_rerank_model(self, model_uuid: str):
+        """Remove rerank model"""
+        for model in self.rerank_models:
+            if model.model_entity.uuid == model_uuid:
+                self.rerank_models.remove(model)
+                return
+
     def get_available_requesters_info(self, model_type: str) -> list[dict]:
         """Get all available requesters"""
         if model_type != '':