fe62f859a6
Switch ConversationCreateResult from a struct to a tagged enum (Ok | Error) Stack: Top: #1783 Bottom: #1784
1055 lines
36 KiB
Rust
1055 lines
36 KiB
Rust
use codex_core::config_types::SandboxMode;
|
|
use codex_core::protocol::AskForApproval;
|
|
use codex_core::protocol::EventMsg;
|
|
use codex_core::protocol::InputItem;
|
|
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
use strum_macros::Display;
|
|
use uuid::Uuid;
|
|
|
|
use mcp_types::CallToolResult;
|
|
use mcp_types::ContentBlock;
|
|
use mcp_types::RequestId;
|
|
use mcp_types::TextContent;
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(transparent)]
|
|
pub struct ConversationId(pub Uuid);
|
|
|
|
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
|
|
#[serde(transparent)]
|
|
pub struct MessageId(pub Uuid);
|
|
|
|
// Requests
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct ToolCallRequest {
|
|
#[serde(rename = "jsonrpc")]
|
|
pub jsonrpc: &'static str,
|
|
pub id: RequestId,
|
|
pub method: &'static str,
|
|
pub params: ToolCallRequestParams,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(tag = "name", content = "arguments", rename_all = "camelCase")]
|
|
pub enum ToolCallRequestParams {
|
|
ConversationCreate(ConversationCreateArgs),
|
|
ConversationStream(ConversationStreamArgs),
|
|
ConversationSendMessage(ConversationSendMessageArgs),
|
|
ConversationsList(ConversationsListArgs),
|
|
}
|
|
|
|
impl ToolCallRequestParams {
|
|
/// Wrap this request in a JSON-RPC request.
|
|
#[allow(dead_code)]
|
|
pub fn into_request(self, id: RequestId) -> ToolCallRequest {
|
|
ToolCallRequest {
|
|
jsonrpc: "2.0",
|
|
id,
|
|
method: "tools/call",
|
|
params: self,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationCreateArgs {
|
|
pub prompt: String,
|
|
pub model: String,
|
|
pub cwd: String,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub approval_policy: Option<AskForApproval>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub sandbox: Option<SandboxMode>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub config: Option<serde_json::Value>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub profile: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub base_instructions: Option<String>,
|
|
}
|
|
|
|
/// Optional overrides for an existing conversation's execution context when sending a message.
|
|
/// Fields left as `None` inherit the current conversation/session settings.
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationOverrides {
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub model: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub cwd: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub approval_policy: Option<AskForApproval>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub sandbox: Option<SandboxMode>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub config: Option<serde_json::Value>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub profile: Option<String>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub base_instructions: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationStreamArgs {
|
|
pub conversation_id: ConversationId,
|
|
}
|
|
|
|
/// If omitted, the message continues from the latest turn.
|
|
/// Set to resume/edit from an earlier parent message in the thread.
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationSendMessageArgs {
|
|
pub conversation_id: ConversationId,
|
|
pub content: Vec<InputItem>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub parent_message_id: Option<MessageId>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
#[serde(flatten)]
|
|
pub conversation_overrides: Option<ConversationOverrides>,
|
|
}
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationsListArgs {
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub limit: Option<u32>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub cursor: Option<String>,
|
|
}
|
|
|
|
// Responses
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct ToolCallResponse {
|
|
pub request_id: RequestId,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub is_error: Option<bool>,
|
|
#[serde(default, skip_serializing_if = "Option::is_none", flatten)]
|
|
pub result: Option<ToolCallResponseResult>,
|
|
}
|
|
|
|
impl From<ToolCallResponse> for CallToolResult {
|
|
fn from(val: ToolCallResponse) -> Self {
|
|
let ToolCallResponse {
|
|
request_id: _request_id,
|
|
is_error,
|
|
result,
|
|
} = val;
|
|
match result {
|
|
Some(res) => match serde_json::to_value(&res) {
|
|
Ok(v) => CallToolResult {
|
|
content: vec![ContentBlock::TextContent(TextContent {
|
|
r#type: "text".to_string(),
|
|
text: v.to_string(),
|
|
annotations: None,
|
|
})],
|
|
is_error,
|
|
structured_content: Some(v),
|
|
},
|
|
Err(e) => CallToolResult {
|
|
content: vec![ContentBlock::TextContent(TextContent {
|
|
r#type: "text".to_string(),
|
|
text: format!("Failed to serialize tool result: {e}"),
|
|
annotations: None,
|
|
})],
|
|
is_error: Some(true),
|
|
structured_content: None,
|
|
},
|
|
},
|
|
None => CallToolResult {
|
|
content: vec![],
|
|
is_error,
|
|
structured_content: None,
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(untagged)]
|
|
pub enum ToolCallResponseResult {
|
|
ConversationCreate(ConversationCreateResult),
|
|
ConversationStream(ConversationStreamResult),
|
|
ConversationSendMessage(ConversationSendMessageResult),
|
|
ConversationsList(ConversationsListResult),
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(untagged)]
|
|
pub enum ConversationCreateResult {
|
|
Ok {
|
|
conversation_id: ConversationId,
|
|
model: String,
|
|
},
|
|
Error {
|
|
message: String,
|
|
},
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationStreamResult {}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
// TODO: remove this status because we have is_error field in the response.
|
|
#[serde(tag = "status", rename_all = "camelCase")]
|
|
pub enum ConversationSendMessageResult {
|
|
Ok,
|
|
Error { message: String },
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationsListResult {
|
|
pub conversations: Vec<ConversationSummary>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub next_cursor: Option<String>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConversationSummary {
|
|
pub conversation_id: ConversationId,
|
|
pub title: String,
|
|
}
|
|
|
|
// Notifications
|
|
#[derive(Debug, Clone, Deserialize, Display)]
|
|
pub enum ServerNotification {
|
|
InitialState(InitialStateNotificationParams),
|
|
StreamDisconnected(StreamDisconnectedNotificationParams),
|
|
CodexEvent(Box<CodexEventNotificationParams>),
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct NotificationMeta {
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub conversation_id: Option<ConversationId>,
|
|
#[serde(skip_serializing_if = "Option::is_none")]
|
|
pub request_id: Option<RequestId>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct InitialStateNotificationParams {
|
|
#[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
|
|
pub meta: Option<NotificationMeta>,
|
|
pub initial_state: InitialStatePayload,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct InitialStatePayload {
|
|
#[serde(default)]
|
|
pub events: Vec<CodexEventNotificationParams>,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
pub struct StreamDisconnectedNotificationParams {
|
|
#[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
|
|
pub meta: Option<NotificationMeta>,
|
|
pub reason: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize)]
|
|
pub struct CodexEventNotificationParams {
|
|
#[serde(rename = "_meta", skip_serializing_if = "Option::is_none")]
|
|
pub meta: Option<NotificationMeta>,
|
|
pub msg: EventMsg,
|
|
}
|
|
|
|
#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
|
|
#[serde(rename_all = "camelCase")]
|
|
pub struct CancelNotificationParams {
|
|
pub request_id: RequestId,
|
|
#[serde(default, skip_serializing_if = "Option::is_none")]
|
|
pub reason: Option<String>,
|
|
}
|
|
|
|
impl Serialize for ServerNotification {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: serde::Serializer,
|
|
{
|
|
use serde::ser::SerializeMap;
|
|
|
|
let mut map = serializer.serialize_map(Some(2))?;
|
|
match self {
|
|
ServerNotification::CodexEvent(p) => {
|
|
map.serialize_entry("method", &format!("notifications/{}", p.msg))?;
|
|
map.serialize_entry("params", p)?;
|
|
}
|
|
ServerNotification::InitialState(p) => {
|
|
map.serialize_entry("method", "notifications/initial_state")?;
|
|
map.serialize_entry("params", p)?;
|
|
}
|
|
ServerNotification::StreamDisconnected(p) => {
|
|
map.serialize_entry("method", "notifications/stream_disconnected")?;
|
|
map.serialize_entry("params", p)?;
|
|
}
|
|
}
|
|
map.end()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Clone, Deserialize, Serialize)]
|
|
#[serde(tag = "method", content = "params", rename_all = "camelCase")]
|
|
pub enum ClientNotification {
|
|
#[serde(rename = "notifications/cancelled")]
|
|
Cancelled(CancelNotificationParams),
|
|
}
|
|
|
|
#[cfg(test)]
|
|
#[allow(clippy::expect_used)]
|
|
#[allow(clippy::unwrap_used)]
|
|
mod tests {
|
|
use std::path::PathBuf;
|
|
|
|
use super::*;
|
|
use codex_core::protocol::McpInvocation;
|
|
use codex_core::protocol::McpToolCallBeginEvent;
|
|
use pretty_assertions::assert_eq;
|
|
use serde::Serialize;
|
|
use serde_json::Value;
|
|
use serde_json::json;
|
|
use uuid::uuid;
|
|
|
|
fn to_val<T: Serialize>(v: &T) -> Value {
|
|
serde_json::to_value(v).expect("serialize to Value")
|
|
}
|
|
|
|
// ----- Requests -----
|
|
|
|
#[test]
|
|
fn serialize_tool_call_request_params_conversation_create_minimal() {
|
|
let req = ToolCallRequestParams::ConversationCreate(ConversationCreateArgs {
|
|
prompt: "".into(),
|
|
model: "o3".into(),
|
|
cwd: "/repo".into(),
|
|
approval_policy: None,
|
|
sandbox: None,
|
|
config: None,
|
|
profile: None,
|
|
base_instructions: None,
|
|
});
|
|
|
|
let observed = to_val(&req.into_request(mcp_types::RequestId::Integer(2)));
|
|
let expected = json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/call",
|
|
"params": {
|
|
"name": "conversationCreate",
|
|
"arguments": {
|
|
"prompt": "",
|
|
"model": "o3",
|
|
"cwd": "/repo"
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_tool_call_request_params_conversation_send_message_with_overrides_and_parent_message_id()
|
|
{
|
|
let req = ToolCallRequestParams::ConversationSendMessage(ConversationSendMessageArgs {
|
|
conversation_id: ConversationId(uuid!("d0f6ecbe-84a2-41c1-b23d-b20473b25eab")),
|
|
content: vec![
|
|
InputItem::Text { text: "Hi".into() },
|
|
InputItem::Image {
|
|
image_url: "https://example.com/cat.jpg".into(),
|
|
},
|
|
InputItem::LocalImage {
|
|
path: "notes.txt".into(),
|
|
},
|
|
],
|
|
parent_message_id: Some(MessageId(uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"))),
|
|
conversation_overrides: Some(ConversationOverrides {
|
|
model: Some("o4-mini".into()),
|
|
cwd: Some("/workdir".into()),
|
|
approval_policy: None,
|
|
sandbox: Some(SandboxMode::DangerFullAccess),
|
|
config: Some(json!({"temp": 0.2})),
|
|
profile: Some("eng".into()),
|
|
base_instructions: Some("Be terse".into()),
|
|
}),
|
|
});
|
|
|
|
let observed = to_val(&req.into_request(mcp_types::RequestId::Integer(2)));
|
|
let expected = json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/call",
|
|
"params": {
|
|
"name": "conversationSendMessage",
|
|
"arguments": {
|
|
"conversation_id": "d0f6ecbe-84a2-41c1-b23d-b20473b25eab",
|
|
"content": [
|
|
{ "type": "text", "text": "Hi" },
|
|
{ "type": "image", "image_url": "https://example.com/cat.jpg" },
|
|
{ "type": "local_image", "path": "notes.txt" }
|
|
],
|
|
"parent_message_id": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"model": "o4-mini",
|
|
"cwd": "/workdir",
|
|
"sandbox": "danger-full-access",
|
|
"config": { "temp": 0.2 },
|
|
"profile": "eng",
|
|
"base_instructions": "Be terse"
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_tool_call_request_params_conversations_list_with_opts() {
|
|
let req = ToolCallRequestParams::ConversationsList(ConversationsListArgs {
|
|
limit: Some(50),
|
|
cursor: Some("abc".into()),
|
|
});
|
|
|
|
let observed = to_val(&req.into_request(RequestId::Integer(2)));
|
|
let expected = json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/call",
|
|
"params": {
|
|
"name": "conversationsList",
|
|
"arguments": {
|
|
"limit": 50,
|
|
"cursor": "abc"
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_tool_call_request_params_conversation_stream() {
|
|
let req = ToolCallRequestParams::ConversationStream(ConversationStreamArgs {
|
|
conversation_id: ConversationId(uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8")),
|
|
});
|
|
|
|
let observed = to_val(&req.into_request(mcp_types::RequestId::Integer(2)));
|
|
let expected = json!({
|
|
"jsonrpc": "2.0",
|
|
"id": 2,
|
|
"method": "tools/call",
|
|
"params": {
|
|
"name": "conversationStream",
|
|
"arguments": {
|
|
"conversation_id": "67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
// ----- Message inputs / sources -----
|
|
|
|
#[test]
|
|
fn serialize_message_input_image_url() {
|
|
let item = InputItem::Image {
|
|
image_url: "https://example.com/x.png".into(),
|
|
};
|
|
let observed = to_val(&item);
|
|
let expected = json!({
|
|
"type": "image",
|
|
"image_url": "https://example.com/x.png"
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_message_input_local_image_path() {
|
|
let url = InputItem::LocalImage {
|
|
path: PathBuf::from("https://example.com/a.pdf"),
|
|
};
|
|
let id = InputItem::LocalImage {
|
|
path: PathBuf::from("file_456"),
|
|
};
|
|
let observed_url = to_val(&url);
|
|
let expected_url = json!({"type":"local_image","path":"https://example.com/a.pdf"});
|
|
assert_eq!(
|
|
observed_url, expected_url,
|
|
"LocalImage with URL path should serialize as image_url"
|
|
);
|
|
let observed_id = to_val(&id);
|
|
let expected_id = json!({"type":"local_image","path":"file_456"});
|
|
assert_eq!(
|
|
observed_id, expected_id,
|
|
"LocalImage with file id should serialize as image_url"
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_message_input_image_url_without_detail() {
|
|
let item = InputItem::Image {
|
|
image_url: "https://example.com/x.png".into(),
|
|
};
|
|
let observed = to_val(&item);
|
|
let expected = json!({
|
|
"type": "image",
|
|
"image_url": "https://example.com/x.png"
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
// ----- Responses -----
|
|
|
|
#[test]
|
|
fn response_success_conversation_create_full_schema() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(1),
|
|
is_error: None,
|
|
result: Some(ToolCallResponseResult::ConversationCreate(
|
|
ConversationCreateResult::Ok {
|
|
conversation_id: ConversationId(uuid!("d0f6ecbe-84a2-41c1-b23d-b20473b25eab")),
|
|
model: "o3".into(),
|
|
},
|
|
)),
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [
|
|
{ "type": "text", "text": "{\"conversation_id\":\"d0f6ecbe-84a2-41c1-b23d-b20473b25eab\",\"model\":\"o3\"}" }
|
|
],
|
|
"structuredContent": {
|
|
"conversation_id": "d0f6ecbe-84a2-41c1-b23d-b20473b25eab",
|
|
"model": "o3"
|
|
}
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"response (ConversationCreate) must match"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(1));
|
|
}
|
|
|
|
#[test]
|
|
fn response_error_conversation_create_full_schema() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(2),
|
|
is_error: Some(true),
|
|
result: Some(ToolCallResponseResult::ConversationCreate(
|
|
ConversationCreateResult::Error {
|
|
message: "Failed to initialize session".into(),
|
|
},
|
|
)),
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [
|
|
{ "type": "text", "text": "{\"message\":\"Failed to initialize session\"}" }
|
|
],
|
|
"isError": true,
|
|
"structuredContent": {
|
|
"message": "Failed to initialize session"
|
|
}
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"error response (ConversationCreate) must match"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(2));
|
|
}
|
|
|
|
#[test]
|
|
fn response_success_conversation_stream_empty_result_object() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(2),
|
|
is_error: None,
|
|
result: Some(ToolCallResponseResult::ConversationStream(
|
|
ConversationStreamResult {},
|
|
)),
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [ { "type": "text", "text": "{}" } ],
|
|
"structuredContent": {}
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"response (ConversationStream) must have empty object result"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(2));
|
|
}
|
|
|
|
#[test]
|
|
fn response_success_send_message_accepted_full_schema() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(3),
|
|
is_error: None,
|
|
result: Some(ToolCallResponseResult::ConversationSendMessage(
|
|
ConversationSendMessageResult::Ok,
|
|
)),
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [ { "type": "text", "text": "{\"status\":\"ok\"}" } ],
|
|
"structuredContent": { "status": "ok" }
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"response (ConversationSendMessageAccepted) must match"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(3));
|
|
}
|
|
|
|
#[test]
|
|
fn response_success_conversations_list_with_next_cursor_full_schema() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(4),
|
|
is_error: None,
|
|
result: Some(ToolCallResponseResult::ConversationsList(
|
|
ConversationsListResult {
|
|
conversations: vec![ConversationSummary {
|
|
conversation_id: ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
)),
|
|
title: "Refactor config loader".into(),
|
|
}],
|
|
next_cursor: Some("next123".into()),
|
|
},
|
|
)),
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [
|
|
{ "type": "text", "text": "{\"conversations\":[{\"conversation_id\":\"67e55044-10b1-426f-9247-bb680e5fe0c8\",\"title\":\"Refactor config loader\"}],\"next_cursor\":\"next123\"}" }
|
|
],
|
|
"structuredContent": {
|
|
"conversations": [
|
|
{
|
|
"conversation_id": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"title": "Refactor config loader"
|
|
}
|
|
],
|
|
"next_cursor": "next123"
|
|
}
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"response (ConversationsList with cursor) must match"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(4));
|
|
}
|
|
|
|
#[test]
|
|
fn response_error_only_is_error_and_request_id_string() {
|
|
let env = ToolCallResponse {
|
|
request_id: RequestId::Integer(4),
|
|
is_error: Some(true),
|
|
result: None,
|
|
};
|
|
let req_id = env.request_id.clone();
|
|
let observed = to_val(&CallToolResult::from(env));
|
|
let expected = json!({
|
|
"content": [],
|
|
"isError": true
|
|
});
|
|
assert_eq!(
|
|
observed, expected,
|
|
"error response must omit `result` and include `isError`"
|
|
);
|
|
assert_eq!(req_id, RequestId::Integer(4));
|
|
}
|
|
|
|
// ----- Notifications -----
|
|
|
|
#[test]
|
|
fn serialize_notification_initial_state_minimal() {
|
|
let params = InitialStateNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: Some(RequestId::Integer(44)),
|
|
}),
|
|
initial_state: InitialStatePayload {
|
|
events: vec![
|
|
CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::TaskStarted,
|
|
},
|
|
CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::AgentMessageDelta(
|
|
codex_core::protocol::AgentMessageDeltaEvent {
|
|
delta: "Loading...".into(),
|
|
},
|
|
),
|
|
},
|
|
],
|
|
},
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::InitialState(params.clone()));
|
|
let expected = json!({
|
|
"method": "notifications/initial_state",
|
|
"params": {
|
|
"_meta": {
|
|
"conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"requestId": 44
|
|
},
|
|
"initial_state": {
|
|
"events": [
|
|
{ "msg": { "type": "task_started" } },
|
|
{ "msg": { "type": "agent_message_delta", "delta": "Loading..." } }
|
|
]
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_initial_state_omits_empty_events_full_json() {
|
|
let params = InitialStateNotificationParams {
|
|
meta: None,
|
|
initial_state: InitialStatePayload { events: vec![] },
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::InitialState(params));
|
|
let expected = json!({
|
|
"method": "notifications/initial_state",
|
|
"params": {
|
|
"initial_state": { "events": [] }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_stream_disconnected() {
|
|
let params = StreamDisconnectedNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: None,
|
|
}),
|
|
reason: "New stream() took over".into(),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::StreamDisconnected(params));
|
|
let expected = json!({
|
|
"method": "notifications/stream_disconnected",
|
|
"params": {
|
|
"_meta": { "conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8" },
|
|
"reason": "New stream() took over"
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_uses_eventmsg_type_in_method() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: Some(RequestId::Integer(44)),
|
|
}),
|
|
msg: EventMsg::AgentMessage(codex_core::protocol::AgentMessageEvent {
|
|
message: "hi".into(),
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/agent_message",
|
|
"params": {
|
|
"_meta": {
|
|
"conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"requestId": 44
|
|
},
|
|
"msg": { "type": "agent_message", "message": "hi" }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_task_started_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: Some(RequestId::Integer(7)),
|
|
}),
|
|
msg: EventMsg::TaskStarted,
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/task_started",
|
|
"params": {
|
|
"_meta": {
|
|
"conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"requestId": 7
|
|
},
|
|
"msg": { "type": "task_started" }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_agent_message_delta_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::AgentMessageDelta(codex_core::protocol::AgentMessageDeltaEvent {
|
|
delta: "stream...".into(),
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/agent_message_delta",
|
|
"params": {
|
|
"msg": { "type": "agent_message_delta", "delta": "stream..." }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_agent_message_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: Some(RequestId::Integer(44)),
|
|
}),
|
|
msg: EventMsg::AgentMessage(codex_core::protocol::AgentMessageEvent {
|
|
message: "hi".into(),
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/agent_message",
|
|
"params": {
|
|
"_meta": {
|
|
"conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"requestId": 44
|
|
},
|
|
"msg": { "type": "agent_message", "message": "hi" }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_agent_reasoning_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::AgentReasoning(codex_core::protocol::AgentReasoningEvent {
|
|
text: "thinking…".into(),
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/agent_reasoning",
|
|
"params": {
|
|
"msg": { "type": "agent_reasoning", "text": "thinking…" }
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_token_count_full_json() {
|
|
let usage = codex_core::protocol::TokenUsage {
|
|
input_tokens: 10,
|
|
cached_input_tokens: Some(2),
|
|
output_tokens: 5,
|
|
reasoning_output_tokens: Some(1),
|
|
total_tokens: 16,
|
|
};
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::TokenCount(usage),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/token_count",
|
|
"params": {
|
|
"msg": {
|
|
"type": "token_count",
|
|
"input_tokens": 10,
|
|
"cached_input_tokens": 2,
|
|
"output_tokens": 5,
|
|
"reasoning_output_tokens": 1,
|
|
"total_tokens": 16
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_session_configured_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: Some(NotificationMeta {
|
|
conversation_id: Some(ConversationId(uuid!(
|
|
"67e55044-10b1-426f-9247-bb680e5fe0c8"
|
|
))),
|
|
request_id: None,
|
|
}),
|
|
msg: EventMsg::SessionConfigured(codex_core::protocol::SessionConfiguredEvent {
|
|
session_id: uuid!("67e55044-10b1-426f-9247-bb680e5fe0c8"),
|
|
model: "codex-mini-latest".into(),
|
|
history_log_id: 42,
|
|
history_entry_count: 3,
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/session_configured",
|
|
"params": {
|
|
"_meta": { "conversationId": "67e55044-10b1-426f-9247-bb680e5fe0c8" },
|
|
"msg": {
|
|
"type": "session_configured",
|
|
"session_id": "67e55044-10b1-426f-9247-bb680e5fe0c8",
|
|
"model": "codex-mini-latest",
|
|
"history_log_id": 42,
|
|
"history_entry_count": 3
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_exec_command_begin_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::ExecCommandBegin(codex_core::protocol::ExecCommandBeginEvent {
|
|
call_id: "c1".into(),
|
|
command: vec!["bash".into(), "-lc".into(), "echo hi".into()],
|
|
cwd: std::path::PathBuf::from("/work"),
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/exec_command_begin",
|
|
"params": {
|
|
"msg": {
|
|
"type": "exec_command_begin",
|
|
"call_id": "c1",
|
|
"command": ["bash", "-lc", "echo hi"],
|
|
"cwd": "/work"
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_mcp_tool_call_begin_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::McpToolCallBegin(McpToolCallBeginEvent {
|
|
call_id: "m1".into(),
|
|
invocation: McpInvocation {
|
|
server: "calc".into(),
|
|
tool: "add".into(),
|
|
arguments: Some(json!({"a":1,"b":2})),
|
|
},
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/mcp_tool_call_begin",
|
|
"params": {
|
|
"msg": {
|
|
"type": "mcp_tool_call_begin",
|
|
"call_id": "m1",
|
|
"invocation": {
|
|
"server": "calc",
|
|
"tool": "add",
|
|
"arguments": { "a": 1, "b": 2 }
|
|
}
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_codex_event_patch_apply_end_full_json() {
|
|
let params = CodexEventNotificationParams {
|
|
meta: None,
|
|
msg: EventMsg::PatchApplyEnd(codex_core::protocol::PatchApplyEndEvent {
|
|
call_id: "p1".into(),
|
|
stdout: "ok".into(),
|
|
stderr: "".into(),
|
|
success: true,
|
|
}),
|
|
};
|
|
|
|
let observed = to_val(&ServerNotification::CodexEvent(Box::new(params)));
|
|
let expected = json!({
|
|
"method": "notifications/patch_apply_end",
|
|
"params": {
|
|
"msg": {
|
|
"type": "patch_apply_end",
|
|
"call_id": "p1",
|
|
"stdout": "ok",
|
|
"stderr": "",
|
|
"success": true
|
|
}
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
// ----- Cancelled notifications -----
|
|
|
|
#[test]
|
|
fn serialize_notification_cancelled_with_reason_full_json() {
|
|
let params = CancelNotificationParams {
|
|
request_id: RequestId::String("r-123".into()),
|
|
reason: Some("user_cancelled".into()),
|
|
};
|
|
|
|
let observed = to_val(&ClientNotification::Cancelled(params));
|
|
let expected = json!({
|
|
"method": "notifications/cancelled",
|
|
"params": {
|
|
"requestId": "r-123",
|
|
"reason": "user_cancelled"
|
|
}
|
|
});
|
|
assert_eq!(observed, expected);
|
|
}
|
|
|
|
#[test]
|
|
fn serialize_notification_cancelled_without_reason_full_json() {
|
|
let params = CancelNotificationParams {
|
|
request_id: RequestId::Integer(77),
|
|
reason: None,
|
|
};
|
|
|
|
let observed = to_val(&ClientNotification::Cancelled(params));
|
|
|
|
// Check exact structure: reason must be omitted.
|
|
assert_eq!(observed["method"], "notifications/cancelled");
|
|
assert_eq!(observed["params"]["requestId"], 77);
|
|
assert!(
|
|
observed["params"].get("reason").is_none(),
|
|
"reason must be omitted when None"
|
|
);
|
|
}
|
|
}
|