Rewind

Author: ConradIrwin

docs/protocol/initialization.mdx

@@ -118,6 +118,10 @@ The Agent **SHOULD** specify whether it supports the following capabilities:
   The `session/load` method is available.
 </ResponseField>
 
+<ResponseField name="rewindSession" type="boolean" post={["default: false"]}>
+  The `session/rewind` method is available.
+</ResponseField>
+
 <ResponseField name="promptCapabilities" type="PromptCapabilities Object">
   Object indicating the different types of content that may be included in
   `session/prompt` requests.

docs/protocol/overview.mdx

@@ -62,6 +62,10 @@ Agents are programs that use generative AI to autonomously modify code. They typ
   Load an existing session (requires `loadSession` capability).
 </ParamField>
 
+<ParamField path="session/rewind">
+  Rewinds an active session to an earlier message (requires `rewindSession` capability).
+</ParamField>
+
 ### Notifications
 
 <ParamField path="session/cancel">

rust/acp.rs

@@ -101,6 +101,22 @@ impl fmt::Display for SessionId {
     }
 }
 
+/// A unique identifier for a prompt sent from the client to the agent.
+///
+/// This is used when both the agent and the client support rewinding conversations
+/// to identify the point in the conversation to rewind to.
+///
+/// See: <https://agentclientprotocol.com/protocol/session-setup#session-id>
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema, PartialEq, Eq, Hash)]
+#[serde(transparent)]
+pub struct PromptId(pub Arc<str>);
+
+impl fmt::Display for PromptId {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
 // Client to Agent
 
 /// A client-side connection to an agent.
@@ -195,6 +211,15 @@ impl Agent for ClientSideConnection {
             .await
     }
 
+    async fn rewind(&self, arguments: RewindRequest) -> Result<(), Error> {
+        self.conn
+            .request(
+                SESSION_REWIND_METHOD_NAME,
+                Some(ClientRequest::RewindRequest(arguments)),
+            )
+            .await
+    }
+
     async fn prompt(&self, arguments: PromptRequest) -> Result<PromptResponse, Error> {
         self.conn
             .request(
@@ -460,6 +485,10 @@ impl<T: Agent> MessageHandler<AgentSide> for T {
                 let response = self.prompt(args).await?;
                 Ok(AgentResponse::PromptResponse(response))
             }
+            ClientRequest::RewindRequest(args) => {
+                self.rewind(args).await?;
+                Ok(AgentResponse::RewindResponse)
+            }
         }
     }
 

rust/agent.rs

@@ -9,7 +9,7 @@ use anyhow::Result;
 use schemars::JsonSchema;
 use serde::{Deserialize, Serialize};
 
-use crate::{ClientCapabilities, ContentBlock, Error, ProtocolVersion, SessionId};
+use crate::{ClientCapabilities, ContentBlock, Error, PromptId, ProtocolVersion, SessionId};
 
 /// The Agent trait defines the interface that all ACP-compliant agents must implement.
 ///
@@ -91,6 +91,11 @@ pub trait Agent {
         arguments: PromptRequest,
     ) -> impl Future<Output = Result<PromptResponse, Error>>;
 
+    /// Rewinds a session.
+    ///
+    /// See: <https://agentclientprotocol.com/protocol/prompt-turn>
+    fn rewind(&self, arguments: RewindRequest) -> impl Future<Output = Result<(), Error>>;
+
     /// Cancels ongoing operations for a session.
     ///
     /// This is a notification sent by the client to cancel an ongoing prompt turn.
@@ -218,6 +223,26 @@ pub struct LoadSessionRequest {
     pub session_id: SessionId,
 }
 
+// Rewind session
+
+/// Request parameters for rewinding a session.
+///
+/// Only available if the agent supports the `rewindSession` capability.
+///
+/// The conversation is rewound to the moment just before the given prompt was
+/// submitted. This allows the user to submit a new version of that prompt through
+/// the UI to attempt to get better results.
+///
+/// See: <https://agentclientprotocol.com/protocol/session-setup#truncating-sessions>
+#[derive(Debug, Clone, Serialize, Deserialize, JsonSchema)]
+#[serde(rename_all = "camelCase")]
+pub struct RewindRequest {
+    /// The prompt ID to rewind to. This prompt, and all subsequent user and agent
+    /// messages should be discarded.
+    pub prompt_id: PromptId,
+    pub session_id: SessionId,
+}
+
 // MCP
 
 /// Configuration for connecting to an MCP (Model Context Protocol) server.
@@ -261,6 +286,9 @@ pub struct EnvVariable {
 pub struct PromptRequest {
     /// The ID of the session to send this user message to
     pub session_id: SessionId,
+    /// The ID of the prompt. Required if both the client and
+    /// the server support rewinding.
+    pub prompt_id: Option<PromptId>,
     /// The blocks of content that compose the user's message.
     ///
     /// As a baseline, the Agent MUST support [`ContentBlock::Text`] and [`ContentBlock::ResourceLink`],
@@ -329,6 +357,9 @@ pub struct AgentCapabilities {
     /// Whether the agent supports `session/load`.
     #[serde(default)]
     pub load_session: bool,
+    /// Whether the agent supports `session/rewind`.
+    #[serde(default)]
+    pub rewind_session: bool,
     /// Prompt capabilities supported by the agent.
     #[serde(default)]
     pub prompt_capabilities: PromptCapabilities,
@@ -378,6 +409,8 @@ pub struct AgentMethodNames {
     pub session_new: &'static str,
     /// Method for loading an existing session.
     pub session_load: &'static str,
+    /// Method for rewinding the current session.
+    pub session_rewind: &'static str,
     /// Method for sending a prompt to the agent.
     pub session_prompt: &'static str,
     /// Notification for cancelling operations.
@@ -390,6 +423,7 @@ pub const AGENT_METHOD_NAMES: AgentMethodNames = AgentMethodNames {
     authenticate: AUTHENTICATE_METHOD_NAME,
     session_new: SESSION_NEW_METHOD_NAME,
     session_load: SESSION_LOAD_METHOD_NAME,
+    session_rewind: SESSION_REWIND_METHOD_NAME,
     session_prompt: SESSION_PROMPT_METHOD_NAME,
     session_cancel: SESSION_CANCEL_METHOD_NAME,
 };
@@ -402,6 +436,8 @@ pub(crate) const AUTHENTICATE_METHOD_NAME: &str = "authenticate";
 pub(crate) const SESSION_NEW_METHOD_NAME: &str = "session/new";
 /// Method name for loading an existing session.
 pub(crate) const SESSION_LOAD_METHOD_NAME: &str = "session/load";
+/// Method name for truncating the current session.
+pub(crate) const SESSION_REWIND_METHOD_NAME: &str = "session/rewind";
 /// Method name for sending a prompt.
 pub(crate) const SESSION_PROMPT_METHOD_NAME: &str = "session/prompt";
 /// Method name for the cancel notification.
@@ -420,6 +456,7 @@ pub enum ClientRequest {
     AuthenticateRequest(AuthenticateRequest),
     NewSessionRequest(NewSessionRequest),
     LoadSessionRequest(LoadSessionRequest),
+    RewindRequest(RewindRequest),
     PromptRequest(PromptRequest),
 }
 
@@ -436,6 +473,7 @@ pub enum AgentResponse {
     AuthenticateResponse,
     NewSessionResponse(NewSessionResponse),
     LoadSessionResponse,
+    RewindResponse,
     PromptResponse(PromptResponse),
 }
 

rust/rpc_tests.rs

@@ -114,6 +114,10 @@ impl Agent for TestAgent {
         Ok(())
     }
 
+    async fn rewind(&self, _arguments: RewindRequest) -> Result<(), Error> {
+        unimplemented!()
+    }
+
     async fn prompt(&self, arguments: PromptRequest) -> Result<PromptResponse, Error> {
         self.prompts_received
             .lock()
@@ -405,6 +409,7 @@ async fn test_full_conversation_flow() {
 
             agent_conn
                 .prompt(PromptRequest {
+                    prompt_id: None,
                     session_id: session_id.clone(),
                     prompt: user_prompt,
                 })