Struct ModelRegistry 

pub struct ModelRegistry { /* private fields */ }

Model registry with embedded + dynamic models

The registry maintains two sets of models:

1. Embedded models: Compiled into the binary, always available
2. Dynamic models: Fetched at runtime (optional), stored in RwLock

Example

use m2m::models::ModelRegistry;

let registry = ModelRegistry::new();

// Lookup by ID
let card = registry.get("openai/gpt-4o").unwrap();
assert_eq!(card.abbrev, "og4o");

// Lookup by abbreviation
let card = registry.get("ml3170i").unwrap();
assert_eq!(card.id, "meta-llama/llama-3.1-70b-instruct");

// Abbreviate a model name
let abbrev = registry.abbreviate("openai/gpt-4o");
assert_eq!(abbrev, "og4o");

// Expand an abbreviation
let id = registry.expand("og4o").unwrap();
assert_eq!(id, "openai/gpt-4o");

Implementations

impl ModelRegistry

pub fn new() -> Self

Create a new registry with embedded models loaded

pub fn get(&self, id_or_abbrev: &str) -> Option<ModelCard>

Get a model by ID or abbreviation

Tries lookups in order:

1. Direct ID match in embedded models
2. Abbreviation match
3. Dynamic models (if any)

pub fn contains(&self, id_or_abbrev: &str) -> bool

Check if a model exists in the registry

pub fn get_encoding(&self, model: &str) -> Encoding

Get the encoding for a model (with fallback inference)

If the model is not in the registry, infers encoding from the model ID.

pub fn get_context_length(&self, model: &str) -> u32

Get the context length for a model (with safe default)

pub fn abbreviate(&self, model_id: &str) -> String

Abbreviate a model ID

Returns the abbreviation from the registry if available, otherwise generates one using the standard algorithm.

pub fn expand(&self, abbrev: &str) -> Option<String>

Expand an abbreviation to full model ID

Returns None if the abbreviation is not recognized.

pub fn list_ids(&self) -> Vec<&str>

List all known model IDs (embedded only, not dynamic)

pub fn list_abbrevs(&self) -> Vec<&str>

List all known abbreviations

pub fn len(&self) -> usize

Get total count of models (embedded + dynamic)

pub fn is_empty(&self) -> bool

Check if registry is empty

pub fn embedded_count(&self) -> usize

Get count of embedded models

pub fn dynamic_count(&self) -> usize

Get count of dynamic models

pub fn add_dynamic(&self, card: ModelCard) -> Result<()>

Add a model to the dynamic registry

pub fn clear_dynamic(&self) -> Result<()>

Clear dynamic models

pub fn get_by_provider(&self, provider: Provider) -> Vec<ModelCard>

Get models filtered by provider

pub fn search(&self, query: &str) -> Vec<ModelCard>

Search models by ID substring

pub fn iter(&self) -> impl Iterator<Item = &ModelCard>

Iterate over all embedded models

Trait Implementations

impl Default for ModelRegistry

fn default() -> Self

Returns the “default value” for a type.