Skip to content

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

refactor(inference): update model factory logic and access gates

Steven Enamakelfe6b7d0a9c3c
diff --git a/crates/openhuman-core/src/inference/provider/factory.rs b/crates/openhuman-core/src/inference/provider/factory.rs
index e828bbfe40..8fe0553104 100644
--- a/crates/openhuman-core/src/inference/provider/factory.rs
+++ b/crates/openhuman-core/src/inference/provider/factory.rs
@@ -23,11 +23,11 @@ mod managed_backend;
mod routing;
mod subprocess_providers;
-pub(crate) use chat_model::{resolves_to_managed_backend, OpenHumanModelFactory};
pub use chat_model::{
create_chat_model_from_string, create_chat_model_from_string_with_model_id,
create_chat_model_in, create_chat_model_with_model_id_in, probe_inference_readiness,
};
+pub(crate) use chat_model::{resolves_to_managed_backend, OpenHumanModelFactory};
pub use credentials::{auth_key_for_slug, lookup_key_for_slug};
pub(crate) use credentials::{
openai_bearer_is_oauth, redact_endpoint_origin, resolve_codex_routing,
@@ -55,9 +55,7 @@ pub(crate) use managed_backend::{
make_openhuman_backend_model_for_options, make_openhuman_backend_model_for_thread_in,
make_openhuman_backend_model_in,
};
-use subprocess_providers::{
- build_claude_code_model, claude_agent_sdk_model_from_string,
-};
+use subprocess_providers::{build_claude_code_model, claude_agent_sdk_model_from_string};
use tinyinference_providers::route::split_model_and_temperature;
/// Test-only seam: inject a mock [`ChatModel`] so e2e tests can drive the
diff --git a/crates/openhuman-core/src/inference/provider/factory/access_gates.rs b/crates/openhuman-core/src/inference/provider/factory/access_gates.rs
index e43ae5e410..fccf26feca 100644
--- a/crates/openhuman-core/src/inference/provider/factory/access_gates.rs
+++ b/crates/openhuman-core/src/inference/provider/factory/access_gates.rs
@@ -148,9 +148,7 @@ pub(crate) fn provider_uses_independent_auth(provider: &str) -> bool {
|| tinyinference_providers::route::ProviderRoute::parse(p).is_some_and(|route| {
matches!(
route.kind(),
- RouteKind::Local(_)
- | RouteKind::ClaudeCode
- | RouteKind::ClaudeAgentSdk
+ RouteKind::Local(_) | RouteKind::ClaudeCode | RouteKind::ClaudeAgentSdk
)
})
}
diff --git a/crates/openhuman-core/src/inference/provider/factory/chat_model.rs b/crates/openhuman-core/src/inference/provider/factory/chat_model.rs
index cd20ecfe0c..0011f09482 100644
--- a/crates/openhuman-core/src/inference/provider/factory/chat_model.rs
+++ b/crates/openhuman-core/src/inference/provider/factory/chat_model.rs
@@ -90,19 +90,28 @@ impl OpenHumanModelFactory<'_> {
let extensions = resolved
.as_deref()
.map(crate::core::runtime::CoreContext::extensions);
- let (model, concrete) = super::managed_backend::make_openhuman_backend_model_for_thread_in(
- extensions,
- role,
- self.config,
- (!pin.is_empty()).then_some(pin),
- request.opts.native_tools,
- self.thread_id,
- self.egress,
- )?;
- let concrete = if concrete.trim().is_empty() { pin } else { &concrete };
+ let (model, concrete) =
+ super::managed_backend::make_openhuman_backend_model_for_thread_in(
+ extensions,
+ role,
+ self.config,
+ (!pin.is_empty()).then_some(pin),
+ request.opts.native_tools,
+ self.thread_id,
+ self.egress,
+ )?;
+ let concrete = if concrete.trim().is_empty() {
+ pin
+ } else {
+ &concrete
+ };
return Ok((
model,
- ResolvedModelRoute::new(PROVIDER_OPENHUMAN, concrete, request.route.as_deref().unwrap_or(role)),
+ ResolvedModelRoute::new(
+ PROVIDER_OPENHUMAN,
+ concrete,
+ request.route.as_deref().unwrap_or(role),
+ ),
));
}
@@ -112,7 +121,9 @@ impl OpenHumanModelFactory<'_> {
.map(crate::core::runtime::CoreContext::extensions);
let mut parsed_route = ProviderRoute::parse(&provider);
if parsed_route.is_none()
- && provider.trim().eq_ignore_ascii_case(CLAUDE_AGENT_SDK_PROVIDER)
+ && provider
+ .trim()
+ .eq_ignore_ascii_case(CLAUDE_AGENT_SDK_PROVIDER)
{
parsed_route = Some(ProviderRoute {
provider: CLAUDE_AGENT_SDK_PROVIDER.to_owned(),
@@ -127,13 +138,19 @@ impl OpenHumanModelFactory<'_> {
}
if let Some(route) = parsed_route.as_mut() {
if !pin.is_empty()
- && matches!(route.kind(), RouteKind::ClaudeCode | RouteKind::ClaudeAgentSdk)
+ && matches!(
+ route.kind(),
+ RouteKind::ClaudeCode | RouteKind::ClaudeAgentSdk
+ )
{
route.model = pin.to_owned();
}
}
if let Some(route) = parsed_route.as_ref().filter(|route| {
- matches!(route.kind(), RouteKind::ClaudeCode | RouteKind::ClaudeAgentSdk)
+ matches!(
+ route.kind(),
+ RouteKind::ClaudeCode | RouteKind::ClaudeAgentSdk
+ )
}) {
if route.temperature.is_some() && matches!(route.kind(), RouteKind::ClaudeCode) {
log::warn!(
@@ -148,7 +165,11 @@ impl OpenHumanModelFactory<'_> {
);
let route_kind = route.kind();
let egress_name = match route_kind {
- RouteKind::ClaudeCode => format!("{}{}", tinyagents_harness::providers::claude_code::PROVIDER_PREFIX, effective_model),
+ RouteKind::ClaudeCode => format!(
+ "{}{}",
+ tinyagents_harness::providers::claude_code::PROVIDER_PREFIX,
+ effective_model
+ ),
RouteKind::ClaudeAgentSdk => format!("{CLAUDE_AGENT_SDK_PREFIX}{effective_model}"),
_ => unreachable!("subprocess route was filtered"),
};
@@ -174,73 +195,91 @@ impl OpenHumanModelFactory<'_> {
resolved_model,
request.route.as_deref().unwrap_or(role),
);
- return Ok((with_request_defaults(model, ModelRequestDefaults {
- model: (!route.model.is_empty()).then(|| route.model.clone()),
- temperature: request.opts.temperature,
- }), route));
+ return Ok((
+ with_request_defaults(
+ model,
+ ModelRequestDefaults {
+ model: (!route.model.is_empty()).then(|| route.model.clone()),
+ temperature: request.opts.temperature,
+ },
+ ),
+ route,
+ ));
}
- let (model, route_provider, resolved_model) = match parsed_route.as_ref().map(ProviderRoute::kind) {
- Some(RouteKind::Local(_)) | None
- if tinyinference_local::profile::kind_from_provider_string(&provider).is_some() =>
- {
- let local = try_create_local_runtime_chat_model_from_string(
- role,
- &provider,
- self.config,
- self.egress,
- );
- let (model, resolved) = match local {
- Some(result) => result?,
- None => return Err(unresolved_chat_model_error_for(
+ let (model, route_provider, resolved_model) =
+ match parsed_route.as_ref().map(ProviderRoute::kind) {
+ Some(RouteKind::Local(_)) | None
+ if tinyinference_local::profile::kind_from_provider_string(&provider)
+ .is_some() =>
+ {
+ let local = try_create_local_runtime_chat_model_from_string(
+ role,
+ &provider,
+ self.config,
+ self.egress,
+ );
+ let (model, resolved) = match local {
+ Some(result) => result?,
+ None => {
+ return Err(unresolved_chat_model_error_for(
+ role,
+ &provider,
+ self.config,
+ self.egress,
+ context_extensions,
+ ))
+ }
+ };
+ let provider = model
+ .profile()
+ .and_then(|p| p.provider.clone())
+ .unwrap_or_else(|| "local".into());
+ (model, provider, resolved)
+ }
+ Some(RouteKind::Cloud { .. }) => {
+ let cloud = try_create_cloud_slug_chat_model_from_string_with_native_tools_for(
role,
&provider,
self.config,
+ request.opts.native_tools,
self.egress,
context_extensions,
- )),
- };
- let provider = model
- .profile()
- .and_then(|p| p.provider.clone())
- .unwrap_or_else(|| "local".into());
- (model, provider, resolved)
- }
- Some(RouteKind::Cloud { .. }) => {
- let cloud = try_create_cloud_slug_chat_model_from_string_with_native_tools_for(
- role,
- &provider,
- self.config,
- request.opts.native_tools,
- self.egress,
- context_extensions,
- );
- let (model, resolved) = match cloud {
- Some(result) => result?,
- None => return Err(unresolved_chat_model_error_for(
+ );
+ let (model, resolved) = match cloud {
+ Some(result) => result?,
+ None => {
+ return Err(unresolved_chat_model_error_for(
+ role,
+ &provider,
+ self.config,
+ self.egress,
+ context_extensions,
+ ))
+ }
+ };
+ let route_provider = model
+ .profile()
+ .and_then(|p| p.provider.clone())
+ .unwrap_or_else(|| {
+ parsed_route
+ .as_ref()
+ .expect("parsed cloud route")
+ .provider
+ .clone()
+ });
+ (model, route_provider, resolved)
+ }
+ _ => {
+ return Err(unresolved_chat_model_error_for(
role,
&provider,
self.config,
self.egress,
context_extensions,
- )),
- };
- let route_provider = model
- .profile()
- .and_then(|p| p.provider.clone())
- .unwrap_or_else(|| parsed_route.as_ref().expect("parsed cloud route").provider.clone());
- (model, route_provider, resolved)
- }
- _ => {
- return Err(unresolved_chat_model_error_for(
- role,
- &provider,
- self.config,
- self.egress,
- context_extensions,
- ));
- }
- };
+ ));
+ }
+ };
let route = ResolvedModelRoute::new(
route_provider,
@@ -319,10 +358,12 @@ fn with_request_defaults(
defaults: ModelRequestDefaults,
) -> Arc<dyn ChatModel<()>> {
match model.profile().cloned() {
- Some(profile) => Arc::new(ProfileOverrideModel::new(model, profile).with_defaults(defaults)),
- None => Arc::new(
- ProfileOverrideModel::new_preserving_profile(model).with_defaults(defaults),
- ),
+ Some(profile) => {
+ Arc::new(ProfileOverrideModel::new(model, profile).with_defaults(defaults))
+ }
+ None => {
+ Arc::new(ProfileOverrideModel::new_preserving_profile(model).with_defaults(defaults))
+ }
}
}
@@ -508,10 +549,13 @@ pub(super) fn with_default_temperature(
model: Arc<dyn ChatModel<()>>,
temperature: f64,
) -> Arc<dyn ChatModel<()>> {
- with_request_defaults(model, ModelRequestDefaults {
+ with_request_defaults(
+ model,
+ ModelRequestDefaults {
model: None,
temperature: Some(temperature),
- })
+ },
+ )
}
/// Reproduce the legacy provider factory's access gates and diagnostics for a
diff --git a/crates/openhuman-core/src/inference/provider/factory_crate_native_tests.rs b/crates/openhuman-core/src/inference/provider/factory_crate_native_tests.rs
index 79d034153f..fe5b0654d5 100644
--- a/crates/openhuman-core/src/inference/provider/factory_crate_native_tests.rs
+++ b/crates/openhuman-core/src/inference/provider/factory_crate_native_tests.rs
@@ -203,7 +203,10 @@ async fn one_shot_chat_models_preserve_factory_temperature_as_request_default()
.await
.expect("explicit-temperature invoke");
- assert_eq!(*seen.lock().expect("probe lock"), vec![Some(0.3), Some(0.9)]);
+ assert_eq!(
+ *seen.lock().expect("probe lock"),
+ vec![Some(0.3), Some(0.9)]
+ );
}
// ── Motion B (#4727): managed-backend crate-native routing ──────────────────
diff --git a/crates/openhuman-core/src/inference/turn_models.rs b/crates/openhuman-core/src/inference/turn_models.rs
index dc33966a15..86d2349302 100644
--- a/crates/openhuman-core/src/inference/turn_models.rs
+++ b/crates/openhuman-core/src/inference/turn_models.rs
@@ -151,9 +151,7 @@ fn build_turn_models_crate(
tinyagents_harness::host::ModelBuildRequest {
role: role.to_owned(),
route: Some((*route).to_owned()),
- purpose: tinyagents_harness::host::ModelPurpose::WorkloadTier(
- (*route).to_owned(),
- ),
+ purpose: tinyagents_harness::host::ModelPurpose::WorkloadTier((*route).to_owned()),
model_pin: Some((*route).to_owned()),
opts: opts.clone(),
}
@@ -189,7 +187,11 @@ fn build_turn_models_crate(
.or_else(crate::inference::provider::factory::test_provider_override::current);
let is_injected = injected.is_some();
let profile = model.profile().cloned().unwrap_or_default();
- let selected_model = profile.model.as_deref().filter(|value| !value.is_empty()).unwrap_or("unknown");
+ let selected_model = profile
+ .model
+ .as_deref()
+ .filter(|value| !value.is_empty())
+ .unwrap_or("unknown");
let provider = profile.provider.as_deref().unwrap_or("unknown");
if is_injected {
crate::attachments::provider::wrap_injected(ctx, model, Arc::new(config.clone()))
@@ -540,9 +542,7 @@ impl TurnModelSource {
egress_tag: None,
};
return tinyagents_harness::host::TurnModelSet::<()>::builder(
- &factory,
- &factory,
- &cn.role,
+ &factory, &factory, &cn.role,
)
.primary_model_pin(model)
.primary_opts(opts.clone())
@@ -551,19 +551,20 @@ impl TurnModelSource {
.summarization_opts(opts)
.build()
.map(|built| {
- built.map_models(|_, inner| {
- let profile = inner.profile().cloned().unwrap_or_default();
- let provider = profile.provider.as_deref().unwrap_or("unknown");
- let resolved = profile.model.as_deref().unwrap_or(model);
- crate::attachments::provider::wrap(
- &ctx,
- inner,
- cn.config.clone(),
- resolved,
- provider,
- )
- })
- .summarizer()
+ built
+ .map_models(|_, inner| {
+ let profile = inner.profile().cloned().unwrap_or_default();
+ let provider = profile.provider.as_deref().unwrap_or("unknown");
+ let resolved = profile.model.as_deref().unwrap_or(model);
+ crate::attachments::provider::wrap(
+ &ctx,
+ inner,
+ cn.config.clone(),
+ resolved,
+ provider,
+ )
+ })
+ .summarizer()
});
}
Err(anyhow::anyhow!("turn model source is missing a model"))