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
Merge branch 'main' into epic-8092-265-routing
Steven Enamakel036ea872a2a2
diff --cc crates/openhuman-core/src/agent/tinyagents/budget.rsindex 663a5e8ac4,908a1e6a83..18c3b14754--- a/crates/openhuman-core/src/agent/tinyagents/budget.rs+++ b/crates/openhuman-core/src/agent/tinyagents/budget.rs@@@ -55,27 -85,18 +85,33 @@@ pub(super) fn install_depthimpl crate::inference::turn_models::TurnModels {/// Wrap every concrete route and summarizer below harness retries/fallback.- pub(crate) fn with_budget(mut self, budget: Option<&ModelBudget>) -> Self {- let Some(budget) = budget else {+ pub(crate) fn with_host_controls(+ mut self,+ budget: Option<&ModelBudget>,+ admission: Option<Arc<dyn PhysicalDispatchAdmission>>,+ ) -> Self {+ if budget.is_none() && admission.is_none() {return self;- };+ }+ if let Some(models) = self.native_model_set.take() {- let models = models.map_models(|_, model| budget.wrap(model));++ let models = models.map_models(|_, model| {++ ModelBudget::control(model, budget, admission.clone())++ });+ let mut registrations = models.registrations("primary").into_iter();+ self.primary = registrations+ .next()+ .expect("native turn set contains its primary")+ .1;+ self.routes = registrations.collect();+ self.summarizer = models.summarizer();+ self.error_slot = models.primary_error_slot();+ self.native_model_set = Some(models);+ return self;+ }- self.primary = budget.wrap(self.primary);- self.summarizer = budget.wrap(self.summarizer);+ self.primary = ModelBudget::control(self.primary, budget, admission.clone());+ self.summarizer = ModelBudget::control(self.summarizer, budget, admission.clone());for (_, route) in &mut self.routes {- *route = budget.wrap(route.clone());+ *route = ModelBudget::control(route.clone(), budget, admission.clone());}self}diff --cc crates/openhuman-core/src/agent/tinyagents/context_wiring.rsindex 79b618f305,7689dc0eb0..cd3bf8aa97--- a/crates/openhuman-core/src/agent/tinyagents/context_wiring.rs+++ b/crates/openhuman-core/src/agent/tinyagents/context_wiring.rs@@@ -122,9 -172,10 +171,10 @@@ fn compression_middlewarepolicy: SummarizationPolicy,strategy: crate::config::CompactionStrategy,context_window: Option<u64>,- summarizer_model: TurnChatModel,+ summarizer_model: Arc<dyn tinyinference_llm::model::ChatModel<()>>,model: &str,memory_turn: Option<Arc<crate::memory::lifecycle::hooks::MemoryTurn>>,+ compaction_notice: Option<CompactionNotice>,) -> ContextCompressionMiddleware {let window = context_window.filter(|w| *w > 0);match strategy {diff --cc crates/openhuman-core/src/agent_runs/agent_chat/mod.rsindex 25d2b59fe5,0000000000..c41ca46d2fmode 100644,000000..100644--- a/crates/openhuman-core/src/agent_runs/agent_chat/mod.rs+++ b/crates/openhuman-core/src/agent_runs/agent_chat/mod.rs@@@ -1,15 -1,0 +1,15 @@@+//! Full agent chat turns and their shared turn guards.++mod attachments;+mod controllers;+mod envelope;+pub(crate) mod guards;+pub(crate) mod params;+mod session_turn;++pub use envelope::AgentChatReply;+pub use session_turn::{- agent_chat, agent_chat_for, agent_chat_reply_for, AgentChatEnv, AgentChatTarget,++ agent_chat, agent_chat_for, agent_chat_reply_for, agent_chat_reply_for_controlled, AgentChatEnv, AgentChatTarget,+};++pub(crate) use controllers::all_registered_controllers as all_inference_agent_chat_registered_controllers;diff --cc crates/openhuman-core/src/agent_runs/agent_chat/session_turn.rsindex e8553095ec,9983223bfe..1b58c94585--- a/crates/openhuman-core/src/agent_runs/agent_chat/session_turn.rs+++ b/crates/openhuman-core/src/agent_runs/agent_chat/session_turn.rs@@@ -429,22 -508,41 +463,23 @@@ pub async fn agent_chat_reply_for_contragent.set_thread_id(Some(id));log::debug!("[inference] agent_chat bound session for thread_id={id}");}- // Host attachments, staged where the provider will look for them: the- // turn's root when it has one, the configured `action_dir` otherwise.- // Their references lead the message, so the model reads the files first- // and the caption after, as an upload with a caption reads.- let staged_message;- let message = match target {+ // Host attachments are staged where the provider will look for them: the+ // turn root, or the configured action directory when no root was supplied.+ let staged_message = match target {AgentChatTarget::Definition { attachments, .. } if !attachments.is_empty() => {- let staging_config = match turn_cwd.as_ref() {- Some(root) => {- let mut scoped = config.clone();- scoped.action_dir = root.clone();- scoped- }- None => config.clone(),- };- let scope = crate::attachments::AttachmentAccessScope {- external_channel: false,- workspace: turn_cwd.clone(),- };- let references = crate::attachments::host::stage_host(+ super::attachments::stage_host_attachments(attachments,turn_session_id.unwrap_or("direct"),- &staging_config,- &scope,+ config,+ turn_cwd.clone(),+ message,)- .await?- .await?;- log::debug!(- "[inference] agent_chat staged {} host attachment(s)",- attachments.len()- );- staged_message = format!("{references}{message}");- staged_message.as_str()++ .await++ .map_err(anyhow::Error::msg)?}- _ => message,+ _ => message.to_string(),};+ let message = staged_message.as_str();if let AgentChatTarget::Definition {untrusted_input: true,..diff --cc crates/openhuman-core/src/channels/tests/runtime_debounce.rsindex 0000000000,6fc0794f88..e7b6cad3e5mode 000000,100644..100644--- a/crates/openhuman-core/src/channels/tests/runtime_debounce.rs+++ b/crates/openhuman-core/src/channels/tests/runtime_debounce.rs@@@ -1,0 -1,432 +1,431 @@@+ use super::super::context::{ChannelRuntimeContext, CHANNEL_MESSAGE_TIMEOUT_SECS};+ use super::super::runtime::{run_message_dispatch_loop, RuntimeChannelMessage};+ use super::super::Channel;+ use super::common::{RecordingChannel, SlowModel, TelegramRecordingChannel};+ use crate::agent::bus::{mock_agent_run_turn, AgentTurnRequest, AgentTurnResponse};+ use crate::config::InboundDebounceConfig;+ use crate::core::bus_testing::MockBusGuard;-use crate::inference::provider;+ use std::collections::HashMap;+ use std::sync::atomic::{AtomicUsize, Ordering};+ use std::sync::{Arc, Mutex};+ use std::time::Duration;+ use tinychannels_bus as traits;+ use tinychannels_bus::module_inbound::PreparedChannelInbound;+ use tokio::sync::{mpsc, Notify};+ use tokio::task::JoinHandle;++ #[derive(Default)]+ struct Turns {+ histories: Mutex<Vec<Vec<(String, String)>>>,+ active: AtomicUsize,+ peak: AtomicUsize,+ }++ impl Turns {+ fn count(&self) -> usize {+ self.histories.lock().unwrap().len()+ }++ fn last_user(&self, turn: usize) -> String {+ let histories = self.histories.lock().unwrap();+ histories[turn]+ .iter()+ .rev()+ .find(|(role, _)| role == "user")+ .map(|(_, content)| content.clone())+ .unwrap_or_default()+ }++ fn history(&self, turn: usize) -> Vec<(String, String)> {+ self.histories.lock().unwrap()[turn].clone()+ }+ }++ async fn install_handler(turns: Arc<Turns>, gate: Option<Arc<Notify>>) -> MockBusGuard {+ mock_agent_run_turn(move |req: AgentTurnRequest| {+ let turns = Arc::clone(&turns);+ let gate = gate.clone();+ async move {+ let index = {+ let mut histories = turns.histories.lock().unwrap();+ histories.push(+ req.history+ .iter()+ .map(|m| (m.role.clone(), m.content.clone()))+ .collect(),+ );+ histories.len()+ };+ let active = turns.active.fetch_add(1, Ordering::SeqCst) + 1;+ turns.peak.fetch_max(active, Ordering::SeqCst);+ if index == 1 {+ if let Some(gate) = gate {+ gate.notified().await;+ }+ }+ turns.active.fetch_sub(1, Ordering::SeqCst);+ Ok(AgentTurnResponse::new(format!("reply {index}")))+ }+ })+ .await+ }++ fn runtime() -> (Arc<RecordingChannel>, Arc<ChannelRuntimeContext>) {+ let channel_impl = Arc::new(RecordingChannel::default());+ let ctx = runtime_with(channel_impl.clone());+ (channel_impl, ctx)+ }++ fn runtime_with(channel: Arc<dyn Channel>) -> Arc<ChannelRuntimeContext> {+ let mut channels_by_name = HashMap::new();+ channels_by_name.insert(channel.name().to_string(), channel);+ Arc::new(ChannelRuntimeContext {+ relay_thread: None,+ channels_by_name: Arc::new(channels_by_name),+ turn_model_source: Some(crate::agent::tinyagents::TurnModelSource::from_model(+ Arc::new(SlowModel {+ delay: Duration::from_millis(1),+ }),+ )),+ default_provider: Arc::new("test-provider".to_string()),+ tools_registry: Arc::new(vec![]),+ system_prompt: crate::channels::ChannelSystemPrompt::fixed("test-system-prompt"),+ model: Arc::new("test-model".to_string()),+ temperature: 0.0,+ max_tool_iterations: 10,+ conversation_histories: Arc::new(Mutex::new(HashMap::new())),+ turn_model_source_cache: Arc::new(Mutex::new(HashMap::new())),+ route_overrides: Arc::new(Mutex::new(HashMap::new())),+ api_url: None,+ inference_url: None,+ reliability: Arc::new(crate::config::ReliabilityConfig::default()),- provider_runtime_options: provider::ProviderRuntimeOptions::default(),++ provider_runtime_options: crate::tools::delegate::ProviderRuntimeOptions::default(),+ workspace_dir: Arc::new(std::env::temp_dir()),+ message_timeout_secs: CHANNEL_MESSAGE_TIMEOUT_SECS,+ multimodal: crate::config::MultimodalConfig::default(),+ multimodal_files: crate::config::MultimodalFileConfig::default(),+ config: None,+ core: None,+ })+ }++ struct Running {+ tx: mpsc::Sender<RuntimeChannelMessage>,+ task: JoinHandle<()>,+ next_ts: u64,+ channel: &'static str,+ }++ impl Running {+ fn start(ctx: Arc<ChannelRuntimeContext>, config: InboundDebounceConfig) -> Self {+ let (tx, rx) = mpsc::channel(32);+ let task = crate::core::runtime::DispatchCtx::ambient()+ .spawn(run_message_dispatch_loop(rx, ctx, 4, config));+ Self {+ tx,+ task,+ next_ts: 1,+ channel: "test-channel",+ }+ }++ fn message(&mut self, sender: &str, content: &str) -> traits::ChannelMessage {+ let ts = self.next_ts;+ self.next_ts += 1;+ traits::ChannelMessage {+ id: format!("m{ts}"),+ sender: sender.to_string(),+ reply_target: sender.to_string(),+ content: content.to_string(),+ channel: self.channel.to_string(),+ timestamp: ts,+ thread_ts: None,+ sender_name: None,+ }+ }++ async fn send(&mut self, sender: &str, content: &str) {+ let message = self.prepared(sender, content);+ self.tx.send(message).await.unwrap();+ }++ fn prepared(&mut self, sender: &str, content: &str) -> RuntimeChannelMessage {+ let message = self.message(sender, content);+ let history_key = format!("{}_{sender}_{sender}", self.channel);+ let prepared = PreparedChannelInbound {+ message: message.clone(),+ envelope: Default::default(),+ history_key: history_key.clone(),+ thread_id: history_key.clone(),+ client_id: self.channel.to_string(),+ session_key: history_key,+ };+ RuntimeChannelMessage {+ message,+ inbound_envelope: None,+ authenticated_relay: false,+ prepared_inbound: Some(prepared),+ }+ }++ async fn send_unprepared(&mut self, sender: &str, content: &str) {+ let message = self.message(sender, content);+ self.tx+ .send(RuntimeChannelMessage::from(message))+ .await+ .unwrap();+ }++ async fn finish(self) {+ drop(self.tx);+ tokio::time::timeout(Duration::from_secs(600), self.task)+ .await+ .expect("dispatch loop drains")+ .expect("dispatch loop does not panic");+ }+ }++ async fn sleep_ms(ms: u64) {+ tokio::time::sleep(Duration::from_millis(ms)).await;+ }++ #[tokio::test(start_paused = true)]+ async fn two_quick_messages_from_one_sender_become_one_turn() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "first").await;+ sleep_ms(500).await;+ run.send("alice", "second").await;+ sleep_ms(1000).await;+ assert_eq!(turns.count(), 0, "still inside the quiet window");+ sleep_ms(2000).await;++ assert_eq!(turns.count(), 1);+ assert!(turns.last_user(0).ends_with("first\nsecond"));+ assert_eq!(channel.sent_messages.lock().await.len(), 1);+ assert!(channel.start_typing_calls.load(Ordering::SeqCst) >= 1);+ run.finish().await;+ assert_eq!(turns.count(), 1);+ }++ #[tokio::test(start_paused = true)]+ async fn text_after_an_image_joins_it_through_the_media_window() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (_channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "[IMAGE:https://example.com/a.png]\nlook")+ .await;+ sleep_ms(3000).await;+ assert_eq!(turns.count(), 0);+ run.send("alice", "what is this?").await;+ sleep_ms(5000).await;++ assert_eq!(turns.count(), 1);+ let user = turns.last_user(0);+ assert!(user.contains("look\nwhat is this?"), "{user}");+ run.finish().await;+ }++ #[tokio::test(start_paused = true)]+ async fn messages_during_a_running_turn_become_one_follow_up_that_sees_its_history() {+ let turns = Arc::new(Turns::default());+ let gate = Arc::new(Notify::new());+ let _guard = install_handler(Arc::clone(&turns), Some(Arc::clone(&gate))).await;+ let (channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "first").await;+ sleep_ms(2000).await;+ assert_eq!(turns.count(), 1, "first turn is running");+ run.send("alice", "second").await;+ sleep_ms(200).await;+ run.send("alice", "third").await;+ sleep_ms(5000).await;+ assert_eq!(turns.count(), 1, "follow-up waits for the running turn");++ gate.notify_one();+ sleep_ms(100).await;+ assert_eq!(turns.count(), 2, "quiet window already passed");+ assert_eq!(turns.peak.load(Ordering::SeqCst), 1);+ assert!(turns.last_user(1).ends_with("second\nthird"));+ let history = turns.history(1);+ assert!(history+ .iter()+ .any(|(role, content)| role == "assistant" && content == "reply 1"));+ assert!(history+ .iter()+ .any(|(role, content)| role == "user" && content.ends_with("first")));+ run.finish().await;+ assert_eq!(channel.sent_messages.lock().await.len(), 2);+ }++ #[tokio::test(start_paused = true)]+ async fn follow_up_keeps_waiting_while_the_user_is_still_typing() {+ let turns = Arc::new(Turns::default());+ let gate = Arc::new(Notify::new());+ let _guard = install_handler(Arc::clone(&turns), Some(Arc::clone(&gate))).await;+ let (_channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "first").await;+ sleep_ms(2000).await;+ run.send("alice", "second").await;+ sleep_ms(100).await;+ gate.notify_one();+ sleep_ms(100).await;+ assert_eq!(turns.count(), 1, "second is still inside its quiet window");+ run.send("alice", "third").await;+ sleep_ms(2000).await;+ assert_eq!(turns.count(), 2);+ assert!(turns.last_user(1).ends_with("second\nthird"));+ run.finish().await;+ }++ #[tokio::test]+ async fn runtime_command_is_answered_without_waiting_for_the_buffer() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let channel = Arc::new(TelegramRecordingChannel::default());+ let ctx = runtime_with(channel.clone());+ let long_window = InboundDebounceConfig {+ debounce_ms: 600_000,+ media_debounce_ms: 600_000,+ max_wait_ms: 600_000,+ ..Default::default()+ };+ let mut run = Running::start(ctx, long_window);+ run.channel = "telegram";++ run.send("alice", "hello").await;+ run.send_unprepared("alice", "/model").await;+ tokio::time::timeout(Duration::from_secs(30), async {+ while channel.sent_messages.lock().await.is_empty() {+ tokio::task::yield_now().await;+ }+ })+ .await+ .expect("the command is answered while the buffer still holds hello");+ assert_eq!(turns.count(), 0);++ run.finish().await;+ assert_eq!(turns.count(), 1);+ assert!(turns.last_user(0).ends_with("hello"));+ }++ #[tokio::test(start_paused = true)]+ async fn a_steady_stream_flushes_at_max_wait() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (_channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ for index in 0..12 {+ run.send("alice", &format!("part {index}")).await;+ sleep_ms(900).await;+ }++ assert_eq!(+ turns.count(),+ 1,+ "deadline at 10s, quiet window would be 11.4s"+ );+ let user = turns.last_user(0);+ assert!(+ user.contains("part 0\n") && user.ends_with("part 11"),+ "{user}"+ );+ run.finish().await;+ }++ #[tokio::test(start_paused = true)]+ async fn disabled_config_runs_one_turn_per_message_in_order() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (_channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::disabled());++ run.send("alice", "one").await;+ run.send("alice", "two").await;+ sleep_ms(100).await;++ assert_eq!(turns.count(), 2);+ assert_eq!(turns.peak.load(Ordering::SeqCst), 1);+ assert!(turns.last_user(0).ends_with("one"));+ assert!(turns.last_user(1).ends_with("two"));+ run.finish().await;+ }++ #[tokio::test(start_paused = true)]+ async fn different_senders_are_never_merged() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "from alice").await;+ run.send("bob", "from bob").await;+ sleep_ms(2000).await;++ assert_eq!(turns.count(), 2);+ let mut users = [turns.last_user(0), turns.last_user(1)];+ users.sort();+ assert!(users[0].ends_with("from alice"));+ assert!(users[1].ends_with("from bob"));+ run.finish().await;+ assert_eq!(channel.sent_messages.lock().await.len(), 2);+ }++ #[tokio::test(start_paused = true)]+ async fn closing_the_queue_flushes_buffered_messages() {+ let turns = Arc::new(Turns::default());+ let _guard = install_handler(Arc::clone(&turns), None).await;+ let (_channel, ctx) = runtime();+ let mut run = Running::start(ctx, InboundDebounceConfig::default());++ run.send("alice", "a").await;+ run.send("alice", "b").await;+ run.finish().await;++ assert_eq!(turns.count(), 1);+ assert!(turns.last_user(0).ends_with("a\nb"));+ }++ #[tokio::test(start_paused = true)]+ async fn a_full_intake_budget_stops_receiving_until_turns_drain() {+ let turns = Arc::new(Turns::default());+ let gate = Arc::new(Notify::new());+ let _guard = install_handler(Arc::clone(&turns), Some(Arc::clone(&gate))).await;+ let (_channel, ctx) = runtime();+ let config = InboundDebounceConfig {+ max_batch_messages: 1,+ ..InboundDebounceConfig::default()+ };+ let mut run = Running::start(ctx, config);++ run.send("alice", "first").await;+ sleep_ms(2000).await;+ assert_eq!(turns.count(), 1);++ let mut accepted = 0;+ for i in 0..200 {+ let message = run.prepared("alice", &format!("queued {i}"));+ if run.tx.try_send(message).is_err() {+ break;+ }+ accepted += 1;+ sleep_ms(1).await;+ }+ assert_eq!(accepted, 4 + 32, "4 held by the loop plus a full queue");++ gate.notify_one();+ run.finish().await;+ assert_eq!(turns.count(), 1 + accepted);+ for i in 0..accepted {+ assert!(turns.last_user(i + 1).ends_with(&format!("queued {i}")));+ }+ }diff --cc crates/openhuman-core/src/inference/host_runtime/ops.rsindex e044fde5db,3ccfcc0a4b..adf4f25779--- a/crates/openhuman-core/src/inference/host_runtime/ops.rs+++ b/crates/openhuman-core/src/inference/host_runtime/ops.rs@@@ -8,12 -8,19 +8,19 @@@#[path = "ops_tests.rs"]mod tests;-mod agent_chat;+mod agent_chat_simple;mod complete_once;mod runtime_ops;-mod turn_guards;-pub use agent_chat::{++pub use crate::agent_runs::agent_chat::{+ agent_chat, agent_chat_for, agent_chat_reply_for, agent_chat_reply_for_controlled,- agent_chat_simple, AgentChatEnv, AgentChatReply, AgentChatTarget,++ AgentChatEnv, AgentChatReply, AgentChatTarget,+ };+pub use agent_chat_simple::agent_chat_simple;- pub use complete_once::{complete_once, CompletionEndpoint};+ pub use complete_once::{+ complete_once, complete_once_controlled, complete_once_observed,+ validate_complete_once_request, CompletionEndpoint,+ };pub use runtime_ops::{local_ai_prompt, local_ai_status, local_ai_summarize, local_ai_transcribe,local_ai_transcribe_bytes, local_ai_tts, local_ai_vision_prompt,diff --cc crates/openhuman-core/src/inference/provider/factory.rsindex e13f5f5691,879540de47..9663e102ad--- a/crates/openhuman-core/src/inference/provider/factory.rs+++ b/crates/openhuman-core/src/inference/provider/factory.rs@@@ -26,33 -57,47 +26,33 @@@ 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 credentials::openai_bearer_is_oauth;-pub use credentials::{auth_key_for_slug, lookup_key_for_slug, redact_endpoint};-pub(crate) use discovery::model_limits_request;+pub(crate) use chat_model::{resolves_to_managed_backend, OpenHumanModelFactory};+pub(crate) use cloud_slug::resolve_cloud_slug_for;+pub(crate) use cloud_spec::{cloud_provider_spec, CloudCredentialResolver};+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,+};pub(crate) use local_runtime::create_local_chat_model_from_string;- pub(crate) use routing::{fallback_diagnostics_for_role, role_uses_implicit_cloud_fallback};-pub(crate) use managed_backend::make_openhuman_backend_model;-pub(crate) use routing::role_uses_implicit_cloud_fallback;++pub(crate) use routing::fallback_diagnostics_for_role;pub use routing::{provider_for_role, role_bypasses_managed_credits};-pub(crate) use tiers::{- is_known_openhuman_tier, is_raw_passthrough_model, oh_tier_supports_vision,-};-pub use tiers::{resolve_model_for_hint, role_for_model_tier};-pub(crate) use turn_model::{- create_turn_chat_model, create_turn_chat_model_from_string,- create_turn_chat_model_from_string_with_native_tools_and_route,- create_turn_chat_model_with_native_tools_and_route,-};+pub(crate) use routing::{workload_router, ConfigRouteSource};-// Factory-internal helpers shared across the submodules (and their tests)-// through `use super::*`.+// Factory-internal helpers shared across the implementation modules.use access_gates::{emit_inference_egress, enforce_local_only_inference};-use chat_model::{unresolved_chat_model_error, with_default_temperature};-use cloud_slug::{- resolve_cloud_slug, try_create_cloud_slug_chat_model,- try_create_cloud_slug_chat_model_from_string,- try_create_cloud_slug_chat_model_with_native_tools,-};-use local_runtime::{- try_create_local_runtime_chat_model, try_create_local_runtime_chat_model_from_string,- OptionalChatModelResult,-};+#[cfg(test)]+use cloud_slug::try_create_cloud_slug_chat_model;+#[cfg(test)]+use cloud_slug::try_create_cloud_slug_chat_model_from_string;+use cloud_slug::try_create_cloud_slug_chat_model_from_string_with_native_tools_for;+use local_runtime::{try_create_local_runtime_chat_model_from_string, OptionalChatModelResult};+#[cfg(test)]+pub(crate) use managed_backend::make_openhuman_backend_model_for_thread;+use managed_backend::managed_chat_model_for;pub(crate) use managed_backend::{- make_openhuman_backend_model_for_options, make_openhuman_backend_model_for_thread,-};-use managed_backend::{managed_chat_model, resolve_managed_model};-use primary_cloud::{legacy_inference_slug, resolve_primary_cloud_provider_string};-use subprocess_providers::{- prepare_claude_agent_sdk_chat_model, try_create_claude_agent_sdk_chat_model,- try_create_claude_agent_sdk_chat_model_from_string, try_create_claude_code_chat_model,- try_create_claude_code_chat_model_from_string,+ make_openhuman_backend_model_for_options, make_openhuman_backend_model_for_thread_in,};-use tiers::{is_abstract_tier_model, managed_default_model};+use subprocess_providers::OpenHumanMcpEndpoint;use tinyinference_providers::route::split_model_and_temperature;/// Test-only seam: inject a mock [`ChatModel`] so e2e tests can drive thediff --cc crates/openhuman-core/src/inference/provider/factory/routing.rsindex 371905cc9c,dbb3dd1962..6e3135f490--- a/crates/openhuman-core/src/inference/provider/factory/routing.rs+++ b/crates/openhuman-core/src/inference/provider/factory/routing.rs@@@ -152,51 -211,14 +152,47 @@@ pub fn role_bypasses_managed_credits(rousable_byo}+/// Native route metadata drives the branded explanation; this helper only+/// determines whether the host should attach that explanation to an error.+pub(crate) fn fallback_diagnostics_for_role(+ role: &str,+ config: &Config,+) -> Option<FallbackDiagnostics> {+ let source = ConfigRouteSource::new(config, PROVIDER_OPENHUMAN);+ WORKLOAD_ROUTER.fallback_diagnostics(role, &source)+}+- pub(crate) fn role_uses_implicit_cloud_fallback(role: &str, config: &Config) -> bool {- fallback_diagnostics_for_role(role, config).is_some()- }-+/// Kept until v0.66; review after 2027-01-11 before removing legacy+/// `inference_url` route compatibility from the host's route source.+fn is_explicit_provider_default(model: &str, config: &Config) -> bool {+ let model = model.trim();+ if model.is_empty() || model.starts_with("hint:") || model.starts_with("openrouter/") {+ return false;+ }+ if !model.contains(':') {+ return model == CLAUDE_AGENT_SDK_PROVIDER;+ }+ let Some((slug, rest)) = model.split_once(':') else {+ return false;+ };+ let slug = slug.trim();+ !slug.is_empty()+ && slug != PROVIDER_OPENHUMAN+ && !rest.trim().is_empty()+ && (config+ .cloud_providers+ .iter()+ .any(|entry| entry.slug == slug)+ || tinyinference_local::profile::is_local_provider_string(model)+ || model.starts_with(tinyagents_harness::providers::claude_code::PROVIDER_PREFIX)+ || model.starts_with(CLAUDE_AGENT_SDK_PREFIX))+}+/// True when a resolved chat-tier provider string can actually run on the/// user's own funding: local runtimes / claude-code carry their own creds; a-/// concrete cloud slug requires a non-empty stored key. Managed/sentinel-/// strings are filtered by the caller and never reach here as "usable".+/// concrete cloud slug requires a non-empty stored key.pub(super) fn route_has_usable_credentials(resolved: &str, config: &Config) -> bool {let r = resolved.trim();- // Local runtimes (ollama/lmstudio/mlx/local-openai) and the local CLI- // delegates carry their own credentials / run on-device.if tinyinference_local::profile::is_local_provider_string(r)|| r.starts_with(tinyagents_harness::providers::claude_code::PROVIDER_PREFIX)|| r == CLAUDE_AGENT_SDK_PROVIDERdiff --cc crates/openhuman-core/src/inference/provider/factory_egress_fallback_tests.rsindex e69a872f53,7ee479d810..62150f782d--- a/crates/openhuman-core/src/inference/provider/factory_egress_fallback_tests.rs+++ b/crates/openhuman-core/src/inference/provider/factory_egress_fallback_tests.rs@@@ -221,23 -214,23 +221,23 @@@ fn implicit_cloud_fallback_is_claimed_o// Unset background route: the role genuinely landed on the cloud because// the local chat model cannot serve it, so the explanation applies.-- assert!(role_uses_implicit_cloud_fallback("vision", &config));++ assert!(fallback_diagnostics_for_role("vision", &config).is_some());// The literal "cloud" is the same "route me wherever the cloud is" intent.config.embeddings_provider = Some("cloud".to_string());-- assert!(role_uses_implicit_cloud_fallback("embeddings", &config));++ assert!(fallback_diagnostics_for_role("embeddings", &config).is_some());// Whitespace is not a configured route.config.memory_provider = Some(" ".to_string());-- assert!(role_uses_implicit_cloud_fallback("memory", &config));++ assert!(fallback_diagnostics_for_role("memory", &config).is_some());// Explicitly routed to a cloud slug: a credential failure here is about// that route, not about the local chat model, so it must not be described// as a fallback.config.vision_provider = Some("anthropic:claude-3-5-sonnet-latest".to_string());-- assert!(!role_uses_implicit_cloud_fallback("vision", &config));++ assert!(fallback_diagnostics_for_role("vision", &config).is_none());// Chat-tier roles are never described as cloud fallbacks, routed or not.for role in ["chat", "reasoning", "coding"] {-- assert!(!role_uses_implicit_cloud_fallback(role, &config));++ assert!(fallback_diagnostics_for_role(role, &config).is_none());}}diff --cc crates/openhuman-core/src/inference/turn_models_native_tests.rsindex 7893f21b43,0000000000..716ed46aacmode 100644,000000..100644--- a/crates/openhuman-core/src/inference/turn_models_native_tests.rs+++ b/crates/openhuman-core/src/inference/turn_models_native_tests.rs@@@ -1,360 -1,0 +1,360 @@@+use super::*;++#[tokio::test]+async fn native_turn_factory_applies_default_temperature_and_preserves_explicit_override() {+ struct TemperatureProbe(Arc<std::sync::Mutex<Vec<Option<f64>>>>);++ #[async_trait]+ impl ChatModel<()> for TemperatureProbe {+ async fn invoke(+ &self,+ _state: &(),+ request: ModelRequest,+ ) -> tinyinference_llm::Result<ModelResponse> {+ self.0.lock().unwrap().push(request.temperature);+ Ok(ModelResponse::assistant("ok"))+ }+ }++ let _guard = crate::inference::inference_test_guard_async().await;+ let seen = Arc::new(std::sync::Mutex::new(Vec::new()));+ let _override = crate::inference::provider::factory::test_provider_override::install_model(+ Arc::new(TemperatureProbe(Arc::clone(&seen))),+ );+ let tmp = tempfile::tempdir().expect("isolated workspace");+ let config = Arc::new(managed_fixture_config(&tmp));+ let ctx = crate::core::runtime::DispatchCtx::unbound();+ let models = TurnModelSource::new_crate_native(&ctx, "chat", config)+ .build("hint:chat", 0.3, None, None)+ .expect("native model set");++ models+ .primary+ .invoke(+ &(),+ ModelRequest::new(vec![tinyinference_llm::message::Message::user("default")]),+ )+ .await+ .expect("default request");+ models+ .primary+ .invoke(+ &(),+ ModelRequest::new(vec![tinyinference_llm::message::Message::user("explicit")])+ .with_temperature(0.9),+ )+ .await+ .expect("explicit request");+ assert_eq!(*seen.lock().unwrap(), vec![Some(0.3), Some(0.9)]);+}+#[tokio::test]+async fn native_budget_wrapping_keeps_owner_error_slots_for_primary_tiers_and_summary() {+ use crate::agent::tinyagents::budget::{CallBudget, ModelBudget, SpendLimits};+ use crate::core::runtime::{CoreContext, DispatchCtx, DomainSet};+ use crate::core::slots::Extensions;++ let _guard = crate::inference::inference_test_guard_async().await;+ let extensions = Extensions::new();+ crate::inference::registry::register_chat_model_in(+ &extensions,+ crate::inference::provider::factory::PROVIDER_OPENHUMAN,+ scoped_model_entry("budget-owner-model", false),+ );+ let context = CoreContext::for_test_with_host_kind_and_extensions(+ crate::core::types::HostKind::Library,+ DomainSet::full(),+ None,+ extensions,+ );+ let ctx = DispatchCtx::new(context.clone());+ let tmp = tempfile::tempdir().expect("isolated workspace");+ let config = Arc::new(managed_fixture_config(&tmp));+ let budget = ModelBudget {+ ledger: tinyinference_llm::model::budget::Budget::new(SpendLimits {+ tokens: Some(0),+ cost_micros: None,+ }),+ call: CallBudget {+ input_tokens: 10_000,+ output_tokens: 1,+ cost_micros: 1,+ },+ };+ let models = TurnModelSource::new_crate_native(&ctx, "chat", config)+ .build("hint:chat", 0.0, None, None)+ .expect("native model set")- .with_budget(Some(&budget));++ .with_host_controls(Some(&budget), None);+ let owner = models+ .native_model_set+ .as_ref()+ .expect("native owner set retained");+ let primary_slot = owner.primary_error_slot();+ let tier_slot = owner+ .workload_error_slot("hint:coding")+ .expect("coding route owns its error slot");+ let summary_slot = owner.summarizer_error_slot();+ let resolver = models.resolver();++ for (request, expected_slot) in [+ (+ ModelResolveRequest::new("chat").as_team_lead(),+ primary_slot,+ ),+ (+ ModelResolveRequest::new("worker").with_model_pin("hint:coding"),+ tier_slot,+ ),+ ] {+ let model = resolver.resolve(&request).await.expect("route resolves");+ let result = model+ .invoke(+ &(),+ ModelRequest::new(vec![tinyinference_llm::message::Message::user(+ "budget this call",+ )]),+ )+ .await;+ let error = result.expect_err("zero token budget rejects each route");+ assert!(+ error.to_string().contains("budget exceeded"),+ "route must fail at its owner budget wrapper: {error}"+ );+ assert!(expected_slot.lock().unwrap().is_some());+ }++ let result = owner+ .summarizer()+ .invoke(+ &(),+ ModelRequest::new(vec![tinyinference_llm::message::Message::user(+ "budget this summary",+ )]),+ )+ .await;+ let error = result.expect_err("zero token budget rejects summary");+ assert!(+ error.to_string().contains("budget exceeded"),+ "summary must fail at its owner budget wrapper: {error}"+ );+ assert!(summary_slot.lock().unwrap().is_some());+}+#[tokio::test]+async fn explicit_provider_string_turn_source_uses_scoped_managed_model() {+ use crate::core::runtime::{CoreContext, DispatchCtx, DomainSet};+ use crate::core::slots::Extensions;+ use crate::core::types::HostKind;++ let provider = crate::inference::provider::factory::PROVIDER_OPENHUMAN;+ let explicit_extensions = Extensions::new();+ crate::inference::registry::register_chat_model_in(+ &explicit_extensions,+ provider,+ scoped_model_entry("explicit-provider-model", false),+ );+ let explicit_context = CoreContext::for_test_with_host_kind_and_extensions(+ HostKind::Library,+ DomainSet::full(),+ None,+ explicit_extensions,+ );+ let ambient_context =+ CoreContext::for_test_with_host_kind(HostKind::Library, DomainSet::full(), None);+ let dispatch = DispatchCtx::new(explicit_context);+ let tmp = tempfile::tempdir().expect("isolated workspace");+ let mut config = managed_fixture_config(&tmp);+ config.chat_provider = Some("unconfigured:must-not-win".into());++ CoreContext::scope(ambient_context, async {+ let source = TurnModelSource::new_crate_native_from_string(+ &dispatch,+ "chat",+ "openhuman",+ Arc::new(config),+ );+ let models = source+ .build("explicit-turn-model", 0.0, None, None)+ .expect("explicit provider string should construct through the scoped model");+ assert_eq!(name_of(&models.primary).await, "explicit-provider-model");+ })+ .await;+}++#[tokio::test]+async fn native_turn_preserves_deepseek_route_metadata_after_cloud_resolution() {+ use crate::config::schema::cloud_providers::{AuthStyle, CloudProviderCreds};+ use crate::core::runtime::{CoreContext, DispatchCtx, DomainSet};+ use crate::core::types::HostKind;++ let tmp = tempfile::tempdir().expect("isolated workspace");+ let config = crate::config::Config {+ config_path: tmp.path().join("config.toml"),+ workspace_dir: tmp.path().join("workspace"),+ chat_provider: Some("deepseek:hint:chat".into()),+ cloud_providers: vec![CloudProviderCreds {+ id: "deepseek-fixture".into(),+ slug: "deepseek".into(),+ label: "DeepSeek fixture".into(),+ endpoint: "https://api.deepseek.com/v1".into(),+ auth_style: AuthStyle::Bearer,+ default_model: Some("deepseek-chat".into()),+ }],+ ..Default::default()+ };+ crate::security::credentials::AuthService::from_config(&config)+ .store_provider_token(+ "provider:deepseek",+ "default",+ "sk-fixture-deepseek",+ Default::default(),+ true,+ )+ .expect("store isolated BYOK credential");+ let context = CoreContext::for_test_with_host_kind(+ HostKind::Library,+ DomainSet::full(),+ Some(tmp.path().join("library")),+ );+ let ctx = DispatchCtx::new(context);+ let models = TurnModelSource::new_crate_native(&ctx, "chat", Arc::new(config))+ .build("hint:chat", 0.2, None, None)+ .expect("configured DeepSeek turn model builds");++ assert_eq!(models.provider_id(), "deepseek");+ let route = models+ .native_model_set+ .as_ref()+ .expect("native owner route set")+ .primary_route();+ assert_eq!(route.provider, "deepseek");+ assert_eq!(route.model, "deepseek-chat");+ assert_eq!(route.route, "hint:chat");+ let profile = models.primary.profile().expect("cloud model profile");+ assert_eq!(profile.provider.as_deref(), Some("deepseek"));+ assert_eq!(profile.model.as_deref(), Some("deepseek-chat"));+}++#[tokio::test]+async fn injected_turn_profile_is_authoritative_and_skips_unselected_routes() {+ use crate::agent::host_overrides::HostOverrides;+ use crate::core::runtime::{ContextOverlay, CoreContext, DispatchCtx, DomainSet};+ use crate::core::slots::Extensions;+ use crate::core::types::HostKind;+ use std::sync::atomic::{AtomicUsize, Ordering};+ use tinyinference_llm::model::ModelProfile;++ struct ProfiledModel {+ profile: ModelProfile,+ }+ #[async_trait]+ impl ChatModel<()> for ProfiledModel {+ fn profile(&self) -> Option<&ModelProfile> {+ Some(&self.profile)+ }+ async fn invoke(+ &self,+ _state: &(),+ _request: ModelRequest,+ ) -> tinyinference_llm::Result<ModelResponse> {+ Ok(ModelResponse::assistant("injected"))+ }+ }++ let _guard = crate::inference::inference_test_guard_async().await;+ let builds = Arc::new(AtomicUsize::new(0));+ let count = Arc::clone(&builds);+ let extensions = Extensions::new();+ crate::inference::registry::register_chat_model_in(+ &extensions,+ crate::inference::provider::factory::PROVIDER_OPENHUMAN,+ crate::inference::registry::ChatModelEntry {+ build: Arc::new(move |_| {+ count.fetch_add(1, Ordering::SeqCst);+ Ok((Arc::new(NamedModel("unselected")), "unselected".into()))+ }),+ probe: None,+ models: None,+ },+ );+ let root = CoreContext::for_test_with_host_kind_and_extensions(+ HostKind::Library,+ DomainSet::full(),+ None,+ extensions,+ );+ let mut profile = ModelProfile::default();+ profile.provider = Some("ollama:injected".into());+ profile.tool_calling = false;+ profile.modalities.image_in = true;+ profile.max_input_tokens = Some(123_456);+ let mut overrides = HostOverrides::default();+ overrides.model = Some(Arc::new(ProfiledModel { profile }));+ let context = root.derive_with(+ ContextOverlay::new(+ crate::config::Config {+ chat_provider: Some("openhuman".into()),+ ..Default::default()+ },+ DomainSet::full(),+ Default::default(),+ )+ .host_overrides(Arc::new(overrides)),+ );+ let ctx = DispatchCtx::new(context);+ let models = TurnModelSource::new_crate_native(&ctx, "chat", Arc::new(Default::default()))+ .build("hint:chat", 0.2, None, None)+ .expect("host injected model builds");++ assert_eq!(models.provider_id(), "ollama:injected");+ assert!(!models.native_tools());+ assert!(models.supports_vision());+ assert!(models.is_local());+ assert_eq!(models.context_window(), Some(123_456));+ assert_eq!(builds.load(Ordering::SeqCst), 0);+}+#[tokio::test]+async fn injected_turn_without_profile_keeps_conservative_capabilities() {+ use crate::agent::host_overrides::HostOverrides;+ use crate::core::runtime::{ContextOverlay, CoreContext, DispatchCtx, DomainSet};+ use crate::core::types::HostKind;++ struct ProfilelessModel;+ #[async_trait]+ impl ChatModel<()> for ProfilelessModel {+ async fn invoke(+ &self,+ _state: &(),+ _request: ModelRequest,+ ) -> tinyinference_llm::Result<ModelResponse> {+ Ok(ModelResponse::assistant("profileless"))+ }+ }++ let root = CoreContext::for_test_with_host_kind(HostKind::Library, DomainSet::full(), None);+ let mut overrides = HostOverrides::default();+ overrides.model = Some(Arc::new(ProfilelessModel));+ let context = root.derive_with(+ ContextOverlay::new(+ crate::config::Config {+ chat_provider: Some("openhuman".into()),+ ..Default::default()+ },+ DomainSet::full(),+ Default::default(),+ )+ .host_overrides(Arc::new(overrides)),+ );+ let ctx = DispatchCtx::new(context.clone());+ let models = CoreContext::scope(context, async {+ TurnModelSource::new_crate_native(&ctx, "chat", Arc::new(Default::default()))+ .build("hint:chat", 0.2, None, None)+ .expect("profileless host-injected model builds")+ })+ .await;++ assert_eq!(models.provider_id(), "injected");+ assert!(!models.native_tools());+ assert!(!models.supports_vision());+ assert!(!models.is_local());+ assert_eq!(models.context_window(), None);+ assert!(models.primary.profile().is_none());+}diff --cc crates/openhuman-tinyhumans/src/inference/managed_model_tests.rsindex 4e57f67e11,cb9fa40995..a3b8e67bb6--- a/crates/openhuman-tinyhumans/src/inference/managed_model_tests.rs+++ b/crates/openhuman-tinyhumans/src/inference/managed_model_tests.rs@@@ -21,74 -31,202 +21,99 @@@ fn managed_model_preserves_the_openhuma}#[test]- fn managed_model_trims_a_configured_model_and_uses_the_product_default_when_blank() {-fn with_thread_id_is_noop_without_explicit_thread() {- let request = ModelRequest::new(vec![Message::user("hi")]);- let updated = with_thread_id(request, None);- assert!(updated.provider_options.get("thread_id").is_none());-}++fn managed_factory_passes_product_default_to_native_model_when_configured_model_is_blank() {+ let configured = build_chat_model(+ Some("https://api.example.test"),+ &ManagedOptions::default(),+ " reasoning-v1 ",+ true,+ None,+ false,+ )+ .expect("configured model");+ assert_eq!(+ configured.cache_identity().as_deref(),+ Some("openhuman:https://api.example.test/openai/v1:reasoning-v1")+ );-#[test]-fn managed_model_keeps_its_explicit_thread_without_an_ambient_scope() {- let model = backend().with_thread_id(Some(" delegate-thread "));- assert_eq!(model.thread_id.as_deref(), Some("delegate-thread"));+ let blank = build_chat_model(+ Some("https://api.example.test"),+ &ManagedOptions::default(),+ " ",+ true,+ None,+ false,+ )+ .expect("blank model falls back to the product default");+ assert_eq!(+ blank.cache_identity().as_deref(),+ Some("openhuman:https://api.example.test/openai/v1:openrouter/deepseek/deepseek-v4-flash")+ );}+ #[test]-fn managed_model_advertises_tool_and_vision_capabilities() {- let model = backend();- let profile = model.profile().expect("managed profile");++fn managed_native_model_exposes_tool_vision_and_physical_attempt_capabilities() {++ use tinyinference_llm::model::{InputModality, InputSource};++++ let model = build_chat_model(++ Some("https://api.example.test"),++ &ManagedOptions::default(),++ "reasoning-v1",++ true,++ None,++ false,++ )++ .expect("managed native model");++++ let profile = model.profile().expect("managed model profile");+ assert!(profile.tool_calling);+ assert!(profile.modalities.image_in);+ assert!(model.tracks_physical_attempts());++ assert!(model.supports_input(++ InputModality::Image,++ "image/png",++ InputSource::Base64++ ));+ }+#[test]-fn managed_model_supports_only_serializable_native_media_inputs() {- use tinyinference_llm::model::{InputModality, InputSource};-- let model = backend();- for mime in ["image/png", "image/jpeg", "image/webp", "image/gif"] {- for source in [InputSource::Base64, InputSource::Url] {- assert!(- model.supports_input(InputModality::Image, mime, source),- "managed transport should serialize {mime} from {source:?}"- );- }- }-- for mime in ["audio/wav", "audio/x-wav", "audio/mpeg", "audio/mp3"] {- assert!(- model.supports_input(InputModality::Audio, mime, InputSource::Base64),- "managed transport should serialize inline {mime}"- );- assert!(- !model.supports_input(InputModality::Audio, mime, InputSource::Url),- "managed transport must not advertise URL serialization for {mime}"- );- }-- for modality in [InputModality::Image, InputModality::Audio] {- for source in [InputSource::Base64, InputSource::Url, InputSource::Path] {- assert!(- !model.supports_input(modality, "application/pdf", source),- "managed transport must reject PDF as {modality:?}/{source:?}"- );- }- }- for modality in [InputModality::Video, InputModality::Document] {- for source in [InputSource::Base64, InputSource::Url, InputSource::Path] {- assert!(- !model.supports_input(modality, "application/octet-stream", source),- "managed transport must reject {modality:?}/{source:?}"- );- }- }- assert!(!model.supports_input(InputModality::Image, "image/tiff", InputSource::Base64));- assert!(!model.supports_input(InputModality::Audio, "audio/ogg", InputSource::Base64));- assert!(!model.supports_input(InputModality::Image, "image/png", InputSource::Path));-}+fn managed_bearer_keeps_the_stored_key_transport_guard() {+ let tmp = tempfile::TempDir::new().expect("temporary credentials");+ openhuman_embed::__host::security::credentials::api_key::store_api_key_in(+ tmp.path(),+ false,+ "test-managed-key",+ )+ .expect("store test API key");+ let options = ManagedOptions {+ openhuman_dir: Some(tmp.path().to_path_buf()),+ secrets_encrypt: false,+ ..ManagedOptions::default()+ };-#[test]-fn resolve_model_normalizes_blank_and_trims_non_empty_values() {assert_eq!(- resolve_model(""),- openhuman_embed::__host::config::MODEL_MANAGED_DEFAULT+ options+ .resolve_bearer("https://api.tinyhumans.ai/openai/v1")+ .expect("managed TLS endpoint accepts the API key"),+ "test-managed-key");assert_eq!(- resolve_model(" \t\n"),- openhuman_embed::__host::config::MODEL_MANAGED_DEFAULT+ options+ .resolve_bearer("http://127.0.0.1:9999/openai/v1")+ .expect("loopback is a valid local test endpoint"),+ "test-managed-key");- assert_eq!(resolve_model(" reasoning-v1 "), "reasoning-v1");- assert_eq!(resolve_model("hint:reasoning"), "hint:reasoning");-}--// ── probe_readiness (B45 — flows provider-connectivity author gate) ────--#[test]-fn is_provider_not_configured_error_matches_exact_backend_shape() {- let err = ProviderError {- provider: "OpenHuman".to_string(),- model: None,- status: Some(400),- code: Some("BAD_REQUEST".to_string()),- message: "API key not configured for provider".to_string(),- retryable: false,- retry_after_ms: None,- raw: None,- ..ProviderError::default()- };- assert!(is_provider_not_configured_error(&err));-}--#[test]-fn is_provider_not_configured_error_rejects_other_400s() {- // A 400 that isn't the "no provider configured" class (e.g. a bad- // request shape) must NOT be classified as provider-not-configured —- // only the exact backend-confirmed signal should ever reject.- let err = ProviderError {- provider: "OpenHuman".to_string(),- model: None,- status: Some(400),- code: Some("BAD_REQUEST".to_string()),- message: "invalid request: messages must not be empty".to_string(),- retryable: false,- retry_after_ms: None,- raw: None,- ..ProviderError::default()- };- assert!(!is_provider_not_configured_error(&err));-}--#[test]-fn is_provider_not_configured_error_tolerates_not_configured_for_provider_wording_drift() {- // The `code_is_bad_request` branch still matches the narrower- // "not configured for provider" substring even when it isn't- // introduced by the exact "api key" prefix — tolerance for backend- // message wording drift, not a broadening to any "not configured".- let err = ProviderError {- provider: "OpenHuman".to_string(),- model: None,- status: Some(400),- code: Some("BAD_REQUEST".to_string()),- message: "credentials not configured for provider 'anthropic'".to_string(),- retryable: false,- retry_after_ms: None,- raw: None,- ..ProviderError::default()- };- assert!(is_provider_not_configured_error(&err));-}--#[test]-fn is_provider_not_configured_error_rejects_generic_not_configured_400() {- // Tightened contract (finding D): a 400 `BAD_REQUEST` whose message- // contains only the generic word "not configured" — but not the- // specific "not configured for provider" phrasing — must fail OPEN,- // not be misclassified as the provider-key signal. Otherwise an- // unrelated backend validation error ("model X not configured", "this- // feature is not configured for your account", …) would falsely- // reject a run/proposal as a provider problem.- let err = ProviderError {- provider: "OpenHuman".to_string(),- model: None,- status: Some(400),- code: Some("BAD_REQUEST".to_string()),- message: "webhook target not configured".to_string(),- retryable: false,- retry_after_ms: None,- raw: None,- ..ProviderError::default()- };- assert!(!is_provider_not_configured_error(&err));-}--#[test]-fn is_provider_not_configured_error_rejects_non_400_status() {- let err = ProviderError {- provider: "OpenHuman".to_string(),- model: None,- status: Some(401),- code: None,- message: "API key not configured for provider".to_string(),- retryable: false,- retry_after_ms: None,- raw: None,- ..ProviderError::default()- };- assert!(!is_provider_not_configured_error(&err));-}--fn seed_app_session(dir: &std::path::Path) {- use openhuman_embed::__host::security::credentials::{- AuthService, APP_SESSION_PROVIDER, DEFAULT_AUTH_PROFILE_NAME,- };- AuthService::new(dir, false)- .store_provider_token(- APP_SESSION_PROVIDER,- DEFAULT_AUTH_PROFILE_NAME,- "test.session.jwt",- std::collections::HashMap::new(),- true,- )- .expect("seed app-session token");+ let plaintext = options+ .resolve_bearer("http://api.example.test/openai/v1")+ .expect_err("a plaintext remote endpoint must not receive the stored key");+ assert!(plaintext.to_string().contains("http://api.example.test"));+ let error = options+ .resolve_bearer("https://api.example.test/openai/v1")+ .expect_err("a foreign HTTPS origin must not receive the stored key");+ assert!(error.to_string().contains("unmanaged or insecure"));}-/// Seed an app-session profile whose recorded `exp` metadata is `expires_at`-/// (RFC3339) so the `resolve_bearer` local-expiry precheck (#5503, part e)-/// can be exercised without a live backend.-fn seed_app_session_with_expiry(dir: &std::path::Path, expires_at: &str) {+fn seed_app_session(dir: &std::path::Path, expires_at: Option<&str>) {use openhuman_embed::__host::security::credentials::{session_support::SESSION_EXPIRES_AT_META, AuthService, APP_SESSION_PROVIDER,DEFAULT_AUTH_PROFILE_NAME,diff --cc vendor/tinyagentsindex c29ab0ee87,aa64b26a06..ca099cfb49--- a/vendor/tinyagents+++ b/vendor/tinyagents@@@ -1,1 -1,1 +1,1 @@@- Subproject commit c29ab0ee8724e1a500f9ad0bb648546b34fd3c34-Subproject commit aa64b26a06377e17e1126f355c620318c347798a++Subproject commit ca099cfb4906375ec0c753089eddb2ca8c7f0999