use serde::{Deserialize, Serialize};
use std::collections::HashMap;
#[derive(Debug, Clone, Serialize)]
pub struct OutboundControlRequest<'a, B: Serialize> {
#[serde(rename = "type")]
pub kind: &'static str, pub request_id: &'a str,
pub request: &'a B,
}
#[derive(Debug, Clone, Serialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct Initialize {
#[serde(skip_serializing_if = "Option::is_none")]
pub hooks: Option<HashMap<HookEventKind, Vec<HookMatcherConfig>>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub system_prompt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub append_system_prompt: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub agents: Option<serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub json_schema: Option<serde_json::Value>,
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub skills: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub plugins: Option<Vec<serde_json::Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub mcp_servers: Option<serde_json::Map<String, serde_json::Value>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_mode_instructions: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_dynamic_sections: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub system_prompt_snapshot: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub prompt_suggestions: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub agent_progress_summaries: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub forward_subagent_text: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub tool_aliases: Option<HashMap<String, String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub supported_dialog_kinds: Option<Vec<String>>,
#[serde(skip_serializing_if = "Option::is_none")]
pub per_task_stop_affordance: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub workspace_trust: Option<WorkspaceTrust>,
}
#[derive(Debug, Clone, Serialize)]
pub struct WorkspaceTrust {
pub accepted: bool,
pub directory: String,
}
#[derive(Debug, Clone, Serialize)]
#[serde(rename_all = "camelCase")]
pub struct HookMatcherConfig {
pub matcher: Option<String>,
pub hook_callback_ids: Vec<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<u32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub enum PermissionMode {
Default,
AcceptEdits,
BypassPermissions,
Plan,
DontAsk,
Auto,
}
impl PermissionMode {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Default => "default",
Self::AcceptEdits => "acceptEdits",
Self::BypassPermissions => "bypassPermissions",
Self::Plan => "plan",
Self::DontAsk => "dontAsk",
Self::Auto => "auto",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Effort {
Low,
Medium,
High,
Xhigh,
Max,
}
impl Effort {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Low => "low",
Self::Medium => "medium",
Self::High => "high",
Self::Xhigh => "xhigh",
Self::Max => "max",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Thinking {
Enabled,
Adaptive,
Disabled,
}
impl Thinking {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Enabled => "enabled",
Self::Adaptive => "adaptive",
Self::Disabled => "disabled",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum ThinkingDisplay {
Summarized,
Omitted,
Highlights,
}
impl ThinkingDisplay {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Summarized => "summarized",
Self::Omitted => "omitted",
Self::Highlights => "highlights",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum Autocompact {
Auto,
Tokens(u64),
}
impl Autocompact {
#[must_use]
pub fn to_arg(self) -> String {
match self {
Self::Auto => "auto".into(),
Self::Tokens(n) => n.to_string(),
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum PermissionPrompts {
Host,
None,
}
impl PermissionPrompts {
#[must_use]
pub fn as_str(self) -> &'static str {
match self {
Self::Host => "host",
Self::None => "none",
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum Priority {
Now,
Next,
Later,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserMessage {
#[serde(rename = "type")]
pub kind: String, pub message: UserMessageBody,
pub parent_tool_use_id: Option<String>,
pub uuid: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub priority: Option<Priority>,
#[serde(default, rename = "shouldQuery", skip_serializing_if = "Option::is_none")]
pub should_query: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub timestamp: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub client_composed: Option<bool>,
}
impl UserMessage {
pub fn text(content: impl Into<String>) -> Self {
Self::blocks(vec![ContentBlock::Text { text: content.into() }])
}
#[must_use]
pub fn blocks(content: Vec<ContentBlock>) -> Self {
Self {
kind: "user".into(),
message: UserMessageBody { role: "user".into(), content },
parent_tool_use_id: None,
uuid: uuid::Uuid::new_v4().to_string(),
priority: None,
should_query: None,
timestamp: None,
client_composed: None,
}
}
#[must_use]
pub fn with_timestamp(mut self, timestamp: impl Into<String>) -> Self {
self.timestamp = Some(timestamp.into());
self
}
#[must_use]
pub fn client_composed(mut self) -> Self {
self.client_composed = Some(true);
self
}
#[must_use]
pub fn with_priority(mut self, priority: Priority) -> Self {
self.priority = Some(priority);
self
}
#[must_use]
pub fn context_only(mut self) -> Self {
self.should_query = Some(false);
self
}
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct UserMessageBody {
pub role: String,
pub content: Vec<ContentBlock>,
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type")]
pub enum ContentBlock {
#[serde(rename = "text")]
Text {
text: String,
},
#[serde(rename = "image")]
Image {
source: ImageSource,
},
#[serde(rename = "document")]
Document {
source: DocumentSource,
#[serde(default, skip_serializing_if = "Option::is_none")]
title: Option<String>,
},
#[serde(rename = "tool_result")]
ToolResult {
tool_use_id: String,
content: Vec<ContentBlock>,
#[serde(default, skip_serializing_if = "Option::is_none")]
is_error: Option<bool>,
},
}
impl ContentBlock {
pub fn image_base64(media_type: impl Into<String>, data: impl Into<String>) -> Self {
Self::Image {
source: ImageSource::Base64 { media_type: media_type.into(), data: data.into() },
}
}
pub fn pdf_base64(data: impl Into<String>) -> Self {
Self::Document {
source: DocumentSource::Base64 { media_type: "application/pdf".into(), data: data.into() },
title: None,
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum DocumentSource {
Base64 {
media_type: String,
data: String,
},
Text {
media_type: String,
data: String,
},
Url {
url: String,
},
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "lowercase")]
pub enum ImageSource {
Base64 {
media_type: String,
data: String,
},
Url {
url: String,
},
}
#[derive(Debug, Clone, Serialize)]
pub struct ControlResponse {
#[serde(rename = "type")]
pub kind: &'static str, pub response: ControlResponseBody,
}
#[derive(Debug, Clone, Serialize)]
#[serde(tag = "subtype", rename_all = "lowercase")]
pub enum ControlResponseBody {
Success {
request_id: String,
response: serde_json::Value,
},
Error {
request_id: String,
error: String,
},
}
impl ControlResponse {
pub fn success(request_id: impl Into<String>, response: serde_json::Value) -> Self {
Self {
kind: "control_response",
response: ControlResponseBody::Success { request_id: request_id.into(), response },
}
}
pub fn error(request_id: impl Into<String>, error: impl Into<String>) -> Self {
Self {
kind: "control_response",
response: ControlResponseBody::Error { request_id: request_id.into(), error: error.into() },
}
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
#[serde(tag = "behavior", rename_all = "camelCase")]
pub enum ToolDecision {
#[serde(rename = "allow")]
Allow {
#[serde(rename = "updatedInput", skip_serializing_if = "Option::is_none")]
updated_input: Option<serde_json::Value>,
#[serde(rename = "updatedPermissions", default, skip_serializing_if = "Option::is_none")]
updated_permissions: Option<Vec<serde_json::Value>>,
},
#[serde(rename = "deny")]
Deny {
message: String,
#[serde(skip_serializing_if = "Option::is_none")]
interrupt: Option<bool>,
},
}
impl ToolDecision {
#[must_use]
pub fn allow() -> Self { Self::Allow { updated_input: None, updated_permissions: None } }
#[must_use]
pub fn allow_with_input(input: serde_json::Value) -> Self {
Self::Allow { updated_input: Some(input), updated_permissions: None }
}
#[must_use]
pub fn allow_and_remember(updates: Vec<serde_json::Value>) -> Self {
Self::Allow { updated_input: None, updated_permissions: Some(updates) }
}
pub fn deny(message: impl Into<String>) -> Self {
Self::Deny { message: message.into(), interrupt: None }
}
}
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize, Default)]
#[serde(rename_all = "camelCase")]
pub struct HookOutput {
#[serde(rename = "continue", skip_serializing_if = "Option::is_none")]
pub continue_: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub suppress_output: Option<bool>,
#[serde(skip_serializing_if = "Option::is_none")]
pub stop_reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub decision: Option<HookDecision>,
#[serde(skip_serializing_if = "Option::is_none")]
pub system_message: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub reason: Option<String>,
#[serde(skip_serializing_if = "Option::is_none")]
pub hook_specific_output: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
#[serde(rename_all = "lowercase")]
pub enum HookDecision {
Approve,
Block,
}
impl HookOutput {
#[must_use]
pub fn allow() -> Self { Self::default() }
pub fn block(reason: impl Into<String>) -> Self {
Self { decision: Some(HookDecision::Block), reason: Some(reason.into()), ..Self::default() }
}
pub fn with_context(event: HookEventKind, context: impl Into<String>) -> Self {
Self {
hook_specific_output: Some(serde_json::json!({
"hookEventName": event,
"additionalContext": context.into(),
})),
..Self::default()
}
}
#[must_use]
pub fn watch_paths(event: HookEventKind, paths: impl IntoIterator<Item = impl Into<String>>) -> Self {
let paths: Vec<String> = paths.into_iter().map(Into::into).collect();
Self {
hook_specific_output: Some(serde_json::json!({
"hookEventName": event,
"watchPaths": paths,
})),
..Self::default()
}
}
#[must_use]
pub fn is_block(&self) -> bool { self.decision == Some(HookDecision::Block) }
}
#[derive(Debug, Clone, Serialize)]
pub struct BackgroundTasksRequest {
pub subtype: &'static str, #[serde(skip_serializing_if = "Option::is_none")]
pub tool_use_id: Option<String>,
}
impl BackgroundTasksRequest {
#[must_use]
pub fn all() -> Self {
Self { subtype: "background_tasks", tool_use_id: None }
}
pub fn one(tool_use_id: impl Into<String>) -> Self {
Self { subtype: "background_tasks", tool_use_id: Some(tool_use_id.into()) }
}
}
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "type")]
#[non_exhaustive]
pub enum InboundMessage {
#[serde(rename = "system")]
System(SystemMessage),
#[serde(rename = "user")]
User(InboundUserMessage),
#[serde(rename = "assistant")]
Assistant(AssistantMessage),
#[serde(rename = "stream_event")]
StreamEvent(StreamEventMessage),
#[serde(rename = "result")]
Result(ResultMessage),
#[serde(rename = "control_request")]
ControlRequest(ControlRequest),
#[serde(rename = "control_response")]
ControlResponse(InboundControlResponse),
#[serde(rename = "keep_alive")]
KeepAlive(KeepAliveMessage),
#[serde(rename = "control_cancel_request")]
ControlCancelRequest(ControlCancelRequest),
#[serde(skip_deserializing)]
Other(serde_json::Value),
#[doc(hidden)]
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ControlCancelRequest {
pub request_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
#[non_exhaustive]
pub struct SystemMessage {
pub subtype: String, pub session_id: String,
#[serde(default)]
pub cwd: String,
#[serde(default)]
pub model: String,
#[serde(default)]
pub claude_code_version: String,
#[serde(default)]
pub permission_mode: String,
#[serde(default)]
pub tools: Vec<String>,
#[serde(default)]
pub betas: Vec<String>,
#[serde(default)]
pub capabilities: Vec<String>,
#[serde(default)]
pub skills: Vec<serde_json::Value>,
#[serde(default)]
pub plugins: Vec<serde_json::Value>,
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
impl SystemMessage {
#[must_use]
pub fn code_mode_active(&self) -> bool {
self.tools.iter().any(|t| t == "REPL" || t == "Eval")
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AssistantMessage {
pub message: AssistantMessageBody,
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub parent_tool_use_id: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct AssistantMessageBody {
pub role: String,
pub content: Vec<AssistantBlock>,
#[serde(default)]
pub stop_reason: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "type")]
#[non_exhaustive]
pub enum AssistantBlock {
#[serde(rename = "text")]
Text {
text: String,
},
#[serde(rename = "tool_use")]
ToolUse {
id: String,
name: String,
input: serde_json::Value,
},
#[serde(rename = "thinking")]
Thinking {
thinking: String,
},
#[serde(rename = "redacted_thinking")]
RedactedThinking {
data: String,
},
#[serde(rename = "server_tool_use")]
ServerToolUse {
id: String,
name: String,
input: serde_json::Value,
},
#[serde(rename = "web_search_tool_result")]
WebSearchToolResult {
tool_use_id: String,
content: serde_json::Value,
},
#[serde(other)]
Unknown,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct InboundUserMessage {
#[serde(default)]
pub uuid: Option<String>,
#[serde(default, rename = "isReplay")]
pub is_replay: Option<bool>,
#[serde(default, rename = "isSynthetic")]
pub is_synthetic: Option<bool>,
#[serde(default)]
pub parent_tool_use_id: Option<String>,
#[serde(default)]
pub agent_id: Option<String>,
#[serde(default)]
pub message: Option<InboundUserBody>,
#[serde(default)]
pub tool_use_result: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct InboundUserBody {
#[serde(default)]
pub content: serde_json::Value,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct InboundToolResult {
pub tool_use_id: String,
#[serde(default)]
pub content: serde_json::Value,
#[serde(default)]
pub is_error: bool,
}
impl InboundUserMessage {
#[must_use]
pub fn tool_results(&self) -> Vec<InboundToolResult> {
let Some(blocks) = self.message.as_ref().and_then(|m| m.content.as_array()) else {
return vec![];
};
blocks
.iter()
.filter(|b| b.get("type").and_then(|t| t.as_str()) == Some("tool_result"))
.filter_map(|b| InboundToolResult::deserialize(b).ok())
.collect()
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct StreamEventMessage {
pub event: serde_json::Value,
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub ttft_ms: Option<u64>,
#[serde(default)]
pub parent_tool_use_id: Option<String>,
}
#[derive(Debug, Clone, Default, Deserialize)]
#[non_exhaustive]
pub struct ResultMessage {
#[serde(default)]
pub subtype: String,
#[serde(default)]
pub is_error: bool,
#[serde(default)]
pub result: Option<String>,
#[serde(default)]
pub errors: Option<Vec<serde_json::Value>>,
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub total_cost_usd: Option<f64>,
#[serde(default)]
pub ttft_ms: Option<u64>,
#[serde(default)]
pub duration_ms: Option<u64>,
#[serde(default)]
pub usage: Option<UsageSummary>,
#[serde(default)]
pub stop_reason: Option<String>,
#[serde(default)]
pub duration_api_ms: Option<u64>,
#[serde(default)]
pub num_turns: Option<u64>,
#[serde(default)]
pub terminal_reason: Option<String>,
#[serde(default)]
pub structured_output: Option<serde_json::Value>,
#[serde(default)]
pub permission_denials: Vec<serde_json::Value>,
#[serde(default, rename = "modelUsage")]
pub model_usage: Option<serde_json::Value>,
#[serde(default)]
pub user_message_uuids: Vec<String>,
#[serde(default)]
pub origin: Option<serde_json::Value>,
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
impl ResultMessage {
#[must_use]
pub fn is_success(&self) -> bool {
self.subtype == "success" && !self.is_error
}
#[must_use]
pub fn answers(&self, uuid: &str) -> bool {
self.user_message_uuids.iter().any(|u| u.eq_ignore_ascii_case(uuid))
}
#[must_use]
pub fn error_kind(&self) -> TurnErrorKind {
match self.subtype.as_str() {
"error_during_execution" => TurnErrorKind::Execution,
"error_max_turns" => TurnErrorKind::MaxTurns,
"error_max_budget_usd" => TurnErrorKind::MaxBudget,
"error_max_structured_output_retries" => TurnErrorKind::StructuredOutputRetries,
"success" => TurnErrorKind::Api,
other => TurnErrorKind::Other(other.to_string()),
}
}
#[must_use]
pub fn error_message(&self) -> String {
if let Some(r) = self.result.as_ref().filter(|r| self.is_error && !r.is_empty()) {
return r.clone();
}
let details: Vec<String> = self.errors.iter().flatten()
.map(|v| v.as_str().map_or_else(|| v.to_string(), str::to_owned))
.collect();
if details.is_empty() { self.subtype.clone() } else { format!("{}: {}", self.subtype, details.join("; ")) }
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub enum TurnErrorKind {
Execution,
MaxTurns,
MaxBudget,
StructuredOutputRetries,
Api,
SessionClosed,
Cancelled,
Other(String),
}
#[derive(Debug, Clone, Deserialize, Default)]
#[non_exhaustive]
pub struct UsageSummary {
#[serde(default)]
pub input_tokens: u64,
#[serde(default)]
pub output_tokens: u64,
#[serde(default)]
pub cache_read_input_tokens: Option<u64>,
#[serde(default)]
pub cache_creation_input_tokens: Option<u64>,
#[serde(default)]
pub cache_creation: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ControlRequest {
pub request_id: String,
pub request: ControlRequestBody,
}
#[derive(Debug, Clone, Deserialize)]
#[serde(tag = "subtype")]
#[non_exhaustive]
pub enum ControlRequestBody {
#[serde(rename = "can_use_tool")]
CanUseTool(CanUseToolRequest),
#[serde(rename = "hook_callback")]
HookCallback(HookCallbackRequest),
#[serde(rename = "mcp_message")]
McpMessage(McpMessageRequest),
#[serde(rename = "elicitation")]
Elicitation(ElicitationRequest),
#[serde(rename = "request_user_dialog")]
RequestUserDialog(UserDialogRequest),
#[serde(other)]
Unsupported,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct CanUseToolRequest {
pub tool_name: String,
pub input: serde_json::Value,
#[serde(default)]
pub tool_use_id: Option<String>,
#[serde(default)]
pub permission_suggestions: Option<Vec<serde_json::Value>>,
#[serde(default)]
pub decision_reason: Option<String>,
#[serde(default)]
pub decision_reason_type: Option<String>,
#[serde(default)]
pub mcp_server: Option<serde_json::Value>,
#[serde(default)]
pub blocked_path: Option<String>,
#[serde(default)]
pub classifier_approvable: Option<bool>,
#[serde(default)]
pub suppress_always_allow_rule: Option<bool>,
#[serde(default)]
pub default_to_no: Option<bool>,
#[serde(default)]
pub matched_ask_rule: Option<serde_json::Value>,
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub display_name: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(default)]
pub agent_id: Option<String>,
#[serde(default)]
pub requires_user_interaction: Option<bool>,
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct ElicitationRequest {
pub mcp_server_name: String,
pub message: String,
#[serde(default)]
pub mode: Option<String>,
#[serde(default)]
pub url: Option<String>,
#[serde(default)]
pub elicitation_id: Option<String>,
#[serde(default)]
pub requested_schema: Option<serde_json::Value>,
#[serde(default)]
pub property_order: Option<Vec<String>>,
#[serde(default)]
pub title: Option<String>,
#[serde(default)]
pub display_name: Option<String>,
#[serde(default)]
pub description: Option<String>,
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Serialize)]
pub struct ElicitationResponse {
pub action: ElicitationAction,
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<serde_json::Map<String, serde_json::Value>>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
#[serde(rename_all = "lowercase")]
pub enum ElicitationAction {
Accept,
Decline,
Cancel,
}
impl ElicitationResponse {
#[must_use]
pub fn accept(content: serde_json::Map<String, serde_json::Value>) -> Self {
Self { action: ElicitationAction::Accept, content: Some(content) }
}
#[must_use]
pub fn decline() -> Self {
Self { action: ElicitationAction::Decline, content: None }
}
#[must_use]
pub fn cancel() -> Self {
Self { action: ElicitationAction::Cancel, content: None }
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct UserDialogRequest {
pub dialog_kind: String,
#[serde(default)]
pub payload: serde_json::Value,
#[serde(default)]
pub tool_use_id: Option<String>,
}
#[derive(Debug, Clone, Serialize, PartialEq)]
pub struct UserDialogResponse {
pub behavior: UserDialogBehavior,
#[serde(skip_serializing_if = "Option::is_none")]
pub result: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Copy, Serialize, PartialEq, Eq)]
#[serde(rename_all = "lowercase")]
pub enum UserDialogBehavior {
Completed,
Cancelled,
}
impl UserDialogResponse {
pub fn completed(result: impl Into<serde_json::Value>) -> Self {
Self { behavior: UserDialogBehavior::Completed, result: Some(result.into()) }
}
#[must_use]
pub fn cancelled() -> Self {
Self { behavior: UserDialogBehavior::Cancelled, result: None }
}
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct McpMessageRequest {
pub server_name: String,
pub message: serde_json::Value,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct HookCallbackRequest {
pub callback_id: String,
pub input: HookEventPayload,
#[serde(default)]
pub tool_use_id: Option<String>,
#[serde(default)]
pub issued_at: Option<u64>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct InboundControlResponse {
pub response: InboundControlResponseBody,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct InboundControlResponseBody {
pub subtype: String, pub request_id: String,
#[serde(default)]
pub response: Option<serde_json::Value>,
#[serde(default)]
pub error: Option<String>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct HookEventPayload {
pub hook_event_name: HookEventKind,
#[serde(default)]
pub tool_name: Option<String>,
#[serde(default)]
pub tool_input: Option<serde_json::Value>,
#[serde(default)]
pub tool_use_id: Option<String>,
#[serde(default)]
pub error: Option<String>,
#[serde(default)]
pub is_interrupt: Option<bool>,
#[serde(default)]
pub session_id: Option<String>,
#[serde(default)]
pub cwd: Option<String>,
#[serde(default)]
pub file_path: Option<String>,
#[serde(default)]
pub event: Option<String>, #[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct BackgroundTask {
pub task_id: String,
#[serde(default)]
pub run_id: Option<String>,
#[serde(default)]
pub task_type: String,
#[serde(default)]
pub subagent_type: Option<String>,
#[serde(default)]
pub description: String,
#[serde(default)]
pub parent_task_id: Option<String>,
#[serde(default)]
pub ambient: Option<bool>,
#[serde(default)]
pub awaited: Option<bool>,
#[serde(default)]
pub off_host: Option<bool>,
}
#[derive(Debug, Clone, Deserialize)]
#[non_exhaustive]
pub struct KeepAliveMessage {
#[serde(flatten)]
pub extra: HashMap<String, serde_json::Value>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
pub struct ToolDef {
pub name: String,
pub description: String,
#[serde(skip_serializing_if = "Option::is_none")]
pub input_schema: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub output_schema: Option<serde_json::Value>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub annotations: Option<ToolAnnotations>,
}
#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct ToolAnnotations {
#[serde(default, skip_serializing_if = "Option::is_none")]
pub read_only_hint: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub destructive_hint: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub idempotent_hint: Option<bool>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub open_world_hint: Option<bool>,
}
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct McpManifest {
pub name: String,
pub tools: Vec<ToolDef>,
#[serde(default)]
pub server_info: Option<serde_json::Value>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[serde(rename_all = "PascalCase")]
#[non_exhaustive]
pub enum HookEventKind {
PreToolUse,
PostToolUse,
PostToolUseFailure,
PostToolBatch,
Notification,
UserPromptSubmit,
UserPromptExpansion,
SessionStart,
SessionEnd,
Stop,
StopFailure,
SubagentStart,
SubagentStop,
PreCompact,
PostCompact,
PreModelSwitch,
PostModelSwitch,
PermissionRequest,
PermissionDenied,
Setup,
TeammateIdle,
TaskCreated,
TaskCompleted,
Elicitation,
ElicitationResult,
ConfigChange,
WorktreeCreate,
WorktreeRemove,
InstructionsLoaded,
CwdChanged,
FileChanged,
DirectoryAdded,
MessageDisplay,
}