feat: refactor model management to introduce provider structure, enhancing model organization and retrieval

src/langbot/pkg/api/http/controller/groups/provider/models.py

@@ -9,12 +9,15 @@ class LLMModelsRouterGroup(group.RouterGroup):
         @self.route('', methods=['GET', 'POST'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY)
         async def _() -> str:
             if quart.request.method == 'GET':
+                provider_uuid = quart.request.args.get('provider_uuid')
+                if provider_uuid:
+                    return self.success(
+                        data={'models': await self.ap.llm_model_service.get_llm_models_by_provider(provider_uuid)}
+                    )
                 return self.success(data={'models': await self.ap.llm_model_service.get_llm_models()})
             elif quart.request.method == 'POST':
                 json_data = await quart.request.json
-
                 model_uuid = await self.ap.llm_model_service.create_llm_model(json_data)
-
                 return self.success(data={'uuid': model_uuid})
 
         @self.route('/<model_uuid>', methods=['GET', 'PUT', 'DELETE'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY)
@@ -52,12 +55,19 @@ class EmbeddingModelsRouterGroup(group.RouterGroup):
         @self.route('', methods=['GET', 'POST'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY)
         async def _() -> str:
             if quart.request.method == 'GET':
+                provider_uuid = quart.request.args.get('provider_uuid')
+                if provider_uuid:
+                    return self.success(
+                        data={
+                            'models': await self.ap.embedding_models_service.get_embedding_models_by_provider(
+                                provider_uuid
+                            )
+                        }
+                    )
                 return self.success(data={'models': await self.ap.embedding_models_service.get_embedding_models()})
             elif quart.request.method == 'POST':
                 json_data = await quart.request.json
-
                 model_uuid = await self.ap.embedding_models_service.create_embedding_model(json_data)
-
                 return self.success(data={'uuid': model_uuid})
 
         @self.route('/<model_uuid>', methods=['GET', 'PUT', 'DELETE'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY)

src/langbot/pkg/api/http/controller/groups/provider/providers.py

@@ -0,0 +1,45 @@
+import quart
+
+from ... import group
+
+
+@group.group_class('models/providers', '/api/v1/provider/providers')
+class ModelProvidersRouterGroup(group.RouterGroup):
+    async def initialize(self) -> None:
+        @self.route('', methods=['GET', 'POST'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY)
+        async def _() -> str:
+            if quart.request.method == 'GET':
+                providers = await self.ap.provider_service.get_providers()
+                # Add model counts
+                for provider in providers:
+                    counts = await self.ap.provider_service.get_provider_model_counts(provider['uuid'])
+                    provider['llm_count'] = counts['llm_count']
+                    provider['embedding_count'] = counts['embedding_count']
+                return self.success(data={'providers': providers})
+            elif quart.request.method == 'POST':
+                json_data = await quart.request.json
+                provider_uuid = await self.ap.provider_service.create_provider(json_data)
+                return self.success(data={'uuid': provider_uuid})
+
+        @self.route(
+            '/<provider_uuid>', methods=['GET', 'PUT', 'DELETE'], auth_type=group.AuthType.USER_TOKEN_OR_API_KEY
+        )
+        async def _(provider_uuid: str) -> str:
+            if quart.request.method == 'GET':
+                provider = await self.ap.provider_service.get_provider(provider_uuid)
+                if provider is None:
+                    return self.http_status(404, -1, 'provider not found')
+                counts = await self.ap.provider_service.get_provider_model_counts(provider_uuid)
+                provider['llm_count'] = counts['llm_count']
+                provider['embedding_count'] = counts['embedding_count']
+                return self.success(data={'provider': provider})
+            elif quart.request.method == 'PUT':
+                json_data = await quart.request.json
+                await self.ap.provider_service.update_provider(provider_uuid, json_data)
+                return self.success()
+            elif quart.request.method == 'DELETE':
+                try:
+                    await self.ap.provider_service.delete_provider(provider_uuid)
+                    return self.success()
+                except ValueError as e:
+                    return self.http_status(400, -1, str(e))

src/langbot/pkg/api/http/controller/groups/space.py

@@ -1,52 +0,0 @@
-import quart
-
-from .. import group
-
-
-DEFAULT_SPACE_URL = 'https://space.langbot.app'
-
-
-@group.group_class('space', '/api/v1/space')
-class SpaceRouterGroup(group.RouterGroup):
-    async def initialize(self) -> None:
-        @self.route('/models/sync', methods=['POST'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(user_email: str) -> str:
-            """Sync models from Space MaaS to local database"""
-            json_data = await quart.request.json or {}
-            space_url = json_data.get('space_url', DEFAULT_SPACE_URL)
-
-            try:
-                stats = await self.ap.space_models_service.sync_models_from_space(user_email, space_url)
-                return self.success(data=stats)
-            except ValueError as e:
-                return self.fail(1, str(e))
-            except Exception as e:
-                return self.fail(2, f'Failed to sync models: {str(e)}')
-
-        @self.route('/models', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(user_email: str) -> str:
-            """Get all synced Space models"""
-            if quart.request.method == 'GET':
-                try:
-                    models = await self.ap.space_models_service.get_space_models()
-                    return self.success(data=models)
-                except Exception as e:
-                    return self.fail(1, f'Failed to get Space models: {str(e)}')
-            elif quart.request.method == 'DELETE':
-                try:
-                    stats = await self.ap.space_models_service.delete_space_models()
-                    return self.success(data=stats)
-                except Exception as e:
-                    return self.fail(1, f'Failed to delete Space models: {str(e)}')
-
-        @self.route('/models/available', methods=['GET'], auth_type=group.AuthType.USER_TOKEN)
-        async def _(user_email: str) -> str:
-            """Get available models from Space (preview before sync)"""
-            try:
-                space_url = quart.request.args.get('space_url', DEFAULT_SPACE_URL)
-                models_data = await self.ap.space_models_service.fetch_space_models(space_url)
-                return self.success(data=models_data)
-            except ValueError as e:
-                return self.fail(1, str(e))
-            except Exception as e:
-                return self.fail(2, f'Failed to fetch available models: {str(e)}')

src/langbot/pkg/api/http/service/model.py

@@ -11,6 +11,18 @@ from ....entity.persistence import pipeline as persistence_pipeline
 from ....provider.modelmgr import requester as model_requester
 
 
+def _parse_provider_api_keys(provider_dict: dict) -> dict:
+    """Parse api_keys if it's a JSON string"""
+    if isinstance(provider_dict.get('api_keys'), str):
+        import json
+
+        try:
+            provider_dict['api_keys'] = json.loads(provider_dict['api_keys'])
+        except Exception:
+            provider_dict['api_keys'] = []
+    return provider_dict
+
+
 class LLMModelsService:
     ap: app.Application
 
@@ -18,29 +30,64 @@ class LLMModelsService:
         self.ap = ap
 
     async def get_llm_models(self, include_secret: bool = True) -> list[dict]:
+        """Get all LLM models with provider info"""
         result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.LLMModel))
-
         models = result.all()
 
-        masked_columns = []
-        if not include_secret:
-            masked_columns = ['api_keys']
+        # Get all providers for lookup
+        providers_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider)
+        )
+        providers = {p.uuid: p for p in providers_result.all()}
 
-        return [
-            self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model, masked_columns)
-            for model in models
-        ]
+        models_list = []
+        for model in models:
+            model_dict = self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
+            provider = providers.get(model.provider_uuid)
+            if provider:
+                provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, provider)
+                provider_dict = _parse_provider_api_keys(provider_dict)
+                if not include_secret:
+                    provider_dict['api_keys'] = ['***'] * len(provider_dict.get('api_keys', []))
+                model_dict['provider'] = provider_dict
+            models_list.append(model_dict)
+
+        return models_list
+
+    async def get_llm_models_by_provider(self, provider_uuid: str) -> list[dict]:
+        """Get LLM models by provider UUID"""
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.LLMModel).where(
+                persistence_model.LLMModel.provider_uuid == provider_uuid
+            )
+        )
+        models = result.all()
+        return [self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, m) for m in models]
 
     async def create_llm_model(self, model_data: dict) -> str:
+        """Create a new LLM model"""
         model_data['uuid'] = str(uuid.uuid4())
 
+        # Handle provider creation if needed
+        if 'provider' in model_data:
+            provider_data = model_data.pop('provider')
+            if provider_data.get('uuid'):
+                model_data['provider_uuid'] = provider_data['uuid']
+            else:
+                # Create new provider
+                provider_uuid = await self.ap.provider_service.find_or_create_provider(
+                    requester=provider_data.get('requester', ''),
+                    base_url=provider_data.get('base_url', ''),
+                    api_keys=provider_data.get('api_keys', []),
+                )
+                model_data['provider_uuid'] = provider_uuid
+
         await self.ap.persistence_mgr.execute_async(sqlalchemy.insert(persistence_model.LLMModel).values(**model_data))
 
         llm_model = await self.get_llm_model(model_data['uuid'])
-
         await self.ap.model_mgr.load_llm_model(llm_model)
 
-        # check if default pipeline has no model bound
+        # Check if default pipeline has no model bound
         result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(persistence_pipeline.LegacyPipeline).where(
                 persistence_pipeline.LegacyPipeline.is_default == True
@@ -56,21 +103,47 @@ class LLMModelsService:
         return model_data['uuid']
 
     async def get_llm_model(self, model_uuid: str) -> dict | None:
+        """Get a single LLM model with provider info"""
         result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
         )
-
         model = result.first()
-
         if model is None:
             return None
 
-        return self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
+        model_dict = self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, model)
+
+        # Get provider
+        provider_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider).where(
+                persistence_model.ModelProvider.uuid == model.provider_uuid
+            )
+        )
+        provider = provider_result.first()
+        if provider:
+            provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, provider)
+            model_dict['provider'] = _parse_provider_api_keys(provider_dict)
+
+        return model_dict
 
     async def update_llm_model(self, model_uuid: str, model_data: dict) -> None:
+        """Update an existing LLM model"""
         if 'uuid' in model_data:
             del model_data['uuid']
 
+        # Handle provider update if needed
+        if 'provider' in model_data:
+            provider_data = model_data.pop('provider')
+            if provider_data.get('uuid'):
+                model_data['provider_uuid'] = provider_data['uuid']
+            else:
+                provider_uuid = await self.ap.provider_service.find_or_create_provider(
+                    requester=provider_data.get('requester', ''),
+                    base_url=provider_data.get('base_url', ''),
+                    api_keys=provider_data.get('api_keys', []),
+                )
+                model_data['provider_uuid'] = provider_uuid
+
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.update(persistence_model.LLMModel)
             .where(persistence_model.LLMModel.uuid == model_uuid)
@@ -78,19 +151,18 @@ class LLMModelsService:
         )
 
         await self.ap.model_mgr.remove_llm_model(model_uuid)
-
         llm_model = await self.get_llm_model(model_uuid)
-
         await self.ap.model_mgr.load_llm_model(llm_model)
 
     async def delete_llm_model(self, model_uuid: str) -> None:
+        """Delete an LLM model"""
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.delete(persistence_model.LLMModel).where(persistence_model.LLMModel.uuid == model_uuid)
         )
-
         await self.ap.model_mgr.remove_llm_model(model_uuid)
 
     async def test_llm_model(self, model_uuid: str, model_data: dict) -> None:
+        """Test an LLM model"""
         runtime_llm_model: model_requester.RuntimeLLMModel | None = None
 
         if model_uuid != '_':
@@ -98,18 +170,11 @@ class LLMModelsService:
                 if model.model_entity.uuid == model_uuid:
                     runtime_llm_model = model
                     break
-
             if runtime_llm_model is None:
                 raise Exception('model not found')
-
         else:
             runtime_llm_model = await self.ap.model_mgr.init_runtime_llm_model(model_data)
 
-        # Mon Nov 10 2025: Commented for some providers may not support thinking parameter
-        # # 有些模型厂商默认开启了思考功能，测试容易延迟
-        # extra_args = model_data.get('extra_args', {})
-        # if not extra_args or 'thinking' not in extra_args:
-        #     extra_args['thinking'] = {'type': 'disabled'}
         extra_args = model_data.get('extra_args', {})
         await runtime_llm_model.requester.invoke_llm(
             query=None,
@@ -127,42 +192,103 @@ class EmbeddingModelsService:
         self.ap = ap
 
     async def get_embedding_models(self) -> list[dict]:
+        """Get all embedding models with provider info"""
         result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.EmbeddingModel))
-
         models = result.all()
-        return [self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, model) for model in models]
+
+        providers_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider)
+        )
+        providers = {p.uuid: p for p in providers_result.all()}
+
+        models_list = []
+        for model in models:
+            model_dict = self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, model)
+            provider = providers.get(model.provider_uuid)
+            if provider:
+                provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, provider)
+                model_dict['provider'] = _parse_provider_api_keys(provider_dict)
+            models_list.append(model_dict)
+
+        return models_list
+
+    async def get_embedding_models_by_provider(self, provider_uuid: str) -> list[dict]:
+        """Get embedding models by provider UUID"""
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.EmbeddingModel).where(
+                persistence_model.EmbeddingModel.provider_uuid == provider_uuid
+            )
+        )
+        models = result.all()
+        return [self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, m) for m in models]
 
     async def create_embedding_model(self, model_data: dict) -> str:
+        """Create a new embedding model"""
         model_data['uuid'] = str(uuid.uuid4())
 
+        if 'provider' in model_data:
+            provider_data = model_data.pop('provider')
+            if provider_data.get('uuid'):
+                model_data['provider_uuid'] = provider_data['uuid']
+            else:
+                provider_uuid = await self.ap.provider_service.find_or_create_provider(
+                    requester=provider_data.get('requester', ''),
+                    base_url=provider_data.get('base_url', ''),
+                    api_keys=provider_data.get('api_keys', []),
+                )
+                model_data['provider_uuid'] = provider_uuid
+
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.insert(persistence_model.EmbeddingModel).values(**model_data)
         )
 
         embedding_model = await self.get_embedding_model(model_data['uuid'])
-
         await self.ap.model_mgr.load_embedding_model(embedding_model)
 
         return model_data['uuid']
 
     async def get_embedding_model(self, model_uuid: str) -> dict | None:
+        """Get a single embedding model with provider info"""
         result = await self.ap.persistence_mgr.execute_async(
             sqlalchemy.select(persistence_model.EmbeddingModel).where(
                 persistence_model.EmbeddingModel.uuid == model_uuid
             )
         )
-
         model = result.first()
-
         if model is None:
             return None
 
-        return self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, model)
+        model_dict = self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, model)
+
+        provider_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider).where(
+                persistence_model.ModelProvider.uuid == model.provider_uuid
+            )
+        )
+        provider = provider_result.first()
+        if provider:
+            provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, provider)
+            model_dict['provider'] = _parse_provider_api_keys(provider_dict)
+
+        return model_dict
 
     async def update_embedding_model(self, model_uuid: str, model_data: dict) -> None:
+        """Update an existing embedding model"""
         if 'uuid' in model_data:
             del model_data['uuid']
 
+        if 'provider' in model_data:
+            provider_data = model_data.pop('provider')
+            if provider_data.get('uuid'):
+                model_data['provider_uuid'] = provider_data['uuid']
+            else:
+                provider_uuid = await self.ap.provider_service.find_or_create_provider(
+                    requester=provider_data.get('requester', ''),
+                    base_url=provider_data.get('base_url', ''),
+                    api_keys=provider_data.get('api_keys', []),
+                )
+                model_data['provider_uuid'] = provider_uuid
+
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.update(persistence_model.EmbeddingModel)
             .where(persistence_model.EmbeddingModel.uuid == model_uuid)
@@ -170,21 +296,20 @@ class EmbeddingModelsService:
         )
 
         await self.ap.model_mgr.remove_embedding_model(model_uuid)
-
         embedding_model = await self.get_embedding_model(model_uuid)
-
         await self.ap.model_mgr.load_embedding_model(embedding_model)
 
     async def delete_embedding_model(self, model_uuid: str) -> None:
+        """Delete an embedding model"""
         await self.ap.persistence_mgr.execute_async(
             sqlalchemy.delete(persistence_model.EmbeddingModel).where(
                 persistence_model.EmbeddingModel.uuid == model_uuid
             )
         )
-
         await self.ap.model_mgr.remove_embedding_model(model_uuid)
 
     async def test_embedding_model(self, model_uuid: str, model_data: dict) -> None:
+        """Test an embedding model"""
         runtime_embedding_model: model_requester.RuntimeEmbeddingModel | None = None
 
         if model_uuid != '_':
@@ -192,10 +317,8 @@ class EmbeddingModelsService:
                 if model.model_entity.uuid == model_uuid:
                     runtime_embedding_model = model
                     break
-
             if runtime_embedding_model is None:
                 raise Exception('model not found')
-
         else:
             runtime_embedding_model = await self.ap.model_mgr.init_runtime_embedding_model(model_data)
 

src/langbot/pkg/api/http/service/provider.py

@@ -0,0 +1,152 @@
+from __future__ import annotations
+
+import uuid
+
+import sqlalchemy
+
+from ....core import app
+from ....entity.persistence import model as persistence_model
+
+
+class ModelProviderService:
+    """Service for managing model providers"""
+
+    ap: app.Application
+
+    def __init__(self, ap: app.Application) -> None:
+        self.ap = ap
+
+    async def get_providers(self) -> list[dict]:
+        """Get all providers"""
+        result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.ModelProvider))
+        providers = result.all()
+        providers_list = []
+        for p in providers:
+            provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, p)
+            # Parse api_keys if it's a JSON string
+            if isinstance(provider_dict.get('api_keys'), str):
+                import json
+
+                try:
+                    provider_dict['api_keys'] = json.loads(provider_dict['api_keys'])
+                except Exception:
+                    provider_dict['api_keys'] = []
+            providers_list.append(provider_dict)
+        return providers_list
+
+    async def get_provider(self, provider_uuid: str) -> dict | None:
+        """Get a single provider by UUID"""
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider).where(
+                persistence_model.ModelProvider.uuid == provider_uuid
+            )
+        )
+        provider = result.first()
+        if provider is None:
+            return None
+        provider_dict = self.ap.persistence_mgr.serialize_model(persistence_model.ModelProvider, provider)
+        # Parse api_keys if it's a JSON string
+        if isinstance(provider_dict.get('api_keys'), str):
+            import json
+
+            try:
+                provider_dict['api_keys'] = json.loads(provider_dict['api_keys'])
+            except Exception:
+                provider_dict['api_keys'] = []
+        return provider_dict
+
+    async def create_provider(self, provider_data: dict) -> str:
+        """Create a new provider"""
+        provider_data['uuid'] = str(uuid.uuid4())
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.insert(persistence_model.ModelProvider).values(**provider_data)
+        )
+        return provider_data['uuid']
+
+    async def update_provider(self, provider_uuid: str, provider_data: dict) -> None:
+        """Update an existing provider"""
+        if 'uuid' in provider_data:
+            del provider_data['uuid']
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.update(persistence_model.ModelProvider)
+            .where(persistence_model.ModelProvider.uuid == provider_uuid)
+            .values(**provider_data)
+        )
+        # Reload all models using this provider
+        await self.ap.model_mgr.load_models_from_db()
+
+    async def delete_provider(self, provider_uuid: str) -> None:
+        """Delete a provider (only if no models reference it)"""
+        # Check if any models use this provider
+        llm_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.LLMModel).where(
+                persistence_model.LLMModel.provider_uuid == provider_uuid
+            )
+        )
+        if llm_result.first() is not None:
+            raise ValueError('Cannot delete provider: LLM models still reference it')
+
+        embedding_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.EmbeddingModel).where(
+                persistence_model.EmbeddingModel.provider_uuid == provider_uuid
+            )
+        )
+        if embedding_result.first() is not None:
+            raise ValueError('Cannot delete provider: Embedding models still reference it')
+
+        await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.delete(persistence_model.ModelProvider).where(
+                persistence_model.ModelProvider.uuid == provider_uuid
+            )
+        )
+
+    async def get_provider_model_counts(self, provider_uuid: str) -> dict:
+        """Get count of models using this provider"""
+        llm_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(sqlalchemy.func.count())
+            .select_from(persistence_model.LLMModel)
+            .where(persistence_model.LLMModel.provider_uuid == provider_uuid)
+        )
+        llm_count = llm_result.scalar() or 0
+
+        embedding_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(sqlalchemy.func.count())
+            .select_from(persistence_model.EmbeddingModel)
+            .where(persistence_model.EmbeddingModel.provider_uuid == provider_uuid)
+        )
+        embedding_count = embedding_result.scalar() or 0
+
+        return {'llm_count': llm_count, 'embedding_count': embedding_count}
+
+    async def find_or_create_provider(self, requester: str, base_url: str, api_keys: list) -> str:
+        """Find existing provider or create new one"""
+        # Try to find existing provider with same config
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider).where(
+                persistence_model.ModelProvider.requester == requester,
+                persistence_model.ModelProvider.base_url == base_url,
+            )
+        )
+        for provider in result.all():
+            if sorted(provider.api_keys or []) == sorted(api_keys or []):
+                return provider.uuid
+
+        # Create new provider
+        provider_name = requester
+        if base_url:
+            try:
+                from urllib.parse import urlparse
+
+                parsed = urlparse(base_url)
+                provider_name = parsed.netloc or requester
+            except Exception:
+                pass
+
+        return await self.create_provider(
+            {
+                'name': provider_name,
+                'requester': requester,
+                'base_url': base_url,
+                'api_keys': api_keys or [],
+            }
+        )

src/langbot/pkg/api/http/service/space_models.py

@@ -1,247 +0,0 @@
-from __future__ import annotations
-
-import typing
-import uuid as uuid_lib
-import aiohttp
-import sqlalchemy
-
-from ....core import app
-from ....entity.persistence import model as persistence_model
-from ....entity.persistence import user as persistence_user
-
-
-DEFAULT_SPACE_URL = 'http://localhost:8383'
-
-# Space's base URL for model API requests (used for requester_config)
-SPACE_API_BASE_URL = 'http://localhost:8383'
-
-
-class SpaceModelsService:
-    """Service for syncing models from Space MaaS"""
-
-    ap: app.Application
-
-    def __init__(self, ap: app.Application) -> None:
-        self.ap = ap
-
-    async def get_space_user_info(self, user_email: str) -> persistence_user.User | None:
-        """Get Space user info for sync operations"""
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_user.User).where(persistence_user.User.user == user_email)
-        )
-        result_list = result.all()
-        return result_list[0] if result_list else None
-
-    async def fetch_space_models(self, space_url: str = DEFAULT_SPACE_URL) -> typing.Dict:
-        """Fetch available models from Space API"""
-        async with aiohttp.ClientSession() as session:
-            async with session.get(f'{space_url}/api/v1/models', params={'page_size': 100}) as response:
-                if response.status != 200:
-                    raise ValueError(f'Failed to fetch models from Space: {await response.text()}')
-                data = await response.json()
-                if data.get('code') != 0:
-                    raise ValueError(f'Failed to fetch models from Space: {data.get("msg")}')
-                return data.get('data', {})
-
-    async def sync_models_from_space(
-        self, user_email: str, space_url: str = DEFAULT_SPACE_URL
-    ) -> typing.Dict[str, typing.Any]:
-        """
-        Sync models from Space to local database.
-        Returns statistics about the sync operation.
-        """
-        # Get user info for API key
-        user_obj = await self.get_space_user_info(user_email)
-        if user_obj is None:
-            raise ValueError('User not found')
-
-        if user_obj.account_type != 'space':
-            raise ValueError('User is not a Space account')
-
-        if not user_obj.space_api_key:
-            raise ValueError('User does not have a Space API key configured')
-
-        # Fetch models from Space
-        models_data = await self.fetch_space_models(space_url)
-        space_models = models_data.get('models', [])
-
-        # Get existing Space models in local database
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.source == 'space')
-        )
-        existing_space_models = {m.space_model_id: m for m in result.all()}
-
-        result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.EmbeddingModel).where(
-                persistence_model.EmbeddingModel.source == 'space'
-            )
-        )
-        existing_space_embedding_models = {m.space_model_id: m for m in result.all()}
-
-        stats = {'created_llm': 0, 'updated_llm': 0, 'created_embedding': 0, 'updated_embedding': 0, 'skipped': 0}
-
-        for model in space_models:
-            model_id = model.get('model_id')
-            category = model.get('category', '')
-
-            if not model_id:
-                stats['skipped'] += 1
-                continue
-
-            if category == 'embedding':
-                # Handle embedding model
-                await self._sync_embedding_model(model, user_obj.space_api_key, existing_space_embedding_models, stats)
-            else:
-                # Handle LLM model (chat, completion, etc.)
-                await self._sync_llm_model(model, user_obj.space_api_key, existing_space_models, stats)
-
-        return stats
-
-    async def _sync_llm_model(
-        self,
-        model: typing.Dict,
-        api_key: str,
-        existing_models: typing.Dict[str, persistence_model.LLMModel],
-        stats: typing.Dict,
-    ) -> None:
-        """Sync a single LLM model from Space"""
-        model_id = model.get('model_id')
-        display_name = model.get('display_name', {})
-        name = display_name.get('zh_Hans', display_name.get('en_US', model_id))
-        description_obj = model.get('description', {})
-        description = description_obj.get('zh_Hans', description_obj.get('en_US', '')) if description_obj else ''
-
-        # Infer abilities from model capabilities
-        abilities = []
-        supported_endpoints = model.get('supported_endpoints', [])
-        if 'vision' in str(supported_endpoints).lower() or 'vision' in model_id.lower():
-            abilities.append('vision')
-        if 'function' in str(supported_endpoints).lower() or 'tool' in str(supported_endpoints).lower():
-            abilities.append('function_call')
-
-        model_data = {
-            'name': name,
-            'description': description[:255] if description else 'Model from Space MaaS',
-            'requester': 'openai-chat-completions',  # Space uses OpenAI-compatible API
-            'requester_config': {
-                'base-url': SPACE_API_BASE_URL,
-                'args': {},
-                'timeout': 120,
-            },
-            'api_keys': [api_key],
-            'abilities': abilities,
-            'extra_args': {'model': model_id},
-            'source': 'space',
-            'space_model_id': model_id,
-        }
-
-        if model_id in existing_models:
-            # Update existing model
-            await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.update(persistence_model.LLMModel)
-                .where(persistence_model.LLMModel.space_model_id == model_id)
-                .values(**model_data)
-            )
-            stats['updated_llm'] += 1
-        else:
-            # Create new model
-            model_data['uuid'] = str(uuid_lib.uuid4())
-            await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.insert(persistence_model.LLMModel).values(**model_data)
-            )
-            stats['created_llm'] += 1
-
-    async def _sync_embedding_model(
-        self,
-        model: typing.Dict,
-        api_key: str,
-        existing_models: typing.Dict[str, persistence_model.EmbeddingModel],
-        stats: typing.Dict,
-    ) -> None:
-        """Sync a single embedding model from Space"""
-        model_id = model.get('model_id')
-        display_name = model.get('display_name', {})
-        name = display_name.get('zh_Hans', display_name.get('en_US', model_id))
-        description_obj = model.get('description', {})
-        description = description_obj.get('zh_Hans', description_obj.get('en_US', '')) if description_obj else ''
-
-        model_data = {
-            'name': name,
-            'description': description[:255] if description else 'Embedding model from Space MaaS',
-            'requester': 'openai-embedding',  # Space uses OpenAI-compatible API
-            'requester_config': {
-                'base-url': SPACE_API_BASE_URL,
-                'args': {},
-                'timeout': 120,
-            },
-            'api_keys': [api_key],
-            'extra_args': {'model': model_id},
-            'source': 'space',
-            'space_model_id': model_id,
-        }
-
-        if model_id in existing_models:
-            # Update existing model
-            await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.update(persistence_model.EmbeddingModel)
-                .where(persistence_model.EmbeddingModel.space_model_id == model_id)
-                .values(**model_data)
-            )
-            stats['updated_embedding'] += 1
-        else:
-            # Create new model
-            model_data['uuid'] = str(uuid_lib.uuid4())
-            await self.ap.persistence_mgr.execute_async(
-                sqlalchemy.insert(persistence_model.EmbeddingModel).values(**model_data)
-            )
-            stats['created_embedding'] += 1
-
-    async def get_space_models(self) -> typing.Dict[str, typing.List]:
-        """Get all synced Space models"""
-        llm_result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.source == 'space')
-        )
-        embedding_result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.EmbeddingModel).where(
-                persistence_model.EmbeddingModel.source == 'space'
-            )
-        )
-
-        return {
-            'llm_models': [
-                self.ap.persistence_mgr.serialize_model(persistence_model.LLMModel, m) for m in llm_result.all()
-            ],
-            'embedding_models': [
-                self.ap.persistence_mgr.serialize_model(persistence_model.EmbeddingModel, m)
-                for m in embedding_result.all()
-            ],
-        }
-
-    async def delete_space_models(self) -> typing.Dict[str, int]:
-        """Delete all synced Space models"""
-        # Remove from model manager first
-        llm_result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.LLMModel).where(persistence_model.LLMModel.source == 'space')
-        )
-        for model in llm_result.all():
-            await self.ap.model_mgr.remove_llm_model(model.uuid)
-
-        embedding_result = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.select(persistence_model.EmbeddingModel).where(
-                persistence_model.EmbeddingModel.source == 'space'
-            )
-        )
-        for model in embedding_result.all():
-            await self.ap.model_mgr.remove_embedding_model(model.uuid)
-
-        # Delete from database
-        llm_delete = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_model.LLMModel).where(persistence_model.LLMModel.source == 'space')
-        )
-        embedding_delete = await self.ap.persistence_mgr.execute_async(
-            sqlalchemy.delete(persistence_model.EmbeddingModel).where(
-                persistence_model.EmbeddingModel.source == 'space'
-            )
-        )
-
-        return {'deleted_llm': llm_delete.rowcount, 'deleted_embedding': embedding_delete.rowcount}

src/langbot/pkg/core/app.py

@@ -20,6 +20,7 @@ from ..persistence import mgr as persistencemgr
 from ..api.http.controller import main as http_controller
 from ..api.http.service import user as user_service
 from ..api.http.service import model as model_service
+from ..api.http.service import provider as provider_service
 from ..api.http.service import pipeline as pipeline_service
 from ..api.http.service import bot as bot_service
 from ..api.http.service import knowledge as knowledge_service
@@ -27,7 +28,6 @@ from ..api.http.service import mcp as mcp_service
 from ..api.http.service import apikey as apikey_service
 from ..api.http.service import webhook as webhook_service
 from ..api.http.service import external_kb as external_kb_service
-from ..api.http.service import space_models as space_models_service
 from ..discover import engine as discover_engine
 from ..storage import mgr as storagemgr
 from ..utils import logcache
@@ -119,6 +119,8 @@ class Application:
 
     embedding_models_service: model_service.EmbeddingModelsService = None
 
+    provider_service: provider_service.ModelProviderService = None
+
     pipeline_service: pipeline_service.PipelineService = None
 
     bot_service: bot_service.BotService = None
@@ -133,8 +135,6 @@ class Application:
 
     webhook_service: webhook_service.WebhookService = None
 
-    space_models_service: space_models_service.SpaceModelsService = None
-
     def __init__(self):
         pass
 

src/langbot/pkg/core/stages/build_app.py

@@ -17,6 +17,7 @@ from ...persistence import mgr as persistencemgr
 from ...api.http.controller import main as http_controller
 from ...api.http.service import user as user_service
 from ...api.http.service import model as model_service
+from ...api.http.service import provider as provider_service
 from ...api.http.service import pipeline as pipeline_service
 from ...api.http.service import bot as bot_service
 from ...api.http.service import knowledge as knowledge_service
@@ -24,7 +25,6 @@ from ...api.http.service import mcp as mcp_service
 from ...api.http.service import apikey as apikey_service
 from ...api.http.service import webhook as webhook_service
 from ...api.http.service import external_kb as external_kb_service
-from ...api.http.service import space_models as space_models_service
 from ...discover import engine as discover_engine
 from ...storage import mgr as storagemgr
 from ...utils import logcache
@@ -115,6 +115,9 @@ class BuildAppStage(stage.BootingStage):
         embedding_models_service_inst = model_service.EmbeddingModelsService(ap)
         ap.embedding_models_service = embedding_models_service_inst
 
+        provider_service_inst = provider_service.ModelProviderService(ap)
+        ap.provider_service = provider_service_inst
+
         pipeline_service_inst = pipeline_service.PipelineService(ap)
         ap.pipeline_service = pipeline_service_inst
 
@@ -136,9 +139,6 @@ class BuildAppStage(stage.BootingStage):
         webhook_service_inst = webhook_service.WebhookService(ap)
         ap.webhook_service = webhook_service_inst
 
-        space_models_service_inst = space_models_service.SpaceModelsService(ap)
-        ap.space_models_service = space_models_service_inst
-
         async def runtime_disconnect_callback(connector: plugin_connector.PluginRuntimeConnector) -> None:
             await asyncio.sleep(3)
             await plugin_connector_inst.initialize()

src/langbot/pkg/entity/persistence/model.py

@@ -3,6 +3,25 @@ import sqlalchemy
 from .base import Base
 
 
+class ModelProvider(Base):
+    """Model provider"""
+
+    __tablename__ = 'model_providers'
+
+    uuid = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True, unique=True)
+    name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
+    requester = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
+    base_url = sqlalchemy.Column(sqlalchemy.String(512), nullable=False)
+    api_keys = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default=[])
+    created_at = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False, server_default=sqlalchemy.func.now())
+    updated_at = sqlalchemy.Column(
+        sqlalchemy.DateTime,
+        nullable=False,
+        server_default=sqlalchemy.func.now(),
+        onupdate=sqlalchemy.func.now(),
+    )
+
+
 class LLMModel(Base):
     """LLM model"""
 
@@ -10,16 +29,9 @@ class LLMModel(Base):
 
     uuid = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True, unique=True)
     name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    description = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    requester = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    requester_config = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default={})
-    api_keys = sqlalchemy.Column(sqlalchemy.JSON, nullable=False)
+    provider_uuid = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
     abilities = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default=[])
     extra_args = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default={})
-    # Source tracking for Space integration: 'local' or 'space'
-    source = sqlalchemy.Column(sqlalchemy.String(32), nullable=False, server_default='local')
-    # Space model ID for synced models (used to track and update synced models)
-    space_model_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=True)
     created_at = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False, server_default=sqlalchemy.func.now())
     updated_at = sqlalchemy.Column(
         sqlalchemy.DateTime,
@@ -30,21 +42,14 @@ class LLMModel(Base):
 
 
 class EmbeddingModel(Base):
-    """Embedding 模型"""
+    """Embedding model"""
 
     __tablename__ = 'embedding_models'
 
     uuid = sqlalchemy.Column(sqlalchemy.String(255), primary_key=True, unique=True)
     name = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    description = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    requester = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
-    requester_config = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default={})
-    api_keys = sqlalchemy.Column(sqlalchemy.JSON, nullable=False)
+    provider_uuid = sqlalchemy.Column(sqlalchemy.String(255), nullable=False)
     extra_args = sqlalchemy.Column(sqlalchemy.JSON, nullable=False, default={})
-    # Source tracking for Space integration: 'local' or 'space'
-    source = sqlalchemy.Column(sqlalchemy.String(32), nullable=False, server_default='local')
-    # Space model ID for synced models (used to track and update synced models)
-    space_model_id = sqlalchemy.Column(sqlalchemy.String(255), nullable=True)
     created_at = sqlalchemy.Column(sqlalchemy.DateTime, nullable=False, server_default=sqlalchemy.func.now())
     updated_at = sqlalchemy.Column(
         sqlalchemy.DateTime,

src/langbot/pkg/persistence/migrations/dbm016_model_provider_refactor.py

@@ -0,0 +1,286 @@
+import uuid as uuid_lib
+
+import sqlalchemy
+from .. import migration
+
+
+@migration.migration_class(16)
+class DBMigrateModelProviderRefactor(migration.DBMigration):
+    """Refactor model structure: create providers from existing models and update references"""
+
+    async def upgrade(self):
+        """Upgrade"""
+        # Step 1: Create model_providers table if not exists
+        await self._create_providers_table()
+
+        # Step 2: Migrate existing models to use providers
+        await self._migrate_llm_models()
+        await self._migrate_embedding_models()
+
+        # Step 3: Remove deprecated columns
+        await self._cleanup_columns()
+
+    async def _create_providers_table(self):
+        """Create model_providers table"""
+        if self.ap.persistence_mgr.db.name == 'postgresql':
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text("""
+                    CREATE TABLE IF NOT EXISTS model_providers (
+                        uuid VARCHAR(255) PRIMARY KEY,
+                        name VARCHAR(255) NOT NULL,
+                        requester VARCHAR(255) NOT NULL,
+                        base_url VARCHAR(512) NOT NULL,
+                        api_keys JSONB NOT NULL DEFAULT '[]',
+                        created_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                        updated_at TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+            )
+        else:
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text("""
+                    CREATE TABLE IF NOT EXISTS model_providers (
+                        uuid VARCHAR(255) PRIMARY KEY,
+                        name VARCHAR(255) NOT NULL,
+                        requester VARCHAR(255) NOT NULL,
+                        base_url VARCHAR(512) NOT NULL,
+                        api_keys JSON NOT NULL DEFAULT '[]',
+                        created_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP,
+                        updated_at DATETIME NOT NULL DEFAULT CURRENT_TIMESTAMP
+                    )
+                """)
+            )
+
+    async def _migrate_llm_models(self):
+        """Migrate LLM models to use providers"""
+        llm_columns = await self._get_columns('llm_models')
+
+        # Add provider_uuid column if not exists
+        if 'provider_uuid' not in llm_columns:
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text('ALTER TABLE llm_models ADD COLUMN provider_uuid VARCHAR(255)')
+            )
+
+        # Only migrate if old columns exist
+        if 'requester' not in llm_columns:
+            return
+
+        # Get all LLM models with old structure
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.text('SELECT uuid, name, requester, requester_config, api_keys FROM llm_models')
+        )
+        models = result.fetchall()
+
+        # Create providers and update models
+        provider_cache = {}  # (requester, base_url, api_keys_str) -> provider_uuid
+
+        for model in models:
+            model_uuid, model_name, requester, requester_config, api_keys = model
+
+            # Extract base_url from requester_config
+            base_url = ''
+            if requester_config:
+                if isinstance(requester_config, str):
+                    import json
+
+                    requester_config = json.loads(requester_config)
+                base_url = requester_config.get('base_url', '') or requester_config.get('base-url', '')
+
+            # Parse api_keys if it's a string
+            if isinstance(api_keys, str):
+                import json
+
+                try:
+                    api_keys = json.loads(api_keys)
+                except Exception:
+                    api_keys = []
+            if not api_keys:
+                api_keys = []
+
+            # Create cache key
+            api_keys_str = str(sorted(api_keys)) if api_keys else '[]'
+            cache_key = (requester, base_url, api_keys_str)
+
+            if cache_key in provider_cache:
+                provider_uuid = provider_cache[cache_key]
+            else:
+                # Create new provider
+                provider_uuid = str(uuid_lib.uuid4())
+                provider_name = f'{requester}'
+                if base_url:
+                    # Extract domain for name
+                    try:
+                        from urllib.parse import urlparse
+
+                        parsed = urlparse(base_url)
+                        provider_name = parsed.netloc or requester
+                    except Exception:
+                        pass
+
+                import json
+
+                api_keys_json = json.dumps(api_keys) if api_keys else '[]'
+
+                await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.text("""
+                        INSERT INTO model_providers (uuid, name, requester, base_url, api_keys)
+                        VALUES (:uuid, :name, :requester, :base_url, :api_keys)
+                    """),
+                    {
+                        'uuid': provider_uuid,
+                        'name': provider_name,
+                        'requester': requester,
+                        'base_url': base_url,
+                        'api_keys': api_keys_json,
+                    },
+                )
+                provider_cache[cache_key] = provider_uuid
+
+            # Update model with provider_uuid
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text('UPDATE llm_models SET provider_uuid = :provider_uuid WHERE uuid = :uuid'),
+                {'provider_uuid': provider_uuid, 'uuid': model_uuid},
+            )
+
+    async def _migrate_embedding_models(self):
+        """Migrate embedding models to use providers"""
+        embedding_columns = await self._get_columns('embedding_models')
+
+        # Add provider_uuid column if not exists
+        if 'provider_uuid' not in embedding_columns:
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text('ALTER TABLE embedding_models ADD COLUMN provider_uuid VARCHAR(255)')
+            )
+
+        # Only migrate if old columns exist
+        if 'requester' not in embedding_columns:
+            return
+
+        # Get all embedding models with old structure
+        result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.text('SELECT uuid, name, requester, requester_config, api_keys FROM embedding_models')
+        )
+        models = result.fetchall()
+
+        # Get existing providers
+        provider_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.text('SELECT uuid, requester, base_url, api_keys FROM model_providers')
+        )
+        existing_providers = provider_result.fetchall()
+
+        provider_cache = {}
+        for p in existing_providers:
+            p_uuid, p_requester, p_base_url, p_api_keys = p
+            api_keys_str = str(sorted(p_api_keys)) if p_api_keys else '[]'
+            provider_cache[(p_requester, p_base_url, api_keys_str)] = p_uuid
+
+        for model in models:
+            model_uuid, model_name, requester, requester_config, api_keys = model
+
+            base_url = ''
+            if requester_config:
+                if isinstance(requester_config, str):
+                    import json
+
+                    requester_config = json.loads(requester_config)
+                base_url = requester_config.get('base_url', '') or requester_config.get('base-url', '')
+
+            # Parse api_keys if it's a string
+            if isinstance(api_keys, str):
+                import json
+
+                try:
+                    api_keys = json.loads(api_keys)
+                except Exception:
+                    api_keys = []
+            if not api_keys:
+                api_keys = []
+
+            api_keys_str = str(sorted(api_keys)) if api_keys else '[]'
+            cache_key = (requester, base_url, api_keys_str)
+
+            if cache_key in provider_cache:
+                provider_uuid = provider_cache[cache_key]
+            else:
+                provider_uuid = str(uuid_lib.uuid4())
+                provider_name = f'{requester}'
+                if base_url:
+                    try:
+                        from urllib.parse import urlparse
+
+                        parsed = urlparse(base_url)
+                        provider_name = parsed.netloc or requester
+                    except Exception:
+                        pass
+
+                import json
+
+                api_keys_json = json.dumps(api_keys) if api_keys else '[]'
+
+                await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.text("""
+                        INSERT INTO model_providers (uuid, name, requester, base_url, api_keys)
+                        VALUES (:uuid, :name, :requester, :base_url, :api_keys)
+                    """),
+                    {
+                        'uuid': provider_uuid,
+                        'name': provider_name,
+                        'requester': requester,
+                        'base_url': base_url,
+                        'api_keys': api_keys_json,
+                    },
+                )
+                provider_cache[cache_key] = provider_uuid
+
+            await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text('UPDATE embedding_models SET provider_uuid = :provider_uuid WHERE uuid = :uuid'),
+                {'provider_uuid': provider_uuid, 'uuid': model_uuid},
+            )
+
+    async def _cleanup_columns(self):
+        """Remove deprecated columns from model tables"""
+        # SQLite doesn't support DROP COLUMN easily, so we skip for SQLite
+        if self.ap.persistence_mgr.db.name != 'postgresql':
+            return
+
+        llm_columns = await self._get_columns('llm_models')
+        deprecated_llm_cols = ['requester', 'requester_config', 'api_keys', 'description', 'source', 'space_model_id']
+        for col in deprecated_llm_cols:
+            if col in llm_columns:
+                await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.text(f'ALTER TABLE llm_models DROP COLUMN IF EXISTS {col}')
+                )
+
+        embedding_columns = await self._get_columns('embedding_models')
+        deprecated_embedding_cols = [
+            'requester',
+            'requester_config',
+            'api_keys',
+            'description',
+            'source',
+            'space_model_id',
+        ]
+        for col in deprecated_embedding_cols:
+            if col in embedding_columns:
+                await self.ap.persistence_mgr.execute_async(
+                    sqlalchemy.text(f'ALTER TABLE embedding_models DROP COLUMN IF EXISTS {col}')
+                )
+
+    async def _get_columns(self, table_name: str) -> list:
+        """Get column names for a table"""
+        if self.ap.persistence_mgr.db.name == 'postgresql':
+            result = await self.ap.persistence_mgr.execute_async(
+                sqlalchemy.text(
+                    f"SELECT column_name FROM information_schema.columns WHERE table_name = '{table_name}';"
+                )
+            )
+            all_result = result.fetchall()
+            return [row[0] for row in all_result]
+        else:
+            result = await self.ap.persistence_mgr.execute_async(sqlalchemy.text(f'PRAGMA table_info({table_name});'))
+            all_result = result.fetchall()
+            return [row[1] for row in all_result]
+
+    async def downgrade(self):
+        """Downgrade"""
+        pass

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

@@ -10,11 +10,9 @@ from . import token
 from ...entity.persistence import model as persistence_model
 from ...entity.errors import provider as provider_errors
 
-FETCH_MODEL_LIST_URL = 'https://api.qchatgpt.rockchin.top/api/v2/fetch/model_list'
-
 
 class ModelManager:
-    """模型管理器"""
+    """Model manager"""
 
     ap: app.Application
 
@@ -24,7 +22,7 @@ class ModelManager:
 
     requester_components: list[engine.Component]
 
-    requester_dict: dict[str, type[requester.ProviderAPIRequester]]  # cache
+    requester_dict: dict[str, type[requester.ProviderAPIRequester]]
 
     def __init__(self, ap: app.Application):
         self.ap = ap
@@ -36,7 +34,6 @@ class ModelManager:
     async def initialize(self):
         self.requester_components = self.ap.discover.get_components_by_kind('LLMAPIRequester')
 
-        # forge requester class dict
         requester_dict: dict[str, type[requester.ProviderAPIRequester]] = {}
         for component in self.requester_components:
             requester_dict[component.metadata.name] = component.get_python_component_class()
@@ -46,29 +43,45 @@ class ModelManager:
         await self.load_models_from_db()
 
     async def load_models_from_db(self):
-        """从数据库加载模型"""
+        """Load models from database"""
         self.ap.logger.info('Loading models from db...')
 
         self.llm_models = []
         self.embedding_models = []
 
-        # llm models
+        # Load all providers first
+        providers_result = await self.ap.persistence_mgr.execute_async(
+            sqlalchemy.select(persistence_model.ModelProvider)
+        )
+        providers = {p.uuid: p for p in providers_result.all()}
+
+        # Load LLM models
         result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.LLMModel))
         llm_models = result.all()
         for llm_model in llm_models:
             try:
-                await self.load_llm_model(llm_model)
+                provider = providers.get(llm_model.provider_uuid)
+                if provider is None:
+                    self.ap.logger.warning(f'Provider {llm_model.provider_uuid} not found for model {llm_model.uuid}')
+                    continue
+                await self.load_llm_model_with_provider(llm_model, provider)
             except provider_errors.RequesterNotFoundError as e:
                 self.ap.logger.warning(f'Requester {e.requester_name} not found, skipping llm model {llm_model.uuid}')
             except Exception as e:
                 self.ap.logger.error(f'Failed to load model {llm_model.uuid}: {e}\n{traceback.format_exc()}')
 
-        # embedding models
+        # Load embedding models
         result = await self.ap.persistence_mgr.execute_async(sqlalchemy.select(persistence_model.EmbeddingModel))
         embedding_models = result.all()
         for embedding_model in embedding_models:
             try:
-                await self.load_embedding_model(embedding_model)
+                provider = providers.get(embedding_model.provider_uuid)
+                if provider is None:
+                    self.ap.logger.warning(
+                        f'Provider {embedding_model.provider_uuid} not found for model {embedding_model.uuid}'
+                    )
+                    continue
+                await self.load_embedding_model_with_provider(embedding_model, provider)
             except provider_errors.RequesterNotFoundError as e:
                 self.ap.logger.warning(
                     f'Requester {e.requester_name} not found, skipping embedding model {embedding_model.uuid}'
@@ -78,27 +91,33 @@ class ModelManager:
 
     async def init_runtime_llm_model(
         self,
-        model_info: persistence_model.LLMModel | sqlalchemy.Row[persistence_model.LLMModel] | dict,
+        model_info: dict,
     ):
-        """初始化运行时 LLM 模型"""
-        if isinstance(model_info, sqlalchemy.Row):
-            model_info = persistence_model.LLMModel(**model_info._mapping)
-        elif isinstance(model_info, dict):
-            model_info = persistence_model.LLMModel(**model_info)
+        """Initialize runtime LLM model from dict (for testing)"""
+        provider_info = model_info.get('provider', {})
+        requester_name = provider_info.get('requester', '')
+        base_url = provider_info.get('base_url', '')
+        api_keys = provider_info.get('api_keys', [])
 
-        if model_info.requester not in self.requester_dict:
-            raise provider_errors.RequesterNotFoundError(model_info.requester)
-
-        requester_inst = self.requester_dict[model_info.requester](ap=self.ap, config=model_info.requester_config)
+        if requester_name not in self.requester_dict:
+            raise provider_errors.RequesterNotFoundError(requester_name)
 
+        requester_cfg = {'base_url': base_url}
+        requester_inst = self.requester_dict[requester_name](ap=self.ap, config=requester_cfg)
         await requester_inst.initialize()
 
+        # Create a temporary model entity
+        model_entity = persistence_model.LLMModel(
+            uuid=model_info.get('uuid', ''),
+            name=model_info.get('name', ''),
+            provider_uuid='',
+            abilities=model_info.get('abilities', []),
+            extra_args=model_info.get('extra_args', {}),
+        )
+
         runtime_llm_model = requester.RuntimeLLMModel(
-            model_entity=model_info,
-            token_mgr=token.TokenManager(
-                name=model_info.uuid,
-                tokens=model_info.api_keys,
-            ),
+            model_entity=model_entity,
+            token_mgr=token.TokenManager(name=model_entity.uuid, tokens=api_keys),
             requester=requester_inst,
         )
 
@@ -106,78 +125,165 @@ class ModelManager:
 
     async def init_runtime_embedding_model(
         self,
-        model_info: persistence_model.EmbeddingModel | sqlalchemy.Row[persistence_model.EmbeddingModel] | dict,
+        model_info: dict,
     ):
-        """初始化运行时 Embedding 模型"""
-        if isinstance(model_info, sqlalchemy.Row):
-            model_info = persistence_model.EmbeddingModel(**model_info._mapping)
-        elif isinstance(model_info, dict):
-            model_info = persistence_model.EmbeddingModel(**model_info)
+        """Initialize runtime embedding model from dict (for testing)"""
+        provider_info = model_info.get('provider', {})
+        requester_name = provider_info.get('requester', '')
+        base_url = provider_info.get('base_url', '')
+        api_keys = provider_info.get('api_keys', [])
 
-        if model_info.requester not in self.requester_dict:
-            raise provider_errors.RequesterNotFoundError(model_info.requester)
-
-        requester_inst = self.requester_dict[model_info.requester](ap=self.ap, config=model_info.requester_config)
+        if requester_name not in self.requester_dict:
+            raise provider_errors.RequesterNotFoundError(requester_name)
 
+        requester_cfg = {'base_url': base_url}
+        requester_inst = self.requester_dict[requester_name](ap=self.ap, config=requester_cfg)
         await requester_inst.initialize()
 
+        model_entity = persistence_model.EmbeddingModel(
+            uuid=model_info.get('uuid', ''),
+            name=model_info.get('name', ''),
+            provider_uuid='',
+            extra_args=model_info.get('extra_args', {}),
+        )
+
         runtime_embedding_model = requester.RuntimeEmbeddingModel(
-            model_entity=model_info,
-            token_mgr=token.TokenManager(
-                name=model_info.uuid,
-                tokens=model_info.api_keys,
-            ),
+            model_entity=model_entity,
+            token_mgr=token.TokenManager(name=model_entity.uuid, tokens=api_keys),
             requester=requester_inst,
         )
 
         return runtime_embedding_model
 
-    async def load_llm_model(
+    async def load_llm_model_with_provider(
         self,
-        model_info: persistence_model.LLMModel | sqlalchemy.Row[persistence_model.LLMModel] | dict,
+        model_info: persistence_model.LLMModel | sqlalchemy.Row,
+        provider: persistence_model.ModelProvider | sqlalchemy.Row,
     ):
-        """加载 LLM 模型"""
-        runtime_llm_model = await self.init_runtime_llm_model(model_info)
+        """Load LLM model with provider info"""
+        if isinstance(model_info, sqlalchemy.Row):
+            model_info = persistence_model.LLMModel(**model_info._mapping)
+        if isinstance(provider, sqlalchemy.Row):
+            provider = persistence_model.ModelProvider(**provider._mapping)
+
+        if provider.requester not in self.requester_dict:
+            raise provider_errors.RequesterNotFoundError(provider.requester)
+
+        requester_cfg = {'base_url': provider.base_url}
+        requester_inst = self.requester_dict[provider.requester](ap=self.ap, config=requester_cfg)
+        await requester_inst.initialize()
+
+        runtime_llm_model = requester.RuntimeLLMModel(
+            model_entity=model_info,
+            token_mgr=token.TokenManager(name=model_info.uuid, tokens=provider.api_keys or []),
+            requester=requester_inst,
+        )
+
         self.llm_models.append(runtime_llm_model)
 
-    async def load_embedding_model(
+    async def load_embedding_model_with_provider(
         self,
-        model_info: persistence_model.EmbeddingModel | sqlalchemy.Row[persistence_model.EmbeddingModel] | dict,
+        model_info: persistence_model.EmbeddingModel | sqlalchemy.Row,
+        provider: persistence_model.ModelProvider | sqlalchemy.Row,
     ):
-        """加载 Embedding 模型"""
-        runtime_embedding_model = await self.init_runtime_embedding_model(model_info)
+        """Load embedding model with provider info"""
+        if isinstance(model_info, sqlalchemy.Row):
+            model_info = persistence_model.EmbeddingModel(**model_info._mapping)
+        if isinstance(provider, sqlalchemy.Row):
+            provider = persistence_model.ModelProvider(**provider._mapping)
+
+        if provider.requester not in self.requester_dict:
+            raise provider_errors.RequesterNotFoundError(provider.requester)
+
+        requester_cfg = {'base_url': provider.base_url}
+        requester_inst = self.requester_dict[provider.requester](ap=self.ap, config=requester_cfg)
+        await requester_inst.initialize()
+
+        runtime_embedding_model = requester.RuntimeEmbeddingModel(
+            model_entity=model_info,
+            token_mgr=token.TokenManager(name=model_info.uuid, tokens=provider.api_keys or []),
+            requester=requester_inst,
+        )
+
         self.embedding_models.append(runtime_embedding_model)
 
+    async def load_llm_model(self, model_info: dict):
+        """Load LLM model from dict (with provider info)"""
+        provider_info = model_info.get('provider', {})
+        if not provider_info:
+            raise ValueError('Provider info is required')
+
+        model_entity = persistence_model.LLMModel(
+            uuid=model_info.get('uuid', ''),
+            name=model_info.get('name', ''),
+            provider_uuid=model_info.get('provider_uuid', ''),
+            abilities=model_info.get('abilities', []),
+            extra_args=model_info.get('extra_args', {}),
+        )
+
+        provider_entity = persistence_model.ModelProvider(
+            uuid=provider_info.get('uuid', ''),
+            name=provider_info.get('name', ''),
+            requester=provider_info.get('requester', ''),
+            base_url=provider_info.get('base_url', ''),
+            api_keys=provider_info.get('api_keys', []),
+        )
+
+        await self.load_llm_model_with_provider(model_entity, provider_entity)
+
+    async def load_embedding_model(self, model_info: dict):
+        """Load embedding model from dict (with provider info)"""
+        provider_info = model_info.get('provider', {})
+        if not provider_info:
+            raise ValueError('Provider info is required')
+
+        model_entity = persistence_model.EmbeddingModel(
+            uuid=model_info.get('uuid', ''),
+            name=model_info.get('name', ''),
+            provider_uuid=model_info.get('provider_uuid', ''),
+            extra_args=model_info.get('extra_args', {}),
+        )
+
+        provider_entity = persistence_model.ModelProvider(
+            uuid=provider_info.get('uuid', ''),
+            name=provider_info.get('name', ''),
+            requester=provider_info.get('requester', ''),
+            base_url=provider_info.get('base_url', ''),
+            api_keys=provider_info.get('api_keys', []),
+        )
+
+        await self.load_embedding_model_with_provider(model_entity, provider_entity)
+
     async def get_model_by_uuid(self, uuid: str) -> requester.RuntimeLLMModel:
-        """通过uuid获取 LLM 模型"""
+        """Get LLM model by uuid"""
         for model in self.llm_models:
             if model.model_entity.uuid == uuid:
                 return model
         raise ValueError(f'LLM model {uuid} not found')
 
     async def get_embedding_model_by_uuid(self, uuid: str) -> requester.RuntimeEmbeddingModel:
-        """通过uuid获取 Embedding 模型"""
+        """Get embedding model by uuid"""
         for model in self.embedding_models:
             if model.model_entity.uuid == uuid:
                 return model
         raise ValueError(f'Embedding model {uuid} not found')
 
     async def remove_llm_model(self, model_uuid: str):
-        """移除 LLM 模型"""
+        """Remove LLM model"""
         for model in self.llm_models:
             if model.model_entity.uuid == model_uuid:
                 self.llm_models.remove(model)
                 return
 
     async def remove_embedding_model(self, model_uuid: str):
-        """移除 Embedding 模型"""
+        """Remove embedding model"""
         for model in self.embedding_models:
             if model.model_entity.uuid == model_uuid:
                 self.embedding_models.remove(model)
                 return
 
     def get_available_requesters_info(self, model_type: str) -> list[dict]:
-        """获取所有可用的请求器"""
+        """Get all available requesters"""
         if model_type != '':
             return [
                 component.to_plain_dict()
@@ -188,14 +294,14 @@ class ModelManager:
             return [component.to_plain_dict() for component in self.requester_components]
 
     def get_available_requester_info_by_name(self, name: str) -> dict | None:
-        """通过名称获取请求器信息"""
+        """Get requester info by name"""
         for component in self.requester_components:
             if component.metadata.name == name:
                 return component.to_plain_dict()
         return None
 
     def get_available_requester_manifest_by_name(self, name: str) -> engine.Component | None:
-        """通过名称获取请求器清单"""
+        """Get requester manifest by name"""
         for component in self.requester_components:
             if component.metadata.name == name:
                 return component

src/langbot/pkg/utils/constants.py

@@ -2,7 +2,7 @@ import langbot
 
 semantic_version = f'v{langbot.__version__}'
 
-required_database_version = 15
+required_database_version = 16
 """Tag the version of the database schema, used to check if the database needs to be migrated"""
 
 debug_mode = False