RAGFlow is an agent-native database: a Retrieval-Augmented Generation (RAG) engine that grew into context infrastructure.
Go agent-harnessagent-native-databaseagentic-aiagentic-retrievalagentic-searchaiai-agentscontext-enginecontext-engineeringcontext-managementharness-engineeringknowledge-compilationragretrieval-augmented-generationretrieval-harnesssearch-harness
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.goindex 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 *enreturn 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.Errordiff --git a/internal/dao/tenant_model_instance.go b/internal/dao/tenant_model_instance.goindex 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, idreturn &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.goindex 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.Creturn 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 portdiff --git a/internal/service/model_service.go b/internal/service/model_service.goindex 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.Contexreturn 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.ProviderNametenantID := provider.TenantIDinstanceID := 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.Contexreturn 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.Dfunc (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, providfunc (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, userIDregion = 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, userIDreturn 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, userIDreturn 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, providreturn 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, providnotExistInstances := 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, providerIreturn 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.Conif 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 *AddModelRereturn 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.goindex 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)+ }+}