acpx 0.1.0

Simple Rust library and tooling for building on ACP.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152

use std::{cell::Cell, error::Error as StdError};

use agent_client_protocol::{self as acp, Client as _};
use tokio::sync::{mpsc, oneshot};
use tokio_util::compat::{TokioAsyncReadCompatExt as _, TokioAsyncWriteCompatExt as _};

pub type PendingSessionUpdate = (acp::SessionNotification, oneshot::Sender<()>);

#[derive(Debug)]
pub struct FixtureAgent {
    session_update_tx: mpsc::UnboundedSender<PendingSessionUpdate>,
    next_session_id: Cell<u64>,
}

impl FixtureAgent {
    pub fn new(session_update_tx: mpsc::UnboundedSender<PendingSessionUpdate>) -> Self {
        Self {
            session_update_tx,
            next_session_id: Cell::new(0),
        }
    }
}

#[async_trait::async_trait(?Send)]
impl acp::Agent for FixtureAgent {
    async fn initialize(
        &self,
        args: acp::InitializeRequest,
    ) -> Result<acp::InitializeResponse, acp::Error> {
        Ok(
            acp::InitializeResponse::new(args.protocol_version).agent_info(
                acp::Implementation::new("acpx-fixture-agent", "0.0.1").title("acpx Fixture Agent"),
            ),
        )
    }

    async fn authenticate(
        &self,
        _args: acp::AuthenticateRequest,
    ) -> Result<acp::AuthenticateResponse, acp::Error> {
        Ok(acp::AuthenticateResponse::default())
    }

    async fn new_session(
        &self,
        _args: acp::NewSessionRequest,
    ) -> Result<acp::NewSessionResponse, acp::Error> {
        let session_number = self.next_session_id.get();
        self.next_session_id.set(session_number + 1);

        Ok(acp::NewSessionResponse::new(acp::SessionId::new(format!(
            "fixture-session-{session_number}"
        )))
        .config_options(vec![acp::SessionConfigOption::select(
            "permission-mode",
            "Permission Mode",
            "ask",
            vec![
                acp::SessionConfigSelectOption::new("ask", "Ask"),
                acp::SessionConfigSelectOption::new("auto-edit", "Auto Edit"),
            ],
        )]))
    }

    async fn load_session(
        &self,
        _args: acp::LoadSessionRequest,
    ) -> Result<acp::LoadSessionResponse, acp::Error> {
        Ok(acp::LoadSessionResponse::new())
    }

    async fn set_session_mode(
        &self,
        _args: acp::SetSessionModeRequest,
    ) -> Result<acp::SetSessionModeResponse, acp::Error> {
        Ok(acp::SetSessionModeResponse::new())
    }

    async fn prompt(&self, args: acp::PromptRequest) -> Result<acp::PromptResponse, acp::Error> {
        for content in args.prompt {
            let (tx, rx) = oneshot::channel();
            self.session_update_tx
                .send((
                    acp::SessionNotification::new(
                        args.session_id.clone(),
                        acp::SessionUpdate::AgentMessageChunk(acp::ContentChunk::new(content)),
                    ),
                    tx,
                ))
                .map_err(|_| acp::Error::internal_error())?;
            rx.await.map_err(|_| acp::Error::internal_error())?;
        }

        Ok(acp::PromptResponse::new(acp::StopReason::EndTurn))
    }

    async fn cancel(&self, _args: acp::CancelNotification) -> Result<(), acp::Error> {
        Ok(())
    }

    async fn set_session_config_option(
        &self,
        args: acp::SetSessionConfigOptionRequest,
    ) -> Result<acp::SetSessionConfigOptionResponse, acp::Error> {
        let option = acp::SessionConfigOption::select(
            args.config_id,
            "Permission Mode",
            args.value,
            vec![
                acp::SessionConfigSelectOption::new("ask", "Ask"),
                acp::SessionConfigSelectOption::new("auto-edit", "Auto Edit"),
            ],
        );

        Ok(acp::SetSessionConfigOptionResponse::new(vec![option]))
    }
}

#[allow(dead_code)]
pub fn run_stdio_main() -> Result<(), Box<dyn StdError>> {
    let runtime = tokio::runtime::Builder::new_current_thread()
        .enable_all()
        .build()?;
    let local_set = tokio::task::LocalSet::new();

    runtime.block_on(local_set.run_until(async move {
        let outgoing = tokio::io::stdout().compat_write();
        let incoming = tokio::io::stdin().compat();
        let (session_update_tx, mut session_update_rx) = mpsc::unbounded_channel();
        let (connection, io_task) = acp::AgentSideConnection::new(
            FixtureAgent::new(session_update_tx),
            outgoing,
            incoming,
            |task| {
                tokio::task::spawn_local(task);
            },
        );

        tokio::task::spawn_local(async move {
            while let Some((notification, ack)) = session_update_rx.recv().await {
                if connection.session_notification(notification).await.is_err() {
                    break;
                }
                let _ = ack.send(());
            }
        });

        io_task.await
    }))?;

    Ok(())
}