a3s 0.9.5

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
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
151
152
153
154

use a3s_code_core::{AgentSession, TokenUsage};
use serde::{Deserialize, Serialize};

use super::session_store::CodeWebSessionMetadata;

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct CreateSessionRequest {
    pub workspace: Option<String>,
    pub cwd: Option<String>,
    pub model: Option<String>,
    pub follow_default_model: Option<bool>,
    pub permission_mode: Option<String>,
    pub planning_mode: Option<String>,
    pub goal_tracking: Option<bool>,
    pub title: Option<String>,
    pub agent_id: Option<String>,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct ChatRequest {
    pub session_id: Option<String>,
    pub workspace: Option<String>,
    pub model: Option<String>,
    pub message: String,
}

#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct SleepSessionRequest {
    pub focus: Option<String>,
}

#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct ForkSessionRequest {
    pub focus: Option<String>,
}

#[derive(Debug, Default, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct ShellSessionRequest {
    pub command: String,
}

#[derive(Debug, Deserialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct ConfirmToolUseRequest {
    pub approved: bool,
    pub reason: Option<String>,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct HealthResponse {
    pub ok: bool,
    pub app: String,
    pub version: String,
    pub config_path: String,
    pub workspace: String,
    pub model: Option<String>,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct SessionResponse {
    session_id: String,
    workspace: String,
    cwd: String,
    model: Option<String>,
    follow_default_model: bool,
    permission_mode: String,
    state: String,
    title: Option<String>,
    agent_id: Option<String>,
    created_at: i64,
}

impl SessionResponse {
    pub(in crate::api::code_web) fn from_session(
        session: &AgentSession,
        model: Option<String>,
        follow_default_model: bool,
        permission_mode: String,
        metadata: &CodeWebSessionMetadata,
    ) -> Self {
        let workspace = session.workspace().display().to_string();
        Self {
            session_id: session.session_id().to_string(),
            workspace: workspace.clone(),
            cwd: workspace,
            model,
            follow_default_model,
            permission_mode,
            state: "connected".to_string(),
            title: metadata.title.clone(),
            agent_id: Some(
                metadata
                    .agent_id
                    .clone()
                    .unwrap_or_else(|| "default".to_string()),
            ),
            created_at: if metadata.created_at > 0 {
                metadata.created_at
            } else {
                chrono::Utc::now().timestamp_millis()
            },
        }
    }
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct KernelSessionResponse {
    pub success: bool,
    pub session: SessionResponse,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct SessionListResponse {
    pub items: Vec<SessionResponse>,
    pub total: usize,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct ChatResponse {
    pub session_id: String,
    pub workspace: String,
    pub model: Option<String>,
    pub text: String,
    pub usage: UsageResponse,
    pub tool_calls_count: usize,
}

#[derive(Debug, Serialize)]
#[serde(rename_all = "camelCase")]
pub(in crate::api::code_web) struct UsageResponse {
    prompt_tokens: usize,
    completion_tokens: usize,
    total_tokens: usize,
}

impl UsageResponse {
    pub(in crate::api::code_web) fn from_usage(usage: TokenUsage) -> Self {
        Self {
            prompt_tokens: usage.prompt_tokens,
            completion_tokens: usage.completion_tokens,
            total_tokens: usage.total_tokens,
        }
    }
}