a3s 0.10.3

a3s — A3S coding agent CLI; `a3s code` launches the interactive TUI
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
91
92
93
94
95
96
97

use super::*;

pub(super) fn budget(max_queries: usize, max_fetches: usize) -> ResearchBudget {
    ResearchBudget {
        max_queries,
        max_fetches,
    }
}

pub(super) fn dimension(id: &str, target_ids: &[&str]) -> ResearchDimension {
    ResearchDimension {
        id: id.to_string(),
        question: format!("What establishes {id}?"),
        material: true,
        source_target_ids: target_ids.iter().map(|id| (*id).to_string()).collect(),
    }
}

pub(super) fn named_target(
    id: &str,
    family: &str,
    role: SourceRole,
    identity: SourceIdentity,
) -> SourceTarget {
    let transport = identity.transport();
    SourceTarget {
        id: id.to_string(),
        source_family_id: family.to_string(),
        role,
        transport,
        match_policy: TargetMatchPolicy::Named { identity },
    }
}

pub(super) fn exploratory_target(id: &str, family: &str, goal: &str) -> SourceTarget {
    SourceTarget {
        id: id.to_string(),
        source_family_id: family.to_string(),
        role: SourceRole::Independent,
        transport: AcquisitionTransport::Web,
        match_policy: TargetMatchPolicy::Exploratory {
            selection_goal: goal.to_string(),
        },
    }
}

pub(super) fn spec(
    scope: EvidenceScope,
    dimensions: Vec<ResearchDimension>,
    source_targets: Vec<SourceTarget>,
    budget: ResearchBudget,
) -> ResearchSpec {
    ResearchSpec {
        version: 2,
        query: "Evaluate the requested decision from traceable evidence.".to_string(),
        language: "en".to_string(),
        current_date: "2026-07-21".to_string(),
        evidence_scope: scope,
        dimensions,
        source_targets,
        budget,
    }
}

pub(super) fn query(
    id: &str,
    transport: AcquisitionTransport,
    mode: QueryMode,
    dimensions: &[&str],
    targets: &[&str],
    fetch_slots: usize,
) -> ResearchQuery {
    ResearchQuery {
        id: id.to_string(),
        text: format!("source-seeking query for {id}"),
        transport,
        mode,
        dimension_ids: dimensions
            .iter()
            .map(|dimension| (*dimension).to_string())
            .collect(),
        source_target_ids: targets.iter().map(|target| (*target).to_string()).collect(),
        fetch_slots,
    }
}

pub(super) fn plan(
    spec: &ResearchSpec,
    queries: Vec<ResearchQuery>,
    gaps: Vec<PlanningGap>,
) -> QueryPlan {
    QueryPlan {
        spec_digest: research_spec_digest(spec),
        queries,
        planning_gaps: gaps,
    }
}