Skip to content

The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.

16.8 KB
Raw Blame
use super::*;
use tinyinference_llm::providers::overrides::{ChatModelEntry, ProviderModelMetadata};

#[test]
fn absent_provider_keeps_default_absent_and_concrete_model_ids_verbatim() {
    assert_eq!(
        crate::inference::registry::provider_default_model("missing-provider"),
        None
    );
    let config = Config::default();
    assert_eq!(
        resolve_provider_model_hint("missing-provider", "vendor/model-id", &config),
        "vendor/model-id"
    );
}

#[test]
fn abstract_hint_markers_do_not_become_raw_model_ids() {
    assert!(is_abstract_model("missing-provider", "hint:unknown"));
    assert!(!is_raw_model("missing-provider", "hint:unknown"));
    assert!(is_raw_model("missing-provider", "vendor/model-id"));
    assert!(is_raw_model("missing-provider", "chat"));
    assert!(is_raw_model("missing-provider", "coding"));
    assert_eq!(
        role_for_provider_model("missing-provider", "hint:coding"),
        "coding"
    );
    assert_eq!(
        role_for_provider_model("missing-provider", "hint:unknown"),
        "chat"
    );
}

#[test]
fn registered_model_defaults_and_aliases_are_context_scoped() {
    use crate::core::slots::Extensions;
    use crate::inference::registry::register_chat_model_in;
    use std::sync::Arc;

    let extensions = Extensions::new();
    register_chat_model_in(
        &extensions,
        crate::inference::provider::factory::PROVIDER_OPENHUMAN,
        ChatModelEntry {
            build: Arc::new(|_| panic!("metadata-only provider entry")),
            probe: None,
            models: Some(ProviderModelMetadata {
                default_model: Arc::new(|| Some("scoped/model".to_string())),
                role_for_model: Arc::new(|model| {
                    (model == "scoped-alias").then(|| "reasoning".to_string())
                }),
                is_alias: Arc::new(|model| model == "scoped-alias"),
                is_raw_model: Arc::new(|model| model == "scoped/model"),
                supports_vision: Arc::new(|_| false),
                resolve_model: Arc::new(|role, _, override_model| {
                    (override_model == Some("scoped-alias")).then(|| format!("scoped-{role}"))
                }),
                context_window: Arc::new(|model| match model {
                    "" => Some(99_999),
                    "scoped/model" => Some(77_777),
                    "hint:reasoning" => Some(88_888),
                    _ => None,
                }),
                default_pricing: Arc::new(|| None),
                without_reasoning: Arc::new(|request| request),
            }),
        },
    );
    assert_eq!(
        crate::inference::registry::provider_default_model_for(
            Some(&extensions),
            crate::inference::provider::factory::PROVIDER_OPENHUMAN
        )
        .as_deref(),
        Some("scoped/model")
    );
    assert_eq!(
        crate::inference::context_window::project_context_window_for_model(
            "scoped/model",
            Some(Some(&extensions))
        )
        .window,
        Some(77_777)
    );
    assert_eq!(
        crate::inference::context_window::project_context_window_for_model(
            "hint:reasoning",
            Some(Some(&extensions))
        )
        .window,
        Some(88_888),
        "a registered provider hook can override a workload tier alias"
    );
    assert_eq!(
        crate::inference::context_window::project_context_window_for_model(
            "   ",
            Some(Some(&extensions))
        )
        .window,
        None,
        "blank model IDs do not query provider hooks or the catalog"
    );
    let context = crate::core::runtime::CoreContext::for_test_with_extensions(
        crate::core::runtime::DomainSet::full(),
        None,
        extensions.clone(),
    );

    assert_eq!(
        crate::inference::registry::provider_default_model(
            crate::inference::provider::factory::PROVIDER_OPENHUMAN
        ),
        None
    );
    crate::core::runtime::CoreContext::sync_scope(context, || {
        assert_eq!(
            crate::inference::context_window::project_context_window_for_model(
                "scoped/model",
                None
            )
            .window,
            Some(77_777),
            "the ambient projection uses the active provider registry"
        );
        assert_ne!(
            crate::inference::context_window::project_context_window_for_model(
                "scoped/model",
                Some(None)
            )
            .window,
            Some(77_777),
            "an explicit process-only projection does not borrow ambient context"
        );
        let empty_extensions = Extensions::new();
        assert_ne!(
            crate::inference::context_window::project_context_window_for_model(
                "scoped/model",
                Some(Some(&empty_extensions))
            )
            .window,
            Some(77_777),
            "an explicit empty context does not borrow the ambient provider registration"
        );
        assert_eq!(
            crate::inference::registry::provider_default_model(
                crate::inference::provider::factory::PROVIDER_OPENHUMAN
            )
            .as_deref(),
            Some("scoped/model")
        );
        assert_eq!(
            crate::inference::registry::provider_model_role(
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias"
            )
            .as_deref(),
            Some("reasoning")
        );
        assert_eq!(
            role_for_provider_model(
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias"
            ),
            "reasoning",
            "the public resolver must use the ambient context registration"
        );
        assert_eq!(
            role_for_provider_model_for(
                Some(&extensions),
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias",
            ),
            "reasoning",
            "an explicit context must use that context's provider hooks"
        );
        assert_eq!(
            role_for_provider_model_for(
                None,
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias",
            ),
            "chat",
            "explicit process-only lookup must not borrow the ambient provider hook"
        );
        assert_eq!(
            resolve_provider_model_hint(
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias",
                &Config::default(),
            ),
            "scoped-reasoning",
            "the public hint resolver must preserve ambient route and model hooks"
        );
        assert_eq!(
            resolve_provider_model_hint_for(
                None,
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias",
                &Config::default(),
            ),
            "scoped-alias",
            "explicit process-only hint resolution must not borrow ambient hooks"
        );
        assert_eq!(
            resolve_provider_model_hint_for(
                Some(&extensions),
                crate::inference::provider::factory::PROVIDER_OPENHUMAN,
                "scoped-alias",
                &Config::default(),
            ),
            "scoped-reasoning",
            "explicit context hint resolution must use that context's hooks"
        );
    });
    assert_eq!(
        crate::inference::registry::provider_default_model(
            crate::inference::provider::factory::PROVIDER_OPENHUMAN
        ),
        None
    );
}

#[test]
fn native_provider_metadata_resolves_by_context_and_preserves_request_fields() {
    use crate::core::slots::Extensions;
    use crate::inference::registry::{
        register_chat_model, register_chat_model_in, unregister_chat_model, ProviderContext,
    };
    use serde_json::json;
    use std::sync::Arc;

    fn entry(label: &'static str, window: u64) -> ChatModelEntry<ProviderContext> {
        ChatModelEntry {
            build: Arc::new(|_| panic!("metadata lookup must not build a model")),
            probe: None,
            models: Some(ProviderModelMetadata {
                default_model: Arc::new(move || Some(format!("{label}/default"))),
                role_for_model: Arc::new(move |model| {
                    (model == format!("{label}/alias")).then(|| format!("{label}/role"))
                }),
                is_alias: Arc::new(move |model| model == format!("{label}/alias")),
                is_raw_model: Arc::new(move |model| model == format!("{label}/raw")),
                supports_vision: Arc::new(move |model| model == format!("{label}/vision")),
                resolve_model: Arc::new(move |role, context: &ProviderContext, pin| {
                    Some(format!(
                        "{label}:{}:{}",
                        context.config.default_model.as_deref().unwrap_or("unset"),
                        pin.unwrap_or(role)
                    ))
                }),
                context_window: Arc::new(move |model| {
                    (model == format!("{label}/raw")).then_some(window)
                }),
                default_pricing: Arc::new(move || Some((format!("{label}/priced"), 1.25, 2.5))),
                without_reasoning: Arc::new(move |mut request| {
                    request.metadata["reasoning_removed_by"] = json!(label);
                    request
                }),
            }),
        }
    }

    let _guard = crate::inference::inference_test_guard();
    let provider = "provider-metadata-scope-regression";
    let process = entry("process", 101);
    register_chat_model(provider, process);
    let a_extensions = Extensions::new();
    register_chat_model_in(&a_extensions, provider, entry("context-a", 202));
    let b_extensions = Extensions::new();
    register_chat_model_in(&b_extensions, provider, entry("context-b", 303));

    let verify = |extensions: Option<&Extensions>, label: &str, window: u64| {
        assert_eq!(
            crate::inference::registry::provider_default_model_for(extensions, provider).as_deref(),
            Some(format!("{label}/default").as_str())
        );
        assert_eq!(
            crate::inference::registry::provider_model_role_for(
                extensions,
                provider,
                &format!("{label}/alias")
            )
            .as_deref(),
            Some(format!("{label}/role").as_str())
        );
        assert!(crate::inference::registry::provider_model_is_alias_for(
            extensions,
            provider,
            &format!("{label}/alias")
        ));
        assert!(
            crate::inference::registry::provider_model_supports_vision_for(
                extensions,
                provider,
                &format!("{label}/vision")
            )
        );
        let config = Config {
            default_model: Some(format!("{label}/config")),
            ..Config::default()
        };
        assert_eq!(
            crate::inference::registry::resolve_provider_model_for(
                extensions,
                provider,
                "chat",
                &config,
                Some("pin")
            ),
            Some(format!("{label}:{label}/config:pin"))
        );
        assert_eq!(
            crate::inference::registry::provider_model_context_window_for(
                extensions,
                provider,
                &format!("{label}/raw")
            ),
            Some(window)
        );
        let mut request = tinyinference_llm::model::ModelRequest::new(vec![]);
        request.model = Some(format!("{label}/raw"));
        request.max_tokens = Some(37);
        request.metadata = json!({"caller": "kept"});
        let ambient_extensions = extensions.cloned().unwrap_or_else(Extensions::new);
        let ambient = crate::core::runtime::CoreContext::for_test_with_extensions(
            crate::core::runtime::DomainSet::full(),
            None,
            ambient_extensions,
        );
        crate::core::runtime::CoreContext::sync_scope(ambient, || {
            assert!(crate::inference::registry::provider_model_is_raw(
                provider,
                &format!("{label}/raw")
            ));
            assert_eq!(
                crate::inference::registry::provider_default_pricing(provider),
                Some((format!("{label}/priced"), 1.25, 2.5))
            );
            let mut request = tinyinference_llm::model::ModelRequest::new(vec![]);
            request.model = Some(format!("{label}/raw"));
            request.max_tokens = Some(37);
            request.metadata = json!({"caller": "kept"});
            let request =
                crate::inference::registry::provider_request_without_reasoning(provider, request);
            assert_eq!(
                request.model.as_deref(),
                Some(format!("{label}/raw").as_str())
            );
            assert_eq!(request.max_tokens, Some(37));
            assert_eq!(
                request.metadata,
                json!({"caller": "kept", "reasoning_removed_by": label})
            );
        });
    };

    verify(None, "process", 101);
    let empty_extensions = Extensions::new();
    verify(Some(&empty_extensions), "process", 101);
    verify(Some(&a_extensions), "context-a", 202);
    verify(Some(&b_extensions), "context-b", 303);

    let ambient_a = crate::core::runtime::CoreContext::for_test_with_extensions(
        crate::core::runtime::DomainSet::full(),
        None,
        a_extensions.clone(),
    );
    crate::core::runtime::CoreContext::sync_scope(ambient_a, || {
        assert_eq!(
            crate::inference::registry::provider_default_model(provider).as_deref(),
            Some("context-a/default")
        );
        assert_eq!(
            crate::inference::registry::provider_default_pricing(provider)
                .as_ref()
                .map(|price| price.0.as_str()),
            Some("context-a/priced")
        );
        let request = crate::inference::registry::provider_request_without_reasoning(
            provider,
            tinyinference_llm::model::ModelRequest::new(vec![]),
        );
        assert_eq!(request.metadata["reasoning_removed_by"], "context-a");
        assert_eq!(
            crate::inference::registry::provider_model_context_window_for(
                None,
                provider,
                "process/raw"
            ),
            Some(101),
            "explicit process-only lookup must ignore ambient registration"
        );
    });
    unregister_chat_model(provider);
}

#[test]
fn managed_builder_uses_the_entry_selected_before_metadata_resolution() {
    use crate::core::slots::Extensions;
    use crate::inference::registry::{register_chat_model_in, ProviderContext};
    use std::sync::Arc;

    let _guard = crate::inference::inference_test_guard();
    let provider = crate::inference::provider::factory::PROVIDER_OPENHUMAN;
    let extensions = Extensions::new();
    let replacement = ChatModelEntry::<ProviderContext> {
        build: Arc::new(|_| {
            Ok((
                Arc::new(tinyagents_harness::testkit::ScriptedModel::replies(vec![
                    "replacement",
                ])),
                "replacement-factory".to_string(),
            ))
        }),
        probe: None,
        models: None,
    };
    let replacement_for_resolver = replacement.clone();
    let extensions_for_resolver = extensions.clone();
    let entry = ChatModelEntry::<ProviderContext> {
        build: Arc::new(|_| {
            Ok((
                Arc::new(tinyagents_harness::testkit::ScriptedModel::replies(vec![
                    "selected",
                ])),
                "selected-factory".to_string(),
            ))
        }),
        probe: None,
        models: Some(ProviderModelMetadata {
            default_model: Arc::new(|| None),
            role_for_model: Arc::new(|_| None),
            is_alias: Arc::new(|_| false),
            is_raw_model: Arc::new(|_| false),
            supports_vision: Arc::new(|_| false),
            resolve_model: Arc::new(move |_, _, _| {
                register_chat_model_in(
                    &extensions_for_resolver,
                    provider,
                    replacement_for_resolver.clone(),
                );
                Some("snapshot/model".to_string())
            }),
            context_window: Arc::new(|_| None),
            default_pricing: Arc::new(|| None),
            without_reasoning: Arc::new(|request| request),
        }),
    };
    register_chat_model_in(&extensions, provider, entry);

    let built = crate::inference::provider::factory::make_openhuman_backend_model_for_thread_in(
        Some(&extensions),
        "chat",
        &Config::default(),
        None,
        true,
        None,
        &crate::security::egress::EgressLedger::none(),
    )
    .expect("the selected entry must remain usable after its registry slot changes");
    assert_eq!(built.1, "selected-factory");
}