1use std::future::Future;
5use std::sync::Arc;
6
7use serde::Deserialize;
8use serde_json::Value;
9
10use crate::approval::ApprovalDecisionInput;
11use crate::msp::{
12 ApprovalMode, ApprovalRequestParams, HistoryPreference, SessionConfig, SessionResumeParams,
13 SessionResumeResult, SessionStartParams, SessionStartResult,
14};
15use crate::session::{Session, SessionOpening, drop_unreadable_snapshot, resume_history_items};
16
17use super::{FacadeError, FacadeResult, MuseClient, invalid_frame, lock};
18
19#[derive(Clone, Debug, Default, PartialEq, Eq)]
23pub struct StartSessionOptions {
24 pub session_id: Option<String>,
28 pub workspace_root: Option<String>,
30 pub workspace_roots: Option<Vec<String>>,
34 pub model_id: Option<String>,
36 pub provider_id: Option<String>,
38 pub approval_mode: Option<ApprovalMode>,
40 pub config: Option<SessionConfig>,
42}
43
44#[derive(Clone, Debug, Default, PartialEq, Eq)]
46pub struct ResumeSessionOptions {
47 pub session_id: String,
49 pub cursor: Option<String>,
52 pub exclude_items: Option<bool>,
55 pub history: Option<HistoryPreference>,
60 pub config: Option<SessionConfig>,
62}
63
64impl MuseClient {
65 pub async fn start_session(&self, options: StartSessionOptions) -> FacadeResult<Session> {
67 let command_id = self.shared.mint_command_id()?;
68 let named = options
71 .session_id
72 .clone()
73 .map(|id| (self.shared.note_open(&id), id));
74 let params = SessionStartParams {
75 command_id,
76 recovery_mode: None,
78 session_id: options.session_id,
79 workspace_root: options.workspace_root,
80 workspace_roots: options.workspace_roots,
81 model_id: options.model_id,
82 provider_id: options.provider_id,
83 approval_mode: options.approval_mode,
84 config: options.config,
85 worktree: None,
88 permission_profile: None,
92 limits: None,
94 };
95 let result = match self
96 .shared
97 .command::<_, SessionStartResult>("session/start", ¶ms)
98 .await
99 {
100 Ok(result) => result,
101 Err(error) => {
102 if let Some((_, id)) = &named
103 && matches!(error, FacadeError::Msp(_))
104 {
105 self.shared.forget_open(id);
106 }
107 return Err(error);
108 }
109 };
110 let session = Session::from_opening(
111 Arc::clone(&self.shared),
112 SessionOpening::Start(Box::new(result)),
113 &[],
114 None,
115 );
116 let reopened = match named {
119 Some((reopened, id)) if id == session.session_id() => reopened,
120 Some((_, id)) => {
121 self.shared.forget_open(&id);
122 self.shared.note_open(session.session_id())
123 }
124 None => self.shared.note_open(session.session_id()),
125 };
126 self.shared.register(&session, reopened);
127 Ok(session)
128 }
129
130 pub async fn resume_session(&self, options: ResumeSessionOptions) -> FacadeResult<Session> {
134 self.resume_with(options, |_| {}).await
135 }
136
137 pub async fn resume_session_with_approval_handler<Handler, HandlerFuture>(
142 &self,
143 options: ResumeSessionOptions,
144 handler: Handler,
145 ) -> FacadeResult<Session>
146 where
147 Handler: Fn(ApprovalRequestParams) -> HandlerFuture + Send + Sync + 'static,
148 HandlerFuture: Future<Output = ApprovalDecisionInput> + Send + 'static,
149 {
150 self.resume_with(options, |session| session.on_approval(handler))
151 .await
152 }
153
154 async fn resume_with(
155 &self,
156 options: ResumeSessionOptions,
157 before_handoff: impl FnOnce(&Session),
158 ) -> FacadeResult<Session> {
159 if lock(&self.shared.discarded_session_ids).contains(&options.session_id) {
160 return Err(FacadeError::SessionDiscarded(options.session_id));
161 }
162 let command_id = self.shared.mint_command_id()?;
163 let reopened = self.shared.note_open(&options.session_id);
165 let params = SessionResumeParams {
166 command_id,
167 recovery_mode: None,
169 session_id: options.session_id,
170 cursor: options.cursor,
171 exclude_items: options.exclude_items,
172 history: options.history,
173 config: options.config,
174 permission_profile: None,
178 };
179 let mut raw = match self
181 .shared
182 .command::<_, Value>("session/resume", ¶ms)
183 .await
184 {
185 Ok(raw) => raw,
186 Err(error) => {
187 if matches!(error, FacadeError::Msp(_)) {
188 self.shared.forget_open(¶ms.session_id);
189 }
190 return Err(error);
191 }
192 };
193 let dropped_snapshot = drop_unreadable_snapshot(&mut raw);
194 let result = SessionResumeResult::deserialize(&raw).map_err(invalid_frame)?;
195 let history = resume_history_items(&raw, &result.history.mode);
196 let session = Session::from_opening(
197 Arc::clone(&self.shared),
198 SessionOpening::Resume(Box::new(result)),
199 history,
200 dropped_snapshot,
201 );
202 before_handoff(&session);
203 session.fix_resume_approval_routing();
204 self.shared.register(&session, reopened);
205 Ok(session)
206 }
207}