tuls 0.1.4

A compact Rust MCP toolbox for filesystem access, HTTP fetches, persistent memory, local process execution, reusable skills, and provider-backed local subagents.
use super::*;
use serde_json::json;
use tempfile::tempdir;

fn server() -> AgentsServer {
    server_with(&[(
        "test.md",
        "---\nname: test\ndescription: test agent\nprovider: openai\nmodel: gpt-5\n---\nanswer",
    )])
}

fn server_with(definitions: &[(&str, &str)]) -> AgentsServer {
    let temp = tempdir().unwrap();
    let agents = temp.path().join(".agents/agents");
    std::fs::create_dir_all(&agents).unwrap();
    for (path, definition) in definitions {
        std::fs::write(agents.join(path), definition).unwrap();
    }
    AgentsServer::new(
        temp.keep(),
        ToolPolicy::from_selectors(&[], &[], TOOL_SPECS).unwrap(),
    )
    .unwrap()
}

#[tokio::test]
async fn hidden_agents_are_absent_from_tools_and_rejected_by_spawn_lookup() {
    let server = server_with(&[
        (
            "leader.md",
            "---\nname: leader\ndescription: hidden leader marker\nprovider: openai\nmodel: gpt-5\nsubagent: false\n---\nlead",
        ),
        (
            "reviewer.md",
            "---\nname: reviewer\ndescription: visible reviewer marker\nprovider: openai\nmodel: gpt-5\n---\nreview",
        ),
    ]);
    let spawn = server
        .tools()
        .into_iter()
        .find(|tool| tool.name == "spawn_agent")
        .unwrap();
    assert_eq!(
        spawn.input_schema["properties"]["name"]["enum"],
        json!(["reviewer"])
    );
    let description = spawn.description.as_deref().unwrap();
    assert!(description.contains("visible reviewer marker"));
    assert!(!description.contains("hidden leader marker"));

    let error = match server
        .runtime
        .prepare_spawn("leader", "recursive task")
        .await
    {
        Ok(_) => panic!("hidden agent was spawnable"),
        Err(error) => error,
    };
    assert_eq!(error.kind, "unknown_agent");
    assert_eq!(error.message, "unknown agent");
    assert!(
        server
            .runtime
            .prepare_spawn("reviewer", "review task")
            .await
            .is_ok()
    );
}

#[test]
fn hidden_only_registry_advertises_no_agent_tools() {
    let server = server_with(&[(
        "leader.md",
        "---\nname: leader\ndescription: hidden leader\nprovider: openai\nmodel: gpt-5\nsubagent: false\n---\nlead",
    )]);
    assert!(server.tools().is_empty());
    assert!(server.get_info().capabilities.tools.is_none());
}

#[test]
fn tools_are_task_native_and_minimal() {
    let server = server();
    let tools = server.tools();
    assert_eq!(
        tools
            .iter()
            .map(|tool| tool.name.as_ref())
            .collect::<Vec<_>>(),
        ["spawn_agent", "send_input"]
    );

    let spawn = tools
        .iter()
        .find(|tool| tool.name == "spawn_agent")
        .unwrap();
    assert_eq!(spawn.input_schema["required"], json!(["name", "task"]));
    assert!(spawn.description.as_deref().unwrap().contains("MCP Task"));

    let input = tools.iter().find(|tool| tool.name == "send_input").unwrap();
    assert_eq!(input.input_schema["required"], json!(["target", "message"]));
    let properties = input.input_schema["properties"].as_object().unwrap();
    assert_eq!(
        properties.keys().map(String::as_str).collect::<Vec<_>>(),
        ["message", "target"]
    );
}

#[test]
fn server_advertises_standard_tasks_extension() {
    let info = server().get_info();
    assert!(info.capabilities.supports_tasks());
    assert!(info.capabilities.tools.is_some());
}

#[test]
fn policy_can_grant_each_agent_tool_independently() {
    let temp = tempdir().unwrap();
    let agents = temp.path().join(".agents/agents");
    std::fs::create_dir_all(&agents).unwrap();
    std::fs::write(
        agents.join("test.md"),
        "---\nname: test\ndescription: test agent\nprovider: openai\nmodel: gpt-5\n---\nanswer",
    )
    .unwrap();
    let server = AgentsServer::new(
        temp.keep(),
        ToolPolicy::from_selectors(&["agents/spawn_agent".into()], &[], TOOL_SPECS).unwrap(),
    )
    .unwrap();
    assert!(server.get_tool("spawn_agent").is_some());
    assert!(server.get_tool("send_input").is_none());
}

#[tokio::test]
async fn agent_tasks_advertise_the_shared_poll_interval() {
    let server = server();
    let turn = server
        .runtime
        .prepare_spawn("test", "first task")
        .await
        .unwrap();
    let CallToolResponse::Task(task) = server.start_task(turn) else {
        panic!("expected a task handle");
    };
    assert_eq!(
        task.task.poll_interval_ms,
        Some(DEFAULT_TASK_POLL_INTERVAL_MS)
    );
}

#[test]
fn completed_task_result_contains_full_text_and_structured_output() {
    let result = runtime::AgentTurnResult {
        id: "agt_1".into(),
        name: "test".into(),
        result: "final answer".into(),
    };
    let rendered = render_turn_result(&result).unwrap();
    assert!(!rendered.is_error.unwrap_or(false));
    assert_eq!(
        rendered.structured_content.as_ref().unwrap()["agentId"],
        "agt_1"
    );
    assert_eq!(
        rendered.structured_content.as_ref().unwrap()["result"],
        "final answer"
    );
    let text = rendered.content[0].as_text().unwrap().text.as_str();
    assert!(text.contains("final answer"));
}

#[test]
fn agent_failures_complete_as_tool_errors_not_task_failures() {
    let error = runtime::AgentTurnError {
        id: "agt_1".into(),
        name: "test".into(),
        kind: "provider_error".into(),
        message: "provider unavailable".into(),
        resumable: true,
    };
    let rendered = render_turn_error(&error).unwrap();
    assert_eq!(rendered.is_error, Some(true));
    let structured = rendered.structured_content.as_ref().expect("structured");
    assert_eq!(structured["agentId"], "agt_1");
    assert_eq!(structured["kind"], "provider_error");
    assert_eq!(structured["resumable"], true);
    let text = rendered.content[0].as_text().unwrap().text.as_str();
    assert!(text.contains("provider_error"));
    assert!(text.contains("send_input"), "resumable error hints: {text}");
}