tandem-tools 0.5.13

Tooling and integrations for the Tandem engine
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
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

use serde_json::Value;
use tandem_types::{
    AccessPermission, DataClass, ResourceKind, ToolCapabilities, ToolDomain, ToolEffect,
    ToolSchema, ToolSecurityDescriptor,
};

pub(crate) fn tool_schema(
    name: &'static str,
    description: impl Into<String>,
    input_schema: Value,
) -> ToolSchema {
    ToolSchema::new(name, description, input_schema)
}

pub(crate) fn tool_schema_with_capabilities(
    name: &'static str,
    description: impl Into<String>,
    input_schema: Value,
    capabilities: ToolCapabilities,
) -> ToolSchema {
    let security = security_descriptor_for_capabilities(&capabilities);
    ToolSchema::new(name, description, input_schema)
        .with_capabilities(capabilities)
        .with_security(security)
}

pub(crate) fn workspace_read_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Read)
        .domain(ToolDomain::Workspace)
        .reads_workspace()
        .preferred_for_discovery()
}

pub(crate) fn workspace_write_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Write)
        .domain(ToolDomain::Workspace)
        .writes_workspace()
        .requires_verification()
}

pub(crate) fn workspace_search_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Search)
        .domain(ToolDomain::Workspace)
        .reads_workspace()
        .preferred_for_discovery()
}

pub(crate) fn shell_execution_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Execute)
        .domain(ToolDomain::Shell)
        .reads_workspace()
        .writes_workspace()
        .network_access()
        .destructive()
        .requires_verification()
}

pub(crate) fn web_fetch_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Fetch)
        .domain(ToolDomain::Web)
        .network_access()
        .preferred_for_discovery()
}

pub(crate) fn apply_patch_capabilities() -> ToolCapabilities {
    ToolCapabilities::new()
        .effect(ToolEffect::Patch)
        .domain(ToolDomain::Workspace)
        .reads_workspace()
        .writes_workspace()
        .requires_verification()
}

fn security_descriptor_for_capabilities(capabilities: &ToolCapabilities) -> ToolSecurityDescriptor {
    let mut security = ToolSecurityDescriptor::new();

    if capabilities.reads_workspace {
        security = security
            .permission(AccessPermission::Read)
            .resource_kind(ResourceKind::Directory)
            .resource_kind(ResourceKind::File)
            .resource_kind(ResourceKind::Repository)
            .data_class(DataClass::Internal)
            .data_class(DataClass::SourceCode);
    }

    if capabilities.writes_workspace {
        security = security
            .permission(AccessPermission::Edit)
            .resource_kind(ResourceKind::Artifact);
    }

    if capabilities.domains.contains(&ToolDomain::Shell)
        || capabilities.effects.contains(&ToolEffect::Execute)
    {
        security = security
            .permission(AccessPermission::Execute)
            .external_side_effect();
    }

    if capabilities.network_access
        && (capabilities.effects.contains(&ToolEffect::Write)
            || capabilities.effects.contains(&ToolEffect::Patch)
            || capabilities.effects.contains(&ToolEffect::Delete)
            || capabilities.effects.contains(&ToolEffect::Execute))
    {
        security = security.external_side_effect();
    }

    if capabilities.domains.contains(&ToolDomain::Web) {
        security = security
            .permission(AccessPermission::View)
            .data_class(DataClass::Public);
    }

    security
}