Skip to content

RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.

fix(model): resolve provider names inside the request's tenant (#21495)

cielb3e86da73694
diff --git a/internal/dao/tenant_model.go b/internal/dao/tenant_model.go
index d7751efa38..cacdea2b05 100644
--- a/internal/dao/tenant_model.go
+++ b/internal/dao/tenant_model.go
@@ -35,41 +35,11 @@ func (dao *TenantModelDAO) Create(ctx context.Context, db *gorm.DB, instance *en
return db.WithContext(ctx).Create(instance).Error
}
-func (dao *TenantModelDAO) CreateBatch(ctx context.Context, db *gorm.DB, models []*entity.TenantModel) error {
- if len(models) == 0 {
- return nil
- }
-
- return db.WithContext(ctx).Transaction(func(tx *gorm.DB) error {
- for _, model := range models {
- if err := tx.WithContext(ctx).Create(model).Error; err != nil {
- return err
- }
- }
- return nil
- })
-}
-
-func (dao *TenantModelDAO) DeleteByModelID(ctx context.Context, db *gorm.DB, modelID string) (int64, error) {
- result := db.WithContext(ctx).Unscoped().Where("id = ?", modelID).Delete(&entity.TenantModel{})
- return result.RowsAffected, result.Error
-}
-
func (dao *TenantModelDAO) DeleteByModelIDAndProviderIDAndInstanceID(ctx context.Context, db *gorm.DB, modelID, providerID, instanceID string) (int64, error) {
result := db.WithContext(ctx).Unscoped().Where("id = ? AND provider_id = ? AND instance_id = ?", modelID, providerID, instanceID).Delete(&entity.TenantModel{})
return result.RowsAffected, result.Error
}
-func (dao *TenantModelDAO) DeleteByProviderIDAndInstanceID(ctx context.Context, db *gorm.DB, provideID, instanceID string) (int64, error) {
- result := db.WithContext(ctx).Unscoped().Where("provider_id = ? AND instance_id = ?", provideID, instanceID).Delete(&entity.TenantModel{})
- return result.RowsAffected, result.Error
-}
-
-func (dao *TenantModelDAO) DeleteByProviderIDAndInstanceIDAndModelName(ctx context.Context, db *gorm.DB, provideID, instanceID, modelName string) (int64, error) {
- result := db.WithContext(ctx).Unscoped().Where("provider_id = ? AND instance_id = ? AND model_name = ?", provideID, instanceID, modelName).Delete(&entity.TenantModel{})
- return result.RowsAffected, result.Error
-}
-
func (dao *TenantModelDAO) UpdateStatusByIDAndScope(ctx context.Context, db *gorm.DB, modelID, providerID, instanceID, status string) (int64, error) {
result := db.WithContext(ctx).Model(&entity.TenantModel{}).Where("id = ? AND provider_id = ? AND instance_id = ?", modelID, providerID, instanceID).Update("status", status)
return result.RowsAffected, result.Error
diff --git a/internal/dao/tenant_model_instance.go b/internal/dao/tenant_model_instance.go
index 221cc4b9b8..c71c2c86a8 100644
--- a/internal/dao/tenant_model_instance.go
+++ b/internal/dao/tenant_model_instance.go
@@ -112,11 +112,6 @@ func (dao *TenantModelInstanceDAO) GetByID(ctx context.Context, db *gorm.DB, id
return &instance, nil
}
-func (dao *TenantModelInstanceDAO) DeleteByProviderIDAndInstanceName(ctx context.Context, db *gorm.DB, providerID, instanceName string) (int64, error) {
- result := db.WithContext(ctx).Unscoped().Where("provider_id = ? and instance_name = ?", providerID, instanceName).Delete(&entity.TenantModelInstance{})
- return result.RowsAffected, result.Error
-}
-
// UpdateByID updates a tenant model instance by primary key.
// Mirrors Python's TenantModelInstanceService.update_by_id.
func (dao *TenantModelInstanceDAO) UpdateByID(ctx context.Context, db *gorm.DB, id string, updates map[string]interface{}) error {
diff --git a/internal/dao/tenant_model_provider.go b/internal/dao/tenant_model_provider.go
index 1865ea5658..cc06228d59 100644
--- a/internal/dao/tenant_model_provider.go
+++ b/internal/dao/tenant_model_provider.go
@@ -61,15 +61,6 @@ func (dao *TenantModelProviderDAO) DeleteByTenantIDAndProviderName(ctx context.C
return result.RowsAffected, result.Error
}
-// ListByID list tenant model providers by ID
-func (dao *TenantModelProviderDAO) ListByID(ctx context.Context, db *gorm.DB, id string) ([]string, error) {
- var providerNames []string
- err := db.WithContext(ctx).Model(&entity.TenantModelProvider{}).
- Where("tenant_id = ?", id).
- Pluck("provider_name", &providerNames).Error
- return providerNames, err
-}
-
// GetByTenantID returns all TenantModelProvider rows for a tenant.
// Mirrors Python's TenantModelProviderService.get_by_tenant_id and is the
// entry point for /api/v1/models ("list all added models"). The Go port
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index d1a452e05c..48a0c00491 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -234,7 +234,7 @@ func isExcludedTenantProvider(name string) bool {
}
func (m *ModelProviderService) DeleteModelProvider(ctx context.Context, userID, providerName string) (common.ErrorCode, error) {
- provider, err := m.getProviderByIDOrName(ctx, userID, providerName, permission.OperationDelete)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationDelete)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -288,7 +288,7 @@ func (m *ModelProviderService) DeleteModelProvider(ctx context.Context, userID,
func (m *ModelProviderService) ListSupportedModels(ctx context.Context, providerName, instanceName, userID string) ([]map[string]interface{}, error) {
providerName = strings.TrimSpace(providerName)
- ownedTenantID, err := requireCurrentTenantID(ctx, userID)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
_, normalizedErr := normalizeModelPermissionError(err)
@@ -296,17 +296,12 @@ func (m *ModelProviderService) ListSupportedModels(ctx context.Context, provider
}
return nil, err
}
- provider, err := m.findProviderByIDOrNameInTenant(ctx, ownedTenantID, providerName)
- if err != nil {
- return nil, err
- }
- if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, permission.OperationRead); err != nil {
- _, normalizedErr := normalizeModelPermissionError(err)
- return nil, normalizedErr
- }
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return nil, instanceLookupError(provider, instanceName, err)
+ }
return nil, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationUse); err != nil {
@@ -433,37 +428,6 @@ func NormalizeAPIKey(raw json.RawMessage) string {
return compact.String()
}
-func (m *ModelProviderService) getProviderByIDOrName(ctx context.Context, userID, providerIDOrName string, operation permission.Operation) (*entity.TenantModelProvider, error) {
- providerIDOrName = strings.TrimSpace(providerIDOrName)
- if providerIDOrName == "" {
- return nil, gorm.ErrRecordNotFound
- }
- provider, err := m.modelProviderDAO.GetByID(ctx, dao.DB, providerIDOrName)
- if err == nil {
- if err := checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, operation); err != nil {
- return nil, err
- }
- return provider, nil
- }
- if !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, err
- }
- providerIDs, scopeErr := accessibleModelResourceIDs(ctx, userID, permission.ResourceKindModelProvider, permission.ResourceRef{}, operation, nil, "")
- if scopeErr != nil {
- return nil, scopeErr
- }
- for _, providerID := range providerIDs {
- candidate, candidateErr := m.modelProviderDAO.GetByID(ctx, dao.DB, providerID)
- if candidateErr != nil {
- return nil, candidateErr
- }
- if strings.EqualFold(candidate.ProviderName, providerIDOrName) {
- return candidate, nil
- }
- }
- return nil, gorm.ErrRecordNotFound
-}
-
func (m *ModelProviderService) findProviderByIDOrNameInTenant(ctx context.Context, tenantID, providerIDOrName string) (*entity.TenantModelProvider, error) {
providerIDOrName = strings.TrimSpace(providerIDOrName)
if providerIDOrName == "" {
@@ -486,13 +450,83 @@ func (m *ModelProviderService) findProviderByIDOrNameInTenant(ctx context.Contex
return nil, gorm.ErrRecordNotFound
}
+// resolveProviderInTenant resolves the provider addressed by a route inside the
+// request's active tenant and authorizes operation on that row.
+//
+// Provider names are only unique per tenant (idx_tenant_provider_user_unique),
+// so a lookup across every tenant a user belongs to can select a same-named
+// provider owned by another tenant.
+func (m *ModelProviderService) resolveProviderInTenant(ctx context.Context, userID, providerIDOrName string, operation permission.Operation) (*entity.TenantModelProvider, error) {
+ tenantID, err := requireCurrentTenantID(ctx, userID)
+ if err != nil {
+ return nil, err
+ }
+ provider, err := m.findProviderByIDOrNameInTenant(ctx, tenantID, providerIDOrName)
+ if err != nil {
+ return nil, err
+ }
+ if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, operation); err != nil {
+ return nil, err
+ }
+ return provider, nil
+}
+
+// errInstanceProviderMismatch reports an instance identifier that exists in the
+// caller's tenant but belongs to a different provider than the request
+// addressed. An instance owned by another tenant stays a plain miss so callers
+// cannot probe foreign identifiers.
+var errInstanceProviderMismatch = errors.New("model instance belongs to another provider")
+
+// resolveInstance resolves the instance segment of a provider route inside
+// provider: primary key first, then instance name.
+//
+// A primary key hit whose provider_id names another provider of the same tenant
+// is a mismatch rather than a miss, so callers never fall through to a name
+// lookup. A hit owned by another tenant is reported as a miss.
+func (m *ModelProviderService) resolveInstance(ctx context.Context, provider *entity.TenantModelProvider, instanceIDOrName string) (*entity.TenantModelInstance, error) {
+ instanceIDOrName = strings.TrimSpace(instanceIDOrName)
+ if instanceIDOrName == "" {
+ return nil, gorm.ErrRecordNotFound
+ }
+ instance, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, instanceIDOrName)
+ if err == nil {
+ if instance.ProviderID == provider.ID {
+ return instance, nil
+ }
+ owner, ownerErr := m.modelProviderDAO.GetByID(ctx, dao.DB, instance.ProviderID)
+ if ownerErr != nil {
+ if errors.Is(ownerErr, gorm.ErrRecordNotFound) {
+ return nil, gorm.ErrRecordNotFound
+ }
+ return nil, ownerErr
+ }
+ if owner.TenantID != provider.TenantID {
+ return nil, gorm.ErrRecordNotFound
+ }
+ return nil, fmt.Errorf("%w: instance %q belongs to provider %q", errInstanceProviderMismatch, instanceIDOrName, instance.ProviderID)
+ }
+ if !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+ return m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceIDOrName)
+}
+
+// instanceLookupError renders the caller-facing message for a failed instance
+// lookup. Callers keep their own error code.
+func instanceLookupError(provider *entity.TenantModelProvider, instanceIDOrName string, err error) error {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return fmt.Errorf("instance '%s' does not belong to provider '%s'", instanceIDOrName, provider.ProviderName)
+ }
+ return fmt.Errorf("no instance found for provider '%s' and instance '%s'", provider.ProviderName, instanceIDOrName)
+}
+
func (m *ModelProviderService) CreateProviderInstance(ctx context.Context, providerIDOrName, instanceName, apiKey, baseURL, region, userID string, modelInfo []CreateInstanceModelInfo) (common.ErrorCode, error) {
providerIDOrName = strings.TrimSpace(providerIDOrName)
apiKey = strings.TrimSpace(apiKey)
baseURL = strings.TrimSpace(baseURL)
region = strings.TrimSpace(region)
- provider, err := m.getProviderByIDOrName(ctx, userID, providerIDOrName, permission.OperationCreate)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationCreate)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -500,7 +534,6 @@ func (m *ModelProviderService) CreateProviderInstance(ctx context.Context, provi
}
return common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerIDOrName)
}
- providerName := provider.ProviderName
tenantID := provider.TenantID
instanceID := common.GenerateToken()
@@ -537,7 +570,7 @@ func (m *ModelProviderService) CreateProviderInstance(ctx context.Context, provi
// (TenantModelInstanceDAO.Create owns its own transaction), so a failure
// here has to be undone explicitly or the tenant keeps a half-populated
// instance and can no longer reuse the instance name.
- if err = m.addModelsToNewInstance(ctx, tenantID, providerName, instanceName, region, modelInfo); err != nil {
+ if err = m.addModelsToNewInstance(ctx, provider, tenantModelInstance, modelInfo); err != nil {
if rollbackErr := m.rollbackCreatedInstance(ctx, instanceID); rollbackErr != nil {
common.Logger.Error("failed to roll back model instance after model creation failure",
zap.String("instance_id", instanceID), zap.Error(rollbackErr))
@@ -550,17 +583,17 @@ func (m *ModelProviderService) CreateProviderInstance(ctx context.Context, provi
// addModelsToNewInstance creates the models of a freshly created provider
// instance, either the requested ones or the provider's factory defaults.
-func (m *ModelProviderService) addModelsToNewInstance(ctx context.Context, tenantID, providerName, instanceName, region string, modelInfo []CreateInstanceModelInfo) error {
+func (m *ModelProviderService) addModelsToNewInstance(ctx context.Context, provider *entity.TenantModelProvider, instance *entity.TenantModelInstance, modelInfo []CreateInstanceModelInfo) error {
if len(modelInfo) > 0 {
for _, model := range modelInfo {
- if err := m.addModelToInstance(ctx, tenantID, providerName, instanceName, model); err != nil {
+ if err := m.addModelToInstance(ctx, provider, instance, model); err != nil {
return err
}
}
return nil
}
// model_info not provided — add all factory default models.
- factoryProvider := dao.GetModelProviderManager().FindProvider(providerName)
+ factoryProvider := dao.GetModelProviderManager().FindProvider(provider.ProviderName)
if factoryProvider == nil {
return nil
}
@@ -578,7 +611,7 @@ func (m *ModelProviderService) addModelsToNewInstance(ctx context.Context, tenan
} else if llm.MaxTokens != nil {
contextLength = *llm.MaxTokens
}
- if err := m.addModelToInstance(ctx, tenantID, providerName, instanceName, CreateInstanceModelInfo{
+ if err := m.addModelToInstance(ctx, provider, instance, CreateInstanceModelInfo{
ModelName: llm.Name,
ModelTypes: llm.ModelTypes,
MaxTokens: contextLength,
@@ -611,7 +644,7 @@ func (m *ModelProviderService) CreateNameOnlyProviderInstance(ctx context.Contex
return common.CodeBadRequest, errors.New("instance name cannot be 'default'")
}
- provider, err := m.getProviderByIDOrName(ctx, userID, providerIDOrName, permission.OperationCreate)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationCreate)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -645,21 +678,11 @@ func (m *ModelProviderService) CreateNameOnlyProviderInstance(ctx context.Contex
}
// addModelToInstance creates a single model under the given provider instance.
-func (m *ModelProviderService) addModelToInstance(ctx context.Context, tenantID, providerName, instanceName string, model CreateInstanceModelInfo) error {
- provider, err := m.modelProviderDAO.GetByTenantIDAndProviderName(ctx, dao.DB, tenantID, providerName)
- if err != nil {
- return fmt.Errorf("no provider found for provider '%s'", providerName)
- }
-
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if err != nil {
- return fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerName, instanceName)
- }
-
+func (m *ModelProviderService) addModelToInstance(ctx context.Context, provider *entity.TenantModelProvider, instance *entity.TenantModelInstance, model CreateInstanceModelInfo) error {
// Check for duplicate model.
- _, err = m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, model.ModelName)
+ _, err := m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, provider.ID, instance.ID, model.ModelName)
if err == nil {
- return fmt.Errorf("model '%s' already exists for provider '%s' and instance '%s'", model.ModelName, providerName, instanceName)
+ return fmt.Errorf("model '%s' already exists for provider '%s' and instance '%s'", model.ModelName, provider.ProviderName, instance.InstanceName)
}
if !errors.Is(err, gorm.ErrRecordNotFound) {
return err
@@ -708,27 +731,21 @@ func (m *ModelProviderService) createModelRecord(ctx context.Context, db *gorm.D
func (m *ModelProviderService) ListProviderInstances(ctx context.Context, providerIDOrName, userID string) ([]map[string]interface{}, common.ErrorCode, error) {
providerIDOrName = strings.TrimSpace(providerIDOrName)
- ownedTenantID, err := requireCurrentTenantID(ctx, userID)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationRead)
if err != nil {
if errors.Is(err, permission.ErrMembershipNotFound) {
return []map[string]interface{}{}, common.CodeSuccess, nil
}
- code, normalizedErr := normalizeModelPermissionError(err)
- return nil, code, normalizedErr
- }
-
- provider, err := m.findProviderByIDOrNameInTenant(ctx, ownedTenantID, providerIDOrName)
- if err != nil {
+ if permissionresponse.IsPermissionError(err) {
+ code, normalizedErr := normalizeModelPermissionError(err)
+ return nil, code, normalizedErr
+ }
if errors.Is(err, gorm.ErrRecordNotFound) {
return nil, common.CodeDataError, fmt.Errorf("no provider found for provider '%s'", providerIDOrName)
}
return nil, common.CodeServerError, err
}
providerRef := permission.ResourceRef{Kind: permission.ResourceKindModelProvider, ID: provider.ID}
- if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeModelPermissionError(err)
- return nil, code, normalizedErr
- }
instances, err := m.modelInstanceDAO.GetAllInstancesByProviderID(ctx, dao.DB, provider.ID)
if err != nil {
@@ -793,35 +810,25 @@ func (m *ModelProviderService) ListProviderInstances(ctx context.Context, provid
func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, providerName, instanceIDOrName, userID string) (map[string]interface{}, common.ErrorCode, error) {
providerName = strings.TrimSpace(providerName)
- ownedTenantID, err := requireCurrentTenantID(ctx, userID)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
return nil, code, normalizedErr
}
- return nil, common.CodeServerError, err
- }
- provider, err := m.findProviderByIDOrNameInTenant(ctx, ownedTenantID, providerName)
- if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
code, normalizedErr := normalizeModelPermissionError(permission.ErrResourceNotFound)
return nil, code, normalizedErr
}
return nil, common.CodeServerError, err
}
- if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, permission.OperationRead); err != nil {
- code, normalizedErr := normalizeModelPermissionError(err)
- return nil, code, normalizedErr
- }
- // Find the instance in the tenant-scoped provider — try ID first, then name.
- var instance *entity.TenantModelInstance
- instance, err = m.modelInstanceDAO.GetByID(ctx, dao.DB, instanceIDOrName)
- if err != nil || instance.ProviderID != provider.ID {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceIDOrName)
- }
+ instance, err := m.resolveInstance(ctx, provider, instanceIDOrName)
if err != nil {
- return nil, common.CodeDataError, fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerName, instanceIDOrName)
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return nil, common.CodeNotFound, instanceLookupError(provider, instanceIDOrName, err)
+ }
+ return nil, common.CodeNotFound, fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerName, instanceIDOrName)
}
access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
Kind: permission.ResourceKindModelInstance,
@@ -863,18 +870,23 @@ func (m *ModelProviderService) ShowProviderInstance(ctx context.Context, provide
}
func (m *ModelProviderService) ShowInstanceBalance(ctx context.Context, providerName, instanceName, userID string) (map[string]interface{}, common.ErrorCode, error) {
- // Check if provider exists
- provider, err := m.getProviderByIDOrName(ctx, userID, providerName, permission.OperationRead)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
return nil, code, normalizedErr
}
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerName)
+ }
return nil, common.CodeServerError, err
}
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) || errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, instanceLookupError(provider, instanceName, err)
+ }
return nil, common.CodeServerError, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationUse); err != nil {
@@ -1394,18 +1406,23 @@ func minimalPNG() []byte {
}
func (m *ModelProviderService) ListTasks(ctx context.Context, providerName, instanceName, userID string) ([]modelModule.ListTaskStatus, common.ErrorCode, error) {
- // Check if provider exists
- provider, err := m.getProviderByIDOrName(ctx, userID, providerName, permission.OperationRead)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
return nil, code, normalizedErr
}
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerName)
+ }
return nil, common.CodeServerError, err
}
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) || errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, instanceLookupError(provider, instanceName, err)
+ }
return nil, common.CodeServerError, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationUse); err != nil {
@@ -1451,18 +1468,23 @@ func (m *ModelProviderService) ListTasks(ctx context.Context, providerName, inst
}
func (m *ModelProviderService) ShowTask(ctx context.Context, providerName, instanceName, taskID, userID string) (*modelModule.TaskResponse, common.ErrorCode, error) {
- // Check if provider exists
- provider, err := m.getProviderByIDOrName(ctx, userID, providerName, permission.OperationRead)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
return nil, code, normalizedErr
}
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerName)
+ }
return nil, common.CodeServerError, err
}
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) || errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, common.CodeNotFound, instanceLookupError(provider, instanceName, err)
+ }
return nil, common.CodeServerError, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationUse); err != nil {
@@ -2021,7 +2043,7 @@ func (m *ModelProviderService) AlterProviderInstance(ctx context.Context, userID
region = strings.TrimSpace(region)
providerIDOrName = strings.TrimSpace(providerIDOrName)
- provider, err := m.getProviderByIDOrName(ctx, userID, providerIDOrName, permission.OperationRead)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -2030,14 +2052,12 @@ func (m *ModelProviderService) AlterProviderInstance(ctx context.Context, userID
return common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerIDOrName)
}
providerName := provider.ProviderName
- tenantID := provider.TenantID
- // Find the instance — try by ID first, then by name.
- instance, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, instanceIDOrName)
- if err != nil || instance.ProviderID != provider.ID {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceIDOrName)
- }
+ instance, err := m.resolveInstance(ctx, provider, instanceIDOrName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return common.CodeNotFound, instanceLookupError(provider, instanceIDOrName, err)
+ }
return common.CodeNotFound, fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerName, instanceIDOrName)
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationUpdate); err != nil {
@@ -2091,6 +2111,7 @@ func (m *ModelProviderService) AlterProviderInstance(ctx context.Context, userID
}
if newInstanceName != "" && newInstanceName != instance.InstanceName {
instanceUpdates["instance_name"] = newInstanceName
+ instance.InstanceName = newInstanceName
}
extraFields := make(map[string]interface{})
@@ -2119,12 +2140,6 @@ func (m *ModelProviderService) AlterProviderInstance(ctx context.Context, userID
return common.CodeServerError, fmt.Errorf("fail to update instance: %w", err)
}
- // Use the (possibly updated) instance_name for model operations.
- effectiveInstanceName := instance.InstanceName
- if newInstanceName != "" {
- effectiveInstanceName = newInstanceName
- }
-
// Upsert models: add new ones, update existing ones, remove ones no longer selected.
// Delete models that are no longer in the submitted model_info.
var idsToRemove []string
@@ -2179,7 +2194,7 @@ func (m *ModelProviderService) AlterProviderInstance(ctx context.Context, userID
}
} else {
// Add new model.
- if err = m.addModelToInstance(ctx, tenantID, providerName, effectiveInstanceName, mdl); err != nil {
+ if err = m.addModelToInstance(ctx, provider, instance, mdl); err != nil {
return common.CodeServerError, err
}
}
@@ -2194,8 +2209,8 @@ func (m *ModelProviderService) DropProviderInstances(ctx context.Context, provid
return common.CodeBadRequest, errors.New("instances is required")
}
- // Find provider by ID or name
- provider, err := m.getProviderByIDOrName(ctx, userID, providerIDOrName, permission.OperationRead)
+ // Find provider by ID or name inside the request's active tenant.
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -2213,26 +2228,16 @@ func (m *ModelProviderService) DropProviderInstances(ctx context.Context, provid
notExistInstances := make([]string, 0)
instanceIDs := make([]string, 0, len(instanceIDOrNames))
for _, idOrName := range instanceIDOrNames {
- var instance *entity.TenantModelInstance
- // Try by ID first, then by name — same as Python.
- if idOrName != "" {
- instance, err = m.modelInstanceDAO.GetByID(ctx, dao.DB, idOrName)
- if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return common.CodeServerError, err
+ instance, resolveErr := m.resolveInstance(ctx, provider, idOrName)
+ if resolveErr != nil {
+ if errors.Is(resolveErr, errInstanceProviderMismatch) {
+ return common.CodeNotFound, instanceLookupError(provider, idOrName, resolveErr)
}
- if instance != nil && instance.ProviderID != provider.ID {
- instance = nil
- }
- }
- if instance == nil {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, idOrName)
- if err != nil {
- if errors.Is(err, gorm.ErrRecordNotFound) {
- notExistInstances = append(notExistInstances, idOrName)
- continue
- }
- return common.CodeServerError, err
+ if errors.Is(resolveErr, gorm.ErrRecordNotFound) {
+ notExistInstances = append(notExistInstances, idOrName)
+ continue
}
+ return common.CodeServerError, resolveErr
}
instanceIDs = append(instanceIDs, instance.ID)
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationDelete); err != nil {
@@ -2277,8 +2282,8 @@ func (m *ModelProviderService) DropProviderInstances(ctx context.Context, provid
}
func (m *ModelProviderService) DropInstanceModels(ctx context.Context, providerIDOrName, instanceIDOrName, userID string, modelNames []string) (common.ErrorCode, error) {
- // Get provider by ID or name (matches Python's get_by_tenant_id_and_provider_id → get_by_tenant_id_and_provider_name fallback).
- provider, err := m.getProviderByIDOrName(ctx, userID, providerIDOrName, permission.OperationRead)
+ // Resolve the provider and instance inside the request's active tenant.
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerIDOrName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -2287,12 +2292,11 @@ func (m *ModelProviderService) DropInstanceModels(ctx context.Context, providerI
return common.CodeDataError, fmt.Errorf("no provider found for provider '%s'", providerIDOrName)
}
- // Get instance by ID or name (matches Python's get_by_id → get_by_provider_id_and_instance_name fallback).
- instance, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, instanceIDOrName)
- if err != nil || instance.ProviderID != provider.ID {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceIDOrName)
- }
+ instance, err := m.resolveInstance(ctx, provider, instanceIDOrName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return common.CodeDataError, instanceLookupError(provider, instanceIDOrName, err)
+ }
return common.CodeDataError, fmt.Errorf("no instance found for provider '%s' and instance '%s'", providerIDOrName, instanceIDOrName)
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationRead); err != nil {
@@ -2345,7 +2349,7 @@ func (m *ModelProviderService) DropInstanceModels(ctx context.Context, providerI
}
func (m *ModelProviderService) ListInstanceModels(ctx context.Context, providerName, instanceName, userID string) ([]map[string]interface{}, error) {
- ownedTenantID, err := requireCurrentTenantID(ctx, userID)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
_, normalizedErr := normalizeModelPermissionError(err)
@@ -2353,22 +2357,13 @@ func (m *ModelProviderService) ListInstanceModels(ctx context.Context, providerN
}
return nil, err
}
- provider, err := m.findProviderByIDOrNameInTenant(ctx, ownedTenantID, providerName)
- if err != nil {
- return nil, err
- }
- if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, provider.ID, permission.OperationRead); err != nil {
- _, normalizedErr := normalizeModelPermissionError(err)
- return nil, normalizedErr
- }
- // Find instance by ID first, then by name
- instance, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, instanceName)
- if err != nil || instance.ProviderID != provider.ID {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
- if err != nil {
- return nil, err
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
+ if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return nil, instanceLookupError(provider, instanceName, err)
}
+ return nil, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationRead); err != nil {
_, normalizedErr := normalizeModelPermissionError(err)
@@ -2453,17 +2448,23 @@ func (m *ModelProviderService) AlterModel(ctx context.Context, providerName, ins
}
// Check if provider exists
- provider, err := m.getProviderByIDOrName(ctx, userID, providerName, permission.OperationRead)
+ provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
return code, normalizedErr
}
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ return common.CodeNotFound, fmt.Errorf("provider '%s' does not exist", providerName)
+ }
return common.CodeServerError, err
}
- instance, err := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, instanceName)
+ instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) || errors.Is(err, gorm.ErrRecordNotFound) {
+ return common.CodeNotFound, instanceLookupError(provider, instanceName, err)
+ }
return common.CodeServerError, err
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationRead); err != nil {
@@ -2595,53 +2596,46 @@ func (m *ModelProviderService) getModelInstanceAndProviderByName(ctx context.Con
if providerName == nil || instanceName == nil || modelName == nil {
return nil, errors.New("provider name, instance name and model name are required when model id is absent")
}
- providerIDs, err := accessibleModelResourceIDs(ctx, userID, permission.ResourceKindModelProvider, permission.ResourceRef{}, permission.OperationRead, nil, "")
+
+ // Provider and instance names are only unique inside one tenant, so a
+ // composite reference resolves inside the request's active tenant.
+ tenantID, err := requireCurrentTenantID(ctx, userID)
if err != nil {
return nil, err
}
-
- var providerEntity *entity.TenantModelProvider
- var instanceEntity *entity.TenantModelInstance
- var modelEntity *entity.TenantModel
- for _, providerID := range providerIDs {
- candidateProvider, providerErr := m.modelProviderDAO.GetByID(ctx, dao.DB, providerID)
- if providerErr != nil {
- return nil, providerErr
- }
- if !strings.EqualFold(candidateProvider.ProviderName, *providerName) {
- continue
- }
- candidateInstance, instanceErr := m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, candidateProvider.ID, *instanceName)
- if instanceErr != nil {
- if errors.Is(instanceErr, gorm.ErrRecordNotFound) {
- continue
- }
- return nil, instanceErr
- }
- if checkErr := checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, candidateInstance.ID, permission.OperationUse); checkErr != nil {
- if errors.Is(checkErr, permission.ErrPermissionDenied) || errors.Is(checkErr, permission.ErrResourceNotFound) {
- continue
- }
- return nil, checkErr
- }
- providerEntity = candidateProvider
- instanceEntity = candidateInstance
- modelEntity, err = m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, providerEntity.ID, instanceEntity.ID, *modelName)
- if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
- return nil, err
- }
+ providerEntity, err := m.findProviderByIDOrNameInTenant(ctx, tenantID, *providerName)
+ if err != nil {
if errors.Is(err, gorm.ErrRecordNotFound) {
- modelEntity = nil
+ return nil, permission.ErrResourceNotFound
}
- if modelEntity != nil {
- if checkErr := checkModelPermission(ctx, userID, permission.ResourceKindModel, modelEntity.ID, permission.OperationUse); checkErr != nil {
- return nil, checkErr
- }
+ return nil, err
+ }
+ if err = checkModelPermission(ctx, userID, permission.ResourceKindModelProvider, providerEntity.ID, permission.OperationRead); err != nil {
+ return nil, err
+ }
+
+ instanceEntity, err := m.resolveInstance(ctx, providerEntity, *instanceName)
+ if err != nil {
+ if errors.Is(err, gorm.ErrRecordNotFound) || errors.Is(err, errInstanceProviderMismatch) {
+ return nil, permission.ErrResourceNotFound
}
- break
+ return nil, err
}
- if providerEntity == nil || instanceEntity == nil {
- return nil, permission.ErrResourceNotFound
+ if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instanceEntity.ID, permission.OperationUse); err != nil {
+ return nil, err
+ }
+
+ modelEntity, err := m.modelDAO.GetModelByProviderIDAndInstanceIDAndModelName(ctx, dao.DB, providerEntity.ID, instanceEntity.ID, *modelName)
+ if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
+ return nil, err
+ }
+ if errors.Is(err, gorm.ErrRecordNotFound) {
+ modelEntity = nil
+ }
+ if modelEntity != nil {
+ if err = checkModelPermission(ctx, userID, permission.ResourceKindModel, modelEntity.ID, permission.OperationUse); err != nil {
+ return nil, err
+ }
}
catalogName := modelModule.CatalogProviderName(providerEntity.ProviderName)
@@ -2848,8 +2842,8 @@ func (m *ModelProviderService) AddModel(ctx context.Context, request *AddModelRe
return common.CodeBadRequest, errors.New("model_name is required")
}
- // Get provider by ID or name (matches Python's get_by_tenant_id_and_provider_id → get_by_tenant_id_and_provider_name fallback).
- provider, err := m.getProviderByIDOrName(ctx, userID, request.ProviderName, permission.OperationRead)
+ // Resolve the provider and instance inside the request's active tenant.
+ provider, err := m.resolveProviderInTenant(ctx, userID, request.ProviderName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
code, normalizedErr := normalizeModelPermissionError(err)
@@ -2857,12 +2851,11 @@ func (m *ModelProviderService) AddModel(ctx context.Context, request *AddModelRe
}
return common.CodeDataError, fmt.Errorf("no provider found for provider '%s'", request.ProviderName)
}
- // Get instance by ID or name (matches Python's get_by_id → get_by_provider_id_and_instance_name fallback).
- instance, err := m.modelInstanceDAO.GetByID(ctx, dao.DB, request.InstanceName)
- if err != nil || instance.ProviderID != provider.ID {
- instance, err = m.modelInstanceDAO.GetByProviderIDAndInstanceName(ctx, dao.DB, provider.ID, request.InstanceName)
- }
+ instance, err := m.resolveInstance(ctx, provider, request.InstanceName)
if err != nil {
+ if errors.Is(err, errInstanceProviderMismatch) {
+ return common.CodeDataError, instanceLookupError(provider, request.InstanceName, err)
+ }
return common.CodeDataError, fmt.Errorf("no instance found for provider '%s' and instance '%s'", request.ProviderName, request.InstanceName)
}
if err = checkModelPermission(ctx, userID, permission.ResourceKindModelInstance, instance.ID, permission.OperationCreate); err != nil {
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index d0f31e7430..bf76c40641 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -1305,3 +1305,253 @@ func TestDropProviderInstancesRollsBackWhenInstanceDeleteFails(t *testing.T) {
t.Fatalf("rollback must keep tenant models for the instance, got %d rows", modelCount)
}
}
+
+// seedDeepSeekProvidersForeignFirst inserts a DeepSeek provider plus a "ds"
+// instance into tenant-1 before tenant-2, so both insertion order and the
+// tenant_id index order put tenant-1 first. Any provider lookup that scans
+// every tenant a user belongs to therefore resolves tenant-1, and every
+// assertion about tenant-2 fails unless the lookup stays inside the request's
+// active tenant.
+func seedDeepSeekProvidersForeignFirst(t *testing.T, db *gorm.DB, tenant1UserID, tenant2UserID string) {
+ t.Helper()
+ activeStatus := entity.TenantMembershipStatusJoined
+ rows := []interface{}{
+ &entity.UserTenant{ID: "user-tenant-1", UserID: tenant1UserID, TenantID: "tenant-1", Role: string(permission.RoleOwner), InvitedBy: tenant1UserID, Status: &activeStatus},
+ &entity.TenantModelProvider{ID: "provider-1", UserID: tenant1UserID, TenantID: "tenant-1", ProviderName: "DeepSeek"},
+ &entity.TenantModelInstance{ID: "instance-1", ProviderID: "provider-1", InstanceName: "ds", APIKey: "sk-tenant-1", Status: "active", Extra: "{}"},
+ &entity.UserTenant{ID: "user-tenant-2", UserID: tenant2UserID, TenantID: "tenant-2", Role: string(permission.RoleOwner), InvitedBy: tenant2UserID, Status: &activeStatus},
+ &entity.TenantModelProvider{ID: "provider-2", UserID: tenant2UserID, TenantID: "tenant-2", ProviderName: "DeepSeek"},
+ &entity.TenantModelInstance{ID: "instance-2", ProviderID: "provider-2", InstanceName: "ds", APIKey: "sk-tenant-2", Status: "active", Extra: "{}"},
+ }
+ for _, row := range rows {
+ if err := db.Create(row).Error; err != nil {
+ t.Fatalf("failed to seed %T: %v", row, err)
+ }
+ }
+}
+
+func reloadTenantModelInstance(t *testing.T, db *gorm.DB, id string) *entity.TenantModelInstance {
+ t.Helper()
+ var instance entity.TenantModelInstance
+ if err := db.Where("id = ?", id).First(&instance).Error; err != nil {
+ t.Fatalf("failed to reload instance %s: %v", id, err)
+ }
+ return &instance
+}
+
+// TestAlterProviderInstanceUsesActiveTenantProvider pins the reported bug: the
+// saved instance belongs to the active tenant's DeepSeek provider even though
+// the user can also read another tenant's same-named provider.
+func TestAlterProviderInstanceUsesActiveTenantProvider(t *testing.T) {
+ db := setupModelProviderServiceTestDB(t)
+ useModelProviderServiceTestDB(t, db)
+ seedDeepSeekProvidersForeignFirst(t, db, "owner-2", "user-1")
+
+ activeStatus := entity.TenantMembershipStatusJoined
+ if err := db.Create(&entity.UserTenant{
+ ID: "user-tenant-1-member", UserID: "user-1", TenantID: "tenant-1", Role: string(permission.RoleNormal), InvitedBy: "owner-2", Status: &activeStatus,
+ }).Error; err != nil {
+ t.Fatalf("failed to seed tenant-1 membership: %v", err)
+ }
+
+ code, err := NewModelProviderService().AlterProviderInstance(
+ serviceTestContext(t, "user-1", "tenant-2"),
+ "user-1",
+ "DeepSeek",
+ "instance-2",
+ "ds",
+ "sk-tenant-2-updated",
+ "https://api.deepseek.com",
+ "default",
+ []CreateInstanceModelInfo{{ModelName: "deepseek-v4-pro", ModelTypes: []string{"chat"}, MaxTokens: 8192}},
+ )
+ if err != nil {
+ t.Fatalf("AlterProviderInstance() error = %v", err)
+ }
+ if code != common.CodeSuccess {
+ t.Fatalf("code = %v, want %v", code, common.CodeSuccess)
+ }
+
+ instance2 := reloadTenantModelInstance(t, db, "instance-2")
+ if instance2.APIKey != "sk-tenant-2-updated" {
+ t.Fatalf("instance-2 api_key = %q, want the submitted key", instance2.APIKey)
+ }
+ if !strings.Contains(instance2.Extra, "https://api.deepseek.com") {
+ t.Fatalf("instance-2 extra = %q, want the submitted base_url", instance2.Extra)
+ }
+ instance1 := reloadTenantModelInstance(t, db, "instance-1")
+ if instance1.APIKey != "sk-tenant-1" {
+ t.Fatalf("instance-1 api_key = %q, want it untouched", instance1.APIKey)
+ }
+
+ var models []*entity.TenantModel
+ if err := db.Where("instance_id = ?", "instance-2").Find(&models).Error; err != nil {
+ t.Fatalf("failed to list models: %v", err)
+ }
+ if len(models) != 1 || models[0].ModelName != "deepseek-v4-pro" || models[0].ProviderID != "provider-2" {
+ t.Fatalf("models = %#v, want one model under provider-2", models)
+ }
+
+ var foreignModels int64
+ if err := db.Model(&entity.TenantModel{}).Where("instance_id = ?", "instance-1").Count(&foreignModels).Error; err != nil {
+ t.Fatalf("failed to count instance-1 models: %v", err)
+ }
+ if foreignModels != 0 {
+ t.Fatalf("instance-1 models = %d, want none", foreignModels)
+ }
+}
+
+// TestAlterProviderInstanceReportsInstanceProviderMismatch covers the instance
+// identifier of another provider inside the same tenant: the request must fail
+// with an explicit message and leave the data untouched.
+func TestAlterProviderInstanceReportsInstanceProviderMismatch(t *testing.T) {
+ db := setupModelProviderServiceTestDB(t)
+ useModelProviderServiceTestDB(t, db)
+ activeStatus := entity.TenantMembershipStatusJoined
+ rows := []interface{}{
+ &entity.UserTenant{ID: "user-tenant-2", UserID: "user-1", TenantID: "tenant-2", Role: string(permission.RoleOwner), InvitedBy: "user-1", Status: &activeStatus},
+ &entity.TenantModelProvider{ID: "provider-deepseek", UserID: "user-1", TenantID: "tenant-2", ProviderName: "DeepSeek"},
+ &entity.TenantModelInstance{ID: "instance-deepseek", ProviderID: "provider-deepseek", InstanceName: "ds", APIKey: "sk-deepseek", Status: "active", Extra: "{}"},
+ &entity.TenantModelProvider{ID: "provider-openai", UserID: "user-1", TenantID: "tenant-2", ProviderName: "OpenAI"},
+ }
+ for _, row := range rows {
+ if err := db.Create(row).Error; err != nil {
+ t.Fatalf("failed to seed %T: %v", row, err)
+ }
+ }
+
+ code, err := NewModelProviderService().AlterProviderInstance(
+ serviceTestContext(t, "user-1", "tenant-2"),
+ "user-1",
+ "OpenAI",
+ "instance-deepseek",
+ "ds",
+ "sk-should-not-be-written",
+ "",
+ "",
+ []CreateInstanceModelInfo{{ModelName: "gpt-test", ModelTypes: []string{"chat"}, MaxTokens: 8192}},
+ )
+ if err == nil {
+ t.Fatal("AlterProviderInstance() error = nil, want an instance/provider mismatch")
+ }
+ if code != common.CodeNotFound {
+ t.Fatalf("code = %v, want %v", code, common.CodeNotFound)
+ }
+ if !strings.Contains(err.Error(), "does not belong to provider") {
+ t.Fatalf("error = %q, want an explicit mismatch message", err)
+ }
+
+ instance := reloadTenantModelInstance(t, db, "instance-deepseek")
+ if instance.APIKey != "sk-deepseek" {
+ t.Fatalf("api_key = %q, want the original key", instance.APIKey)
+ }
+ var modelCount int64
+ if err := db.Model(&entity.TenantModel{}).Where("instance_id = ?", "instance-deepseek").Count(&modelCount).Error; err != nil {
+ t.Fatalf("failed to count models: %v", err)
+ }
+ if modelCount != 0 {
+ t.Fatalf("models = %d, want no writes after the mismatch", modelCount)
+ }
+}
+
+// TestAlterProviderInstanceScopesToActiveTenant saves the same provider name in
+// two tenants owned by one user and asserts each save touches only its own row.
+func TestAlterProviderInstanceScopesToActiveTenant(t *testing.T) {
+ db := setupModelProviderServiceTestDB(t)
+ useModelProviderServiceTestDB(t, db)
+ seedDeepSeekProvidersForeignFirst(t, db, "user-1", "user-1")
+
+ service := NewModelProviderService()
+ if code, err := service.AlterProviderInstance(
+ serviceTestContext(t, "user-1", "tenant-2"),
+ "user-1", "DeepSeek", "instance-2", "ds", "sk-from-tenant-2", "", "",
+ []CreateInstanceModelInfo{{ModelName: "model-2", ModelTypes: []string{"chat"}, MaxTokens: 8192}},
+ ); err != nil || code != common.CodeSuccess {
+ t.Fatalf("AlterProviderInstance(tenant-2) = (%v, %v), want success", code, err)
+ }
+ if code, err := service.AlterProviderInstance(
+ serviceTestContext(t, "user-1", "tenant-1"),
+ "user-1", "DeepSeek", "instance-1", "ds", "sk-from-tenant-1", "", "",
+ []CreateInstanceModelInfo{{ModelName: "model-1", ModelTypes: []string{"chat"}, MaxTokens: 8192}},
+ ); err != nil || code != common.CodeSuccess {
+ t.Fatalf("AlterProviderInstance(tenant-1) = (%v, %v), want success", code, err)
+ }
+
+ instance2 := reloadTenantModelInstance(t, db, "instance-2")
+ if instance2.APIKey != "sk-from-tenant-2" {
+ t.Fatalf("instance-2 api_key = %q, want %q", instance2.APIKey, "sk-from-tenant-2")
+ }
+ instance1 := reloadTenantModelInstance(t, db, "instance-1")
+ if instance1.APIKey != "sk-from-tenant-1" {
+ t.Fatalf("instance-1 api_key = %q, want %q", instance1.APIKey, "sk-from-tenant-1")
+ }
+
+ var models2, models1 []*entity.TenantModel
+ if err := db.Where("provider_id = ?", "provider-2").Find(&models2).Error; err != nil {
+ t.Fatalf("failed to list provider-2 models: %v", err)
+ }
+ if err := db.Where("provider_id = ?", "provider-1").Find(&models1).Error; err != nil {
+ t.Fatalf("failed to list provider-1 models: %v", err)
+ }
+ if len(models2) != 1 || models2[0].ModelName != "model-2" || models2[0].InstanceID != "instance-2" {
+ t.Fatalf("provider-2 models = %#v, want model-2 on instance-2", models2)
+ }
+ if len(models1) != 1 || models1[0].ModelName != "model-1" || models1[0].InstanceID != "instance-1" {
+ t.Fatalf("provider-1 models = %#v, want model-1 on instance-1", models1)
+ }
+}
+
+// TestAddModelUsesActiveTenantProvider keeps AddModel inside the active tenant.
+func TestAddModelUsesActiveTenantProvider(t *testing.T) {
+ db := setupModelProviderServiceTestDB(t)
+ useModelProviderServiceTestDB(t, db)
+ seedDeepSeekProvidersForeignFirst(t, db, "user-1", "user-1")
+
+ code, err := NewModelProviderService().AddModel(
+ serviceTestContext(t, "user-1", "tenant-2"),
+ &AddModelRequest{ProviderName: "DeepSeek", InstanceName: "instance-2", ModelName: "added-model", ModelTypes: []string{"chat"}, MaxTokens: 1024},
+ "user-1",
+ )
+ if err != nil {
+ t.Fatalf("AddModel() error = %v", err)
+ }
+ if code != common.CodeSuccess {
+ t.Fatalf("code = %v, want %v", code, common.CodeSuccess)
+ }
+
+ var model entity.TenantModel
+ if err := db.Where("model_name = ?", "added-model").First(&model).Error; err != nil {
+ t.Fatalf("failed to reload added model: %v", err)
+ }
+ if model.ProviderID != "provider-2" || model.InstanceID != "instance-2" {
+ t.Fatalf("model provider/instance = %q/%q, want provider-2/instance-2", model.ProviderID, model.InstanceID)
+ }
+}
+
+// TestCreateProviderInstanceUsesActiveTenantProvider keeps new instances inside
+// the active tenant's provider row.
+func TestCreateProviderInstanceUsesActiveTenantProvider(t *testing.T) {
+ db := setupModelProviderServiceTestDB(t)
+ useModelProviderServiceTestDB(t, db)
+ seedDeepSeekProvidersForeignFirst(t, db, "user-1", "user-1")
+
+ code, err := NewModelProviderService().CreateProviderInstance(
+ serviceTestContext(t, "user-1", "tenant-2"),
+ "DeepSeek", "created-in-tenant-2", "sk-created", "", "default", "user-1",
+ []CreateInstanceModelInfo{{ModelName: "deepseek-v4-pro", ModelTypes: []string{"chat"}, MaxTokens: 8192}},
+ )
+ if err != nil {
+ t.Fatalf("CreateProviderInstance() error = %v", err)
+ }
+ if code != common.CodeSuccess {
+ t.Fatalf("code = %v, want %v", code, common.CodeSuccess)
+ }
+
+ var created entity.TenantModelInstance
+ if err := db.Where("instance_name = ?", "created-in-tenant-2").First(&created).Error; err != nil {
+ t.Fatalf("failed to reload created instance: %v", err)
+ }
+ if created.ProviderID != "provider-2" {
+ t.Fatalf("created instance provider_id = %q, want provider-2", created.ProviderID)
+ }
+}