use std::collections::HashMap;
use std::sync::OnceLock;
fn load_aliases() -> HashMap<String, String> {
let mut merged: HashMap<String, String> = HashMap::new();
for file in crate::config::files().unwrap_or_default() {
merged.extend(
file.conf
.aliases
.iter()
.map(|(k, v)| (k.clone(), v.clone())),
);
}
merged
}
fn aliases() -> &'static HashMap<String, String> {
static CACHE: OnceLock<HashMap<String, String>> = OnceLock::new();
CACHE.get_or_init(load_aliases)
}
const OLLAMA_NAMES: &[(&str, &str)] = &[
("nomic-embed-text", "docker.io/ai/nomic-embed-text-v1.5"),
("bge-m3", "hf.co/ggml-org/bge-m3-Q8_0-GGUF"),
];
fn alias_for<'a>(aliases: &'a HashMap<String, String>, reference: &str) -> Option<&'a str> {
let bare = reference.strip_suffix(":latest");
[Some(reference), bare]
.into_iter()
.flatten()
.find_map(|key| aliases.get(key).map(String::as_str))
}
fn ollama_name(reference: &str) -> Option<&'static str> {
let name = reference.strip_suffix(":latest").unwrap_or(reference);
OLLAMA_NAMES
.iter()
.find_map(|(ollama, target)| (*ollama == name).then_some(*target))
}
const REGISTRY_SCHEMES: &[&str] = &["hf", "huggingface", "ms", "modelscope"];
pub(crate) const PASSTHROUGH_SCHEMES: &[&str] = &["ngc://", "s3://", "gs://"];
#[derive(Debug)]
pub struct InvalidReference(String);
impl std::fmt::Display for InvalidReference {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
f.write_str(&self.0)
}
}
impl std::error::Error for InvalidReference {}
struct ParsedRef<'a> {
scheme: Option<&'a str>,
host: Option<&'a str>,
namespace: Vec<&'a str>,
model: &'a str,
tag: Option<&'a str>,
digest: Option<&'a str>,
}
const MAX_HOST_LEN: usize = 350;
const MAX_PART_LEN: usize = 128;
fn is_part_first_byte(b: u8) -> bool {
b.is_ascii_alphanumeric() || b == b'_'
}
fn is_part_byte(b: u8) -> bool {
is_part_first_byte(b) || b == b'.' || b == b'-'
}
fn check_part(part: &str, kind: &str, allow_dot: bool, max_len: usize) -> Result<(), String> {
if part.is_empty() {
return Err(format!("{kind} is empty"));
}
if part.len() > max_len {
return Err(format!("{kind} exceeds {max_len} bytes"));
}
let bytes = part.as_bytes();
if !is_part_first_byte(bytes[0]) {
return Err(format!(
"{kind} {part:?} starts with invalid character {:?}",
bytes[0] as char
));
}
for &b in &bytes[1..] {
if !is_part_byte(b) || (b == b'.' && !allow_dot) {
return Err(format!(
"{kind} {part:?} contains invalid character {:?}",
b as char
));
}
}
Ok(())
}
fn check_host(host: &str) -> Result<(), String> {
if host.len() > MAX_HOST_LEN {
return Err(format!("host exceeds {MAX_HOST_LEN} bytes"));
}
let (name, port) = match host.split_once(':') {
Some((name, port)) => (name, Some(port)),
None => (host, None),
};
check_part(name, "host", true, MAX_HOST_LEN)?;
if let Some(port) = port {
if port.is_empty() || port.len() > 5 || !port.bytes().all(|b| b.is_ascii_digit()) {
return Err(format!("host port {port:?} is not 1-5 digits"));
}
}
Ok(())
}
fn check_digest(digest: &str) -> Result<(), String> {
if digest.len() > MAX_PART_LEN {
return Err(format!("digest exceeds {MAX_PART_LEN} bytes"));
}
let Some((algo, hex)) = digest.split_once(':') else {
return Err(format!(
"digest {digest:?} is missing the algorithm separator ':'"
));
};
if algo.is_empty()
|| !algo
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit())
{
return Err(format!("digest algorithm {algo:?} is not [a-z0-9]+"));
}
if hex.is_empty() || !hex.bytes().all(|b| b.is_ascii_hexdigit()) {
return Err(format!("digest value {hex:?} is not hexadecimal"));
}
Ok(())
}
fn is_host_component(first: &str) -> bool {
first.contains('.') || first.contains(':') || first.eq_ignore_ascii_case("localhost")
}
fn parse_registry_ref(reference: &str) -> Result<ParsedRef<'_>, InvalidReference> {
let fail = |detail: String| {
InvalidReference(format!("invalid model reference {reference:?}: {detail}"))
};
if reference.trim().is_empty() {
return Err(fail("empty".to_owned()));
}
let (scheme, rest) = match reference.split_once("://") {
Some((scheme, rest)) if REGISTRY_SCHEMES.contains(&scheme) => (Some(scheme), rest),
Some((scheme, _)) => {
return Err(fail(format!("unsupported or malformed scheme {scheme:?}")));
}
None => (None, reference),
};
if rest.is_empty() {
return Err(fail("empty reference after scheme".to_owned()));
}
let (rest, digest) = match rest.split_once('@') {
Some((rest, digest)) => {
check_digest(digest).map_err(fail)?;
(rest, Some(digest))
}
None => (rest, None),
};
let last_component_start = rest.rfind('/').map_or(0, |i| i + 1);
let (name, tag) = match rest[last_component_start..].find(':') {
Some(offset) => {
let i = last_component_start + offset;
(&rest[..i], Some(&rest[i + 1..]))
}
None => (rest, None),
};
if let Some(tag) = tag {
check_part(tag, "tag", true, MAX_PART_LEN).map_err(fail)?;
}
let components: Vec<&str> = name.split('/').collect();
let (host, path) = match components.split_first() {
Some((first, path)) if !path.is_empty() && is_host_component(first) => (Some(*first), path),
_ => (None, components.as_slice()),
};
if let Some(host) = host {
check_host(host).map_err(fail)?;
}
let (model, namespace) = path.split_last().expect("path has at least the model");
for component in namespace {
check_part(component, "namespace component", false, MAX_PART_LEN).map_err(fail)?;
}
check_part(model, "model", true, MAX_PART_LEN).map_err(fail)?;
let parsed = ParsedRef {
scheme,
host,
namespace: namespace.to_vec(),
model,
tag,
digest,
};
debug_assert_eq!(rejoin(&parsed), reference);
Ok(parsed)
}
fn rejoin(parsed: &ParsedRef<'_>) -> String {
let mut out = String::new();
if let Some(scheme) = parsed.scheme {
out.push_str(scheme);
out.push_str("://");
}
let mut components: Vec<&str> = Vec::new();
components.extend(parsed.host);
components.extend(parsed.namespace.iter().copied());
components.push(parsed.model);
out.push_str(&components.join("/"));
if let Some(tag) = parsed.tag {
out.push(':');
out.push_str(tag);
}
if let Some(digest) = parsed.digest {
out.push('@');
out.push_str(digest);
}
out
}
#[cfg(any(test, feature = "fuzzing"))]
fn assert_parsed_ref_grammar(parsed: &ParsedRef<'_>, reference: &str) {
let assert_name_part = |kind: &str, part: &str, allow_dot: bool, max_len: usize| {
assert_ne!(part, "..", "{reference:?} parsed with a \"..\" {kind}");
assert!(!part.is_empty(), "{reference:?} parsed an empty {kind}");
assert!(
part.len() <= max_len,
"{reference:?} parsed an over-length {kind}: {part:?}"
);
let bytes = part.as_bytes();
assert!(
is_part_first_byte(bytes[0]),
"{reference:?} parsed a {kind} with an invalid first byte: {part:?}"
);
for &b in &bytes[1..] {
assert!(
is_part_byte(b) && (allow_dot || b != b'.'),
"{reference:?} parsed a {kind} with a byte outside its allowlist: {part:?}"
);
}
};
if let Some(scheme) = parsed.scheme {
assert!(
REGISTRY_SCHEMES.contains(&scheme),
"{reference:?} parsed with an unknown scheme: {scheme:?}"
);
}
if let Some(host) = parsed.host {
assert!(
host.len() <= MAX_HOST_LEN,
"{reference:?} parsed an over-length host: {host:?}"
);
let (name, port) = match host.split_once(':') {
Some((name, port)) => (name, Some(port)),
None => (host, None),
};
assert_name_part("host name", name, true, MAX_HOST_LEN);
if let Some(port) = port {
assert!(
!port.is_empty() && port.len() <= 5 && port.bytes().all(|b| b.is_ascii_digit()),
"{reference:?} parsed a host port that is not 1-5 digits: {host:?}"
);
}
}
for ns in &parsed.namespace {
assert_name_part("namespace component", ns, false, MAX_PART_LEN);
}
assert_name_part("model", parsed.model, true, MAX_PART_LEN);
if let Some(tag) = parsed.tag {
assert_name_part("tag", tag, true, MAX_PART_LEN);
}
if let Some(digest) = parsed.digest {
assert_ne!(digest, "..", "{reference:?} parsed with a \"..\" digest");
assert!(
digest.len() <= MAX_PART_LEN,
"{reference:?} parsed an over-length digest: {digest:?}"
);
let Some((algo, hex)) = digest.split_once(':') else {
panic!("{reference:?} parsed a digest without an algo separator: {digest:?}");
};
assert!(
!algo.is_empty()
&& algo
.bytes()
.all(|b| b.is_ascii_lowercase() || b.is_ascii_digit()),
"{reference:?} parsed a digest algorithm that is not [a-z0-9]+: {digest:?}"
);
assert!(
!hex.is_empty() && hex.bytes().all(|b| b.is_ascii_hexdigit()),
"{reference:?} parsed a digest with a non-hex value: {digest:?}"
);
}
}
#[cfg(feature = "fuzzing")]
#[doc(hidden)]
pub fn fuzz_check_parse_registry_ref(reference: &str) {
if let Ok(parsed) = parse_registry_ref(reference) {
assert_parsed_ref_grammar(&parsed, reference);
}
}
#[cfg(feature = "fuzzing")]
#[doc(hidden)]
pub fn fuzz_check_validate_reference(reference: &str) {
if reference.starts_with('/') || PASSTHROUGH_SCHEMES.iter().any(|s| reference.starts_with(s)) {
let _ = validate_reference(reference);
return;
}
if validate_reference(reference).is_ok() {
match parse_registry_ref(reference) {
Ok(parsed) => assert_parsed_ref_grammar(&parsed, reference),
Err(e) => panic!(
"{reference:?}: validate_reference() accepted but parse_registry_ref() \
rejected it: {e}"
),
}
}
}
#[cfg(feature = "fuzzing")]
#[doc(hidden)]
pub fn fuzz_check_resolve_ollama_api(reference: &str) {
let resolved = resolve_ollama_api(reference);
let validated = validate_reference(reference);
assert_eq!(
resolved.is_ok(),
validated.is_ok(),
"{reference:?}: resolve_ollama_api() and validate_reference() disagree: \
resolve_ollama_api={resolved:?}, validate_reference={validated:?}"
);
}
pub fn validate_reference(reference: &str) -> Result<(), InvalidReference> {
validate_reference_parsed(reference).map(|_| ())
}
fn validate_reference_parsed(reference: &str) -> Result<Option<ParsedRef<'_>>, InvalidReference> {
let reject = |detail: &str| {
Err(InvalidReference(format!(
"invalid model reference {reference:?}: {detail}"
)))
};
if reference.trim().is_empty() {
return reject("empty");
}
if reference.starts_with('/') {
if reference.chars().any(|c| c.is_ascii_control()) {
return reject("contains a control character");
}
return Ok(None);
}
for scheme in PASSTHROUGH_SCHEMES {
if let Some(rest) = reference.strip_prefix(scheme) {
if rest.is_empty() {
return reject(&format!("empty reference after {scheme:?} scheme"));
}
if reference.chars().any(|c| c.is_ascii_control()) {
return reject("contains a control character");
}
return Ok(None);
}
}
parse_registry_ref(reference).map(Some)
}
pub fn resolve(reference: &str) -> Result<String, InvalidReference> {
let parsed = validate_reference_parsed(reference)?;
Ok(resolve_inner(reference, parsed))
}
fn resolve_inner(reference: &str, parsed: Option<ParsedRef<'_>>) -> String {
for passthrough in PASSTHROUGH_SCHEMES {
if reference.starts_with(passthrough) {
return reference.to_owned();
}
}
if reference.starts_with('/') {
return reference.to_owned();
}
let reference = if let Some(r) = reference
.strip_prefix("hf://")
.or_else(|| reference.strip_prefix("huggingface://"))
{
r
}
else if let Some(r) = reference.strip_prefix("modelscope://") {
return format!("ms://{r}");
} else if reference.starts_with("ms://") {
return reference.to_owned();
} else {
reference
};
if let Some(mapped) = alias_for(aliases(), reference) {
return mapped.to_string();
}
if parsed.is_some_and(|p| p.host.is_some()) {
return reference.to_owned();
}
format!("hf.co/{reference}")
}
fn is_bare(reference: &str) -> bool {
!reference.contains('/')
}
pub fn resolve_ollama_api(reference: &str) -> Result<String, InvalidReference> {
let parsed = validate_reference_parsed(reference)?;
if is_bare(reference) {
if let Some(target) = alias_for(aliases(), reference).or_else(|| ollama_name(reference)) {
return Ok(target.to_string());
}
return Ok(format!("docker.io/ai/{reference}"));
}
Ok(resolve_inner(reference, parsed))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn validate_reference_accepts_valid_shapes() {
for r in [
"gemma4",
"qwen3.5:0.8B",
"unsloth/Qwen3.5-0.8B-GGUF",
"hf.co/foo/bar",
"localhost:5000/foo/bar:tag",
"docker.io/ai/gemma4@sha256:abc",
"hf://owner/repo",
"ms://x",
"ngc://x",
"s3://b/k",
"gs://b/k",
"s3://bucket/models/qwen/",
"gs://bucket/a/b/",
"ngc://org/team/model",
"/abs/path/model.gguf",
"/models/My Model/x.gguf",
] {
assert!(validate_reference(r).is_ok(), "{r:?} should be accepted");
}
}
#[test]
fn validate_reference_rejects_bad_shapes() {
for r in [
"",
" ",
"oci://",
"http://x",
"hf://",
"a\tb",
"/abs/pa\tth",
"s3://",
"s3://bucket/k\tey",
"../../../etc/passwd",
"a/../b",
"docker.io/ai/%2e%2e",
"hf:///foo",
"ms:///x",
"hf.co//foo",
"owner//repo",
"trailing/slash/",
"hf.co/owner/repo?expand[]=siblings",
"hf.co/owner/repo#frag",
"a b",
"model:",
"m:t:x",
"a@b/c",
"m@sha256:abc:tag",
] {
assert!(validate_reference(r).is_err(), "{r:?} should be rejected");
}
}
#[test]
fn validate_reference_rejects_over_length_parts() {
assert!(validate_reference(&format!("{}.com/ns/model", "a".repeat(350))).is_err());
assert!(validate_reference(&format!("{}.com/ns/model", "a".repeat(346))).is_ok());
assert!(validate_reference(&"a".repeat(129)).is_err());
assert!(validate_reference(&"a".repeat(128)).is_ok());
assert!(validate_reference(&format!("model:{}", "t".repeat(129))).is_err());
assert!(validate_reference(&format!("hf.co/{}/model", "n".repeat(129))).is_err());
}
#[test]
fn validate_reference_accepts_long_real_model_names() {
for r in [
"hf.co/DavidAU/Qwen3.6-40B-Claude-4.6-Opus-Deckard-Heretic-Uncensored-Thinking-NEO-CODE-Di-IMatrix-MAX-GGUF",
"hf.co/mradermacher/Llama3.3-8B-Instruct-Thinking-Heretic-Uncensored-Claude-4.5-Opus-High-Reasoning-i1-GGUF",
] {
assert!(validate_reference(r).is_ok(), "{r:?} should be accepted");
}
}
#[test]
fn validate_reference_rejects_dotted_namespace_components() {
assert!(validate_reference("hf.co/own.er/repo").is_err());
assert!(validate_reference("docker.io/a.i/gemma4").is_err());
assert!(validate_reference("hf.co/owner/re.po").is_ok());
assert!(validate_reference("qwen3.5:0.8B").is_ok());
}
#[test]
fn validate_reference_rejects_malformed_digests() {
for r in [
"docker.io/ai/gemma4@sha256",
"docker.io/ai/gemma4@sha256:",
"docker.io/ai/gemma4@:abc",
"docker.io/ai/gemma4@sha256:xyz-nonhex",
"docker.io/ai/gemma4@SHA256:abc",
"docker.io/ai/gemma4@",
] {
assert!(validate_reference(r).is_err(), "{r:?} should be rejected");
}
assert!(validate_reference("docker.io/ai/gemma4@sha256:ABCDEF").is_ok());
assert!(validate_reference("docker.io/ai/gemma4:tag@sha256:abc").is_ok());
}
#[test]
fn validate_reference_applies_the_port_rule() {
assert!(validate_reference("localhost:5000/x").is_ok());
assert!(validate_reference("host.example:99999/x").is_ok());
assert!(validate_reference("host.example:999999/x").is_err());
assert!(validate_reference("localhost:/x").is_err());
assert!(validate_reference("host.example:8o80/x").is_err());
}
#[test]
fn parse_registry_ref_parts_rejoin_to_the_input() {
for r in [
"gemma4",
"qwen3.5:0.8B",
"unsloth/Qwen3.5-0.8B-GGUF",
"hf.co/foo/bar",
"localhost:5000/foo/bar:tag",
"docker.io/ai/gemma4@sha256:abc",
"docker.io/ai/gemma4:tag@sha256:ABCDEF",
"hf://owner/repo",
"huggingface://owner/repo",
"hf://hf.co/owner/repo",
"ms://owner/repo",
"modelscope://owner/repo",
"example.com:5000/ns/model:tag",
"localhost/ns/model",
] {
let parsed = parse_registry_ref(r).unwrap_or_else(|e| panic!("{e}"));
let mut rejoined = String::new();
if let Some(scheme) = parsed.scheme {
rejoined.push_str(scheme);
rejoined.push_str("://");
}
let mut components: Vec<&str> = Vec::new();
components.extend(parsed.host);
components.extend(&parsed.namespace);
components.push(parsed.model);
rejoined.push_str(&components.join("/"));
if let Some(tag) = parsed.tag {
rejoined.push(':');
rejoined.push_str(tag);
}
if let Some(digest) = parsed.digest {
rejoined.push('@');
rejoined.push_str(digest);
}
assert_eq!(rejoined, r);
}
}
#[test]
fn parse_registry_ref_holds_the_part_invariants() {
let long = "a".repeat(400);
let nasty = [
"../../../etc/passwd".to_owned(),
"a/../b".to_owned(),
"hf.co/../x".to_owned(),
"hf://../x".to_owned(),
"%2e%2e/x".to_owned(),
"a?b".to_owned(),
"a#b".to_owned(),
"a b".to_owned(),
"a\tb".to_owned(),
"a\0b".to_owned(),
":/x".to_owned(),
"://x".to_owned(),
"x@sha256:..".to_owned(),
"x:..".to_owned(),
long.clone(),
format!("{long}/m"),
format!("{long}.com/m"),
format!("m:{long}"),
format!("m@sha256:{long}"),
format!("hf.co/{long}/m"),
"hf.co/owner/repo".to_owned(),
"qwen3.5:0.8B".to_owned(),
];
for r in &nasty {
let Ok(parsed) = parse_registry_ref(r) else {
continue;
};
assert_parsed_ref_grammar(&parsed, r);
}
}
#[test]
fn parse_registry_ref_oracle_holds_on_the_seed_corpus() {
let dir =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/parse_registry_ref");
let mut seeds = 0usize;
for entry in std::fs::read_dir(&dir).expect("read the seed corpus directory") {
let path = entry.expect("read a corpus directory entry").path();
let data = std::fs::read(&path).unwrap_or_else(|e| panic!("read {path:?}: {e}"));
seeds += 1;
let Ok(s) = std::str::from_utf8(&data) else {
continue;
};
if let Ok(parsed) = parse_registry_ref(s) {
assert_parsed_ref_grammar(&parsed, s);
}
}
assert!(seeds > 0, "seed corpus at {dir:?} is empty");
}
#[test]
fn validate_reference_oracle_holds_on_the_seed_corpus() {
let dir =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/validate_reference");
let mut seeds = 0usize;
for entry in std::fs::read_dir(&dir).expect("read the seed corpus directory") {
let path = entry.expect("read a corpus directory entry").path();
let data = std::fs::read(&path).unwrap_or_else(|e| panic!("read {path:?}: {e}"));
seeds += 1;
let Ok(s) = std::str::from_utf8(&data) else {
continue;
};
if s.starts_with('/') || PASSTHROUGH_SCHEMES.iter().any(|p| s.starts_with(p)) {
let _ = validate_reference(s);
continue;
}
if validate_reference(s).is_ok() {
let parsed = parse_registry_ref(s).unwrap_or_else(|e| {
panic!("{s:?}: validate_reference() accepted but parse_registry_ref() rejected it: {e}")
});
assert_parsed_ref_grammar(&parsed, s);
}
}
assert!(seeds > 0, "seed corpus at {dir:?} is empty");
}
#[test]
fn resolve_ollama_api_oracle_holds_on_the_seed_corpus() {
let dir =
std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("fuzz/corpus/resolve_ollama_api");
let mut seeds = 0usize;
for entry in std::fs::read_dir(&dir).expect("read the seed corpus directory") {
let path = entry.expect("read a corpus directory entry").path();
let data = std::fs::read(&path).unwrap_or_else(|e| panic!("read {path:?}: {e}"));
seeds += 1;
let Ok(s) = std::str::from_utf8(&data) else {
continue;
};
assert_eq!(
resolve_ollama_api(s).is_ok(),
validate_reference(s).is_ok(),
"{s:?}: resolve_ollama_api() and validate_reference() disagree"
);
}
assert!(seeds > 0, "seed corpus at {dir:?} is empty");
}
#[test]
fn resolve_ollama_api_defaults_bare_names_to_docker_ai() {
assert_eq!(resolve_ollama_api("gemma4").unwrap(), "docker.io/ai/gemma4");
assert_eq!(
resolve_ollama_api("gemma4:e4b").unwrap(),
"docker.io/ai/gemma4:e4b"
);
assert_eq!(
resolve_ollama_api("qwen3.5").unwrap(),
"docker.io/ai/qwen3.5"
);
assert_eq!(
resolve_ollama_api("qwen3.5:0.8B").unwrap(),
"docker.io/ai/qwen3.5:0.8B"
);
}
#[test]
fn resolve_ollama_api_maps_the_ollama_embedding_names() {
for (name, target) in [
("nomic-embed-text", "docker.io/ai/nomic-embed-text-v1.5"),
(
"nomic-embed-text:latest",
"docker.io/ai/nomic-embed-text-v1.5",
),
("bge-m3", "hf.co/ggml-org/bge-m3-Q8_0-GGUF"),
("bge-m3:latest", "hf.co/ggml-org/bge-m3-Q8_0-GGUF"),
(
"nomic-embed-text:v1.5",
"docker.io/ai/nomic-embed-text:v1.5",
),
("bge-m3-large", "docker.io/ai/bge-m3-large"),
] {
assert_eq!(resolve_ollama_api(name).unwrap(), target, "{name}");
}
}
#[test]
fn a_configured_alias_answers_name_latest_too_and_exact_entries_win() {
let aliases = HashMap::from([
("bge-m3".to_string(), "hf.co/acme/custom".to_string()),
("gemma4:latest".to_string(), "hf.co/acme/pinned".to_string()),
("gemma4".to_string(), "hf.co/acme/floating".to_string()),
]);
for (reference, target) in [
("bge-m3", Some("hf.co/acme/custom")),
("bge-m3:latest", Some("hf.co/acme/custom")),
("gemma4", Some("hf.co/acme/floating")),
("gemma4:latest", Some("hf.co/acme/pinned")),
("bge-m3:v2", None),
("other", None),
] {
assert_eq!(alias_for(&aliases, reference), target, "{reference}");
}
}
#[test]
fn resolve_ollama_api_leaves_structured_references_to_resolve() {
assert_eq!(
resolve_ollama_api("unsloth/Qwen3.5-0.8B-GGUF").unwrap(),
resolve("unsloth/Qwen3.5-0.8B-GGUF").unwrap()
);
assert_eq!(
resolve_ollama_api("hf.co/foo/bar").unwrap(),
"hf.co/foo/bar"
);
assert_eq!(
resolve_ollama_api("docker.io/ai/gemma4").unwrap(),
"docker.io/ai/gemma4"
);
}
#[test]
fn resolve_ollama_api_matches_resolve_for_uri_schemes_and_paths() {
assert_eq!(
resolve_ollama_api("hf://unsloth/Qwen3.5-0.8B-GGUF").unwrap(),
resolve("hf://unsloth/Qwen3.5-0.8B-GGUF").unwrap()
);
assert_eq!(
resolve_ollama_api("/abs/path/model.gguf").unwrap(),
"/abs/path/model.gguf"
);
}
#[test]
fn is_bare_rejects_only_slashes() {
assert!(is_bare("gemma4"));
assert!(is_bare("gemma4:e4b"));
assert!(!is_bare("unsloth/gemma4"));
assert!(is_bare("qwen3.5"));
assert!(is_bare("qwen3.5:0.8B"));
assert!(!is_bare("hf.co/gemma4"));
}
#[test]
fn resolve_fills_in_default_registry_like_ollama_parse_name() {
assert_eq!(
resolve_ollama_api("mistral").unwrap(),
"docker.io/ai/mistral"
);
assert_eq!(
resolve_ollama_api("mistral:7b").unwrap(),
"docker.io/ai/mistral:7b"
);
assert_eq!(resolve("namespace/model").unwrap(), "hf.co/namespace/model");
assert_eq!(
resolve("example.com/ns/model:tag").unwrap(),
"example.com/ns/model:tag"
);
assert_eq!(
resolve("example.com:5000/ns/model:tag").unwrap(),
"example.com:5000/ns/model:tag"
);
assert_eq!(resolve("localhost/ns/model").unwrap(), "localhost/ns/model");
assert_eq!(resolve("a/b/c").unwrap(), "hf.co/a/b/c");
assert_eq!(resolve("hf://a/b/c").unwrap(), "hf.co/a/b/c");
}
#[test]
fn resolve_splits_uri_schemes_like_ollama_parse_name() {
assert_eq!(resolve("hf://owner/repo").unwrap(), "hf.co/owner/repo");
assert_eq!(
resolve("huggingface://owner/repo").unwrap(),
"hf.co/owner/repo"
);
assert_eq!(
resolve("hf://hf.co/owner/repo").unwrap(),
"hf.co/owner/repo"
);
assert_eq!(
resolve("modelscope://owner/repo").unwrap(),
"ms://owner/repo"
);
assert_eq!(resolve("ms://owner/repo").unwrap(), "ms://owner/repo");
assert_eq!(resolve("s3://bucket/key").unwrap(), "s3://bucket/key");
assert_eq!(resolve("gs://bucket/key").unwrap(), "gs://bucket/key");
assert_eq!(resolve("ngc://org/model").unwrap(), "ngc://org/model");
}
#[test]
fn resolve_requires_a_slash_to_treat_a_component_as_a_host() {
assert_eq!(resolve("qwen3.5:0.8B").unwrap(), "hf.co/qwen3.5:0.8B");
assert_eq!(resolve("qwen3.5").unwrap(), "hf.co/qwen3.5");
assert_eq!(resolve("hf.co/foo/bar").unwrap(), "hf.co/foo/bar");
assert_eq!(resolve("localhost/foo").unwrap(), "localhost/foo");
assert_eq!(
resolve("unsloth/Qwen3.5-0.8B-GGUF").unwrap(),
"hf.co/unsloth/Qwen3.5-0.8B-GGUF"
);
}
#[test]
fn resolve_recognizes_an_explicit_port_as_a_host() {
assert_eq!(
resolve("localhost:5000/foo/bar").unwrap(),
"localhost:5000/foo/bar"
);
assert_eq!(
resolve("registry.example.com:5000/foo").unwrap(),
"registry.example.com:5000/foo"
);
assert_eq!(
resolve("localhost:5000/foo/bar:tag").unwrap(),
"localhost:5000/foo/bar:tag"
);
}
#[test]
fn resolve_and_resolve_ollama_api_reject_invalid_references() {
assert!(resolve("hf:///foo").is_err());
assert!(resolve("hf.co//foo").is_err());
assert!(resolve_ollama_api("hf.co//foo").is_err());
assert!(resolve_ollama_api("ms:///x").is_err());
assert_eq!(resolve("hf://owner/repo").unwrap(), "hf.co/owner/repo");
assert_eq!(resolve_ollama_api("gemma4").unwrap(), "docker.io/ai/gemma4");
}
#[test]
fn validate_reference_rejects_malformed_scheme_prefixes() {
assert!(validate_reference("http:/evil.test/x").is_err());
assert!(validate_reference("oci:/registry/ns/model").is_err());
assert!(validate_reference("hf:/owner/repo").is_err());
assert!(validate_reference("http://evil.test/x").is_err());
assert!(validate_reference("oci://registry/ns/model").is_err());
assert!(validate_reference("1a://evil.test/x").is_err());
assert!(validate_reference("my_scheme://x").is_err());
assert!(validate_reference("://x").is_err());
assert!(validate_reference("1a:/evil.test/x").is_err());
assert!(validate_reference(":/x").is_err());
assert!(validate_reference("localhost:/foo").is_err());
assert!(validate_reference("hf://owner/repo").is_ok());
assert!(validate_reference("s3://bucket/models/qwen/").is_ok());
assert!(validate_reference("localhost:5000/foo/bar:tag").is_ok());
assert!(validate_reference("docker.io/ai/gemma4@sha256:abc").is_ok());
assert!(validate_reference("qwen3.5:0.8B").is_ok());
}
}