Struct ModelService 

pub struct ModelService {
    repo: Arc<dyn ModelRepository>,
}

Service for model operations.

This service provides high-level model management by delegating to the injected ModelRepository. It adds no business logic beyond what the repository provides - it’s a thin facade.

Fields

repo: Arc<dyn ModelRepository>

Implementations

impl ModelService

pub fn new(repo: Arc<dyn ModelRepository>) -> Self

Create a new model service with the given repository.

pub async fn list(&self) -> Result<Vec<Model>, CoreError>

List all models.

pub async fn get(&self, identifier: &str) -> Result<Option<Model>, CoreError>

Get a model by its identifier (id, name, or HF ID).

pub async fn get_by_id(&self, id: i64) -> Result<Option<Model>, CoreError>

Get a model by its database ID.

pub async fn get_by_name(&self, name: &str) -> Result<Option<Model>, CoreError>

Get a model by name.

pub async fn find_by_identifier( &self, identifier: &str, ) -> Result<Model, CoreError>

Find a model by identifier (id, name, or HF ID). Returns error if not found.

pub async fn find_by_name(&self, name: &str) -> Result<Model, CoreError>

Find a model by name. Returns error if not found.

pub async fn add(&self, model: NewModel) -> Result<Model, CoreError>

Add a new model.

pub async fn import_from_file( &self, file_path: &Path, gguf_parser: &dyn GgufParserPort, param_count_override: Option<f64>, ) -> Result<Model, CoreError>

Import a model from a local GGUF file with full metadata extraction.

Validates file, parses GGUF metadata, detects capabilities, and registers with rich metadata. This is the canonical way to add local models.

Arguments

• file_path - Absolute path to the GGUF file
• gguf_parser - Parser implementation for metadata extraction
• param_count_override - Optional user override for parameter count

Returns

Returns the registered Model with full metadata, or validation error.

Design

This method orchestrates:

1. File validation (existence, extension)
2. GGUF metadata parsing (architecture, quantization, context)
3. Capability detection (reasoning, tool-calling from metadata)
4. Chat template inference (additional capability signals)
5. Auto-tag generation from detected capabilities
6. Model persistence with complete NewModel struct

pub async fn update(&self, model: &Model) -> Result<(), CoreError>

Update a model.

pub async fn delete(&self, id: i64) -> Result<(), CoreError>

Delete a model by ID.

pub async fn remove(&self, identifier: &str) -> Result<Model, CoreError>

Remove a model by identifier. Returns the removed model.

pub async fn list_tags(&self) -> Result<Vec<String>, CoreError>

List all unique tags used across all models.

pub async fn add_tag(&self, model_id: i64, tag: String) -> Result<(), CoreError>

Add a tag to a model.

If the tag already exists on the model, this is a no-op.

pub async fn remove_tag( &self, model_id: i64, tag: &str, ) -> Result<(), CoreError>

Remove a tag from a model.

If the tag doesn’t exist on the model, this is a no-op.

pub async fn get_tags(&self, model_id: i64) -> Result<Vec<String>, CoreError>

Get all tags for a specific model.

pub async fn get_by_tag(&self, tag: &str) -> Result<Vec<Model>, CoreError>

Get all models that have a specific tag.

pub async fn get_filter_options(&self) -> Result<ModelFilterOptions, CoreError>

Get filter options aggregated from all models.

Returns distinct quantizations, parameter count range, and context length range for use in the GUI filter popover.

Note: Uses in-memory aggregation for simplicity. This is acceptable for typical model libraries (<100 models). Revisit if libraries grow large.

pub async fn bootstrap_capabilities(&self) -> Result<(), CoreError>

Backfill capabilities for models that don’t have them set.

This runs on startup to handle models with unknown capabilities. Only infers if capabilities are empty (0/unknown).

INVARIANT

Never overwrite explicitly-set capabilities. Only infer when unknown.