fix(test): reject empty v2 prompts in Testy and simple_agent_v2 (#463)

ACP v2 forbids clients from sending an empty prompt array and lets agents
reject one with -32602 without inserting it. Testy v2 and the
simple_agent_v2 example now do so during prompt admission.

Co-authored-by: Claude <noreply@anthropic.com>

Author: benbrandt

md/testy.md

@@ -116,7 +116,8 @@ replay was not requested. Neither is a replayed historical change, and the
 snapshot is not another completed turn.
 
 Prompts may contain only the baseline `text` and `resource_link` content blocks; any other block
-is rejected with `-32602` before the turn begins. `session/list` returns every session in one page
+is rejected with `-32602` before the turn begins. An empty `prompt` array is likewise rejected with
+`-32602` without inserting a user message. `session/list` returns every session in one page
 and never issues `nextCursor`, so any `cursor` is rejected with `-32602`.
 
 A prompt that arrives while the session has foreground work is held, not rejected. Held prompts

src/agent-client-protocol-test/src/testy/v2.rs

@@ -681,11 +681,15 @@ impl ConnectTo<Client> for V2Testy {
     }
 }
 
+/// Clients must not send an empty prompt, and Testy rejects one with `-32602`.
 /// Testy advertises no prompt capabilities, so only the baseline `text` and `resource_link`
 /// blocks are supported. v2 Agents must reject any other block with `-32602`.
 fn validate_prompt_content(
     blocks: &[acp::ContentBlock],
 ) -> Result<(), agent_client_protocol::Error> {
+    if blocks.is_empty() {
+        return Err(invalid_params("prompt must not be empty"));
+    }
     for block in blocks {
         match block {
             acp::ContentBlock::Text(_) | acp::ContentBlock::ResourceLink(_) => {}

src/agent-client-protocol-test/tests/testy_v2.rs

@@ -654,6 +654,69 @@ async fn testy_v2_rejects_unadvertised_prompt_content() {
         .expect("Testy v2 prompt content validation failed");
 }
 
+#[tokio::test(flavor = "current_thread")]
+async fn testy_v2_rejects_empty_prompt_without_inserting_it() {
+    let (event_tx, mut event_rx) = unbounded_channel();
+    let update_tx = event_tx.clone();
+    Client
+        .v2()
+        .on_receive_notification(
+            async move |update: v2::UpdateSessionNotification,
+                        _connection: V2ConnectionTo<agent_client_protocol::Agent>| {
+                update_tx
+                    .send(TestEvent::Update(Box::new(update)))
+                    .map_err(Error::into_internal_error)
+            },
+            agent_client_protocol::on_receive_notification!(),
+        )
+        .connect_with(Testy::new().v2(), async move |connection| {
+            connection
+                .send_request(v2::InitializeRequest::new(
+                    ProtocolVersion::V2,
+                    implementation(),
+                ))
+                .block_task()
+                .await?;
+            let session_id = connection
+                .send_request(v2::NewSessionRequest::new(PathBuf::from("/tmp")))
+                .block_task()
+                .await?
+                .session_id;
+
+            let error = connection
+                .send_request(v2::PromptRequest::new(session_id.clone(), vec![]))
+                .block_task()
+                .await
+                .expect_err("an empty prompt should be rejected");
+            assert_eq!(error.code, agent_client_protocol::ErrorCode::InvalidParams);
+
+            let accepted = connection
+                .send_request(v2::PromptRequest::new(
+                    session_id,
+                    vec![TestyCommand::Greet.to_prompt().into()],
+                ))
+                .block_task()
+                .await
+                .expect("the session accepts a prompt after an empty one is rejected");
+
+            // The first user message belongs to the accepted prompt, so the
+            // empty prompt inserted nothing.
+            loop {
+                match next_update(&mut event_rx).await.update {
+                    v2::SessionUpdate::UserMessage(message) => {
+                        assert_eq!(message.message_id, accepted.message_id);
+                        break;
+                    }
+                    v2::SessionUpdate::SessionInfoUpdate(_) => {}
+                    other => panic!("expected the accepted user message, got {other:?}"),
+                }
+            }
+            Ok(())
+        })
+        .await
+        .expect("Testy v2 empty prompt validation failed");
+}
+
 #[tokio::test(flavor = "current_thread")]
 async fn testy_v2_unimplemented_scenarios_end_with_error_stop_reason() {
     let (event_tx, mut event_rx) = unbounded_channel();

src/agent-client-protocol/examples/simple_agent_v2.rs

@@ -146,6 +146,10 @@ impl EchoAgent {
             .get_mut(session_id)
             .filter(|session| session.active)
             .ok_or_else(|| session_not_found(session_id))?;
+        // Clients must not send an empty prompt; reject one without inserting it.
+        if prompt.is_empty() {
+            return Err(invalid_params("prompt must not be empty"));
+        }
         // No prompt capabilities are advertised, so only the baseline `text` and
         // `resource_link` blocks are supported. Anything else must be rejected.
         if prompt.iter().any(|block| {
@@ -676,3 +680,33 @@ fn reject_mcp_servers(mcp_servers: &[v2::McpServer]) -> Result<()> {
         ))
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn rejects_empty_prompt_without_inserting_it() {
+        let agent = EchoAgent::default();
+        let session_id = agent
+            .create_session(v2::NewSessionRequest::new("/tmp"))
+            .expect("session should be created");
+
+        let Err(error) = agent.admit_prompt(&session_id, &[]) else {
+            panic!("an empty prompt should be rejected");
+        };
+        assert_eq!(error.code, agent_client_protocol::ErrorCode::InvalidParams);
+        {
+            let state = agent.state.lock().expect("session state lock poisoned");
+            let session = &state.sessions[&session_id];
+            assert!(!session.foreground_work, "no work should start");
+            assert!(session.held_prompts.is_empty(), "nothing should be held");
+            assert!(session.history.is_empty(), "nothing should be inserted");
+        }
+
+        assert!(matches!(
+            agent.admit_prompt(&session_id, &[v2::ContentBlock::from("hello")]),
+            Ok(PromptAdmission::Inserted)
+        ));
+    }
+}