greentic 0.2.2

The fastest, most secure and extendable digital workers platform
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

// src/schema.rs

use std::{collections::HashSet, fs, path::PathBuf, sync::Arc};

use anyhow::Error;
use channel_plugin::message::LogLevel;
use schemars::schema_for;
use serde_json::{Value, json};

use crate::{
    channel::manager::ChannelManager,
    config::{ConfigManager, MapConfigManager},
    executor::Executor,
    flow::{manager::Flow, session::{InMemorySessionStore}},
    logger::{FileTelemetry, LogConfig, Logger, OpenTelemetryLogger},
    secret::{TestSecretsManager, SecretsManager},
};

/// The entry point invoked by `main.rs` for `Commands::Schema`.
pub async fn write_schema(
    out_dir: PathBuf,
    tools_dir: PathBuf,
    channels_dir: PathBuf,
    remote_channels: Vec<String>,
    log_level: String,
    log_dir: PathBuf,
    event_dir: PathBuf,
) -> Result<(), Error> {
    fs::create_dir_all(&out_dir)?;

    // 2) flow schema
    let flow_schema = schema_for!(Flow);
    let flow_json = serde_json::to_string_pretty(&flow_schema)?;
    fs::write(out_dir.join("flow.schema.json"), flow_json)?;

    // 3) tool schemas
    let _ = FileTelemetry::init_files(log_level.as_str(), log_dir.join("schema.log"), event_dir);
    let log_config = LogConfig::new(LogLevel::Info, Some(log_dir), None);
    let logger = Logger(Box::new(OpenTelemetryLogger::new()));
    let secrets = SecretsManager(TestSecretsManager::new());
    let executor = Executor::new(secrets.clone(), logger);
    executor
        .watch_tool_dir(tools_dir)
        .await
        .expect("Could not load tools");
    write_tools_schema(executor.clone(), &out_dir)?;

    // 4) channel schemas
    let config = ConfigManager(MapConfigManager::new());
    let store = InMemorySessionStore::new(10);
    let channel_mgr = ChannelManager::new(config, secrets, "123".to_string(),store.clone(), log_config)
        .await
        .expect("Could not start channels");
    let _ = channel_mgr.clone().start_all(channels_dir, remote_channels).await;

    for wrapper in channel_mgr.channels().iter() {
        let (name, schema) = wrapper
            .wrapper()
            .schema_json()
            .await
            .expect("Could not get schema_json from wrapper");
        let filename = format!("channel-{}.schema.json", name.to_lowercase());
        fs::write(out_dir.join(filename), schema)?;
    }

    channel_mgr.shutdown_all(false, 0);

    Ok(())
}

/// Emit each tool’s parameter+secret schema under `out_dir/tool-<tool_id>/`.
fn write_tools_schema(executor: Arc<Executor>, out_dir: &PathBuf) -> anyhow::Result<()> {
    for key in executor.list_tool_keys() {
        let tool = executor
            .get_tool(key.clone())
            .expect("`key` came from `list_tool_keys`");

        // parameters schema
        let params_schema: Value = tool.parameters();

        // build properties object
        let mut props = serde_json::Map::new();
        props.insert("parameters".to_string(), params_schema);

        // secrets subschema, if any

        let mut required = Vec::new();
        let secret_keys = tool.secrets();
        if !secret_keys.is_empty() {
            let mut sec_props = serde_json::Map::new();
            for sk in &secret_keys {
                let mut field = serde_json::Map::new();
                field.insert("type".into(), json!("string"));

                field.insert("description".into(), json!(&sk.description));

                sec_props.insert(sk.name.clone(), Value::Object(field));
                if sk.required {
                    required.push(Value::String(sk.name.clone()));
                }
            }
            // de-duplicaet secrets
            let mut seen = HashSet::new();
            required.retain(|v| {
                if let Value::String(s) = v {
                    seen.insert(s.clone())
                } else {
                    true
                }
            });

            let mut sec_schema = serde_json::Map::new();
            sec_schema.insert("type".into(), json!("object"));
            sec_schema.insert("properties".into(), Value::Object(sec_props));
            if !required.is_empty() {
                sec_schema.insert("required".into(), Value::Array(required.clone()));
                props.insert("secrets".into(), Value::Object(sec_schema));
                // ensure top‐level requires "secrets"
                required.push(Value::String("secrets".into()));
            }
        }

        // assemble full schema
        let mut root = serde_json::Map::new();
        root.insert(
            "$schema".into(),
            json!("http://json-schema.org/draft-07/schema#"),
        );
        root.insert("title".into(), json!(tool.name()));
        root.insert("description".into(), json!(tool.description()));
        root.insert("type".into(), json!("object"));
        root.insert("properties".into(), Value::Object(props));
        if !required.is_empty() {
            root.insert("required".into(), Value::Array(required));
        }

        let json_text = serde_json::to_string_pretty(&Value::Object(root))?;

        // write under tool-<id>/tool-<id>.schema.json
        let tool_dir = out_dir.join(format!("tool-{}", key));
        fs::create_dir_all(&tool_dir)?;
        let filename = format!("tool-{}.schema.json", key);
        fs::write(tool_dir.join(filename), json_text)?;
    }

    Ok(())
}