[fix]: allow model catalog URLs (pricing + parameters) to be overridden via env vars

framework/modelcatalog/config.go

@@ -1,6 +1,8 @@
 package modelcatalog
 
 import (
+	"os"
+	"strings"
 	"time"
 )
 
@@ -18,10 +20,27 @@ const (
 	ConfigLastParamsSyncKey       = "LastModelParametersSync"
 	DefaultPricingURL             = "https://getbifrost.ai/datasheet"
 	DefaultModelParametersURL     = "https://getbifrost.ai/datasheet/model-parameters"
+	PricingURLEnvVar              = "BIFROST_PRICING_URL"
+	ModelParametersURLEnvVar      = "BIFROST_MODEL_PARAMETERS_URL"
 	DefaultPricingTimeout         = 45 * time.Second
 	DefaultModelParametersTimeout = 45 * time.Second
 )
 
+func defaultURLWithEnv(defaultURL, envVar string) string {
+	if value := strings.TrimSpace(os.Getenv(envVar)); value != "" {
+		return value
+	}
+	return defaultURL
+}
+
+func defaultPricingURL() string {
+	return defaultURLWithEnv(DefaultPricingURL, PricingURLEnvVar)
+}
+
+func defaultModelParametersURL() string {
+	return defaultURLWithEnv(DefaultModelParametersURL, ModelParametersURLEnvVar)
+}
+
 // Config is the model pricing configuration.
 type Config struct {
 	PricingURL          *string `json:"pricing_url,omitempty"`

framework/modelcatalog/config_test.go

@@ -0,0 +1,51 @@
+package modelcatalog
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"sync/atomic"
+	"testing"
+)
+
+func TestDefaultURLWithEnv(t *testing.T) {
+	t.Setenv(PricingURLEnvVar, " https://internal.example/datasheet ")
+	if got := defaultPricingURL(); got != "https://internal.example/datasheet" {
+		t.Fatalf("expected env pricing URL, got %q", got)
+	}
+
+	t.Setenv(ModelParametersURLEnvVar, "")
+	if got := defaultModelParametersURL(); got != DefaultModelParametersURL {
+		t.Fatalf("expected default model parameters URL, got %q", got)
+	}
+}
+
+func TestLoadModelParametersFromURLUsesConfiguredURL(t *testing.T) {
+	var requested atomic.Bool
+	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		requested.Store(true)
+		_ = json.NewEncoder(w).Encode(map[string]any{
+			"test-model": map[string]any{
+				"max_output_tokens": 4096,
+			},
+		})
+	}))
+	defer server.Close()
+
+	mc := &ModelCatalog{
+		modelParametersURL: server.URL,
+		logger:             noOpLogger{},
+	}
+
+	params, err := mc.loadModelParametersFromURL(context.Background())
+	if err != nil {
+		t.Fatalf("expected model parameters load to succeed, got %v", err)
+	}
+	if !requested.Load() {
+		t.Fatal("expected configured URL to be requested")
+	}
+	if _, ok := params["test-model"]; !ok {
+		t.Fatal("expected test model parameters to be loaded")
+	}
+}

framework/modelcatalog/main.go

@@ -66,11 +66,11 @@ type ModelCatalog struct {
 // Init initializes the model catalog
 func Init(ctx context.Context, config *Config, configStore configstore.ConfigStore, logger schemas.Logger) (*ModelCatalog, error) {
 	// Initialize pricing URL and sync interval
-	pricingURL := DefaultPricingURL
+	pricingURL := defaultPricingURL()
 	if config.PricingURL != nil {
 		pricingURL = *config.PricingURL
 	}
-	modelParametersURL := DefaultModelParametersURL
+	modelParametersURL := defaultModelParametersURL()
 	if config.ModelParametersURL != nil && *config.ModelParametersURL != "" {
 		modelParametersURL = *config.ModelParametersURL
 	}
@@ -273,12 +273,11 @@ func (mc *ModelCatalog) UpdateSyncConfig(ctx context.Context, config *Config) er
 	}
 
 	// Update pricing configuration
-	mc.pricingURL = DefaultPricingURL
+	mc.pricingURL = defaultPricingURL()
 	if config.PricingURL != nil {
 		mc.pricingURL = *config.PricingURL
 	}
-
-	mc.modelParametersURL = DefaultModelParametersURL
+	mc.modelParametersURL = defaultModelParametersURL()
 	if config.ModelParametersURL != nil && *config.ModelParametersURL != "" {
 		mc.modelParametersURL = *config.ModelParametersURL
 	}

transports/bifrost-http/lib/config.go

@@ -2997,7 +2997,13 @@ func ResolveFrameworkPricingConfig(
 	fileConfig *framework.FrameworkConfig,
 ) (*configstoreTables.TableFrameworkConfig, *modelcatalog.Config, bool) {
 	defaultPricingURL := modelcatalog.DefaultPricingURL
+	if value := strings.TrimSpace(os.Getenv(modelcatalog.PricingURLEnvVar)); value != "" {
+		defaultPricingURL = value
+	}
 	defaultModelParametersURL := modelcatalog.DefaultModelParametersURL
+	if value := strings.TrimSpace(os.Getenv(modelcatalog.ModelParametersURLEnvVar)); value != "" {
+		defaultModelParametersURL = value
+	}
 	defaultSyncSeconds := int64(modelcatalog.DefaultSyncInterval.Seconds())
 
 	filePricingURL := (*string)(nil)
@@ -3081,9 +3087,19 @@ func ResolveFrameworkPricingConfig(
 	configID := uint(0)
 
 	// Hash the file-resolved values; skip if nothing valid survived Phase 1.
+	hashPricingURL := filePricingURL
+	if skipURLBackfill {
+		hashPricingURL = nil
+	}
+	hashModelParametersURL := fileModelParametersURL
+	if skipModelParamsURLBackfill {
+		hashModelParametersURL = nil
+	}
+
 	fileHash := ""
-	if fileConfig != nil && fileConfig.Pricing != nil && !skipURLBackfill && (filePricingURL != nil || fileSyncSeconds != nil) {
-		h, err := configstore.GenerateFrameworkConfigHash(filePricingURL, fileModelParametersURL, fileSyncSeconds)
+	if fileConfig != nil && fileConfig.Pricing != nil &&
+		(hashPricingURL != nil || hashModelParametersURL != nil || fileSyncSeconds != nil) {
+		h, err := configstore.GenerateFrameworkConfigHash(hashPricingURL, hashModelParametersURL, fileSyncSeconds)
 		if err != nil {
 			logger.Warn("failed to compute framework config hash: %v", err)
 		} else {
@@ -3101,7 +3117,7 @@ func ResolveFrameworkPricingConfig(
 		configID = dbConfig.ID
 
 		if dbConfig.PricingURL != nil {
-			if fileChanged && filePricingURL != nil {
+			if fileChanged && filePricingURL != nil && !skipURLBackfill {
 				logger.Info("pricing_url from config.json overrides DB (file hash changed) — updating DB")
 				needsDBUpdate = true
 			} else {
@@ -3111,7 +3127,12 @@ func ResolveFrameworkPricingConfig(
 			needsDBUpdate = true
 		}
 		if dbConfig.ModelParametersURL != nil && *dbConfig.ModelParametersURL != "" {
-			resolvedModelParametersURL = dbConfig.ModelParametersURL
+			if fileChanged && fileModelParametersURL != nil && !skipModelParamsURLBackfill {
+				logger.Info("model_parameters_url from config.json overrides DB (file hash changed) — updating DB")
+				needsDBUpdate = true
+			} else {
+				resolvedModelParametersURL = dbConfig.ModelParametersURL
+			}
 		} else if !skipModelParamsURLBackfill {
 			needsDBUpdate = true
 		}

transports/bifrost-http/lib/config_test.go

@@ -425,11 +425,14 @@ func (m *MockConfigStore) Ping(ctx context.Context) error                 { retu
 func (m *MockConfigStore) EncryptPlaintextRows(ctx context.Context) error { return nil }
 func (m *MockConfigStore) Close(ctx context.Context) error                { return nil }
 func (m *MockConfigStore) DB() *gorm.DB                                   { return nil }
-func (m *MockConfigStore) ScopedDB(ctx context.Context) *gorm.DB          { return nil }
 func (m *MockConfigStore) ExecuteTransaction(ctx context.Context, fn func(tx *gorm.DB) error) error {
 	return fn(nil)
 }
 
+func (m *MockConfigStore) ScopedDB(ctx context.Context) *gorm.DB {
+	return m.DB()
+}
+
 func (m *MockConfigStore) GetOauthConfigByID(ctx context.Context, id string) (*tables.TableOauthConfig, error) {
 	return nil, nil
 }
@@ -16238,6 +16241,121 @@ func TestResolveFrameworkPricingConfig(t *testing.T) {
 		require.Equal(t, newFileSyncSeconds, *normalizedModelCatalog.PricingSyncInterval)
 	})
 
+	t.Run("file model parameters url overrides db when file changes after ui edit", func(t *testing.T) {
+		storedHash, err := configstore.GenerateFrameworkConfigHash(nil, &defaultModelParamsURL, nil)
+		require.NoError(t, err)
+		uiEditedModelParamsURL := "https://ui-edited.example.com/model-parameters.json"
+		dbConfig := &tables.TableFrameworkConfig{
+			ID:                  10,
+			PricingURL:          &dbURL,
+			ModelParametersURL:  &uiEditedModelParamsURL,
+			PricingSyncInterval: &dbSyncSeconds,
+			ConfigHash:          storedHash,
+		}
+		newFileModelParamsURL := "https://new-file.example.com/model-parameters.json"
+		fileConfig := &framework.FrameworkConfig{
+			Pricing: &modelcatalog.Config{
+				ModelParametersURL: &newFileModelParamsURL,
+			},
+		}
+
+		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(dbConfig, fileConfig)
+		require.True(t, needsDBUpdate)
+		require.Equal(t, uint(10), normalizedTable.ID)
+		require.Equal(t, dbURL, *normalizedTable.PricingURL)
+		require.Equal(t, newFileModelParamsURL, *normalizedTable.ModelParametersURL)
+		require.Equal(t, dbSyncSeconds, *normalizedTable.PricingSyncInterval)
+		require.Equal(t, dbURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, newFileModelParamsURL, *normalizedModelCatalog.ModelParametersURL)
+		require.Equal(t, dbSyncSeconds, *normalizedModelCatalog.PricingSyncInterval)
+		require.NotEqual(t, storedHash, normalizedTable.ConfigHash)
+	})
+
+	t.Run("unresolved model parameters env does not block pricing file change", func(t *testing.T) {
+		oldFileURL := "https://old-file.example.com/pricing.json"
+		missingModelParamsEnv := "env.BIFROST_TEST_MODEL_PARAMS_URL_NONEXISTENT_XYZ"
+		storedHash, err := configstore.GenerateFrameworkConfigHash(&oldFileURL, &missingModelParamsEnv, nil)
+		require.NoError(t, err)
+		prev, existed := os.LookupEnv("BIFROST_TEST_MODEL_PARAMS_URL_NONEXISTENT_XYZ")
+		os.Unsetenv("BIFROST_TEST_MODEL_PARAMS_URL_NONEXISTENT_XYZ")
+		t.Cleanup(func() {
+			if existed {
+				os.Setenv("BIFROST_TEST_MODEL_PARAMS_URL_NONEXISTENT_XYZ", prev)
+			}
+		})
+
+		dbModelParamsURL := "https://db.example.com/model-parameters.json"
+		dbConfig := &tables.TableFrameworkConfig{
+			ID:                  11,
+			PricingURL:          &dbURL,
+			ModelParametersURL:  &dbModelParamsURL,
+			PricingSyncInterval: &dbSyncSeconds,
+			ConfigHash:          storedHash,
+		}
+		newFileURL := "https://new-file.example.com/pricing.json"
+		fileConfig := &framework.FrameworkConfig{
+			Pricing: &modelcatalog.Config{
+				PricingURL:         &newFileURL,
+				ModelParametersURL: &missingModelParamsEnv,
+			},
+		}
+
+		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(dbConfig, fileConfig)
+		require.True(t, needsDBUpdate)
+		require.Equal(t, uint(11), normalizedTable.ID)
+		require.Equal(t, newFileURL, *normalizedTable.PricingURL)
+		require.Equal(t, dbModelParamsURL, *normalizedTable.ModelParametersURL)
+		require.Equal(t, dbSyncSeconds, *normalizedTable.PricingSyncInterval)
+		require.Equal(t, newFileURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, dbModelParamsURL, *normalizedModelCatalog.ModelParametersURL)
+		require.Equal(t, dbSyncSeconds, *normalizedModelCatalog.PricingSyncInterval)
+		require.NotEqual(t, storedHash, normalizedTable.ConfigHash)
+	})
+
+	t.Run("unresolved pricing env does not block other file changes", func(t *testing.T) {
+		missingPricingEnv := "env.BIFROST_TEST_PRICING_URL_NONEXISTENT_XYZ"
+		oldModelParamsURL := "https://old-file.example.com/model-parameters.json"
+		oldSyncSeconds := int64((12 * time.Hour).Seconds())
+		storedHash, err := configstore.GenerateFrameworkConfigHash(&missingPricingEnv, &oldModelParamsURL, &oldSyncSeconds)
+		require.NoError(t, err)
+		prev, existed := os.LookupEnv("BIFROST_TEST_PRICING_URL_NONEXISTENT_XYZ")
+		os.Unsetenv("BIFROST_TEST_PRICING_URL_NONEXISTENT_XYZ")
+		t.Cleanup(func() {
+			if existed {
+				os.Setenv("BIFROST_TEST_PRICING_URL_NONEXISTENT_XYZ", prev)
+			}
+		})
+
+		dbModelParamsURL := "https://db.example.com/model-parameters.json"
+		dbConfig := &tables.TableFrameworkConfig{
+			ID:                  12,
+			PricingURL:          &dbURL,
+			ModelParametersURL:  &dbModelParamsURL,
+			PricingSyncInterval: &dbSyncSeconds,
+			ConfigHash:          storedHash,
+		}
+		newModelParamsURL := "https://new-file.example.com/model-parameters.json"
+		newSyncSeconds := int64((48 * time.Hour).Seconds())
+		fileConfig := &framework.FrameworkConfig{
+			Pricing: &modelcatalog.Config{
+				PricingURL:          &missingPricingEnv,
+				ModelParametersURL:  &newModelParamsURL,
+				PricingSyncInterval: &newSyncSeconds,
+			},
+		}
+
+		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(dbConfig, fileConfig)
+		require.True(t, needsDBUpdate)
+		require.Equal(t, uint(12), normalizedTable.ID)
+		require.Equal(t, dbURL, *normalizedTable.PricingURL)
+		require.Equal(t, newModelParamsURL, *normalizedTable.ModelParametersURL)
+		require.Equal(t, newSyncSeconds, *normalizedTable.PricingSyncInterval)
+		require.Equal(t, dbURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, newModelParamsURL, *normalizedModelCatalog.ModelParametersURL)
+		require.Equal(t, newSyncSeconds, *normalizedModelCatalog.PricingSyncInterval)
+		require.NotEqual(t, storedHash, normalizedTable.ConfigHash)
+	})
+
 	t.Run("fallback to file when db fields are missing", func(t *testing.T) {
 		dbConfig := &tables.TableFrameworkConfig{
 			ID:                  3,
@@ -16261,14 +16379,45 @@ func TestResolveFrameworkPricingConfig(t *testing.T) {
 	})
 
 	t.Run("fallback to defaults when db and file are missing", func(t *testing.T) {
+		t.Setenv(modelcatalog.PricingURLEnvVar, "")
+		t.Setenv(modelcatalog.ModelParametersURLEnvVar, "")
+
 		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(nil, nil)
 		require.False(t, needsDBUpdate)
 		require.Equal(t, defaultURL, *normalizedTable.PricingURL)
+		require.Equal(t, defaultModelParamsURL, *normalizedTable.ModelParametersURL)
 		require.Equal(t, defaultSyncSeconds, *normalizedTable.PricingSyncInterval)
 		require.Equal(t, defaultURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, defaultModelParamsURL, *normalizedModelCatalog.ModelParametersURL)
 		require.Equal(t, defaultSyncSeconds, *normalizedModelCatalog.PricingSyncInterval)
 	})
 
+	t.Run("fallback default pricing url uses env override", func(t *testing.T) {
+		envURL := "https://env-default.example.com/pricing.json"
+		t.Setenv(modelcatalog.PricingURLEnvVar, envURL)
+		t.Setenv(modelcatalog.ModelParametersURLEnvVar, "")
+
+		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(nil, nil)
+		require.False(t, needsDBUpdate)
+		require.Equal(t, envURL, *normalizedTable.PricingURL)
+		require.Equal(t, defaultModelParamsURL, *normalizedTable.ModelParametersURL)
+		require.Equal(t, envURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, defaultModelParamsURL, *normalizedModelCatalog.ModelParametersURL)
+	})
+
+	t.Run("fallback default model parameters url uses env override", func(t *testing.T) {
+		envURL := "https://env-default.example.com/model-parameters.json"
+		t.Setenv(modelcatalog.PricingURLEnvVar, "")
+		t.Setenv(modelcatalog.ModelParametersURLEnvVar, envURL)
+
+		normalizedTable, normalizedModelCatalog, needsDBUpdate := ResolveFrameworkPricingConfig(nil, nil)
+		require.False(t, needsDBUpdate)
+		require.Equal(t, defaultURL, *normalizedTable.PricingURL)
+		require.Equal(t, envURL, *normalizedTable.ModelParametersURL)
+		require.Equal(t, defaultURL, *normalizedModelCatalog.PricingURL)
+		require.Equal(t, envURL, *normalizedModelCatalog.ModelParametersURL)
+	})
+
 	t.Run("invalid db interval (zero) falls back and requests db update", func(t *testing.T) {
 		invalidDBSync := int64(0)
 		dbConfig := &tables.TableFrameworkConfig{