Skip to content

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

fix: unify saved provider model listing (#21753)

buua436fb33d2e0af59
diff --git a/internal/handler/providers.go b/internal/handler/providers.go
index 70a3776069..6b0049ef64 100644
--- a/internal/handler/providers.go
+++ b/internal/handler/providers.go
@@ -196,7 +196,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
regionOverride = &value
}
apiKeyConfig := json.RawMessage(c.Query("api_key_config"))
- instanceModels, err := h.modelProviderService.ListSupportedModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"), service.ListSupportedModelsOptions{
+ instanceModels, err := h.fetchSavedProviderModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"), service.SavedProviderModelOptions{
APIKeyConfig: apiKeyConfig,
BaseURL: baseURLOverride,
Region: regionOverride,
@@ -205,28 +205,14 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
common.ErrorWithCode(c, common.CodeDataError, err.Error())
return
}
- for _, model := range instanceModels {
- if _, ok := model["max_tokens"]; !ok {
- if contextLength, ok := model["context_length"]; ok && contextLength != nil {
- model["max_tokens"] = contextLength
- }
- }
- }
common.SuccessWithData(c, instanceModels, "success")
return
}
_, baseURLProvided := c.GetQuery("base_url")
_, regionProvided := c.GetQuery("region")
if instanceName != "" && !apiKeyProvided && !baseURLProvided && !regionProvided {
- instanceModels, err := h.modelProviderService.ListSupportedModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"), service.ListSupportedModelsOptions{})
+ instanceModels, err := h.fetchSavedProviderModels(c.Request.Context(), providerName, instanceName, c.GetString("user_id"), service.SavedProviderModelOptions{})
if err == nil {
- for _, model := range instanceModels {
- if _, ok := model["max_tokens"]; !ok {
- if contextLength, ok := model["context_length"]; ok && contextLength != nil {
- model["max_tokens"] = contextLength
- }
- }
- }
common.SuccessWithData(c, instanceModels, "success")
return
}
@@ -236,7 +222,7 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
}
}
- result, err := FetchProviderModels(c.Request.Context(), providerName, apiKey, baseURL)
+ result, err := FetchProviderModels(c.Request.Context(), providerName, apiKey, baseURL, region)
if err != nil {
var codedErr *common.CodedError
if errors.As(err, &codedErr) {
@@ -249,10 +235,19 @@ func (h *ProviderHandler) ListModels(c *gin.Context) {
common.SuccessWithData(c, result, "success")
}
+func (h *ProviderHandler) fetchSavedProviderModels(ctx context.Context, providerName, instanceName, userID string, options service.SavedProviderModelOptions) ([]map[string]interface{}, error) {
+ config, err := h.modelProviderService.ResolveSavedProviderModelConfig(ctx, providerName, instanceName, userID, options)
+ if err != nil {
+ return nil, err
+ }
+
+ return FetchProviderModels(ctx, providerName, config.APIKey, config.BaseURL, config.Region)
+}
+
// FetchProviderModels returns the bundled model catalog, optionally enriched
// with models discovered from the configured provider endpoint. Admin uses the
// same catalog behavior while resolving its system-scoped provider data.
-func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL string) ([]map[string]interface{}, error) {
+func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL, region string) ([]map[string]interface{}, error) {
// 1. Get static models from config (maybe nil when models list is empty)
staticModels, _ := dao.GetModelProviderManager().ListModels(providerName)
if staticModels == nil {
@@ -262,6 +257,10 @@ func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL stri
// 2. Attempt live API fetch when the provider has enough connection data.
apiKey = strings.TrimSpace(apiKey)
baseURL = strings.TrimSpace(baseURL)
+ region = strings.TrimSpace(region)
+ if region == "" {
+ region = "default"
+ }
var remoteModels []map[string]interface{}
remoteFetched := false
// remoteFetchErr records why a requested live fetch produced nothing, so it
@@ -283,7 +282,7 @@ func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL stri
}
}
- canFetchRemote := baseURL != ""
+ canFetchRemote := baseURL != "" || apiKey != ""
if bedrockProvider {
// Bedrock's existing SigV4 modes keep using the static catalog. Only
// API-key auth needs a live catalog scoped to the supplied credential.
@@ -292,14 +291,12 @@ func FetchProviderModels(ctx context.Context, providerName, apiKey, baseURL stri
if canFetchRemote {
providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
if providerInfo != nil && providerInfo.ModelDriver != nil {
- region := "default"
- baseURLByRegion := map[string]string{region: baseURL}
- driver := providerInfo.ModelDriver.NewInstance(baseURLByRegion)
+ driver := providerInfo.ModelDriver
+ if baseURL != "" {
+ driver = driver.NewInstance(map[string]string{region: baseURL})
+ }
if driver != nil {
- apiConfig := &models.APIConfig{
- ApiKey: &apiKey,
- Region: &region,
- }
+ apiConfig := &models.APIConfig{ApiKey: &apiKey, Region: &region}
if liveModels, err := driver.ListModels(ctx, apiConfig); err == nil {
remoteFetched = true
for _, m := range liveModels {
@@ -812,7 +809,7 @@ func (h *ProviderHandler) ListInstanceModels(c *gin.Context) {
if keywords == "true" {
// list supported models
- modelList, err := h.modelProviderService.ListSupportedModels(ctx, providerName, instanceName, c.GetString("user_id"), service.ListSupportedModelsOptions{})
+ modelList, err := h.fetchSavedProviderModels(ctx, providerName, instanceName, c.GetString("user_id"), service.SavedProviderModelOptions{})
if err != nil {
common.ErrorWithCode(c, common.CodeServerError, err.Error())
return
diff --git a/internal/handler/providers_test.go b/internal/handler/providers_test.go
index 7d2a587bea..a51ae6c309 100644
--- a/internal/handler/providers_test.go
+++ b/internal/handler/providers_test.go
@@ -2,6 +2,7 @@ package handler
import (
"bytes"
+ "context"
"encoding/json"
"net/http"
"net/http/httptest"
@@ -16,6 +17,7 @@ import (
"ragflow/internal/common"
"ragflow/internal/dao"
"ragflow/internal/entity"
+ modelModule "ragflow/internal/entity/models"
"ragflow/internal/permission"
"ragflow/internal/permission/testsupport"
"ragflow/internal/service"
@@ -287,6 +289,79 @@ func TestProviderHandlerAlterModelRejectsMissingModelSelector(t *testing.T) {
}
}
+type providerModelListProbe struct {
+ *modelModule.DummyModel
+ apiKey string
+ region string
+ calls int
+}
+
+func (p *providerModelListProbe) ListModels(_ context.Context, config *modelModule.APIConfig) ([]modelModule.ListModelResponse, error) {
+ p.calls++
+ if config.ApiKey != nil {
+ p.apiKey = *config.ApiKey
+ }
+ if config.Region != nil {
+ p.region = *config.Region
+ }
+ return []modelModule.ListModelResponse{{Name: "gpt-live-test", ModelTypes: []string{"chat"}}}, nil
+}
+
+func (p *providerModelListProbe) NewInstance(map[string]string) modelModule.ModelDriver {
+ return p
+}
+
+func TestListModelsSavedCredentialsUsesProviderCatalogMerge(t *testing.T) {
+ db := setupProviderHandlerTestDB(t)
+ useProviderHandlerTestDB(t, db)
+ seedProviderHandlerModel(t, db)
+
+ provider := dao.GetModelProviderManager().FindProvider("OpenAI")
+ if provider == nil {
+ t.Fatal("OpenAI provider is not configured")
+ }
+ probe := &providerModelListProbe{DummyModel: modelModule.NewDummyModel(nil, modelModule.URLSuffix{})}
+ originalDriver := provider.ModelDriver
+ provider.ModelDriver = probe
+ t.Cleanup(func() { provider.ModelDriver = originalDriver })
+
+ gin.SetMode(gin.TestMode)
+ recorder := httptest.NewRecorder()
+ ctx, _ := gin.CreateTestContext(recorder)
+ ctx.Request = httptest.NewRequest(http.MethodGet, "/providers/OpenAI/models?use_saved_credentials=true&instance_name=default", nil)
+ ctx.Params = gin.Params{{Key: "provider_id_or_name", Value: "OpenAI"}}
+ ctx.Set("user_id", "user-1")
+ ctx.Request = ctx.Request.WithContext(permission.WithSubject(ctx.Request.Context(), permission.Subject{
+ UserID: "user-1", TenantID: "tenant-1",
+ }))
+
+ NewProviderHandler(nil, service.NewModelProviderService(), service.NewModelCallService()).ListModels(ctx)
+ body := decodeProviderHandlerResponse(t, recorder)
+ if common.ErrorCode(body["code"].(float64)) != common.CodeSuccess {
+ t.Fatalf("ListModels() response = %v, want success", body)
+ }
+ if probe.calls != 1 || probe.apiKey != "sk-test" || probe.region != "default" {
+ t.Fatalf("provider list calls=%d region=%q, want one call with saved key and default region", probe.calls, probe.region)
+ }
+
+ models, ok := body["data"].([]interface{})
+ if !ok {
+ t.Fatalf("ListModels() data = %T, want model list", body["data"])
+ }
+ modelNames := make(map[string]bool, len(models))
+ for _, item := range models {
+ model, ok := item.(map[string]interface{})
+ if !ok {
+ t.Fatalf("model entry = %T, want object", item)
+ }
+ name, _ := model["name"].(string)
+ modelNames[name] = true
+ }
+ if !modelNames["gpt-live-test"] || !modelNames["gpt-5.6"] {
+ t.Fatalf("ListModels() names = %v, want live model and catalog model", modelNames)
+ }
+}
+
func TestProviderHandlerAlterModelRejectsInvalidStatus(t *testing.T) {
ctx, recorder := newProviderHandlerRequest(
t,
diff --git a/internal/service/model_service.go b/internal/service/model_service.go
index 6b72116655..5c9ed09094 100644
--- a/internal/service/model_service.go
+++ b/internal/service/model_service.go
@@ -290,32 +290,42 @@ func (m *ModelProviderService) DeleteModelProvider(ctx context.Context, userID,
return common.CodeSuccess, nil
}
-// ListSupportedModelsOptions contains owner-only overrides for a saved
+// SavedProviderModelOptions contains owner-only overrides for a saved
// provider instance's endpoint and non-secret configuration.
-type ListSupportedModelsOptions struct {
+type SavedProviderModelOptions struct {
APIKeyConfig json.RawMessage
BaseURL *string
Region *string
}
-func (m *ModelProviderService) ListSupportedModels(ctx context.Context, providerName, instanceName, userID string, options ListSupportedModelsOptions) ([]map[string]interface{}, error) {
+// SavedProviderModelConfig contains the credentials and endpoint to use when
+// discovering models through a saved provider instance.
+type SavedProviderModelConfig struct {
+ APIKey string
+ BaseURL string
+ Region string
+}
+
+// ResolveSavedProviderModelConfig validates access to a saved provider
+// instance and returns the credentials and endpoint for model discovery.
+func (m *ModelProviderService) ResolveSavedProviderModelConfig(ctx context.Context, providerName, instanceName, userID string, options SavedProviderModelOptions) (SavedProviderModelConfig, error) {
providerName = strings.TrimSpace(providerName)
provider, err := m.resolveProviderInTenant(ctx, userID, providerName, permission.OperationRead)
if err != nil {
if permissionresponse.IsPermissionError(err) {
_, normalizedErr := normalizeModelPermissionError(err)
- return nil, normalizedErr
+ return SavedProviderModelConfig{}, normalizedErr
}
- return nil, err
+ return SavedProviderModelConfig{}, err
}
instance, err := m.resolveInstance(ctx, provider, instanceName)
if err != nil {
if errors.Is(err, errInstanceProviderMismatch) {
- return nil, instanceLookupError(provider, instanceName, err)
+ return SavedProviderModelConfig{}, instanceLookupError(provider, instanceName, err)
}
- return nil, err
+ return SavedProviderModelConfig{}, err
}
access, err := permission.NewDatabaseChecker(dao.DB).ResolveAccess(ctx, permission.Subject{UserID: userID}, permission.ResourceRef{
Kind: permission.ResourceKindModelInstance,
@@ -326,30 +336,24 @@ func (m *ModelProviderService) ListSupportedModels(ctx context.Context, provider
err = permission.ErrPermissionDenied
}
_, normalizedErr := normalizeModelPermissionError(err)
- return nil, normalizedErr
+ return SavedProviderModelConfig{}, normalizedErr
}
if access.Source != permission.AccessSourceOwner && hasSavedProviderInstanceOverrides(options.APIKeyConfig, options.BaseURL, options.Region) {
_, normalizedErr := normalizeModelPermissionError(permission.ErrPermissionDenied)
- return nil, normalizedErr
- }
- providerName = provider.ProviderName
-
- providerInfo := dao.GetModelProviderManager().FindProvider(providerName)
- if providerInfo == nil {
- return nil, fmt.Errorf("provider %s not found", providerName)
+ return SavedProviderModelConfig{}, normalizedErr
}
var extra map[string]string
err = json.Unmarshal([]byte(instance.Extra), &extra)
if err != nil {
- return nil, err
+ return SavedProviderModelConfig{}, err
}
apiKey := instance.APIKey
if len(bytes.TrimSpace(options.APIKeyConfig)) > 0 && !bytes.Equal(bytes.TrimSpace(options.APIKeyConfig), []byte("null")) {
apiKey, err = mergeSavedProviderAPIKeyConfig(instance.APIKey, options.APIKeyConfig)
if err != nil {
- return nil, err
+ return SavedProviderModelConfig{}, err
}
}
region := extra["region"]
@@ -363,43 +367,15 @@ func (m *ModelProviderService) ListSupportedModels(ctx context.Context, provider
if options.BaseURL != nil {
baseURL = strings.TrimSpace(*options.BaseURL)
}
-
- apiConfig := &modelModule.APIConfig{
- ApiKey: &apiKey,
- Region: &region,
- }
- if options.BaseURL != nil {
- apiConfig.BaseURL = &baseURL
- }
-
- driver := providerInfo.ModelDriver
-
- // For local deployed models
- if baseURL != "" {
- driver, err = newModelDriverForBaseURL(driver, providerName, region, baseURL)
- if err != nil {
- return nil, err
- }
+ if region == "" {
+ region = "default"
}
- modelList, err := driver.ListModels(ctx, apiConfig)
- if err != nil {
- return nil, err
- }
- var result []map[string]interface{}
- for _, model := range modelList {
- result = append(result, map[string]interface{}{
- "name": model.Name,
- "max_dimension": model.MaxDimension,
- "max_batch_size": model.MaxBatchSize,
- "dimensions": model.Dimensions,
- "context_length": model.ContextLength,
- "max_output": model.MaxOutput,
- "model_types": model.ModelTypes,
- "thinking": model.Thinking,
- })
- }
- return result, nil
+ return SavedProviderModelConfig{
+ APIKey: apiKey,
+ BaseURL: baseURL,
+ Region: region,
+ }, nil
}
type CreateInstanceModelInfo struct {
diff --git a/internal/service/model_service_test.go b/internal/service/model_service_test.go
index 5252788690..68bb80dd1c 100644
--- a/internal/service/model_service_test.go
+++ b/internal/service/model_service_test.go
@@ -717,8 +717,8 @@ func TestProviderModelListingUsesOwnedTenant(t *testing.T) {
if _, err = service.ListInstanceModels(serviceTestContext(t, "user-1", "user-1"), "provider-2", "default", "user-1"); !errors.Is(err, gorm.ErrRecordNotFound) {
t.Fatalf("ListInstanceModels() for another tenant's provider error = %v, want record not found", err)
}
- if _, err = service.ListSupportedModels(serviceTestContext(t, "user-1", "user-1"), "provider-2", "default", "user-1", ListSupportedModelsOptions{}); !errors.Is(err, gorm.ErrRecordNotFound) {
- t.Fatalf("ListSupportedModels() for another tenant's provider error = %v, want record not found", err)
+ if _, err = service.ResolveSavedProviderModelConfig(serviceTestContext(t, "user-1", "user-1"), "provider-2", "default", "user-1", SavedProviderModelOptions{}); !errors.Is(err, gorm.ErrRecordNotFound) {
+ t.Fatalf("ResolveSavedProviderModelConfig() for another tenant's provider error = %v, want record not found", err)
}
}
@@ -836,7 +836,7 @@ func TestMergeProviderAPIKeyPreservesBlankCredentialsAndSupportsClear(t *testing
}
}
-func TestListSupportedModelsUsePermissionCannotOverrideSavedEndpoint(t *testing.T) {
+func TestResolveSavedProviderModelConfigUsePermissionCannotOverrideSavedEndpoint(t *testing.T) {
db := setupModelProviderServiceTestDB(t)
useModelProviderServiceTestDB(t, db)
seedModelProviderServiceScope(t, db)
@@ -855,44 +855,27 @@ func TestListSupportedModelsUsePermissionCannotOverrideSavedEndpoint(t *testing.
}).Error; err != nil {
t.Fatalf("seed tenant member: %v", err)
}
- provider := dao.GetModelProviderManager().FindProvider("OpenAI")
- if provider == nil {
- t.Fatal("OpenAI provider is not configured")
- }
- probe := &remoteModelProbeDriver{DummyModel: modelModule.NewDummyModel(nil, modelModule.URLSuffix{})}
- originalDriver := provider.ModelDriver
- provider.ModelDriver = probe
- t.Cleanup(func() { provider.ModelDriver = originalDriver })
-
service := NewModelProviderService()
ctx := serviceTestContext(t, "member-1", "tenant-1")
- if _, err := service.ListSupportedModels(ctx, "OpenAI", "default", "member-1", ListSupportedModelsOptions{}); err != nil {
- t.Fatalf("ListSupportedModels(use saved credentials) error = %v, want success", err)
- }
- if probe.listCalls != 1 || probe.listConfig == nil || probe.listConfig.ApiKey == nil || *probe.listConfig.ApiKey != "sk-owner-secret" {
- t.Fatalf("saved-credential list config = %+v, calls %d; want stored key used once", probe.listConfig, probe.listCalls)
+ config, err := service.ResolveSavedProviderModelConfig(ctx, "OpenAI", "default", "member-1", SavedProviderModelOptions{})
+ if err != nil {
+ t.Fatalf("ResolveSavedProviderModelConfig(use saved credentials) error = %v, want success", err)
}
- if probe.baseURLs["us-east-1"] != "https://stored.example" || probe.listConfig.Region == nil || *probe.listConfig.Region != "us-east-1" {
- t.Fatalf("saved endpoint = driver URLs %v, config %+v; want persisted endpoint", probe.baseURLs, probe.listConfig)
+ if config.APIKey != "sk-owner-secret" || config.BaseURL != "https://stored.example" || config.Region != "us-east-1" {
+ t.Fatalf("saved model config = %+v, want stored credentials and endpoint", config)
}
attackerURL := "https://attacker.example"
- _, err := service.ListSupportedModels(ctx, "OpenAI", "default", "member-1", ListSupportedModelsOptions{BaseURL: &attackerURL})
+ _, err = service.ResolveSavedProviderModelConfig(ctx, "OpenAI", "default", "member-1", SavedProviderModelOptions{BaseURL: &attackerURL})
if err == nil || !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("ListSupportedModels(use permission with endpoint override) error = %v, want hidden denial", err)
- }
- if probe.listCalls != 1 {
- t.Fatalf("provider was called %d times after rejecting endpoint override, want 1", probe.listCalls)
+ t.Fatalf("ResolveSavedProviderModelConfig(use permission with endpoint override) error = %v, want hidden denial", err)
}
- _, err = service.ListSupportedModels(ctx, "OpenAI", "default", "member-1", ListSupportedModelsOptions{
+ _, err = service.ResolveSavedProviderModelConfig(ctx, "OpenAI", "default", "member-1", SavedProviderModelOptions{
APIKeyConfig: json.RawMessage(`{"paddleocr_api_url":"https://attacker.example"}`),
})
if err == nil || !errors.Is(err, permission.ErrPermissionDenied) {
- t.Fatalf("ListSupportedModels(use permission with provider endpoint override) error = %v, want hidden denial", err)
- }
- if probe.listCalls != 1 {
- t.Fatalf("provider was called %d times after rejecting provider config override, want 1", probe.listCalls)
+ t.Fatalf("ResolveSavedProviderModelConfig(use permission with provider endpoint override) error = %v, want hidden denial", err)
}
ownerCtx := serviceTestContext(t, "user-1", "tenant-1")
@@ -901,11 +884,17 @@ func TestListSupportedModelsUsePermissionCannotOverrideSavedEndpoint(t *testing.
t.Fatalf("ShowProviderInstance(owner) = (%v, %v, %v), want owner metadata", ownerInstance, code, err)
}
ownerURL := "https://owner-override.example"
- if _, err = service.ListSupportedModels(ownerCtx, "OpenAI", "default", "user-1", ListSupportedModelsOptions{BaseURL: &ownerURL}); err != nil {
- t.Fatalf("ListSupportedModels(owner endpoint override) error = %v, want success", err)
+ ownerRegion := "eu-west-1"
+ ownerConfig, err := service.ResolveSavedProviderModelConfig(ownerCtx, "OpenAI", "default", "user-1", SavedProviderModelOptions{
+ APIKeyConfig: json.RawMessage(`{"group_id":"owner-group"}`),
+ BaseURL: &ownerURL,
+ Region: &ownerRegion,
+ })
+ if err != nil {
+ t.Fatalf("ResolveSavedProviderModelConfig(owner overrides) error = %v, want success", err)
}
- if probe.listCalls != 2 || probe.listConfig == nil || probe.listConfig.BaseURL == nil || *probe.listConfig.BaseURL != ownerURL || probe.listConfig.ApiKey == nil || *probe.listConfig.ApiKey != "sk-owner-secret" {
- t.Fatalf("owner override config = %+v, calls %d; want saved key sent only to owner endpoint", probe.listConfig, probe.listCalls)
+ if ownerConfig.BaseURL != ownerURL || ownerConfig.Region != ownerRegion || ownerConfig.APIKey != `{"api_key":"sk-owner-secret","group_id":"owner-group"}` {
+ t.Fatalf("owner override config = %+v; want stored key, owner config and endpoint overrides", ownerConfig)
}
}