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

use crate::agent::runloop::unified::turn::context::{
    PreparedAssistantToolCall, TurnHandlerOutcome,
};
use anyhow::Result;
use call::{handle_prepared_tool_call_dispatch, push_invalid_tool_args_response};
use std::time::Instant;

mod call;

pub(crate) async fn handle_tool_calls<'a, 'b>(
    t_ctx: &mut super::handlers::ToolOutcomeContext<'a, 'b>,
    tool_calls: &[PreparedAssistantToolCall],
) -> Result<Option<TurnHandlerOutcome>> {
    if tool_calls.is_empty() {
        return Ok(None);
    }

    let planning_started = Instant::now();
    let mut valid_calls = 0usize;
    let mut parallel_safe_calls = 0usize;
    for tool_call in tool_calls {
        if tool_call.args().is_some() {
            valid_calls += 1;
        }
        if tool_call.is_parallel_safe() {
            parallel_safe_calls += 1;
        }
    }

    if valid_calls == 0 {
        for tool_call in tool_calls {
            if let Some(err) = tool_call.args_error() {
                push_invalid_tool_args_response(
                    t_ctx.ctx.working_history,
                    tool_call.call_id(),
                    tool_call.tool_name(),
                    err,
                );
            }
        }
        return Ok(None);
    }

    let batch_candidate = t_ctx.ctx.full_auto && valid_calls > 1;
    tracing::debug!(
        target: "vtcode.turn.metrics",
        metric = "tool_dispatch_plan",
        total_calls = valid_calls,
        batch_candidate,
        parallel_safe_calls,
        planning_ms = planning_started.elapsed().as_millis(),
        "turn metric"
    );

    if batch_candidate {
        let outcome = crate::agent::runloop::unified::turn::tool_outcomes::handlers::handle_tool_call_batch_prepared(t_ctx, tool_calls).await?;
        if let Some(o) = outcome {
            return Ok(Some(o));
        }
    } else {
        for tool_call in tool_calls {
            if let Some(err) = tool_call.args_error() {
                push_invalid_tool_args_response(
                    t_ctx.ctx.working_history,
                    tool_call.call_id(),
                    tool_call.tool_name(),
                    err,
                );
                continue;
            }

            let outcome = handle_prepared_tool_call_dispatch(t_ctx, tool_call).await?;
            if let Some(o) = outcome {
                return Ok(Some(o));
            }
        }
    }

    Ok(None)
}