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(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.goindex 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.goindex 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, mif 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.APIKeyvar extra map[string]string@@ -323,6 +329,13 @@ func resolveModelConfigFromProviderInstance(ctx context.Context, db *gorm.DB, teif 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.APIKeyvar extra map[string]stringdiff --git a/internal/ingestion/component/dispatch_model_test.go b/internal/ingestion/component/dispatch_model_test.goindex 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)+ }+}