vtcode-core 0.104.1

use anyhow::Result;
use tokio::sync::mpsc;
use vtcode_core::config::models::ModelId;
use vtcode_core::config::types::ReasoningEffortLevel;
use vtcode_core::core::agent::runner::{AgentRunner, RunnerSettings};
use vtcode_core::core::agent::steering::SteeringMessage;
use vtcode_core::core::agent::task::{Task, TaskOutcome};
use vtcode_core::core::agent::types::AgentType;

#[tokio::test]
async fn test_agent_steering_stop() -> Result<()> {
    // Setup
    let (steering_tx, steering_rx) = mpsc::unbounded_channel();

    // Create a mock workspace
    let temp_dir = tempfile::tempdir()?;
    let workspace_path = temp_dir.path().to_path_buf();

    // Initialize AgentRunner
    // We use a dummy model ID since we won't actually be calling an LLM in this test
    // or we might mock it if needed. For now, we rely on the loop check happening before the LLM check.
    // If we need a real model, we might need to mock the provider.
    // However, since we want to test steering *interruption*, we can try to send the stop signal immediately.

    let model_id = ModelId::Gemini31ProPreview;
    let api_key = "dummy-key".to_string();
    let session_id = "test-session".to_string();

    let mut runner = AgentRunner::new(
        AgentType::Single,
        model_id,
        api_key,
        workspace_path,
        session_id,
        RunnerSettings {
            reasoning_effort: Some(ReasoningEffortLevel::Medium),
            verbosity: None,
        },
        Some(steering_rx),
    )
    .await?;

    // Create a dummy task
    let task = Task {
        id: "test-task".into(),
        title: "Test Task".into(),
        description: "Do nothing".into(),
        instructions: None,
    };

    // Spawn the runner in a separate task so we can send signals
    let runner_handle =
        tokio::spawn(async move { runner.execute_task_with_retry(&task, &[], 1).await });

    // Send Stop signal immediately
    steering_tx.send(SteeringMessage::SteerStop)?;

    // Wait for result
    let result = runner_handle.await??;

    // Verify that the task was cancelled
    assert_eq!(result.outcome, TaskOutcome::Cancelled);

    Ok(())
}

#[tokio::test]
async fn test_agent_steering_pause_resume() -> Result<()> {
    // This test is harder to implement deterministically without a mock provider that pauses
    // But we can try to rely on the fact that the runner checks steering at the start of the loop.
    Ok(())
}