Enum TokenCounterResolution 

#[non_exhaustive]
pub enum TokenCounterResolution {
    Matched(Arc<dyn TokenCounter>),
    Fallback(Arc<dyn TokenCounter>),
}

Outcome of TokenCounterRegistry::resolve — surfaces whether a registered entry actually matched (provider, model) or the registry’s fallback counter was returned because no entry matched.

Making fallback visible at the type level lets production cost estimation paths log / alert on unknown models without inspecting encoding_name() after the fact (invariant 15 — silent fallback is not an option). Callers consume the resolution via pattern match — there is no “give me the counter regardless” shortcut, because such a shortcut would re-enable silent absorption of the fallback.

let counter = match registry.resolve("openai", "gpt-9") {
    Resolution::Matched(c) => c,
    Resolution::Fallback(c) => {
        tracing::warn!("unknown model — using fallback counter");
        c
    }
};

Operators that intentionally accept the fallback bind both arms to the same name (Resolution::Matched(c) | Resolution::Fallback(c) => c). The pattern is short, and the call site signals the deliberate choice in source.

Future variants

Resolution is #[non_exhaustive]. The two predicates Self::is_match and Self::is_fallback each return true only for their own variant — !is_match() and is_fallback() are not equivalent under future variant additions. Operators that want to alert on the no-match branch should match on Self::Fallback explicitly.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

Matched(Arc<dyn TokenCounter>)

A registered (provider, model_prefix) entry matched.

Fallback(Arc<dyn TokenCounter>)

No entry matched; the registry’s fallback counter is returned.

Implementations

impl Resolution

pub fn counter(&self) -> &Arc<dyn TokenCounter>

Borrow the resolved counter regardless of which branch matched. Operators that need the owned Arc consume the enum through a pattern match.

pub const fn is_match(&self) -> bool

true when a registered entry matched.

pub const fn is_fallback(&self) -> bool

true when no entry matched and the fallback was returned. Distinct from !is_match() — Resolution is non_exhaustive, so a future variant could make both predicates return false.

Trait Implementations

impl Clone for Resolution

fn clone(&self) -> Resolution

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Resolution

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.