sage-cli 0.13.57

Command-line interface for Sage Agent
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
148
149
150

//! Example demonstrating the AskUserQuestion tool
//!
//! This example shows how the agent can ask users questions during execution
//! to gather information, clarify requirements, or get decisions.

use sage_core::tools::Tool;
use sage_core::tools::types::ToolCall;
use sage_tools::AskUserQuestionTool;
use serde_json::json;
use std::collections::HashMap;

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    println!("=== AskUserQuestion Tool Demo ===\n");

    let tool = AskUserQuestionTool::new();

    // Example 1: Single question
    println!("Example 1: Single choice question");
    println!("-----------------------------------");

    let mut args = HashMap::new();
    args.insert(
        "questions".to_string(),
        json!([{
            "question": "Which authentication method should we use for the API?",
            "header": "Auth method",
            "options": [
                {
                    "label": "OAuth 2.0",
                    "description": "Industry standard OAuth 2.0 authentication with token-based flow"
                },
                {
                    "label": "JWT",
                    "description": "JSON Web Tokens for stateless authentication"
                },
                {
                    "label": "API Keys",
                    "description": "Simple API key authentication for service-to-service communication"
                }
            ],
            "multi_select": false
        }]),
    );

    let call = ToolCall {
        id: "call-1".to_string(),
        name: tool.name().to_string(),
        arguments: args,
        call_id: None,
    };

    let result = tool.execute(&call).await?;
    println!("{}\n", result.output.unwrap());

    // Example 2: Multiple questions
    println!("Example 2: Multiple questions");
    println!("------------------------------");

    let mut args2 = HashMap::new();
    args2.insert(
        "questions".to_string(),
        json!([
            {
                "question": "Which frontend framework should we use?",
                "header": "Framework",
                "options": [
                    {
                        "label": "React",
                        "description": "Popular component-based library with large ecosystem"
                    },
                    {
                        "label": "Vue.js",
                        "description": "Progressive framework with gentle learning curve"
                    }
                ]
            },
            {
                "question": "Which state management solution?",
                "header": "State mgmt",
                "options": [
                    {
                        "label": "Redux",
                        "description": "Predictable state container with time-travel debugging"
                    },
                    {
                        "label": "MobX",
                        "description": "Simple, scalable state management with reactive programming"
                    }
                ]
            }
        ]),
    );

    let call2 = ToolCall {
        id: "call-2".to_string(),
        name: tool.name().to_string(),
        arguments: args2,
        call_id: None,
    };

    let result2 = tool.execute(&call2).await?;
    println!("{}\n", result2.output.unwrap());

    // Example 3: Multi-select question
    println!("Example 3: Multi-select question");
    println!("--------------------------------");

    let mut args3 = HashMap::new();
    args3.insert(
        "questions".to_string(),
        json!([{
            "question": "Which features should we prioritize for the MVP?",
            "header": "Features",
            "options": [
                {
                    "label": "User authentication",
                    "description": "Login, registration, and password reset"
                },
                {
                    "label": "Dark mode",
                    "description": "Support for light and dark color schemes"
                },
                {
                    "label": "i18n",
                    "description": "Internationalization and localization support"
                },
                {
                    "label": "Analytics",
                    "description": "Usage tracking and analytics dashboard"
                }
            ],
            "multi_select": true
        }]),
    );

    let call3 = ToolCall {
        id: "call-3".to_string(),
        name: tool.name().to_string(),
        arguments: args3,
        call_id: None,
    };

    let result3 = tool.execute(&call3).await?;
    println!("{}\n", result3.output.unwrap());

    println!("=== Demo Complete ===");

    Ok(())
}