vtcode 0.99.1

A Rust-based terminal coding agent with modular architecture supporting multiple LLM providers
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96

use std::time::Duration;

use anyhow::{Result, bail};
use vtcode_core::cli::args::BackgroundSubagentArgs;
use vtcode_core::subagents::{SpawnAgentRequest, SubagentController, SubagentControllerConfig};
use vtcode_core::tools::exec_session::ExecSessionManager;
use vtcode_core::tools::registry::PtySessionManager;

use crate::startup::StartupContext;

pub(crate) async fn handle_background_subagent_command(
    startup: &StartupContext,
    args: BackgroundSubagentArgs,
) -> Result<()> {
    if args.prompt.trim().is_empty() {
        bail!("background subagent prompt cannot be empty");
    }

    let workspace_root = startup.agent_config.workspace.clone();
    let mut vt_cfg = startup.config.clone();
    vt_cfg.subagents.background.auto_restore = false;

    let pty_sessions = PtySessionManager::new(workspace_root.clone(), vt_cfg.pty.clone());
    let exec_sessions = ExecSessionManager::new(workspace_root.clone(), pty_sessions.clone());
    let controller = SubagentController::new(SubagentControllerConfig {
        workspace_root,
        parent_session_id: args.parent_session_id,
        parent_model: startup.agent_config.model.clone(),
        parent_provider: startup.agent_config.provider.clone(),
        parent_reasoning_effort: startup.agent_config.reasoning_effort,
        api_key: startup.agent_config.api_key.clone(),
        vt_cfg,
        openai_chatgpt_auth: startup.agent_config.openai_chatgpt_auth.clone(),
        depth: 0,
        exec_sessions,
        pty_manager: pty_sessions.manager().clone(),
    })
    .await?;

    controller
        .set_turn_delegation_hints_from_input("delegate this task to a background subagent")
        .await;
    controller
        .set_parent_session_id(args.session_id.clone())
        .await;

    let spawned = controller
        .spawn(SpawnAgentRequest {
            agent_type: Some(args.agent_name.clone()),
            message: Some(args.prompt.clone()),
            background: true,
            max_turns: args.max_turns,
            model: args.model_override.clone(),
            reasoning_effort: args.reasoning_override.clone(),
            ..SpawnAgentRequest::default()
        })
        .await?;

    let status = controller
        .wait(std::slice::from_ref(&spawned.id), Some(300_000))
        .await?;
    if let Some(status) = status {
        if let Some(summary) = status.summary.as_deref() {
            println!("background-subagent-summary: {}", summary.trim());
        }
        if let Some(error) = status.error.as_deref() {
            eprintln!("background-subagent-error: {}", error.trim());
        }
        if !status.status.is_terminal()
            || matches!(
                status.status,
                vtcode_core::subagents::SubagentStatus::Completed
            )
        {
            println!(
                "background-subagent-ready: {} {}",
                status.agent_name, status.session_id
            );
        } else {
            bail!(
                "background subagent '{}' exited with status {}",
                status.agent_name,
                status.status.as_str()
            );
        }
    } else {
        println!(
            "background-subagent-ready: {} {}",
            args.agent_name, args.session_id
        );
    }

    loop {
        tokio::time::sleep(Duration::from_secs(3600)).await;
    }
}