Benson Wong
19fb5f35e9
Add setParamsByID filter that applies different request parameters based
on the requested model ID, enabling per-alias behaviour for a single
loaded model.
- add SetParamsByID field to Filters struct and SanitizedSetParamsByID
method
- substitute ${MODEL_ID} and other macros in setParamsByID keys and
values
- validate no unknown macros remain in keys or values after substitution
- apply setParamsByID in proxyInferenceHandler after setParams (can
override it)
- update config-schema.json with setParamsByID definition
- update UI to show aliases and make them selectable in the Playground
closes #534
115 lines
3.2 KiB
Go
115 lines
3.2 KiB
Go
package config
|
|
|
|
import (
|
|
"slices"
|
|
"sort"
|
|
"strings"
|
|
)
|
|
|
|
// ProtectedParams is a list of parameters that cannot be set or stripped via filters
|
|
// These are protected to prevent breaking the proxy's ability to route requests correctly
|
|
var ProtectedParams = []string{"model"}
|
|
|
|
// Filters contains filter settings for modifying request parameters
|
|
// Used by both models and peers
|
|
type Filters struct {
|
|
// StripParams is a comma-separated list of parameters to remove from requests
|
|
// The "model" parameter can never be removed
|
|
StripParams string `yaml:"stripParams"`
|
|
|
|
// SetParams is a dictionary of parameters to set/override in requests
|
|
// Protected params (like "model") cannot be set
|
|
SetParams map[string]any `yaml:"setParams"`
|
|
|
|
// SetParamsByID maps requested model IDs to parameters to set/override in requests.
|
|
// Useful with aliases: a single loaded model can behave differently depending on
|
|
// which alias the client used. Applied after SetParams, so it can override those values.
|
|
// Protected params (like "model") cannot be set.
|
|
SetParamsByID map[string]map[string]any `yaml:"setParamsByID"`
|
|
}
|
|
|
|
// SanitizedStripParams returns a sorted list of parameters to strip,
|
|
// with duplicates, empty strings, and protected params removed
|
|
func (f Filters) SanitizedStripParams() []string {
|
|
if f.StripParams == "" {
|
|
return nil
|
|
}
|
|
|
|
params := strings.Split(f.StripParams, ",")
|
|
cleaned := make([]string, 0, len(params))
|
|
seen := make(map[string]bool)
|
|
|
|
for _, param := range params {
|
|
trimmed := strings.TrimSpace(param)
|
|
// Skip protected params, empty strings, and duplicates
|
|
if slices.Contains(ProtectedParams, trimmed) || trimmed == "" || seen[trimmed] {
|
|
continue
|
|
}
|
|
seen[trimmed] = true
|
|
cleaned = append(cleaned, trimmed)
|
|
}
|
|
|
|
if len(cleaned) == 0 {
|
|
return nil
|
|
}
|
|
|
|
slices.Sort(cleaned)
|
|
return cleaned
|
|
}
|
|
|
|
// SanitizedSetParamsByID returns the params to set for the given requestedModelID,
|
|
// with protected params removed and keys sorted for consistent iteration order.
|
|
// Returns nil if the ID has no entry or all its params are protected.
|
|
func (f Filters) SanitizedSetParamsByID(requestedModelID string) (map[string]any, []string) {
|
|
if len(f.SetParamsByID) == 0 {
|
|
return nil, nil
|
|
}
|
|
params, found := f.SetParamsByID[requestedModelID]
|
|
if !found || len(params) == 0 {
|
|
return nil, nil
|
|
}
|
|
result := make(map[string]any, len(params))
|
|
keys := make([]string, 0, len(params))
|
|
for key, value := range params {
|
|
if slices.Contains(ProtectedParams, key) {
|
|
continue
|
|
}
|
|
result[key] = value
|
|
keys = append(keys, key)
|
|
}
|
|
sort.Strings(keys)
|
|
if len(result) == 0 {
|
|
return nil, nil
|
|
}
|
|
return result, keys
|
|
}
|
|
|
|
// SanitizedSetParams returns a copy of SetParams with protected params removed
|
|
// and keys sorted for consistent iteration order
|
|
func (f Filters) SanitizedSetParams() (map[string]any, []string) {
|
|
if len(f.SetParams) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
result := make(map[string]any, len(f.SetParams))
|
|
keys := make([]string, 0, len(f.SetParams))
|
|
|
|
for key, value := range f.SetParams {
|
|
// Skip protected params
|
|
if slices.Contains(ProtectedParams, key) {
|
|
continue
|
|
}
|
|
result[key] = value
|
|
keys = append(keys, key)
|
|
}
|
|
|
|
// Sort keys for consistent ordering
|
|
sort.Strings(keys)
|
|
|
|
if len(result) == 0 {
|
|
return nil, nil
|
|
}
|
|
|
|
return result, keys
|
|
}
|