# How Magnitude Ensures Model ID Consistency Across Provider Formats Using Resilient Symbols

> Magnitude ensures model ID consistency across provider formats. Learn how its resilient symbols and atomizeModelId function create a canonical stream for reliable classification.

- Repository: [Magnitude/magnitude](https://github.com/magnitudedev/magnitude)
- Tags: internals
- Published: 2026-09-06

---

**Magnitude normalizes every provider-specific model identifier into a canonical atom stream using the `atomizeModelId` function and a resilient symbol-based DSL, enabling consistent classification regardless of format variations.**

Magnitude solves the **model ID consistency** problem by decoupling raw provider strings from downstream classification logic. When you work with AI providers like Bedrock, Fireworks, or local GGUF files, the same logical model appears in wildly different formats. This article explains how Magnitude's classifier system transforms these messy identifiers into a unified representation using **resilient symbols** that tolerate variation in separators, capitalization, and versioning schemes.

## The Atomization Pipeline

At the heart of Magnitude's approach is the **model-ID atomizer** implemented in [`packages/providers/src/classifier/atomizer.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/atomizer.ts). The `atomizeModelId` function performs three deterministic operations on every raw identifier:

1. **Strips provider noise** — removes path prefixes, file extensions, version suffixes, and artifact markers
2. **Normalizes case** — converts the entire string to lower-case
3. **Splits into typed atoms** — segments the cleaned string into a sequence of labeled tokens

This atom stream becomes the universal intermediate representation that all matching logic consumes.

```typescript
// Example: normalizing a Bedrock-style ID
import { atomizeModelId } from "@magnitudedev/providers/src/classifier/atomizer";

const raw = "meta.llama3-1-8b-instruct-v1:0";
const atoms = atomizeModelId(raw);
// → [{type:'lit',value:'meta'}, {type:'sep',value:'.'}, {type:'lit',value:'llama3'},
//    {type:'sep',value:'-'}, {type:'lit',value:'1'}, {type:'sep',value:'-'},
//    {type:'lit',value:'8b'}, {type:'sep',value:'-'}, {type:'lit',value:'instruct'},
//    {type:'dot',value:'-'}, {type:'lit',value:'v1'}, {type:'sep',value:':'},
//    {type:'lit',value:'0'}]

```

## Resilient Symbol Types in the DSL

The symbol-based DSL defined in [`packages/providers/src/classifier/symbols.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/symbols.ts) provides six atom types designed to absorb real-world variation:

- **`lit`** — exact literal text (case-insensitive). Normalizes to lower-case so "Llama-3" and "llama_3" match identically.
- **`sep`** — separator flexibility. Matches `-`, `_`, `:`, or their absence, handling "model-v1", "model_v1", or "modelv1" uniformly.
- **`dot`** — decimal point equivalence. Treats both "3.5" and "3p5" as the same version component.
- **`num`** — any all-digit atom. Matches version numbers without constraining length.
- **`ver`** — full version pattern. Accepts `digit[.p]digit`, single digits, or the dot/p-equivalent forms.
- **`opt`** — optional literal text. Enables optional capability markers like "q4" in "q4-gguf".

These symbols make the pattern language **resilient by design** rather than requiring exhaustive enumeration of format permutations.

## Pattern Matching with Extra Atom Tolerance

The **matching engine** in [`packages/providers/src/classifier/matcher.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/matcher.ts) walks the atom stream left-to-right against registered family patterns. Critically, it allows **extra atoms to be ignored** — size tokens, dates, capability markers, and provider-specific noise that survive atomization do not prevent a match.

```typescript
// Example: matching the atom stream against a family pattern
import { match } from "@magnitudedev/providers/src/classifier/matcher";
import { lit, sep, dot, num, ver, opt } from "@magnitudedev/providers/src/classifier/symbols";

const family = {
  familyId: "llama",
  patterns: [
    {
      pattern: [lit("llama"), sep(), ver()],
      priority: 10,
    },
  ],
};

const result = match(atoms, [family]);
// → { familyId: "llama", priority: 10 }

```

This tolerance means the same logical model ID produces identical classification results whether sourced from:

- `meta.llama3-1-8b-instruct-v1:0` (Bedrock format)
- `accounts/fireworks/models/llama-v3p1-8b-instruct` (custom endpoint)
- `glm-5.2.gguf` (local file)

## Typed Model IDs at the System Boundary

While atomization handles internal consistency, Magnitude also provides a typed wrapper for external interfaces. The `ProviderModelIdSchema` in [`packages/ai/src/provider/model.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/ai/src/provider/model.ts) creates validated model identifiers that flow through the system:

```typescript
// Using the ProviderModelIdSchema to create a typed ID (later atomized)
import { ProviderModelIdSchema } from "@magnitudedev/ai";

const providerId = ProviderModelIdSchema.make("meta-llama/Llama-3.3-70B-Instruct");

```

This schema establishes the contract between provider-specific inputs and the internal atomization pipeline.

## Key Source Files

| File | Role |
|------|------|
| [`packages/providers/src/classifier/atomizer.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/atomizer.ts) | Strips provider noise, lower-cases, and splits into typed atoms |
| [`packages/providers/src/classifier/symbols.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/symbols.ts) | Defines the resilient DSL symbols (`lit`, `sep`, `dot`, `num`, `ver`, `opt`) |
| [`packages/providers/src/classifier/matcher.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/matcher.ts) | Executes pattern matching on the atom stream, ignoring irrelevant atoms |
| [`packages/ai/src/provider/model.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/ai/src/provider/model.ts) | Declares `ProviderModelIdSchema`, the typed wrapper used throughout the system |

## Summary

- **Model ID consistency** is achieved through deterministic atomization rather than regex or string normalization
- The `atomizeModelId` function in [`packages/providers/src/classifier/atomizer.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/atomizer.ts) creates a canonical representation by stripping noise, lower-casing, and tokenizing
- **Resilient symbols** in [`packages/providers/src/classifier/symbols.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/symbols.ts) tolerate variation in separators, decimal notation, and optional components
- The matcher in [`packages/providers/src/classifier/matcher.ts`](https://github.com/magnitudedev/magnitude/blob/main/packages/providers/src/classifier/matcher.ts) ignores extraneous atoms, enabling matches despite provider-specific additions
- `ProviderModelIdSchema` provides a typed boundary for model identifiers entering the system

## Frequently Asked Questions

### What problem does Magnitude's model ID atomization solve?

Provider-specific formats encode the same logical model in incompatible ways. Bedrock uses dot-delimited paths with version suffixes, Fireworks uses hyphenated slugs, and local files include extensions. Without normalization, classification logic would need provider-specific branches. Atomization collapses these variations into a single format that downstream code can process uniformly.

### How do resilient symbols handle version number differences?

The `ver` symbol accepts `digit[.p]digit` patterns, single digits, and either `.` or `p` as decimal separators. This means "3.5", "3p5", "3-5", and "35" (when context makes the digits unambiguous) all match the same version pattern. The `dot` symbol specifically bridges the gap between conventional decimal notation and the "p" notation used in some model naming conventions.

### Why does the matcher ignore extra atoms instead of requiring exact matches?

Real-world model IDs contain variable metadata: quantization levels (`q4`, `q8`), context sizes (`32k`, `128k`), dates, and provider-specific tags. These are meaningful for some purposes but irrelevant for family classification. By ignoring unmatched atoms after satisfying the pattern, Magnitude avoids maintaining exhaustive exclusion lists while remaining precise about core identity.

### Where does the atomization happen in Magnitude's request flow?

Atomization occurs before any classification or catalog lookup. When a model ID enters the system—whether through `ProviderModelIdSchema.make()` or direct provider configuration—the `atomizeModelId` function transforms it immediately. This ensures catalogs, resolvers, and UI components always operate on the normalized representation without duplicating normalization logic.