LocalAI/core/config/backend_capabilities.go

package config

import (
	"slices"
	"strings"

	"github.com/mudler/LocalAI/pkg/model"
)

// Usecase name constants — the canonical string values used in gallery entries,
// model configs (known_usecases), and UsecaseInfoMap keys.
const (
	UsecaseChat                = "chat"
	UsecaseCompletion          = "completion"
	UsecaseEdit                = "edit"
	UsecaseVision              = "vision"
	UsecaseEmbeddings          = "embeddings"
	UsecaseTokenize            = "tokenize"
	UsecaseImage               = "image"
	UsecaseUpscale             = "upscale"
	UsecaseVideo               = "video"
	Usecase3D                  = "3d"
	Usecase3DAnimation         = "3d_animation"
	UsecaseMotion              = "motion"
	UsecaseTranscript          = "transcript"
	UsecaseTTS                 = "tts"
	UsecaseSoundGeneration     = "sound_generation"
	UsecaseRerank              = "rerank"
	UsecaseDetection           = "detection"
	UsecaseDepth               = "depth"
	UsecaseForecast            = "forecast"
	UsecaseVAD                 = "vad"
	UsecaseAudioTransform      = "audio_transform"
	UsecaseDiarization         = "diarization"
	UsecaseSoundClassification = "sound_classification"
	UsecaseRealtimeAudio       = "realtime_audio"
	UsecaseFaceRecognition     = "face_recognition"
	UsecaseSpeakerRecognition  = "speaker_recognition"
	UsecaseTokenClassify       = "token_classify"
	UsecaseScore               = "score"
	UsecaseDecisions           = "decisions"
)

// GRPCMethod identifies a Backend service RPC from backend.proto.
type GRPCMethod string

const (
	MethodPredict            GRPCMethod = "Predict"
	MethodPredictStream      GRPCMethod = "PredictStream"
	MethodEmbedding          GRPCMethod = "Embedding"
	MethodGenerateImage      GRPCMethod = "GenerateImage"
	MethodUpscaleImage       GRPCMethod = "UpscaleImage"
	MethodGenerateVideo      GRPCMethod = "GenerateVideo"
	MethodGenerate3D         GRPCMethod = "Generate3D"
	MethodAnimate3D          GRPCMethod = "Animate3D"
	MethodMotionStream       GRPCMethod = "MotionStream"
	MethodAudioTranscription GRPCMethod = "AudioTranscription"
	MethodTTS                GRPCMethod = "TTS"
	MethodTTSStream          GRPCMethod = "TTSStream"
	MethodSoundGeneration    GRPCMethod = "SoundGeneration"
	MethodTokenizeString     GRPCMethod = "TokenizeString"
	MethodDetect             GRPCMethod = "Detect"
	MethodDepth              GRPCMethod = "Depth"
	MethodForecast           GRPCMethod = "Forecast"
	MethodRerank             GRPCMethod = "Rerank"
	MethodVAD                GRPCMethod = "VAD"
	MethodAudioTransform     GRPCMethod = "AudioTransform"
	MethodDiarize            GRPCMethod = "Diarize"
	MethodSoundDetection     GRPCMethod = "SoundDetection"
	MethodAudioToAudioStream GRPCMethod = "AudioToAudioStream"
	MethodFaceVerify         GRPCMethod = "FaceVerify"
	MethodFaceAnalyze        GRPCMethod = "FaceAnalyze"
	MethodVoiceVerify        GRPCMethod = "VoiceVerify"
	MethodVoiceEmbed         GRPCMethod = "VoiceEmbed"
	MethodVoiceAnalyze       GRPCMethod = "VoiceAnalyze"
	MethodTokenClassify      GRPCMethod = "TokenClassify"
	MethodScore              GRPCMethod = "Score"
)

// UsecaseInfo describes a single known_usecase value and how it maps
// to the gRPC backend API.
type UsecaseInfo struct {
	// Flag is the ModelConfigUsecase bitmask value.
	Flag ModelConfigUsecase
	// GRPCMethod is the primary Backend service RPC this usecase maps to.
	GRPCMethod GRPCMethod
	// IsModifier is true when this usecase doesn't map to its own gRPC RPC
	// but modifies how another RPC behaves (e.g., vision uses Predict with images).
	IsModifier bool
	// DependsOn names the usecase(s) this modifier requires (e.g., "chat").
	DependsOn string
	// Description is a human/LLM-readable explanation of what this usecase means.
	Description string
}

// UsecaseInfoMap maps each known_usecase string to its gRPC and semantic info.
var UsecaseInfoMap = map[string]UsecaseInfo{
	UsecaseMotion: {Flag: FLAG_MOTION, GRPCMethod: MethodMotionStream, Description: "Timestamped human pose streams with native or SMPL skeletons."},
	UsecaseChat: {
		Flag:        FLAG_CHAT,
		GRPCMethod:  MethodPredict,
		Description: "Conversational/instruction-following via the Predict RPC with chat templates.",
	},
	UsecaseCompletion: {
		Flag:        FLAG_COMPLETION,
		GRPCMethod:  MethodPredict,
		Description: "Text completion via the Predict RPC with a completion template.",
	},
	UsecaseEdit: {
		Flag:        FLAG_EDIT,
		GRPCMethod:  MethodPredict,
		Description: "Text editing via the Predict RPC with an edit template.",
	},
	UsecaseVision: {
		Flag:        FLAG_VISION,
		GRPCMethod:  MethodPredict,
		IsModifier:  true,
		DependsOn:   UsecaseChat,
		Description: "The model accepts images alongside text in the Predict RPC. For llama-cpp this requires an mmproj file.",
	},
	UsecaseEmbeddings: {
		Flag:        FLAG_EMBEDDINGS,
		GRPCMethod:  MethodEmbedding,
		Description: "Vector embedding generation via the Embedding RPC.",
	},
	UsecaseTokenize: {
		Flag:        FLAG_TOKENIZE,
		GRPCMethod:  MethodTokenizeString,
		Description: "Tokenization via the TokenizeString RPC without running inference.",
	},
	UsecaseUpscale: {
		Flag:        FLAG_UPSCALE,
		GRPCMethod:  MethodUpscaleImage,
		Description: "Image upscaling via the UpscaleImage RPC.",
	},
	UsecaseImage: {
		Flag:        FLAG_IMAGE,
		GRPCMethod:  MethodGenerateImage,
		Description: "Image generation via the GenerateImage RPC (Stable Diffusion, Flux, etc.).",
	},
	UsecaseVideo: {
		Flag:        FLAG_VIDEO,
		GRPCMethod:  MethodGenerateVideo,
		Description: "Video generation via the GenerateVideo RPC, with optional image or audio conditioning when supported by the backend.",
	},
	Usecase3D: {
		Flag:        FLAG_3D,
		GRPCMethod:  MethodGenerate3D,
		Description: "Image-conditioned 3D asset generation via the Generate3D RPC — a binary glTF (GLB) mesh with optional PBR material (TRELLIS.2).",
	},
	Usecase3DAnimation: {
		Flag:        FLAG_3D_ANIMATION,
		GRPCMethod:  MethodAnimate3D,
		Description: "3D animation with model-specific conditioning inputs, exported as binary glTF (GLB).",
	},
	UsecaseTranscript: {
		Flag:        FLAG_TRANSCRIPT,
		GRPCMethod:  MethodAudioTranscription,
		Description: "Speech-to-text via the AudioTranscription RPC.",
	},
	UsecaseTTS: {
		Flag:        FLAG_TTS,
		GRPCMethod:  MethodTTS,
		Description: "Text-to-speech via the TTS RPC.",
	},
	UsecaseSoundGeneration: {
		Flag:        FLAG_SOUND_GENERATION,
		GRPCMethod:  MethodSoundGeneration,
		Description: "Music/sound generation via the SoundGeneration RPC (not speech).",
	},
	UsecaseRerank: {
		Flag:        FLAG_RERANK,
		GRPCMethod:  MethodRerank,
		Description: "Document reranking via the Rerank RPC.",
	},
	UsecaseDetection: {
		Flag:        FLAG_DETECTION,
		GRPCMethod:  MethodDetect,
		Description: "Object detection via the Detect RPC with bounding boxes.",
	},
	UsecaseDepth: {
		Flag:        FLAG_DEPTH,
		GRPCMethod:  MethodDepth,
		Description: "Per-pixel metric depth, camera pose and 3D point cloud via the Depth RPC (Depth Anything 3).",
	},
	UsecaseForecast: {
		Flag:        FLAG_FORECAST,
		GRPCMethod:  MethodForecast,
		Description: "Time-series quantile forecasting via the Forecast RPC (timestral.cpp).",
	},
	UsecaseVAD: {
		Flag:        FLAG_VAD,
		GRPCMethod:  MethodVAD,
		Description: "Voice activity detection via the VAD RPC.",
	},
	UsecaseAudioTransform: {
		Flag:        FLAG_AUDIO_TRANSFORM,
		GRPCMethod:  MethodAudioTransform,
		Description: "Audio-in / audio-out transformations (echo cancellation, noise suppression, dereverberation, voice conversion) via the AudioTransform RPC.",
	},
	UsecaseDiarization: {
		Flag:        FLAG_DIARIZATION,
		GRPCMethod:  MethodDiarize,
		Description: "Speaker diarization (who-spoke-when, per-speaker segments) via the Diarize RPC.",
	},
	UsecaseSoundClassification: {
		Flag:        FLAG_SOUND_CLASSIFICATION,
		GRPCMethod:  MethodSoundDetection,
		Description: "Sound-event classification / audio tagging (scored AudioSet labels like baby cry, glass breaking, alarms) via the SoundDetection RPC.",
	},
	UsecaseRealtimeAudio: {
		Flag:        FLAG_REALTIME_AUDIO,
		GRPCMethod:  MethodAudioToAudioStream,
		Description: "Self-contained any-to-any audio model for the Realtime API — accepts microphone audio and emits speech + transcript (+ optional function calls) from a single backend via the AudioToAudioStream RPC.",
	},
	UsecaseFaceRecognition: {
		Flag:        FLAG_FACE_RECOGNITION,
		GRPCMethod:  MethodFaceVerify,
		Description: "Face recognition — verify identity, analyze attributes (age/gender/emotion) via FaceVerify and FaceAnalyze RPCs.",
	},
	UsecaseSpeakerRecognition: {
		Flag:        FLAG_SPEAKER_RECOGNITION,
		GRPCMethod:  MethodVoiceVerify,
		Description: "Speaker recognition — verify identity, embed and analyze voice via VoiceVerify, VoiceEmbed and VoiceAnalyze RPCs.",
	},
	UsecaseTokenClassify: {
		Flag:        FLAG_TOKEN_CLASSIFY,
		GRPCMethod:  MethodTokenClassify,
		Description: "Per-token classification (NER) via the TokenClassify RPC — the PII detector tier. Declared explicitly via known_usecases; never auto-guessed, since the token-classification head is not useful as general generation or embeddings.",
	},
	UsecaseScore: {
		Flag:        FLAG_SCORE,
		GRPCMethod:  MethodScore,
		Description: "Joint log-probability scoring of candidate continuations via the Score RPC. Declared explicitly via known_usecases and usable alongside generation usecases.",
	},
	UsecaseDecisions: {
		Flag:        FLAG_DECISIONS,
		GRPCMethod:  MethodScore,
		Description: "Decision models (served by POST /v1/systemone): typed choice, noul and score questions over a state text, answered by a non-generative decision model through the Score RPC (question_type systemone). Declared explicitly via known_usecases.",
	},
}

// BackendCapability describes which gRPC methods and usecases a backend supports.
// Derived from reviewing actual implementations in backend/go/ and backend/python/.
type BackendCapability struct {
	// GRPCMethods lists the Backend service RPCs this backend implements.
	GRPCMethods []GRPCMethod
	// PossibleUsecases lists all usecase strings this backend can support.
	PossibleUsecases []string
	// DefaultUsecases lists the conservative safe defaults.
	DefaultUsecases []string
	// AcceptsImages indicates multimodal image input in Predict.
	AcceptsImages bool
	// AcceptsVideos indicates multimodal video input in Predict.
	AcceptsVideos bool
	// AcceptsAudios indicates multimodal audio input in Predict.
	AcceptsAudios bool
	// AudioTransformInputMono16k declares that this backend's AudioTransform
	// input must be folded to 16 kHz mono 16-bit WAV before it is handed over.
	//
	// Opt-IN, and the default of false means "hand the backend the upload as
	// it is". The /audio/transform endpoint used to fold EVERY upload to
	// 16 kHz mono, which is what LocalVQE wants for acoustic echo cancellation
	// and what no source separation model can survive: htdemucs and
	// mel_band_roformer refuse any rate but their checkpoint's own (44.1 kHz
	// for every published one) and work in stereo, so every separation request
	// made through the HTTP API failed with an INTERNAL raised inside the
	// engine, while a direct gRPC call worked. Declaring the need rather than
	// defaulting to it means a backend that wants the fold says so and a
	// backend that does not needs no entry here at all.
	AudioTransformInputMono16k bool
	// VoiceCloning describes the backend's per-request reference-audio
	// contract. Model variants that share a backend may narrow this further;
	// use VoiceCloningForModel for UI/API decisions.
	VoiceCloning *VoiceCloningCapability
	// TTSVoices lists named voices built into the backend.
	TTSVoices []TTSVoice
	// Description is a human-readable summary of the backend.
	Description string
}

// VoiceCloningCapability is the model-facing contract for reusable reference
// voices. The first release intentionally accepts only browser-normalizable
// PCM WAV so every advertised backend sees the same input shape.
type VoiceCloningCapability struct {
	ReferenceTranscriptRequired bool     `json:"reference_transcript_required"`
	AcceptedAudioFormats        []string `json:"accepted_audio_formats"`
}

func referenceVoiceCloning() *VoiceCloningCapability {
	return &VoiceCloningCapability{
		ReferenceTranscriptRequired: true,
		AcceptedAudioFormats:        []string{"audio/wav"},
	}
}

// TTSVoicesForModel returns model-specific metadata or the backend's built-in
// catalog. The returned slice is safe for callers to modify.
func TTSVoicesForModel(cfg *ModelConfig) []TTSVoice {
	if cfg == nil {
		return nil
	}
	if len(cfg.TTSConfig.Voices) > 0 {
		return slices.Clone(cfg.TTSConfig.Voices)
	}
	capability := GetBackendCapability(cfg.Backend)
	if capability == nil {
		return nil
	}
	return slices.Clone(capability.TTSVoices)
}

// BackendCapabilities maps each backend name (as used in model configs and gallery
// entries) to its verified capabilities. This is the single source of truth for
// what each backend supports.
//
// Backend names use hyphens (e.g., "llama-cpp") matching the gallery convention.
// Use NormalizeBackendName() for names with dots (e.g., "llama.cpp").
var BackendCapabilities = map[string]BackendCapability{
	// --- LLM / text generation backends ---
	// llama.cpp also serves Qwen3-TTS, so TTS is in the union below. It is NOT
	// in DefaultUsecases: a bare GGUF served by llama.cpp is a chat model, and
	// the TTS models declare known_usecases: [tts]. VoiceCloning is likewise
	// narrowed per model in VoiceCloningForModel, since the vast majority of
	// llama-cpp models in the gallery are text LLMs that clone nothing.
	"llama-cpp": {
		GRPCMethods: []GRPCMethod{MethodPredict, MethodPredictStream, MethodEmbedding, MethodTokenizeString, MethodScore, MethodTTS, MethodTTSStream,
			MethodAudioTranscription, MethodAudioToAudioStream},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseEdit, UsecaseEmbeddings, UsecaseTokenize, UsecaseVision, UsecaseScore, UsecaseDecisions, UsecaseTTS,
			UsecaseTranscript, UsecaseRealtimeAudio},
		DefaultUsecases: []string{UsecaseChat},
		AcceptsImages:   true, // requires mmproj
		VoiceCloning:    referenceVoiceCloning(),
		Description:     "llama.cpp GGUF models: LLM inference with optional vision via mmproj, Qwen3-TTS speech with reference-audio cloning, and LFM3-Audio speech recognition, text-to-speech and speech-to-speech",
	},
	// privacy-filter is the standalone GGML engine (backend/cpp/privacy-filter,
	// wrapping privacy-filter.cpp) for the openai-privacy-filter PII/NER token
	// classifier — the dedicated TokenClassify path that replaces the
	// patched-llama.cpp route. Never auto-guessed; declared explicitly via
	// known_usecases: [token_classify].
	"privacy-filter": {
		GRPCMethods:      []GRPCMethod{MethodTokenClassify},
		PossibleUsecases: []string{UsecaseTokenClassify},
		DefaultUsecases:  []string{UsecaseTokenClassify},
		Description:      "privacy-filter.cpp — standalone GGML backend for openai-privacy-filter PII/NER token classification",
	},
	"vllm": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream, MethodEmbedding},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseEmbeddings, UsecaseVision},
		DefaultUsecases:  []string{UsecaseChat},
		AcceptsImages:    true,
		AcceptsVideos:    true,
		Description:      "vLLM engine — high-throughput LLM serving with optional multimodal",
	},
	"sglang": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream, MethodTokenizeString},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseTokenize, UsecaseVision},
		DefaultUsecases:  []string{UsecaseChat},
		AcceptsImages:    true,
		Description:      "SGLang — fast LLM inference with structured generation and optional vision",
	},
	// vllm-cpp serves two mutually exclusive engine handles from one backend:
	// a text engine, and MiniMax-H3's video+audio engine when the model config
	// declares the H3 checkpoint set. Both usecases are possible, and chat is
	// the default because a config that says nothing is a text model.
	//
	// AcceptsImages is the fl2va keyframe (start_image/end_image), the same
	// reason longcat-video declares it; the text path takes no image input.
	//
	// TokenClassify is possible (GLiNER2.5 zero-shot NER via vllm_gliner_ner,
	// ABI v27), declared explicitly via known_usecases: [token_classify]. The
	// engine refuses non-BoundaryExtractor architectures, so a chat or embedding
	// model returns an error rather than silent garbage.
	"vllm-cpp": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream, MethodGenerateVideo, MethodTokenClassify, MethodScore},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseVision, UsecaseVideo, UsecaseTokenClassify, UsecaseScore, UsecaseDecisions},
		DefaultUsecases:  []string{UsecaseChat},
		AcceptsImages:    true,
		Description:      "vllm.cpp — the LocalAI team's C++20 port of vLLM; text generation, MiniMax-H3 video+audio generation, GLiNER2.5 zero-shot NER, cua-s1-forms scoring, and decision models (kev, laya, CLM, GLiNER2.5-Decide, xor, nimble)",
	},
	"vllm-omni": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream, MethodGenerateImage, MethodGenerateVideo, MethodTTS},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseImage, UsecaseVideo, UsecaseTTS, UsecaseVision},
		DefaultUsecases:  []string{UsecaseChat},
		AcceptsImages:    true,
		AcceptsVideos:    true,
		AcceptsAudios:    true,
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "vLLM omni-modal — supports text, image, video generation and TTS",
	},
	"transformers": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream, MethodEmbedding, MethodTTS, MethodSoundGeneration},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseEmbeddings, UsecaseTTS, UsecaseSoundGeneration},
		DefaultUsecases:  []string{UsecaseChat},
		Description:      "HuggingFace transformers — general-purpose Python inference",
	},
	"mlx": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion},
		DefaultUsecases:  []string{UsecaseChat},
		Description:      "Apple MLX framework — optimized for Apple Silicon",
	},
	"mlx-distributed": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion},
		DefaultUsecases:  []string{UsecaseChat},
		Description:      "MLX distributed inference across multiple Apple Silicon devices",
	},
	"mlx-vlm": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodPredictStream},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseVision},
		DefaultUsecases:  []string{UsecaseChat, UsecaseVision},
		AcceptsImages:    true,
		AcceptsAudios:    true,
		Description:      "MLX vision-language models with multimodal input",
	},
	"mlx-audio": {
		GRPCMethods:      []GRPCMethod{MethodPredict, MethodTTS},
		PossibleUsecases: []string{UsecaseChat, UsecaseCompletion, UsecaseTTS},
		DefaultUsecases:  []string{UsecaseChat},
		Description:      "MLX audio models — text generation and TTS",
	},

	// --- Image/video generation backends ---
	"diffusers": {
		GRPCMethods:      []GRPCMethod{MethodGenerateImage, MethodUpscaleImage, MethodGenerateVideo, MethodSoundGeneration},
		PossibleUsecases: []string{UsecaseImage, UsecaseUpscale, UsecaseVideo, UsecaseSoundGeneration},
		DefaultUsecases:  []string{UsecaseImage},
		Description:      "HuggingFace diffusers — image, video, and sound generation",
	},
	"longcat-video": {
		GRPCMethods:      []GRPCMethod{MethodGenerateVideo},
		PossibleUsecases: []string{UsecaseVideo},
		DefaultUsecases:  []string{UsecaseVideo},
		AcceptsImages:    true,
		AcceptsAudios:    true,
		Description:      "LongCat-Video — text, image, and audio-conditioned avatar video generation on NVIDIA CUDA",
	},
	"mlx-video": {
		GRPCMethods:      []GRPCMethod{MethodGenerateVideo},
		PossibleUsecases: []string{UsecaseVideo},
		DefaultUsecases:  []string{UsecaseVideo},
		AcceptsImages:    true,
		Description:      "MLX-Video — LTX-2 and Wan video generation on Apple Silicon",
	},
	"stablediffusion": {
		GRPCMethods:      []GRPCMethod{MethodGenerateImage},
		PossibleUsecases: []string{UsecaseImage},
		DefaultUsecases:  []string{UsecaseImage},
		Description:      "Stable Diffusion native backend",
	},
	"stablediffusion-ggml": {
		GRPCMethods:      []GRPCMethod{MethodGenerateImage, MethodUpscaleImage},
		PossibleUsecases: []string{UsecaseImage, UsecaseUpscale},
		DefaultUsecases:  []string{UsecaseImage},
		Description:      "Stable Diffusion via GGML quantized models",
	},

	// --- 3D generation backends ---
	"gemxcpp": {GRPCMethods: []GRPCMethod{MethodMotionStream}, PossibleUsecases: []string{UsecaseMotion}, DefaultUsecases: []string{UsecaseMotion}, Description: "GEM-X live human motion on CPU/Vulkan; SOMA-77 and SMPL-24 pose streams"},
	"kimodocpp": {
		GRPCMethods:      []GRPCMethod{MethodAnimate3D},
		PossibleUsecases: []string{Usecase3DAnimation},
		DefaultUsecases:  []string{Usecase3DAnimation},
		Description:      "kimodo.cpp — text-to-motion on CPU/Vulkan, exported as animated skeleton GLB",
	},
	"trellis2cpp": {
		GRPCMethods:      []GRPCMethod{MethodGenerate3D},
		PossibleUsecases: []string{Usecase3D},
		DefaultUsecases:  []string{Usecase3D},
		Description:      "trellis2.cpp — C++/GGML port of Microsoft TRELLIS.2: single-image to textured 3D mesh (GLB)",
	},

	// --- Speech-to-text backends ---
	"whisper": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodVAD},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseVAD},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "OpenAI Whisper — speech recognition and voice activity detection",
	},
	"faster-whisper": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "CTranslate2-accelerated Whisper for faster transcription",
	},
	"whisperx": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "WhisperX — Whisper with word-level timestamps and speaker diarization",
	},
	"moonshine": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "Moonshine speech recognition",
	},
	"nemo": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "NVIDIA NeMo speech recognition",
	},
	// parakeet-cpp loads three model kinds, picked from the GGUF: an ASR model
	// transcribes (and labels speakers when a diarization_model companion is
	// attached), a Nemotron-3-Diarization model answers Diarize, and a CED model
	// answers SoundDetection. A model with a speaker encoder (a bundle's voice
	// component or a speaker_model companion) also answers VoiceEmbed and
	// VoiceVerify. PossibleUsecases is the union. speaker_recognition is never
	// guessed, since most parakeet models have no speaker encoder: a bundle
	// declares it in known_usecases.
	"parakeet-cpp": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodDiarize, MethodSoundDetection, MethodVoiceEmbed, MethodVoiceVerify},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseDiarization, UsecaseSoundClassification, UsecaseSpeakerRecognition},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "NVIDIA NeMo Parakeet ASR, Nemotron-3-Diarization speaker diarization and CED sound-event detection (parakeet.cpp)",
	},
	// nemo-speech-cpp is one gRPC server in front of four NeMo-Speech.cpp model
	// families, picked at load time from the GGUF general.architecture key, so
	// PossibleUsecases is their UNION and no single model serves all of it: an
	// asr model transcribes (and diarizes, when a Sortformer model is attached
	// through options), a sortformer model only diarizes, a magpietts model only
	// synthesizes, and a Riva-Translate model only answers Predict.
	//
	// UsecaseChat sits alongside UsecaseCompletion for the translation family
	// because Predict and PredictStream are exactly the RPCs /v1/chat/completions
	// drives, and chat is what a translation model is useful through: each turn
	// goes in as the prompt and comes back translated. The flag is not a gate on
	// any endpoint (a request naming the model explicitly is served either way);
	// what it buys is being eligible as the default chat model when a request
	// names none (core/http/routes/openai.go) and appearing in the React UI's
	// chat model picker (CAP_CHAT in react-ui/src/utils/capabilities.js).
	//
	// Leaving it out is not neutral: chat is a gallery filter key and completion
	// is not (usecaseFilters in core/http/routes/ui_api.go), so
	// GET /api/backends/usecases would grey the Chat filter out and hide a
	// Riva-Translate gallery entry from the one filter that fits it.
	//
	// DefaultUsecases is transcript alone because that is the only family whose
	// weights a bare `backend: nemo-speech-cpp` config is likely to name; a model
	// of any other family should pin its own known_usecases.
	//
	// No VoiceCloning key: MagpieTTS synthesizes from baked speaker ids, not from
	// a reference clip, so advertising cloning would accept a `voice:
	// "profile:<id>"` request the backend cannot serve.
	"nemo-speech-cpp": {
		GRPCMethods: []GRPCMethod{
			MethodAudioTranscription, MethodDiarize,
			MethodTTS, MethodTTSStream,
			MethodPredict, MethodPredictStream,
		},
		PossibleUsecases: []string{
			UsecaseTranscript, UsecaseDiarization, UsecaseTTS,
			UsecaseCompletion, UsecaseChat,
		},
		DefaultUsecases: []string{UsecaseTranscript},
		Description:     "NVIDIA NeMo-Speech.cpp: one server for Nemotron ASR (offline, streaming and live), Sortformer diarization, MagpieTTS synthesis and Riva-Translate translation; the model's GGUF architecture decides which",
	},
	"qwen-asr": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "Qwen automatic speech recognition",
	},
	"voxtral": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription},
		PossibleUsecases: []string{UsecaseTranscript},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "Voxtral speech recognition",
	},
	"vibevoice": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodTTS},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTranscript, UsecaseTTS},
		Description:      "VibeVoice — bidirectional speech (transcription and synthesis)",
	},
	"vibevoice-cpp": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodTTS, MethodTTSStream},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTranscript, UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "VibeVoice C++ — bidirectional speech, C++ backend with streaming TTS",
	},
	"sherpa-onnx": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodTTS, MethodTTSStream, MethodVAD},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseTTS, UsecaseVAD},
		DefaultUsecases:  []string{UsecaseTranscript},
		Description:      "Sherpa-ONNX — multi-model speech toolkit (ASR, TTS, VAD)",
	},
	// audio-cpp is one gRPC server in front of ~30 audio.cpp model families, so
	// PossibleUsecases is their UNION and no single model serves all of it:
	// which RPCs a given model answers is decided by the family baked into its
	// GGUF, and every audio-cpp gallery entry pins its own known_usecases.
	//
	// VoiceCloning is not decoration here. VoiceCloningForModel returns nil as
	// soon as the backend has no capability entry, BEFORE it consults the
	// model's own tts.voice_cloning override, so without this key a
	// `voice: "profile:<id>"` request is refused with 400 for every audio-cpp
	// model and no model YAML can rescue it, on a backend that ships
	// audio-cpp-chatterbox, whose family advertises cloning and not plain TTS,
	// so a reference clip is the only way to use it at all.
	//
	// Deliberately NOT AudioTransformInputMono16k: the families this backend
	// reaches through AudioTransform are separation and conversion (htdemucs,
	// mel_band_roformer, seed_vc), which refuse any rate but their
	// checkpoint's own and work from the stereo image.
	"audio-cpp": {
		GRPCMethods: []GRPCMethod{
			MethodTTS, MethodTTSStream, MethodAudioTranscription,
			MethodVAD, MethodDiarize, MethodSoundGeneration, MethodAudioTransform,
		},
		PossibleUsecases: []string{
			UsecaseTTS, UsecaseTranscript, UsecaseVAD, UsecaseDiarization,
			UsecaseSoundGeneration, UsecaseAudioTransform,
		},
		DefaultUsecases: []string{UsecaseTTS},
		VoiceCloning:    referenceVoiceCloning(),
		Description:     "audio.cpp native engine: one server for TTS, voice cloning, ASR, forced alignment, VAD, diarization, source separation and music generation; the model's family decides which",
	},

	// --- TTS backends ---
	"piper": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		Description:      "Piper — fast neural TTS optimized for Raspberry Pi",
	},
	"kokoro": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		Description:      "Kokoro TTS",
	},
	"coqui": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Coqui TTS — multi-speaker neural synthesis",
	},
	"kitten-tts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		Description:      "Kitten TTS",
	},
	"outetts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		Description:      "OuteTTS",
	},
	"pocket-tts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		TTSVoices: []TTSVoice{
			{Name: "juergen", Language: "de_DE", Gender: "male"},
			{Name: "alba", Language: "en_US", Gender: "female"},
			{Name: "bill_boerst", Language: "en_US", Gender: "male"},
			{Name: "charles", Language: "en_US", Gender: "male"},
			{Name: "george", Language: "en_US", Gender: "male"},
			{Name: "javert", Language: "en_US", Gender: "male"},
			{Name: "jean", Language: "en_US", Gender: "male"},
			{Name: "marius", Language: "en_US", Gender: "male"},
			{Name: "michael", Language: "en_US", Gender: "male"},
			{Name: "paul", Language: "en_US", Gender: "male"},
			{Name: "peter_yearsley", Language: "en_US", Gender: "male"},
			{Name: "stuart_bell", Language: "en_US", Gender: "male"},
			{Name: "anna", Language: "en_US", Gender: "female"},
			{Name: "azelma", Language: "en_US", Gender: "female"},
			{Name: "caro_davy", Language: "en_US", Gender: "female"},
			{Name: "cosette", Language: "en_US", Gender: "female"},
			{Name: "eponine", Language: "en_US", Gender: "female"},
			{Name: "eve", Language: "en_US", Gender: "female"},
			{Name: "fantine", Language: "en_US", Gender: "female"},
			{Name: "jane", Language: "en_US", Gender: "female"},
			{Name: "mary", Language: "en_US", Gender: "female"},
			{Name: "vera", Language: "en_US", Gender: "female"},
			{Name: "lola", Language: "es_ES", Gender: "female"},
			{Name: "estelle", Language: "fr_FR", Gender: "female"},
			{Name: "giovanni", Language: "it_IT", Gender: "male"},
			{Name: "rafael", Language: "pt_PT", Gender: "male"},
		},
		Description: "Pocket TTS — lightweight text-to-speech",
	},
	"qwen-tts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Qwen TTS",
	},
	"qwen3-tts-cpp": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodTTSStream},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Qwen3 TTS C++ - text-to-speech with streaming, named speakers, voice design and cloning (qwentts.cpp / GGML)",
	},
	"magpie-tts-cpp": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodTTSStream},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		Description:      "Magpie TTS C++ - NVIDIA Magpie TTS Multilingual 357M with 5 baked voices and 9+ languages (magpie-tts.cpp / GGML)",
	},
	"faster-qwen3-tts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Faster Qwen3 TTS — accelerated Qwen TTS",
	},
	"fish-speech": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Fish Speech TTS",
	},
	"neutts": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "NeuTTS — neural text-to-speech",
	},
	"chatterbox": {
		GRPCMethods:      []GRPCMethod{MethodTTS},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "Chatterbox TTS",
	},
	"voxcpm": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodTTSStream},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "VoxCPM TTS with streaming support",
	},
	"omnivoice-cpp": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodTTSStream},
		PossibleUsecases: []string{UsecaseTTS},
		DefaultUsecases:  []string{UsecaseTTS},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "OmniVoice C++ — multilingual TTS with streaming voice cloning and voice design",
	},
	"crispasr": {
		GRPCMethods:      []GRPCMethod{MethodAudioTranscription, MethodTTS, MethodTTSStream, MethodVAD},
		PossibleUsecases: []string{UsecaseTranscript, UsecaseTTS, UsecaseVAD},
		DefaultUsecases:  []string{UsecaseTranscript},
		VoiceCloning:     referenceVoiceCloning(),
		Description:      "CrispASR GGUF runtime — speech recognition, VAD, and model-dependent TTS",
	},

	// --- Sound generation backends ---
	"ace-step": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodSoundGeneration},
		PossibleUsecases: []string{UsecaseTTS, UsecaseSoundGeneration},
		DefaultUsecases:  []string{UsecaseSoundGeneration},
		Description:      "ACE-Step — music and sound generation",
	},
	"acestep-cpp": {
		GRPCMethods:      []GRPCMethod{MethodSoundGeneration},
		PossibleUsecases: []string{UsecaseSoundGeneration},
		DefaultUsecases:  []string{UsecaseSoundGeneration},
		Description:      "ACE-Step C++ — native sound generation",
	},
	"transformers-musicgen": {
		GRPCMethods:      []GRPCMethod{MethodTTS, MethodSoundGeneration},
		PossibleUsecases: []string{UsecaseTTS, UsecaseSoundGeneration},
		DefaultUsecases:  []string{UsecaseSoundGeneration},
		Description:      "Meta MusicGen via transformers — music generation from text",
	},

	// --- Audio transform backends ---
	"localvqe": {
		GRPCMethods:      []GRPCMethod{MethodAudioTransform},
		PossibleUsecases: []string{UsecaseAudioTransform},
		DefaultUsecases:  []string{UsecaseAudioTransform},
		// The model is trained on 16 kHz mono speech and its AEC needs the
		// input and the loopback reference in the same shape, so the endpoint
		// keeps folding uploads for this backend.
		AudioTransformInputMono16k: true,
		Description:                "LocalVQE — joint AEC, noise suppression, and dereverberation for 16 kHz mono speech",
	},

	// --- Utility backends ---
	"rerankers": {
		GRPCMethods:      []GRPCMethod{MethodRerank},
		PossibleUsecases: []string{UsecaseRerank},
		DefaultUsecases:  []string{UsecaseRerank},
		Description:      "Cross-encoder reranking models",
	},
	"rfdetr": {
		GRPCMethods:      []GRPCMethod{MethodDetect},
		PossibleUsecases: []string{UsecaseDetection},
		DefaultUsecases:  []string{UsecaseDetection},
		Description:      "RF-DETR object detection",
	},
	"rfdetr-cpp": {
		GRPCMethods:      []GRPCMethod{MethodDetect},
		PossibleUsecases: []string{UsecaseDetection},
		DefaultUsecases:  []string{UsecaseDetection},
		Description:      "RF-DETR C++ object detection",
	},
	"depth-anything": {
		GRPCMethods:      []GRPCMethod{MethodDepth, MethodPredict, MethodGenerateImage},
		PossibleUsecases: []string{UsecaseDepth},
		DefaultUsecases:  []string{UsecaseDepth},
		AcceptsImages:    true,
		Description:      "Depth Anything 3 C++ — per-pixel metric depth, camera pose and 3D point cloud",
	},
	"timestral-cpp": {
		GRPCMethods:      []GRPCMethod{MethodForecast},
		PossibleUsecases: []string{UsecaseForecast},
		DefaultUsecases:  []string{UsecaseForecast},
		Description:      "timestral.cpp (C++/ggml, CPU only): quantile forecasts for numeric time series with optional covariates",
	},

	// --- Face and speaker recognition backends ---
	"insightface": {
		GRPCMethods:      []GRPCMethod{MethodEmbedding, MethodDetect, MethodFaceVerify, MethodFaceAnalyze},
		PossibleUsecases: []string{UsecaseEmbeddings, UsecaseDetection, UsecaseFaceRecognition},
		DefaultUsecases:  []string{UsecaseFaceRecognition},
		AcceptsImages:    true,
		Description:      "InsightFace — face detection, embedding, verification and attribute analysis",
	},
	"speaker-recognition": {
		GRPCMethods:      []GRPCMethod{MethodVoiceVerify, MethodVoiceEmbed, MethodVoiceAnalyze},
		PossibleUsecases: []string{UsecaseSpeakerRecognition},
		DefaultUsecases:  []string{UsecaseSpeakerRecognition},
		Description:      "Speaker recognition — voice identity verification and analysis",
	},
	"voice-detect": {
		GRPCMethods:      []GRPCMethod{MethodVoiceVerify, MethodVoiceEmbed, MethodVoiceAnalyze},
		PossibleUsecases: []string{UsecaseSpeakerRecognition},
		DefaultUsecases:  []string{UsecaseSpeakerRecognition},
		Description:      "voice-detect.cpp: C++/ggml speaker embedding, verification and voice analysis (age/gender/emotion)",
	},
	"face-detect": {
		GRPCMethods:      []GRPCMethod{MethodEmbedding, MethodDetect, MethodFaceVerify, MethodFaceAnalyze},
		PossibleUsecases: []string{UsecaseEmbeddings, UsecaseDetection, UsecaseFaceRecognition},
		DefaultUsecases:  []string{UsecaseFaceRecognition},
		AcceptsImages:    true,
		Description:      "face-detect.cpp: C++/ggml face detection, embedding, verification and attribute analysis",
	},
	"silero-vad": {
		GRPCMethods:      []GRPCMethod{MethodVAD},
		PossibleUsecases: []string{UsecaseVAD},
		DefaultUsecases:  []string{UsecaseVAD},
		Description:      "Silero VAD — voice activity detection",
	},
}

// NormalizeBackendName converts backend names to the canonical hyphenated form
// used in gallery entries (e.g., "llama.cpp" → "llama-cpp").
func NormalizeBackendName(backend string) string {
	return strings.ReplaceAll(backend, ".", "-")
}

// galleryChannelSuffixes are the release-channel suffixes appended to a backend
// name in the gallery ("llama-cpp" vs "llama-cpp-development" vs
// "llama-cpp-quantization"). They carry no engine information, so they are
// stripped before any family or capability lookup falls back.
var galleryChannelSuffixes = []string{"-development", "-quantization"}

// galleryHardwarePrefixes are the acceleration prefixes the gallery prepends
// when it publishes one concrete backend image per hardware capability behind a
// meta name: "cpu-localvqe", "vulkan-localvqe", "cuda12-audio-cpp",
// "metal-darwin-arm64-llama-cpp". They carry no engine information either, and
// an operator may pin any of them in a model config's `backend:`.
//
// This is the exhaustive set present in backend/index.yaml, longest first so
// "cuda13-nvidia-l4t-arm64-" is tried before "cuda13-" and
// "intel-sycl-f16-" before "intel-". Stripping is a FALLBACK only (see
// GetBackendCapability), so a backend whose real name happened to start with
// one of these would still be found by its exact name first.
var galleryHardwarePrefixes = []string{
	"cuda13-nvidia-l4t-arm64-",
	"metal-darwin-arm64-",
	"nvidia-l4t-arm64-",
	"intel-sycl-f16-",
	"intel-sycl-f32-",
	"nvidia-l4t-",
	"vulkan-",
	"cuda12-",
	"cuda13-",
	"metal-",
	"intel-",
	"rocm-",
	"cpu-",
}

// stripBackendVariant reduces a concrete gallery backend name to the meta name
// its capabilities are registered under: "vulkan-localvqe-development" becomes
// "localvqe". Returns the input unchanged when nothing matches.
//
// Both halves are needed. A pinned variant carries a hardware prefix, a release
// channel carries a suffix, and backend/index.yaml ships names with both.
func stripBackendVariant(name string) string {
	for _, suffix := range galleryChannelSuffixes {
		if strings.HasSuffix(name, suffix) {
			name = strings.TrimSuffix(name, suffix)
			break
		}
	}
	for _, prefix := range galleryHardwarePrefixes {
		if strings.HasPrefix(name, prefix) {
			return strings.TrimPrefix(name, prefix)
		}
	}
	return name
}

// IsLlamaCppBackend reports whether a backend name refers to a build of the
// llama.cpp gRPC server. The gallery ships one concrete backend per hardware
// capability ("vulkan-llama-cpp", "cuda12-llama-cpp", "metal-llama-cpp", ...)
// behind the "llama-cpp" meta name, and an operator may pin any of them in a
// model config. They all run the same server, so anything gated on "is this
// llama.cpp" must accept the whole family: an exact match against "llama-cpp"
// silently skips every pinned variant (see #10945, where skipping the media
// marker probe broke all vision requests).
//
// The empty name matches too: it is the GGUF auto-detect path, which resolves
// to llama.cpp.
//
// ik-llama.cpp is deliberately excluded. It is a separate engine with its own
// gRPC server that happens to share the "-llama-cpp" suffix.
func IsLlamaCppBackend(backend string) bool {
	name := NormalizeBackendName(backend)
	if name == "" {
		return true
	}
	for _, suffix := range galleryChannelSuffixes {
		name = strings.TrimSuffix(name, suffix)
	}
	if strings.HasSuffix(name, "ik-llama-cpp") {
		return false
	}
	return name == "llama-cpp" || strings.HasSuffix(name, "-llama-cpp")
}

// nonLlamaSamplerBackends lists backends whose native sampler defaults differ
// from llama.cpp's, so LocalAI must NOT inject llama.cpp's top_k=40 default for
// them (issue #6632). mlx_lm's intended default is top_k=0 (disabled) and mlx
// does not remap 0->40, so shipping 40 silently changes sampling for clients
// that omit top_k. Leaving TopK nil lets the wire value default to 0.
//
// This is intentionally a small allow-list of KNOWN non-llama backends: empty
// and unknown backends fall through to the llama.cpp default to preserve the
// GGUF auto-detect path's behavior.
var nonLlamaSamplerBackends = map[string]struct{}{
	"mlx":             {},
	"mlx-vlm":         {},
	"mlx-distributed": {},
}

// UsesLlamaSamplerDefaults reports whether a backend should receive llama.cpp's
// sampler defaults (e.g. top_k=40). Empty/unknown backends return true so the
// GGUF auto-detect path (which resolves to llama.cpp) keeps today's behavior;
// only the known non-llama backends in nonLlamaSamplerBackends return false.
func UsesLlamaSamplerDefaults(backend string) bool {
	if backend == "" {
		return true
	}
	_, isNonLlama := nonLlamaSamplerBackends[NormalizeBackendName(backend)]
	return !isNonLlama
}

// UsesLlamaCppServingOptions reports whether a backend understands llama.cpp's
// serving-tuning model options - the free-form option strings cache_reuse /
// n_cache_reuse (cross-request KV-prefix reuse) and parallel / n_parallel
// (concurrent slots). These are llama.cpp server flags; LocalAI injects them as
// defaults, but a backend that strictly validates its options (e.g.
// longcat-video) rejects an unknown one with "unknown model option(s)" at
// LoadModel. Only the llama.cpp backend - and the empty/auto-detect case, which
// resolves to llama.cpp from a GGUF file, mirroring how llamaCppDefaults is
// registered - should receive them.
//
// This is an allow-list on purpose (unlike UsesLlamaSamplerDefaults's
// deny-list): these options are meaningful to no other backend, so a new
// backend defaults to NOT getting them rather than breaking the same way.
func UsesLlamaCppServingOptions(backend string) bool {
	switch NormalizeBackendName(backend) {
	case "", "llama-cpp":
		return true
	}
	return false
}

// GetBackendCapability returns the capability info for a backend, or nil if unknown.
// Handles backend name normalization.
//
// A PINNED GALLERY VARIANT RESOLVES TO ITS META NAME. The gallery ships one
// image per hardware capability ("cpu-localvqe", "vulkan-localvqe",
// "metal-localvqe") and an operator may put any of them in a model's
// `backend:`. They are the same engine, so an exact-match-only lookup silently
// downgraded every pinned model to "unknown backend": vulkan-localvqe lost the
// 16 kHz mono fold that /audio/transform used to apply unconditionally and
// started failing inside LocalVQE, and a pinned audio-cpp variant would lose
// its voice-cloning contract the same way. Same class of bug as #10945, same
// answer as IsLlamaCppBackend.
//
// Exact match FIRST, so a backend genuinely registered under a variant-looking
// name keeps its own entry and stripping can never shadow it.
func GetBackendCapability(backend string) *BackendCapability {
	capability, _ := resolveBackendCapability(backend)
	return capability
}

// resolveBackendCapability is GetBackendCapability plus the key the entry was
// found under. Callers that then branch on backend identity MUST use that key,
// not the name they passed in. VoiceCloningForModel is the reason this exists:
// its per-backend switch encodes which model variants of a backend can clone,
// and keying it on the caller's spelling meant "cuda12-vibevoice-cpp" resolved
// the capability by stripping but missed the "vibevoice-cpp" case, falling
// through to the permissive default and advertising cloning for the 0.5B model
// that cannot do it.
func resolveBackendCapability(backend string) (*BackendCapability, string) {
	name := NormalizeBackendName(backend)
	if cap, ok := BackendCapabilities[name]; ok {
		return &cap, name
	}
	if base := stripBackendVariant(name); base != name {
		if cap, ok := BackendCapabilities[base]; ok {
			return &cap, base
		}
	}
	return nil, name
}

// AudioTransformRequiresMono16kInput reports whether /audio/transform must fold
// uploads to 16 kHz mono before handing them to this backend.
//
// False for an unknown backend, which is the safe answer: an unregistered
// backend gets its upload unchanged, so a model that needs the file intact
// (source separation, voice conversion at 44.1 kHz) works without an entry
// here, and one that needs the fold cannot get it by accident.
//
// Pinned gallery variants are covered: GetBackendCapability strips the hardware
// prefix and the release-channel suffix, so cpu-localvqe, vulkan-localvqe and
// metal-localvqe all fold exactly as "localvqe" does. They must, because the
// usecase gate does not stand in for this one: naming a model explicitly makes
// BuildFilteredFirstAvailableDefaultModel return before it filters.
func AudioTransformRequiresMono16kInput(backend string) bool {
	capability := GetBackendCapability(backend)
	return capability != nil && capability.AudioTransformInputMono16k
}

// llmAutoLoadUsecases are the usecases that mark a backend able to serve a
// text/LLM GGUF model. A GGUF model that declares no explicit backend must only
// be auto-tried against backends carrying one of these usecases - never against
// audio/codec/image backends (e.g. opus) that happen to be installed alongside
// it (see issue #9287).
var llmAutoLoadUsecases = []string{
	UsecaseChat,
	UsecaseCompletion,
	UsecaseEdit,
	UsecaseEmbeddings,
}

// isLLMCapableForAutoLoad reports whether the named backend is known to serve
// text/LLM models, for pkg/model's GGUF backend auto-detection (#9287). Backends
// absent from the capability table are treated as not LLM-capable.
func isLLMCapableForAutoLoad(name string) bool {
	capability := GetBackendCapability(name)
	if capability == nil {
		return false
	}
	for _, u := range capability.PossibleUsecases {
		if slices.Contains(llmAutoLoadUsecases, u) {
			return true
		}
	}
	return false
}

func init() {
	// Wire the LLM-capability filter into pkg/model's GGUF backend
	// auto-detection. pkg/model is a lower-level package and must not import
	// core/config (that would form a core/config -> pkg/model -> core/config
	// import cycle), so core/config registers the predicate here instead (#9287).
	model.RegisterLLMCapableBackendFunc(isLLMCapableForAutoLoad)
}

// VoiceCloningForModel returns the reference-audio contract only when the
// installed model variant can honor it. Several backends serve both Base
// (voice cloning) and CustomVoice/VoiceDesign models, so backend name alone is
// deliberately insufficient. Operators with custom filenames can opt in or
// out explicitly with tts.voice_cloning; the model option spelling remains a
// compatibility fallback for configurations created before the typed field.
func VoiceCloningForModel(cfg *ModelConfig) *VoiceCloningCapability {
	if cfg == nil {
		return nil
	}
	capability, backend := resolveBackendCapability(cfg.Backend)
	if capability == nil || capability.VoiceCloning == nil {
		return nil
	}
	if cfg.VoiceCloning != nil {
		if !*cfg.VoiceCloning {
			return nil
		}
		return cloneVoiceCloningCapability(capability.VoiceCloning)
	}

	if enabled, explicit := voiceCloningOverride(cfg.Options); explicit {
		if !enabled {
			return nil
		}
		return cloneVoiceCloningCapability(capability.VoiceCloning)
	}

	identity := strings.ToLower(strings.Join([]string{cfg.Name, cfg.Model, strings.Join(cfg.Options, " ")}, " "))
	supported := false
	switch backend {
	case "qwen3-tts-cpp", "qwen-tts", "vllm-omni":
		supported = strings.Contains(identity, "base") || strings.Contains(identity, "voiceclone") || strings.Contains(identity, "voice_clone")
	case "vibevoice-cpp":
		// Realtime 0.5B consumes a precomputed .gguf voice prompt; the 1.5B
		// path consumes raw WAV references per request.
		supported = strings.Contains(identity, "1.5b")
	case "coqui":
		supported = strings.Contains(identity, "xtts") || strings.Contains(identity, "your_tts")
	case "crispasr":
		supported = strings.Contains(identity, "f5-tts") || strings.Contains(identity, "f5_tts")
	case "llama-cpp":
		// llama.cpp is overwhelmingly a text-LLM backend that happens to also
		// serve Qwen3-TTS, so the permissive default below would advertise
		// reference-audio cloning on every GGUF chat model in the gallery.
		// Narrow on the declared usecase rather than the model name: the TTS
		// checkpoints are the only llama-cpp models that carry
		// known_usecases: [tts], name matching would have to guess at
		// third-party GGUF repacks, and "base" (the substring the Qwen and
		// vLLM cases key on) is a routine word in text-model names.
		//
		// Deliberately reads the declared bit instead of HasUsecases, which
		// falls through to GuessUsecases and would hand the decision to a
		// heuristic that never had a llama.cpp TTS model in mind.
		supported = cfg.KnownUsecases != nil && (*cfg.KnownUsecases&FLAG_TTS) == FLAG_TTS
	default:
		supported = true
	}
	if !supported {
		return nil
	}
	return cloneVoiceCloningCapability(capability.VoiceCloning)
}

func voiceCloningOverride(options []string) (enabled, explicit bool) {
	for _, option := range options {
		parts := strings.FieldsFunc(option, func(r rune) bool { return r == ':' || r == '=' })
		if len(parts) != 2 || !strings.EqualFold(strings.TrimSpace(parts[0]), "voice_cloning") {
			continue
		}
		switch strings.ToLower(strings.TrimSpace(parts[1])) {
		case "true", "1", "yes", "on":
			return true, true
		case "false", "0", "no", "off":
			return false, true
		}
	}
	return false, false
}

func cloneVoiceCloningCapability(capability *VoiceCloningCapability) *VoiceCloningCapability {
	if capability == nil {
		return nil
	}
	clone := *capability
	clone.AcceptedAudioFormats = slices.Clone(capability.AcceptedAudioFormats)
	return &clone
}

// PossibleUsecasesForBackend returns all usecases a backend can support.
// Returns nil if the backend is unknown.
func PossibleUsecasesForBackend(backend string) []string {
	if cap := GetBackendCapability(backend); cap != nil {
		return cap.PossibleUsecases
	}
	return nil
}

// DefaultUsecasesForBackendCap returns the conservative default usecases.
// Returns nil if the backend is unknown.
func DefaultUsecasesForBackendCap(backend string) []string {
	if cap := GetBackendCapability(backend); cap != nil {
		return cap.DefaultUsecases
	}
	return nil
}

// IsValidUsecaseForBackend checks whether a usecase is in a backend's possible set.
// Returns true for unknown backends (permissive fallback).
func IsValidUsecaseForBackend(backend, usecase string) bool {
	cap := GetBackendCapability(backend)
	if cap == nil {
		return true // unknown backend — don't restrict
	}
	return slices.Contains(cap.PossibleUsecases, usecase)
}

// AllBackendNames returns a sorted list of all known backend names.
func AllBackendNames() []string {
	names := make([]string, 0, len(BackendCapabilities))
	for name := range BackendCapabilities {
		names = append(names, name)
	}
	slices.Sort(names)
	return names
}