Skip to content

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

fix(ingestion): reject disabled model instances during resolution (#20207)

Bruce-Yii301e1498bc99
diff --git a/internal/dao/model_context_test.go b/internal/dao/model_context_test.go
index 06904e9aa7..be304e0d3f 100644
--- a/internal/dao/model_context_test.go
+++ b/internal/dao/model_context_test.go
@@ -349,3 +349,105 @@ func TestResolveModelContentLength_StoredMistralOCRProvider(t *testing.T) {
t.Fatalf("tenant model id = %d, want %d", got, want)
}
}
+
+// TestResolveModelContentLength_LegacyCompositeNeverUsesNonDefaultInstance
+// verifies that a legacy two-part "model@provider" reference never resolves
+// another instance's tenant override. The reference implicitly means the
+// "default" instance; when that instance is missing, the resolution must not
+// borrow the provider's sole active instance, because that reports the
+// context window of a deployment the caller did not select. An explicit
+// "model@instance@provider" reference keeps resolving that instance.
+func TestResolveModelContentLength_LegacyCompositeNeverUsesNonDefaultInstance(t *testing.T) {
+ db := openModelContextTestDB(t)
+ pushDB(t, db)
+ ctx := t.Context()
+
+ if err := db.Create(&entity.TenantModelProvider{
+ ID: "provider-openai",
+ ProviderName: "OpenAI",
+ TenantID: "tenant-1",
+ }).Error; err != nil {
+ t.Fatalf("create provider: %v", err)
+ }
+ if err := db.Create(&entity.TenantModelInstance{
+ ID: "instance-prod",
+ ProviderID: "provider-openai",
+ InstanceName: "prod",
+ Status: "active",
+ }).Error; err != nil {
+ t.Fatalf("create instance: %v", err)
+ }
+ if err := db.Create(&entity.TenantModel{
+ ID: "0123456789abcdef0123456789abcdef",
+ ProviderID: "provider-openai",
+ InstanceID: "instance-prod",
+ ModelName: "gpt-4o",
+ ModelType: int(entity.ModelTypeChat),
+ Status: "active",
+ Extra: `{"max_tokens": 32000}`,
+ }).Error; err != nil {
+ t.Fatalf("create model: %v", err)
+ }
+
+ // The implicit "default" instance does not exist, so the "prod" instance's
+ // tenant override must not answer a two-part reference.
+ if got := ResolveModelContentLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
+ t.Fatalf("ResolveModelContentLength(gpt-4o@OpenAI) = %d, want 128000 (the default instance is unavailable; another instance must not be substituted)", got)
+ }
+ // An explicit instance reference still resolves that instance.
+ if got := ResolveModelContentLength(ctx, db, "tenant-1", "gpt-4o@prod@OpenAI", "", ""); got != 32000 {
+ t.Fatalf("ResolveModelContentLength(gpt-4o@prod@OpenAI) = %d, want 32000 (explicit instance reference)", got)
+ }
+}
+
+// TestResolveModelContentLength_LegacyCompositeDoesNotGuessBetweenActiveInstances
+// verifies that a legacy two-part reference does not pick one of several
+// active instances when the implicit "default" instance is missing. Each
+// instance keeps its own override for explicit references.
+func TestResolveModelContentLength_LegacyCompositeDoesNotGuessBetweenActiveInstances(t *testing.T) {
+ db := openModelContextTestDB(t)
+ pushDB(t, db)
+ ctx := t.Context()
+
+ if err := db.Create(&entity.TenantModelProvider{
+ ID: "provider-openai",
+ ProviderName: "OpenAI",
+ TenantID: "tenant-1",
+ }).Error; err != nil {
+ t.Fatalf("create provider: %v", err)
+ }
+ for _, instance := range []*entity.TenantModelInstance{
+ {ID: "instance-prod", ProviderID: "provider-openai", InstanceName: "prod", Status: "active"},
+ {ID: "instance-staging", ProviderID: "provider-openai", InstanceName: "staging", Status: "active"},
+ } {
+ if err := db.Create(instance).Error; err != nil {
+ t.Fatalf("create instance %s: %v", instance.InstanceName, err)
+ }
+ }
+ for _, model := range []*entity.TenantModel{
+ {
+ ID: "model-prod", ProviderID: "provider-openai", InstanceID: "instance-prod",
+ ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active",
+ Extra: `{"max_tokens": 32000}`,
+ },
+ {
+ ID: "model-staging", ProviderID: "provider-openai", InstanceID: "instance-staging",
+ ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active",
+ Extra: `{"max_tokens": 16000}`,
+ },
+ } {
+ if err := db.Create(model).Error; err != nil {
+ t.Fatalf("create model %s: %v", model.ID, err)
+ }
+ }
+
+ if got := ResolveModelContentLength(ctx, db, "tenant-1", "gpt-4o@OpenAI", "", ""); got != 128000 {
+ t.Fatalf("ResolveModelContentLength(gpt-4o@OpenAI) = %d, want 128000 (no default instance; no instance may be guessed)", got)
+ }
+ if got := ResolveModelContentLength(ctx, db, "tenant-1", "gpt-4o@prod@OpenAI", "", ""); got != 32000 {
+ t.Fatalf("ResolveModelContentLength(gpt-4o@prod@OpenAI) = %d, want 32000", got)
+ }
+ if got := ResolveModelContentLength(ctx, db, "tenant-1", "gpt-4o@staging@OpenAI", "", ""); got != 16000 {
+ t.Fatalf("ResolveModelContentLength(gpt-4o@staging@OpenAI) = %d, want 16000", got)
+ }
+}
diff --git a/internal/ingestion/component/dispatch_model.go b/internal/ingestion/component/dispatch_model.go
index 721207bc82..a703a985d7 100644
--- a/internal/ingestion/component/dispatch_model.go
+++ b/internal/ingestion/component/dispatch_model.go
@@ -264,6 +264,12 @@ func resolveModelConfigByID(ctx context.Context, db *gorm.DB, tenantID string, m
if err != nil {
return nil, err
}
+ // A disabled instance must not be used: its credentials are no longer
+ // accepted by the provider, and running against it would hide that the
+ // selected deployment is unavailable. Mirrors the service-layer check.
+ if !strings.EqualFold(instance.Status, "active") {
+ return nil, fmt.Errorf("model instance %q is disabled", instance.InstanceName)
+ }
apiKey := instance.APIKey
var extra map[string]string
@@ -323,6 +329,13 @@ func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, te
if err != nil {
return nil, "", nil, 0, fmt.Errorf("instance %q lookup failed: %w", instanceName, err)
}
+ // The instance named by the reference must be usable. A two-part
+ // "model@provider" reference names the "default" instance implicitly, so
+ // an inactive default fails here instead of being answered by another
+ // instance of the same provider.
+ if !strings.EqualFold(instance.Status, "active") {
+ return nil, "", nil, 0, fmt.Errorf("model instance %q is disabled", instanceName)
+ }
apiKey := instance.APIKey
var extra map[string]string
diff --git a/internal/ingestion/component/dispatch_model_test.go b/internal/ingestion/component/dispatch_model_test.go
index b6eb00bf6e..25fb4f9ce1 100644
--- a/internal/ingestion/component/dispatch_model_test.go
+++ b/internal/ingestion/component/dispatch_model_test.go
@@ -344,3 +344,104 @@ func TestResolveModelConfigChainedDBStatementIsolationFixedOnly(t *testing.T) {
t.Fatalf("resolver dropped the caller's rejecting scope: %v", err)
}
}
+
+// openDispatchModelTestDB opens an isolated in-memory database holding the
+// tenant model tables the dispatch resolvers read.
+func openDispatchModelTestDB(t *testing.T) *gorm.DB {
+ t.Helper()
+ db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{TranslateError: true})
+ if err != nil {
+ t.Fatalf("open sqlite: %v", err)
+ }
+ if err := db.AutoMigrate(&entity.TenantModelProvider{}, &entity.TenantModelInstance{}, &entity.TenantModel{}); err != nil {
+ t.Fatalf("migrate: %v", err)
+ }
+ return db
+}
+
+// TestResolveModelConfig_InactiveInstanceIsAnExplicitFailure verifies that a
+// model whose instance is inactive fails with an explicit error on both
+// resolution paths, instead of running against the disabled instance's
+// credentials. A two-part "model@provider" reference names the "default"
+// instance implicitly, so an inactive default must fail the same way.
+func TestResolveModelConfig_InactiveInstanceIsAnExplicitFailure(t *testing.T) {
+ db := openDispatchModelTestDB(t)
+ for _, row := range []interface{}{
+ &entity.TenantModelProvider{ID: "provider-openai", TenantID: "tenant-1", ProviderName: "OpenAI"},
+ &entity.TenantModelInstance{ID: "instance-default", ProviderID: "provider-openai", InstanceName: "default", APIKey: `{"OPENAI_API_KEY": "sk-inactive"}`, Status: "inactive"},
+ &entity.TenantModel{ID: "model-1", ProviderID: "provider-openai", InstanceID: "instance-default", ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active"},
+ } {
+ if err := db.Create(row).Error; err != nil {
+ t.Fatalf("seed %T: %v", row, err)
+ }
+ }
+
+ for _, tc := range []struct{ name, modelRef string }{
+ {name: "tenant model id", modelRef: "model-1"},
+ {name: "composite reference", modelRef: "gpt-4o@default@OpenAI"},
+ {name: "legacy two-part reference", modelRef: "gpt-4o@OpenAI"},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ driver, modelName, apiConfig, contextLength, err := defaultResolveModelConfig(t.Context(), db, "tenant-1", entity.ModelTypeChat, tc.modelRef)
+ if err == nil {
+ t.Fatalf("an inactive instance must fail explicitly, got driver=%v model=%q", driver, modelName)
+ }
+ if !strings.Contains(strings.ToLower(err.Error()), "disabled") {
+ t.Fatalf("error does not report the disabled instance: %v", err)
+ }
+ if driver != nil || modelName != "" || apiConfig != nil || contextLength != 0 {
+ t.Fatal("failed resolution returned a partial configuration")
+ }
+ })
+ }
+}
+
+// TestResolveModelConfig_MaxTokensOverrideSetsContextWindowOnly verifies that
+// a tenant "max_tokens" override moves the resolved context window only: the
+// provider catalog's context_length is used when there is no override, and the
+// override never turns the model into an output-generation cap.
+func TestResolveModelConfig_MaxTokensOverrideSetsContextWindowOnly(t *testing.T) {
+ db := openDispatchModelTestDB(t)
+ for _, row := range []interface{}{
+ &entity.TenantModelProvider{ID: "provider-openai", TenantID: "tenant-1", ProviderName: "OpenAI"},
+ &entity.TenantModelInstance{ID: "instance-default", ProviderID: "provider-openai", InstanceName: "default", Status: "active"},
+ &entity.TenantModel{ID: "model-1", ProviderID: "provider-openai", InstanceID: "instance-default", ModelName: "gpt-4o", ModelType: int(entity.ModelTypeChat), Status: "active"},
+ } {
+ if err := db.Create(row).Error; err != nil {
+ t.Fatalf("seed %T: %v", row, err)
+ }
+ }
+
+ catalogModel, err := dao.GetModelProviderManager().GetModelByName("OpenAI", "gpt-4o")
+ if err != nil {
+ t.Fatalf("resolve provider model: %v", err)
+ }
+ if catalogModel.ContextLength == nil {
+ t.Fatal("provider model has no context_length")
+ }
+
+ // Without an override the catalog context window is used.
+ _, _, _, contextLength, err := defaultResolveModelConfig(t.Context(), db, "tenant-1", entity.ModelTypeChat, "gpt-4o@default@OpenAI")
+ if err != nil {
+ t.Fatalf("resolve model config: %v", err)
+ }
+ if contextLength != *catalogModel.ContextLength {
+ t.Fatalf("context length = %d, want catalog context_length %d", contextLength, *catalogModel.ContextLength)
+ }
+
+ // The tenant override replaces the context window only.
+ if err := db.Model(&entity.TenantModel{}).Where("id = ?", "model-1").
+ Update("extra", `{"max_tokens": 2000}`).Error; err != nil {
+ t.Fatalf("set model extra: %v", err)
+ }
+ _, _, _, contextLength, err = defaultResolveModelConfig(t.Context(), db, "tenant-1", entity.ModelTypeChat, "gpt-4o@default@OpenAI")
+ if err != nil {
+ t.Fatalf("resolve model config with override: %v", err)
+ }
+ if contextLength != 2000 {
+ t.Fatalf("context length = %d, want the tenant max_tokens override 2000", contextLength)
+ }
+ if catalogModel.MaxOutput != nil && *catalogModel.MaxOutput == contextLength {
+ t.Fatalf("resolved context length %d equals the catalog max_output; the context window and the output cap are indistinguishable", contextLength)
+ }
+}