vv-agent 0.6.2

VectorVein agent runtime, SDK, CLI, tools, and workspace backends
Documentation 
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

use std::collections::BTreeMap;

use serde_json::{json, Value};

use crate::tools::base::{SubTaskRunner, ToolContext};
use crate::types::{AgentStatus, SubTaskRequest, ToolExecutionResult};

use super::request::BatchRequestEntry;
use super::response;

pub(super) fn run_batch_sync(
    context: &mut ToolContext,
    runner: SubTaskRunner,
    total: usize,
    entries: Vec<BatchRequestEntry>,
) -> ToolExecutionResult {
    let mut prepared_requests = Vec::new();
    let mut invalid_results = BTreeMap::new();
    for entry in entries {
        if let Some(request) = entry.request {
            prepared_requests.push((entry.index, request));
        } else {
            invalid_results.insert(
                entry.index,
                json!({
                    "index": entry.index,
                    "status": "failed",
                    "error": entry.error.unwrap_or_else(|| "Invalid task item".to_string()),
                }),
            );
        }
    }

    let outcomes = run_prepared_requests(context, runner, prepared_requests);
    let outcome_map: BTreeMap<_, _> = outcomes.into_iter().collect();
    let mut results = Vec::new();
    let mut completed = 0usize;
    let mut failed = 0usize;
    for index in 0..total {
        if let Some(payload) = invalid_results.remove(&index) {
            failed += 1;
            results.push(payload);
            continue;
        }
        let outcome = outcome_map
            .get(&index)
            .expect("valid sub-task request should have an outcome");
        if outcome.status == AgentStatus::Completed {
            completed += 1;
        } else {
            failed += 1;
        }
        let mut payload = outcome.to_value();
        payload["index"] = Value::Number((index as u64).into());
        results.push(payload);
    }

    let payload = json!({
        "summary": {
            "total": total,
            "completed": completed,
            "failed": failed,
        },
        "results": results,
        "wait_for_completion": true,
    });
    if completed == 0 {
        return response::all_batch_tasks_failed(payload);
    }
    response::success(payload)
}

fn run_prepared_requests(
    context: &mut ToolContext,
    runner: SubTaskRunner,
    prepared_requests: Vec<(usize, SubTaskRequest)>,
) -> Vec<(usize, crate::types::SubTaskOutcome)> {
    if let Some(backend) = context.execution_backend.clone() {
        let runner = runner.clone();
        backend.parallel_map(
            move |(index, request)| (index, runner(request)),
            prepared_requests,
        )
    } else {
        prepared_requests
            .into_iter()
            .map(|(index, request)| (index, runner(request)))
            .collect()
    }
}