tuls 0.1.3

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 {
    let temp = tempdir().unwrap();
    let agents = temp.path().join(".agents/agents");
    std::fs::create_dir_all(&agents).unwrap();
    std::fs::write(
        agents.join("test.toml"),
        "name='test'\ndescription='test agent'\ninstructions='answer'\nmodel='gpt-5'\nmodel_provider='openai'\n",
    )
    .unwrap();
    AgentsServer::new(
        temp.keep(),
        ToolPolicy::from_selectors(&[], &[], TOOL_SPECS).unwrap(),
    )
    .unwrap()
}

#[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.toml"),
        "name='test'\ndescription='test agent'\ninstructions='answer'\nmodel='gpt-5'\nmodel_provider='openai'\n",
    )
    .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}");
}