The fastest, cheapest, most efficient open-source agent harness. Run more than 500 agents on a $10 VPS.
Rust agent-orchestrationai-agentsai-assistantdesktopllmlocal-firstmcppersonal-aiprivacyrustsecond-braintauri
feat(inference): implement openhuman model factory adapter
Steven Enamakel7d8b2c5588f4
diff --git a/crates/openhuman-core/src/inference/provider/factory/chat_model.rs b/crates/openhuman-core/src/inference/provider/factory/chat_model.rsindex e9d842c14c..cbfc01b260 100644--- a/crates/openhuman-core/src/inference/provider/factory/chat_model.rs+++ b/crates/openhuman-core/src/inference/provider/factory/chat_model.rs@@ -4,8 +4,165 @@use super::*;use crate::config::ops::resolve_primary_cloud_provider_string;use crate::core::runtime::DispatchCtx;-#[cfg(not(test))]use crate::inference::provider::factory::access_gates::verify_session_active;+use tinyagents_harness::host::{+ BuildOpts, ModelBuildGate, ModelBuildRequest, ModelFactory, ModelPurpose,+};+use tinyinference_llm::model::{ModelRequestDefaults, ProfileOverrideModel, ResolvedModelRoute};++/// OpenHuman's host policy and construction adapter for a harness turn.+///+/// The harness owns turn assembly; this adapter resolves OpenHuman provider+/// configuration and enforces product access policy for each requested model.+pub(crate) struct OpenHumanModelFactory<'a> {+ pub(crate) ctx: &'a DispatchCtx,+ pub(crate) config: &'a Config,+ pub(crate) primary_provider: Option<&'a str>,+ pub(crate) egress: &'a EgressLedger,+ pub(crate) thread_id: Option<&'a str>,+}++impl OpenHumanModelFactory<'_> {+ fn provider_for(&self, request: &ModelBuildRequest) -> String {+ match request.purpose {+ ModelPurpose::Primary | ModelPurpose::Summarization => self+ .primary_provider+ .map(str::to_owned)+ .unwrap_or_else(|| provider_for_role(&request.role, self.config)),+ ModelPurpose::WorkloadTier(_) => provider_for_role(&request.role, self.config),+ }+ }++ fn injected(&self, request: &ModelBuildRequest) -> Option<Arc<dyn ChatModel<()>>> {+ let local = self.ctx.host_overrides()?;+ let route = request.route.as_deref();+ match request.purpose {+ ModelPurpose::Primary => local.model_for(&request.role),+ ModelPurpose::Summarization => local+ .role_models+ .get("summarization")+ .cloned()+ .or_else(|| local.model_for(&request.role)),+ ModelPurpose::WorkloadTier(_) => route+ .and_then(|route| local.role_models.get(route))+ .or_else(|| local.role_models.get(&request.role))+ .cloned(),+ }+ }++ fn build_request(+ &self,+ request: &ModelBuildRequest,+ ) -> anyhow::Result<(Arc<dyn ChatModel<()>>, ResolvedModelRoute)> {+ let role = request.role.as_str();+ let pin = request.model_pin.as_deref().unwrap_or("");+ let provider = self.provider_for(request);+ if let Some(model) = self.injected(request) {+ let profile = model.profile().cloned().unwrap_or_default();+ let route = ResolvedModelRoute::new(+ profile.provider.as_deref().unwrap_or("injected"),+ profile.model.as_deref().unwrap_or(pin),+ request.route.as_deref().unwrap_or(role),+ );+ return Ok((model, route));+ }++ if resolves_to_managed_backend(role, self.config)+ || matches!(request.purpose, ModelPurpose::Primary | ModelPurpose::Summarization)+ && provider.trim() == PROVIDER_OPENHUMAN+ {+ let resolved = self.ctx.resolved();+ 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 };+ return Ok((+ model,+ ResolvedModelRoute::new(PROVIDER_OPENHUMAN, concrete, request.route.as_deref().unwrap_or(role)),+ ));+ }++ let (model, route_provider, resolved_model) = if let Some(result) =+ try_create_claude_agent_sdk_chat_model_from_string(role, &provider, self.config, self.egress)+ {+ let model = result?;+ let concrete = if pin.is_empty() { model.profile().and_then(|p| p.model.clone()).unwrap_or_default() } else { pin.to_owned() };+ (model, CLAUDE_AGENT_SDK_PROVIDER.to_owned(), concrete)+ } else if let Some(result) = try_create_claude_code_chat_model_from_string(+ role, &provider, self.config, (!pin.is_empty()).then_some(pin), self.egress,+ ) {+ let (model, _) = result?;+ (model, "claude-code".to_owned(), pin.to_owned())+ } else if let Some(result) = try_create_local_runtime_chat_model(role, self.config, self.egress) {+ let (model, resolved) = result?;+ let provider = model.profile().and_then(|p| p.provider.clone()).unwrap_or_else(|| "local".into());+ (model, provider, resolved)+ } else if let Some(result) = try_create_cloud_slug_chat_model_with_native_tools_for(+ role, self.config, request.opts.native_tools, self.egress,+ self.ctx.resolved().as_deref().map(crate::core::runtime::CoreContext::extensions),+ ) {+ let (model, resolved) = result?;+ let provider = provider.trim().split(':').next().unwrap_or(provider.trim()).to_owned();+ (model, provider, resolved)+ } else {+ let extensions = self.ctx.resolved().as_deref().map(crate::core::runtime::CoreContext::extensions);+ return Err(unresolved_chat_model_error_for(role, &provider, self.config, self.egress, extensions));+ };++ let route = ResolvedModelRoute::new(+ route_provider,+ resolved_model,+ request.route.as_deref().unwrap_or(role),+ );+ Ok((model, route))+ }+}++impl ModelBuildGate for OpenHumanModelFactory<'_> {+ fn check(&self, request: &ModelBuildRequest) -> anyhow::Result<()> {+ // Explicit host model injection is authoritative and has no provider+ // construction, credential, or egress side effect to gate.+ if self.injected(request).is_some() {+ return Ok(());+ }+ let provider = self.provider_for(request);+ enforce_local_only_inference(&request.role, &provider)?;+ crate::inference::provider::factory::access_gates::verify_provider_session(+ self.config,+ &provider,+ )?;+ Ok(())+ }+}++impl ModelFactory<()> for OpenHumanModelFactory<'_> {+ fn build(+ &self,+ request: &ModelBuildRequest,+ ) -> anyhow::Result<(Arc<dyn ChatModel<()>>, ResolvedModelRoute)> {+ let (model, route) = self.build_request(request)?;+ let opts = ModelRequestDefaults {+ model: (!route.model.is_empty()).then(|| route.model.clone()),+ temperature: request.opts.temperature,+ };+ let model = if let Some(profile) = model.profile().cloned() {+ Arc::new(ProfileOverrideModel::new(model, profile).with_defaults(opts))+ as Arc<dyn ChatModel<()>>+ } else {+ model+ };+ Ok((model, route))+ }+}/// Build an `Arc<dyn ChatModel>` for the given workload role, under `ctx`.///