mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
Add the `supportedServerRequests` initialize capability across the app-server protocol, clients, and connection session state. This lets surfaces explicitly advertise which conversational permission approval requests they know how to receive. Keep this branch limited to the opt-in contract and the bookkeeping needed to store that capability per connection. Delivery and UI handling stay in later stacked PRs so existing clients remain backward compatible and the review surface stays small.
290 lines
9.2 KiB
Rust
290 lines
9.2 KiB
Rust
use anyhow::Result;
|
|
use app_test_support::DEFAULT_CLIENT_NAME;
|
|
use app_test_support::McpProcess;
|
|
use app_test_support::create_mock_responses_server_sequence_unchecked;
|
|
use app_test_support::to_response;
|
|
use codex_app_server_protocol::AskForApproval;
|
|
use codex_app_server_protocol::ClientInfo;
|
|
use codex_app_server_protocol::InitializeCapabilities;
|
|
use codex_app_server_protocol::JSONRPCError;
|
|
use codex_app_server_protocol::JSONRPCMessage;
|
|
use codex_app_server_protocol::JSONRPCResponse;
|
|
use codex_app_server_protocol::MockExperimentalMethodParams;
|
|
use codex_app_server_protocol::RequestId;
|
|
use codex_app_server_protocol::ThreadRealtimeStartParams;
|
|
use codex_app_server_protocol::ThreadRealtimeStartTransport;
|
|
use codex_app_server_protocol::ThreadStartParams;
|
|
use codex_app_server_protocol::ThreadStartResponse;
|
|
use pretty_assertions::assert_eq;
|
|
use std::path::Path;
|
|
use std::time::Duration;
|
|
use tempfile::TempDir;
|
|
use tokio::time::timeout;
|
|
|
|
const DEFAULT_TIMEOUT: Duration = Duration::from_secs(10);
|
|
|
|
#[tokio::test]
|
|
async fn mock_experimental_method_requires_experimental_api_capability() -> Result<()> {
|
|
let codex_home = TempDir::new()?;
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_mock_experimental_method_request(MockExperimentalMethodParams::default())
|
|
.await?;
|
|
let error = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
assert_experimental_capability_error(error, "mock/experimentalMethod");
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn realtime_conversation_start_requires_experimental_api_capability() -> Result<()> {
|
|
let codex_home = TempDir::new()?;
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_thread_realtime_start_request(ThreadRealtimeStartParams {
|
|
thread_id: "thr_123".to_string(),
|
|
prompt: Some(Some("hello".to_string())),
|
|
session_id: None,
|
|
transport: None,
|
|
voice: None,
|
|
})
|
|
.await?;
|
|
let error = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
assert_experimental_capability_error(error, "thread/realtime/start");
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn realtime_webrtc_start_requires_experimental_api_capability() -> Result<()> {
|
|
let codex_home = TempDir::new()?;
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_thread_realtime_start_request(ThreadRealtimeStartParams {
|
|
thread_id: "thr_123".to_string(),
|
|
prompt: Some(Some("hello".to_string())),
|
|
session_id: None,
|
|
transport: Some(ThreadRealtimeStartTransport::Webrtc {
|
|
sdp: "v=offer\r\n".to_string(),
|
|
}),
|
|
voice: None,
|
|
})
|
|
.await?;
|
|
let error = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
assert_experimental_capability_error(error, "thread/realtime/start");
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn thread_start_mock_field_requires_experimental_api_capability() -> Result<()> {
|
|
let server = create_mock_responses_server_sequence_unchecked(Vec::new()).await;
|
|
let codex_home = TempDir::new()?;
|
|
create_config_toml(codex_home.path(), &server.uri())?;
|
|
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_thread_start_request(ThreadStartParams {
|
|
mock_experimental_field: Some("mock".to_string()),
|
|
..Default::default()
|
|
})
|
|
.await?;
|
|
|
|
let error = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
assert_experimental_capability_error(error, "thread/start.mockExperimentalField");
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn thread_start_without_dynamic_tools_allows_without_experimental_api_capability()
|
|
-> Result<()> {
|
|
let server = create_mock_responses_server_sequence_unchecked(Vec::new()).await;
|
|
let codex_home = TempDir::new()?;
|
|
create_config_toml(codex_home.path(), &server.uri())?;
|
|
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_thread_start_request(ThreadStartParams {
|
|
model: Some("mock-model".to_string()),
|
|
..Default::default()
|
|
})
|
|
.await?;
|
|
let response: JSONRPCResponse = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_response_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
let _: ThreadStartResponse = to_response(response)?;
|
|
Ok(())
|
|
}
|
|
|
|
#[tokio::test]
|
|
async fn thread_start_granular_approval_policy_requires_experimental_api_capability() -> Result<()>
|
|
{
|
|
let server = create_mock_responses_server_sequence_unchecked(Vec::new()).await;
|
|
let codex_home = TempDir::new()?;
|
|
create_config_toml(codex_home.path(), &server.uri())?;
|
|
|
|
let mut mcp = McpProcess::new(codex_home.path()).await?;
|
|
let init = mcp
|
|
.initialize_with_capabilities(
|
|
default_client_info(),
|
|
Some(InitializeCapabilities {
|
|
experimental_api: false,
|
|
supported_server_requests: None,
|
|
opt_out_notification_methods: None,
|
|
}),
|
|
)
|
|
.await?;
|
|
let JSONRPCMessage::Response(_) = init else {
|
|
anyhow::bail!("expected initialize response, got {init:?}");
|
|
};
|
|
|
|
let request_id = mcp
|
|
.send_thread_start_request(ThreadStartParams {
|
|
approval_policy: Some(AskForApproval::Granular {
|
|
sandbox_approval: true,
|
|
rules: false,
|
|
skill_approval: false,
|
|
request_permissions: true,
|
|
mcp_elicitations: false,
|
|
}),
|
|
..Default::default()
|
|
})
|
|
.await?;
|
|
|
|
let error = timeout(
|
|
DEFAULT_TIMEOUT,
|
|
mcp.read_stream_until_error_message(RequestId::Integer(request_id)),
|
|
)
|
|
.await??;
|
|
assert_experimental_capability_error(error, "askForApproval.granular");
|
|
Ok(())
|
|
}
|
|
|
|
fn default_client_info() -> ClientInfo {
|
|
ClientInfo {
|
|
name: DEFAULT_CLIENT_NAME.to_string(),
|
|
title: None,
|
|
version: "0.1.0".to_string(),
|
|
}
|
|
}
|
|
|
|
fn assert_experimental_capability_error(error: JSONRPCError, reason: &str) {
|
|
assert_eq!(error.error.code, -32600);
|
|
assert_eq!(
|
|
error.error.message,
|
|
format!("{reason} requires experimentalApi capability")
|
|
);
|
|
assert_eq!(error.error.data, None);
|
|
}
|
|
|
|
fn create_config_toml(codex_home: &Path, server_uri: &str) -> std::io::Result<()> {
|
|
let config_toml = codex_home.join("config.toml");
|
|
std::fs::write(
|
|
config_toml,
|
|
format!(
|
|
r#"
|
|
model = "mock-model"
|
|
approval_policy = "never"
|
|
sandbox_mode = "read-only"
|
|
|
|
model_provider = "mock_provider"
|
|
|
|
[model_providers.mock_provider]
|
|
name = "Mock provider for test"
|
|
base_url = "{server_uri}/v1"
|
|
wire_api = "responses"
|
|
request_max_retries = 0
|
|
stream_max_retries = 0
|
|
"#
|
|
),
|
|
)
|
|
}
|