use serde::Serialize;
use serde::de::DeserializeOwned;
use crate::client::FacadeResult;
use crate::errors::ProtocolError;
use crate::msp::{
FeedbackClassification, FeedbackSubmitParams, FeedbackSubmitResult, HookListParams,
HookListResult, RecapRequestParams, RecapRequestResult, SessionSideChatParams,
SessionSideChatResult, SkillListParams, SkillListResult, TaskListParams, TaskListResult,
WorkflowControlResult, WorkflowPauseParams, WorkflowResumeParams, WorkflowResumeResult,
};
use super::Session;
use super::submit::require_accepted;
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct SubmitFeedbackOptions {
pub classification: FeedbackClassification,
pub note: String,
pub with_files: bool,
pub attach_session_record: bool,
pub client_artifacts_path: Option<String>,
}
impl Session {
pub async fn list_tasks(&self) -> FacadeResult<TaskListResult> {
let params = TaskListParams {
session_id: self.inner.session_id.clone(),
};
self.query("task/list", ¶ms).await
}
pub async fn list_skills(&self) -> FacadeResult<SkillListResult> {
let params = SkillListParams {
session_id: self.inner.session_id.clone(),
};
self.query("skill/list", ¶ms).await
}
pub async fn list_hooks(&self) -> FacadeResult<HookListResult> {
let params = HookListParams {
session_id: self.inner.session_id.clone(),
};
self.query("hook/list", ¶ms).await
}
pub async fn pause_workflow(
&self,
workflow_run_id: impl Into<String>,
) -> FacadeResult<WorkflowControlResult> {
let command_id = self.mint_command_id()?;
let params = WorkflowPauseParams {
session_id: self.inner.session_id.clone(),
command_id: command_id.clone(),
workflow_run_id: workflow_run_id.into(),
};
let result: WorkflowControlResult = self.query("workflow/pause", ¶ms).await?;
require_echo("workflow/pause", &result.command_id, &command_id)?;
require_accepted("workflow/pause", &result.status)?;
Ok(result)
}
pub async fn resume_workflow(
&self,
workflow_run_id: impl Into<String>,
) -> FacadeResult<WorkflowResumeResult> {
let command_id = self.mint_command_id()?;
let params = WorkflowResumeParams {
session_id: self.inner.session_id.clone(),
command_id: command_id.clone(),
workflow_run_id: workflow_run_id.into(),
};
let result: WorkflowResumeResult = self.query("workflow/resume", ¶ms).await?;
require_echo("workflow/resume", &result.command_id, &command_id)?;
require_accepted("workflow/resume", &result.status)?;
Ok(result)
}
pub async fn request_recap(&self) -> FacadeResult<RecapRequestResult> {
let command_id = self.mint_command_id()?;
let params = RecapRequestParams {
session_id: self.inner.session_id.clone(),
command_id: command_id.clone(),
};
let result: RecapRequestResult = self.query("recap/request", ¶ms).await?;
require_echo("recap/request", &result.command_id, &command_id)?;
require_accepted("recap/request", &result.status)?;
Ok(result)
}
pub async fn submit_feedback(
&self,
options: SubmitFeedbackOptions,
) -> FacadeResult<FeedbackSubmitResult> {
let params = FeedbackSubmitParams {
classification: options.classification,
note: options.note,
with_files: options.with_files,
attach_session_record: options.attach_session_record,
session_id: Some(self.inner.session_id.clone()),
client_artifacts_path: options.client_artifacts_path,
};
self.query("feedback/submit", ¶ms).await
}
pub async fn open_side_chat(&self) -> FacadeResult<SessionSideChatResult> {
let params = SessionSideChatParams {
command_id: self.mint_command_id()?,
session_id: self.inner.session_id.clone(),
};
self.query("session/sideChat", ¶ms).await
}
fn mint_command_id(&self) -> FacadeResult<String> {
self.inner.ensure_available()?;
self.inner.client.mint_command_id()
}
async fn query<P, R>(&self, method: &str, params: &P) -> FacadeResult<R>
where
P: Serialize,
R: DeserializeOwned,
{
self.inner.ensure_available()?;
self.inner.client.command(method, params).await
}
}
fn require_echo(method: &str, echoed: &str, sent: &str) -> Result<(), ProtocolError> {
if echoed == sent {
Ok(())
} else {
Err(ProtocolError::new(
format!("{method} echoed command id {echoed}, expected {sent}"),
None,
))
}
}