Skip to content

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

Merge branch 'main' into epic-8092-265-routing

Steven Enamakel036ea872a2a2
diff --cc crates/openhuman-core/src/agent/tinyagents/budget.rs
index 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_depth
impl 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.rs
index 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_middleware
policy: 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.rs
index 25d2b59fe5,0000000000..c41ca46d2f
mode 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.rs
index 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_contr
agent.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.rs
index 0000000000,6fc0794f88..e7b6cad3e5
mode 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.rs
index 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.rs
index 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 the
diff --cc crates/openhuman-core/src/inference/provider/factory/routing.rs
index 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(ro
usable_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_PROVIDER
diff --cc crates/openhuman-core/src/inference/provider/factory_egress_fallback_tests.rs
index 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.rs
index 7893f21b43,0000000000..716ed46aac
mode 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.rs
index 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/tinyagents
index c29ab0ee87,aa64b26a06..ca099cfb49
--- a/vendor/tinyagents
+++ b/vendor/tinyagents
@@@ -1,1 -1,1 +1,1 @@@
- Subproject commit c29ab0ee8724e1a500f9ad0bb648546b34fd3c34
-Subproject commit aa64b26a06377e17e1126f355c620318c347798a
++Subproject commit ca099cfb4906375ec0c753089eddb2ca8c7f0999