muse_code_sdk/session/
wire_verbs.rs1use serde::Serialize;
8use serde::de::DeserializeOwned;
9
10use crate::client::FacadeResult;
11use crate::errors::ProtocolError;
12use crate::msp::{
13 FeedbackClassification, FeedbackSubmitParams, FeedbackSubmitResult, HookListParams,
14 HookListResult, RecapRequestParams, RecapRequestResult, SessionSideChatParams,
15 SessionSideChatResult, SkillListParams, SkillListResult, TaskListParams, TaskListResult,
16 WorkflowControlResult, WorkflowPauseParams, WorkflowResumeParams, WorkflowResumeResult,
17};
18
19use super::Session;
20use super::submit::require_accepted;
21
22#[derive(Clone, Debug, PartialEq, Eq)]
24pub struct SubmitFeedbackOptions {
25 pub classification: FeedbackClassification,
27 pub note: String,
29 pub with_files: bool,
31 pub attach_session_record: bool,
34 pub client_artifacts_path: Option<String>,
37}
38
39impl Session {
40 pub async fn list_tasks(&self) -> FacadeResult<TaskListResult> {
43 let params = TaskListParams {
44 session_id: self.inner.session_id.clone(),
45 };
46 self.query("task/list", ¶ms).await
47 }
48
49 pub async fn list_skills(&self) -> FacadeResult<SkillListResult> {
51 let params = SkillListParams {
52 session_id: self.inner.session_id.clone(),
53 };
54 self.query("skill/list", ¶ms).await
55 }
56
57 pub async fn list_hooks(&self) -> FacadeResult<HookListResult> {
60 let params = HookListParams {
61 session_id: self.inner.session_id.clone(),
62 };
63 self.query("hook/list", ¶ms).await
64 }
65
66 pub async fn pause_workflow(
70 &self,
71 workflow_run_id: impl Into<String>,
72 ) -> FacadeResult<WorkflowControlResult> {
73 let command_id = self.mint_command_id()?;
74 let params = WorkflowPauseParams {
75 session_id: self.inner.session_id.clone(),
76 command_id: command_id.clone(),
77 workflow_run_id: workflow_run_id.into(),
78 };
79 let result: WorkflowControlResult = self.query("workflow/pause", ¶ms).await?;
80 require_echo("workflow/pause", &result.command_id, &command_id)?;
81 require_accepted("workflow/pause", &result.status)?;
82 Ok(result)
83 }
84
85 pub async fn resume_workflow(
90 &self,
91 workflow_run_id: impl Into<String>,
92 ) -> FacadeResult<WorkflowResumeResult> {
93 let command_id = self.mint_command_id()?;
94 let params = WorkflowResumeParams {
95 session_id: self.inner.session_id.clone(),
96 command_id: command_id.clone(),
97 workflow_run_id: workflow_run_id.into(),
98 };
99 let result: WorkflowResumeResult = self.query("workflow/resume", ¶ms).await?;
100 require_echo("workflow/resume", &result.command_id, &command_id)?;
101 require_accepted("workflow/resume", &result.status)?;
102 Ok(result)
103 }
104
105 pub async fn request_recap(&self) -> FacadeResult<RecapRequestResult> {
108 let command_id = self.mint_command_id()?;
109 let params = RecapRequestParams {
110 session_id: self.inner.session_id.clone(),
111 command_id: command_id.clone(),
112 };
113 let result: RecapRequestResult = self.query("recap/request", ¶ms).await?;
114 require_echo("recap/request", &result.command_id, &command_id)?;
115 require_accepted("recap/request", &result.status)?;
116 Ok(result)
117 }
118
119 pub async fn submit_feedback(
125 &self,
126 options: SubmitFeedbackOptions,
127 ) -> FacadeResult<FeedbackSubmitResult> {
128 let params = FeedbackSubmitParams {
129 classification: options.classification,
130 note: options.note,
131 with_files: options.with_files,
132 attach_session_record: options.attach_session_record,
133 session_id: Some(self.inner.session_id.clone()),
134 client_artifacts_path: options.client_artifacts_path,
135 };
136 self.query("feedback/submit", ¶ms).await
137 }
138
139 pub async fn open_side_chat(&self) -> FacadeResult<SessionSideChatResult> {
143 let params = SessionSideChatParams {
144 command_id: self.mint_command_id()?,
145 session_id: self.inner.session_id.clone(),
146 };
147 self.query("session/sideChat", ¶ms).await
148 }
149
150 fn mint_command_id(&self) -> FacadeResult<String> {
154 self.inner.ensure_available()?;
155 self.inner.client.mint_command_id()
156 }
157
158 async fn query<P, R>(&self, method: &str, params: &P) -> FacadeResult<R>
161 where
162 P: Serialize,
163 R: DeserializeOwned,
164 {
165 self.inner.ensure_available()?;
166 self.inner.client.command(method, params).await
167 }
168}
169
170fn require_echo(method: &str, echoed: &str, sent: &str) -> Result<(), ProtocolError> {
171 if echoed == sent {
172 Ok(())
173 } else {
174 Err(ProtocolError::new(
175 format!("{method} echoed command id {echoed}, expected {sent}"),
176 None,
177 ))
178 }
179}