Skip to content

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

9.0 KB
Raw Blame
use anyhow::Result;
use async_trait::async_trait;
use openhuman_core::agent::OpenHumanSessionHost;
use tinytools::{PermissionLevel, Tool, ToolResult};
use tinytools_agent::dialect::NativeDialect;

use parking_lot::Mutex;
use serde_json::json;
use std::sync::Arc;
use tinyinference_llm::message::{AssistantMessage, Message};
use tinyinference_llm::model::{ChatModel, ModelProfile, ModelRequest, ModelResponse};
use tinyinference_llm::tool::ToolCall;

struct MockCalendarModel {
    captured_messages: Arc<Mutex<Vec<Message>>>,
    iter_count: Arc<Mutex<usize>>,
    profile: ModelProfile,
}

#[async_trait]
impl ChatModel<()> for MockCalendarModel {
    fn profile(&self) -> Option<&ModelProfile> {
        Some(&self.profile)
    }

    async fn invoke(
        &self,
        _state: &(),
        request: ModelRequest,
    ) -> tinyinference_llm::Result<ModelResponse> {
        let mut count = self.iter_count.lock();
        *count += 1;

        let mut captured = self.captured_messages.lock();
        for msg in request.messages {
            captured.push(msg.clone());
        }

        if *count == 1 {
            // Return a tool call to GOOGLECALENDAR_EVENTS_LIST
            Ok(ModelResponse {
                message: AssistantMessage {
                    id: None,
                    content: Vec::new(),
                    tool_calls: vec![ToolCall::new(
                        "call_1",
                        "GOOGLECALENDAR_EVENTS_LIST",
                        json!({
                        "timeMin": "2026-04-27T00:00:00Z",
                        "timeMax": "2026-05-04T00:00:00Z"
                        }),
                    )],
                    usage: None,
                    origin: None,
                },
                usage: None,
                finish_reason: Some("tool_calls".into()),
                raw: None,
                resolved_model: None,
                continue_turn: None,
                served_from_cache: false,
                correlation: None,
                resolved_route: None,
            })
        } else {
            // End the loop
            Ok(ModelResponse::assistant("You have no events this week."))
        }
    }
}

fn calendar_model(captured_messages: Arc<Mutex<Vec<Message>>>) -> Arc<MockCalendarModel> {
    let profile = ModelProfile {
        tool_calling: true,
        ..Default::default()
    };
    Arc::new(MockCalendarModel {
        captured_messages,
        iter_count: Arc::new(Mutex::new(0)),
        profile,
    })
}

struct MockCalendarTool;

#[async_trait]
impl Tool for MockCalendarTool {
    fn name(&self) -> &str {
        "GOOGLECALENDAR_EVENTS_LIST"
    }
    fn description(&self) -> &str {
        "List calendar events"
    }
    fn parameters_schema(&self) -> serde_json::Value {
        json!({
            "type": "object",
            "properties": {
                "timeMin": { "type": "string" },
                "timeMax": { "type": "string" }
            }
        })
    }
    async fn execute(&self, _args: serde_json::Value) -> Result<ToolResult> {
        Ok(ToolResult::success("[]"))
    }
    fn permission_level(&self) -> PermissionLevel {
        PermissionLevel::ReadOnly
    }
}

#[tokio::test]
async fn test_orchestrator_has_current_date_context() -> Result<()> {
    let captured_messages = Arc::new(Mutex::new(Vec::new()));
    let model = calendar_model(captured_messages.clone());
    let workspace = tempfile::tempdir()?;
    let _ =
        openhuman_core::agent_registry::host_definition::AgentDefinitionRegistry::init_global_builtins();

    let mut agent = OpenHumanSessionHost::builder()
        .model_name("test/session-fixture".to_string())
        .chat_model(model)
        .tools(vec![Box::new(MockCalendarTool)])
        .tool_dispatcher(Box::new(NativeDialect))
        .agent_definition_name("orchestrator")
        .workspace_dir(workspace.path().to_path_buf())
        .build()?;

    // Trigger a turn
    let _ = agent.turn("what is on my calendar this week?").await?;

    let messages = captured_messages.lock();
    // The system prompt carries the static grounding *rule* (#3602) — the
    // concrete clock no longer lives here, it rides the per-turn user message
    // so a long-lived session can't go stale.
    messages
        .iter()
        .find(|m| matches!(m, Message::System(_)) && m.text().contains("## Current Date & Time"))
        .expect("System prompt should carry the Current Date & Time grounding rule");

    // The live date/time is injected on the user message every turn. Assert it
    // carries the stamp and a concrete year token.
    let user_msg = messages
        .iter()
        .find(|m| matches!(m, Message::User(_)) && m.text().contains("Current Date & Time:"))
        .expect("User message should carry the per-turn Current Date & Time stamp");
    // Assert a concrete `YYYY-MM-DD HH:MM:SS` shape rather than a decade token
    // (which would rot as years advance).
    let user_text = user_msg.text();
    let after = user_text
        .split("Current Date & Time: ")
        .nth(1)
        .expect("stamp must follow the canonical prefix");
    let dt = after
        .get(0..19)
        .expect("stamp must include YYYY-MM-DD HH:MM:SS");
    chrono::NaiveDateTime::parse_from_str(dt, "%Y-%m-%d %H:%M:%S")
        .expect("user message stamp must include a parseable YYYY-MM-DD HH:MM:SS");

    Ok(())
}

#[tokio::test]
async fn test_subagent_has_current_date_context() -> Result<()> {
    let captured_messages = Arc::new(Mutex::new(Vec::new()));
    let model = calendar_model(captured_messages.clone());

    let _ =
        openhuman_core::agent_registry::host_definition::AgentDefinitionRegistry::init_global_builtins();

    let parent = openhuman_core::agent::subagent_host::ParentExecutionContext {
        agent_definition_id: "orchestrator".into(),
        allowed_subagent_ids: ["summarizer".to_string()].into_iter().collect(),
        turn_model_source: openhuman_core::agent::tinyagents::TurnModelSource::from_model(model),
        all_tools: Arc::new(vec![Box::new(MockCalendarTool)]),
        all_tool_specs: Arc::new(vec![Arc::new(MockCalendarTool.spec())]),
        // #6145: empty means "same surface as `all_tool_specs`" — the
        // catalogue falls back to it, so these stubs keep the behaviour
        // they had before the parent's visible set became its own field.
        visible_tool_specs: Arc::new(Vec::new()),
        visible_tool_names: std::collections::HashSet::new(),
        subagent_tool_ceiling_names: std::collections::HashSet::new(),
        model_name: "test-model".into(),
        temperature: 0.4,
        workspace_dir: std::env::temp_dir(),
        workspace_descriptor: None,
        agent_config: openhuman_core::config::AgentConfig::default(),
        workflows: Arc::new(vec![]),
        memory_context: Arc::new(None),
        session_id: "test-session".into(),
        channel: "test".into(),
        connected_integrations: vec![],
        tool_call_format: tinytools_agent::dialect::ToolCallFormat::PFormat,
        session_key: "0_test".into(),
        session_parent_prefix: None,
        on_progress: None,
        run_queue: None,
        host_env: Default::default(),
    };

    let mut def =
        openhuman_core::agent_registry::host_definition::AgentDefinitionRegistry::global()
            .unwrap()
            .get("summarizer")
            .unwrap()
            .clone();
    // A Hint sub-agent builds a fresh provider via the workload factory
    // instead of inheriting `parent.provider` — which here would resolve to
    // the OpenHuman backend and fail with "No backend session" before the
    // MockCalendarModel ever sees a request. This test only asserts prompt
    // construction (the "Current Date & Time" context), so override the
    // model spec to Inherit to keep the real definition (prompt, tools,
    // scope) while routing through the captured mock provider. Provider *routing* for Hint sub-agents is covered by
    // `subagent_runner::ops::tests::resolve_subagent_provider_*`.
    def.model = tinyagents_definition::ModelSpec::Inherit;

    // The parent is an explicit value on the run options, not ambient state.
    let mut options = openhuman_core::agent::subagent_host::SubagentRunOptions::default();
    options.run_context.parent = Some(parent);
    let parent =
        options
            .run_context
            .clone()
            .into_tinyagents(tinyagents_harness::context::RunConfig::new(
                "calendar-grounding-subagent-test",
            ));
    let _ = openhuman_core::agent::subagent_host::OpenHumanSubagentHost::new(def, options)
        .run(&parent, "list my calendar events for today".into())
        .await;

    let messages = captured_messages.lock();
    // Use substring search on all user messages
    let mut found = false;
    for m in messages.iter() {
        if matches!(m, Message::User(_)) && m.text().contains("Current Date & Time:") {
            found = true;
            break;
        }
    }

    assert!(
        found,
        "User message should contain Current Date & Time context"
    );

    Ok(())
}