use indexmap::IndexMap;
use schemars::JsonSchema;
use serde::{Deserialize, Serialize};
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.Payload")]
#[serde(tag = "type", rename_all = "snake_case")]
pub enum Payload {
#[schemars(title = "Initialize")]
Initialize {
mcp_kind: super::super::McpKind,
#[serde(flatten)]
params: InitializeRequest,
},
#[schemars(title = "ToolsList")]
ToolsList {
mcp_kind: super::super::McpKind,
#[serde(flatten)]
params: crate::mcp::tool::ListToolsRequest,
},
#[schemars(title = "ToolsCall")]
ToolsCall {
mcp_kind: super::super::McpKind,
#[serde(flatten)]
params: crate::mcp::tool::CallToolRequestParams,
},
#[schemars(title = "ResourcesList")]
ResourcesList {
mcp_kind: super::super::McpKind,
#[serde(flatten)]
params: crate::mcp::resource::ListResourcesRequest,
},
#[schemars(title = "ResourcesRead")]
ResourcesRead {
mcp_kind: super::super::McpKind,
#[serde(flatten)]
params: crate::mcp::resource::ReadResourceRequestParams,
},
#[schemars(title = "SessionTerminate")]
SessionTerminate { mcp_kind: super::super::McpKind },
#[schemars(title = "ReadMessageQueue")]
ReadMessageQueue(ReadMessageQueueRequest),
#[schemars(title = "Retrieve")]
Retrieve(super::super::retrieve::Request),
#[schemars(title = "Script")]
Script(ScriptRequest),
#[schemars(title = "Drop")]
Drop(DropRequest),
#[schemars(title = "LaboratoryExportBegin")]
LaboratoryExportBegin(LaboratoryExportBeginRequest),
#[schemars(title = "LaboratoryExportRead")]
LaboratoryExportRead(LaboratoryExportReadRequest),
#[schemars(title = "LaboratoryExportAbort")]
LaboratoryExportAbort(LaboratoryExportAbortRequest),
#[schemars(title = "LaboratoryImportBegin")]
LaboratoryImportBegin(LaboratoryImportBeginRequest),
#[schemars(title = "LaboratoryImportWrite")]
LaboratoryImportWrite(LaboratoryImportWriteRequest),
#[schemars(title = "LaboratoryImportEnd")]
LaboratoryImportEnd(LaboratoryImportEndRequest),
#[schemars(title = "LaboratoryImportAbort")]
LaboratoryImportAbort(LaboratoryImportAbortRequest),
#[schemars(title = "LaboratoryTransfer")]
LaboratoryTransfer(LaboratoryTransferRequest),
#[schemars(title = "LaboratoryLocalTransfer")]
LaboratoryLocalTransfer(LaboratoryLocalTransferRequest),
#[schemars(title = "Command")]
Command {
identity: crate::identity::Identity,
plugin: crate::mcp::server::Plugin,
request: crate::cli::command::Request,
},
}
impl Payload {
pub fn mcp_kind(&self) -> Option<super::super::McpKind> {
match self {
Payload::Initialize { mcp_kind, .. }
| Payload::ToolsList { mcp_kind, .. }
| Payload::ToolsCall { mcp_kind, .. }
| Payload::ResourcesList { mcp_kind, .. }
| Payload::ResourcesRead { mcp_kind, .. }
| Payload::SessionTerminate { mcp_kind } => Some(mcp_kind.clone()),
Payload::ReadMessageQueue(_)
| Payload::Retrieve(_)
| Payload::Script(_)
| Payload::Drop(_)
| Payload::LaboratoryExportBegin(_)
| Payload::LaboratoryExportRead(_)
| Payload::LaboratoryExportAbort(_)
| Payload::LaboratoryImportBegin(_)
| Payload::LaboratoryImportWrite(_)
| Payload::LaboratoryImportEnd(_)
| Payload::LaboratoryImportAbort(_)
| Payload::LaboratoryTransfer(_)
| Payload::LaboratoryLocalTransfer(_)
| Payload::Command { .. }
=> None,
}
}
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.ReadMessageQueueRequest")]
pub struct ReadMessageQueueRequest {
pub agent_instance_hierarchy: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.DropRequest")]
pub struct DropRequest {
pub response_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryExportBeginRequest")]
pub struct LaboratoryExportBeginRequest {
pub laboratory_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub machine_state: Option<String>,
pub path: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryExportReadRequest")]
pub struct LaboratoryExportReadRequest {
pub transfer_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryExportAbortRequest")]
pub struct LaboratoryExportAbortRequest {
pub transfer_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryImportBeginRequest")]
pub struct LaboratoryImportBeginRequest {
pub laboratory_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub machine_state: Option<String>,
pub path: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryImportWriteRequest")]
pub struct LaboratoryImportWriteRequest {
pub transfer_id: String,
#[serde(skip)]
pub data: Vec<u8>,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryImportEndRequest")]
pub struct LaboratoryImportEndRequest {
pub transfer_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryImportAbortRequest")]
pub struct LaboratoryImportAbortRequest {
pub transfer_id: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryTransferRequest")]
pub struct LaboratoryTransferRequest {
pub source_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub source_machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub source_machine_state: Option<String>,
pub source_path: String,
pub destination_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub destination_machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub destination_machine_state: Option<String>,
pub destination_path: String,
}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.LaboratoryLocalTransferRequest")]
pub struct LaboratoryLocalTransferRequest {
pub source_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub source_machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub source_machine_state: Option<String>,
pub source_path: String,
pub destination_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub destination_machine: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub destination_machine_state: Option<String>,
pub destination_path: String,
}
#[derive(Debug, Clone, Default, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.InitializeRequest")]
pub struct InitializeRequest {}
#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
#[schemars(rename = "client_objectiveai_mcp.server_request.ScriptRequest")]
pub struct ScriptRequest {
pub script: crate::agent::script::Script,
pub messages: Vec<crate::agent::completions::message::Message>,
pub agent_instance_hierarchy: String,
pub agent_id: String,
pub agent_full_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub agent_remote: Option<String>,
pub response_id: String,
#[serde(default, skip_serializing_if = "Option::is_none")]
#[schemars(extend("omitempty" = true))]
pub response_ids: Option<String>,
}
#[cfg(test)]
mod command_request_tests {
use super::*;
fn update_request() -> crate::cli::command::Request {
crate::cli::command::Request::Update(
crate::cli::command::update::Request {
path_type: crate::cli::command::update::Path::Update,
base: crate::cli::command::RequestBase {
jq: None,
python: None,
timeout_seconds: None,
max_tokens: None,
},
},
)
}
#[test]
fn command_round_trips_and_has_no_mcp_kind() {
let payload = Payload::Command {
identity: crate::identity::Identity {
response_id: Some("resp-1".to_string()),
..Default::default()
},
plugin: crate::mcp::server::Plugin {
owner: "acme".to_string(),
name: "widgets".to_string(),
version: "1.2.3".to_string(),
},
request: update_request(),
};
assert!(payload.mcp_kind().is_none());
let envelope = super::super::Request {
id: "cmd-1".to_string(),
headers: indexmap::IndexMap::new(),
payload,
};
let text = serde_json::to_string(&envelope).unwrap();
let value: serde_json::Value = serde_json::from_str(&text).unwrap();
assert_eq!(value["type"], "command");
assert_eq!(value["plugin"]["owner"], "acme");
assert_eq!(value["identity"]["response_id"], "resp-1");
let back: super::super::Request = serde_json::from_str(&text).unwrap();
assert!(matches!(
back.payload,
Payload::Command { plugin, .. } if plugin.name == "widgets",
));
}
#[test]
fn command_fields_are_required() {
for missing in ["identity", "plugin", "request"] {
let mut frame = serde_json::json!({
"id": "cmd-2",
"type": "command",
"identity": {},
"plugin": {
"owner": "a", "name": "b",
"version": "1.0.0", "mcp": "m",
},
"request": {"path_type": "update", "jq": null, "python": null},
});
frame.as_object_mut().unwrap().remove(missing);
assert!(
serde_json::from_str::<super::super::Request>(&frame.to_string())
.is_err(),
"expected parse failure with {missing} absent",
);
}
}
}