procyon 0.1.2

Terminal development harness for Stellar and Soroban smart contracts, driven by a language model
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

//! Adapter for Anthropic's `/v1/messages`.
//!
//! The client is the only part that talks to the network: the wire shapes live in `wire`, the
//! stream reassembly in `stream`, and the neutral vocabulary they translate to and from is in
//! `agent`.

mod stream;
mod wire;

use color_eyre::Result;
use reqwest::Client;
use tokio::sync::mpsc;

use self::stream::StreamState;
use self::wire::{MessagesRequest, MessagesResponse};
use crate::agent::{ContentPart, Message, StreamOutcome, ToolDefinition};
use crate::sse::EventReader;

pub struct ClaudeClient {
    client: Client,
    api_key: String,
    base_url: String,
    api_version: String,
    model: String,
    max_tokens: u32,
}

impl ClaudeClient {
    pub fn new(api_key: String) -> Self {
        Self {
            client: crate::llm::http_client(),
            api_key,
            base_url: "https://api.anthropic.com".to_string(),
            api_version: "2023-06-01".to_string(),
            model: "claude-sonnet-5".to_string(),
            max_tokens: 4096,
        }
    }

    pub fn with_model(mut self, model: String) -> Self {
        self.model = model;
        self
    }

    pub fn with_max_tokens(mut self, max_tokens: u32) -> Self {
        self.max_tokens = max_tokens;
        self
    }

    #[allow(dead_code)]
    pub fn with_base_url(mut self, base_url: String) -> Self {
        self.base_url = base_url.trim_end_matches('/').to_string();
        self
    }

    #[allow(dead_code)]
    pub fn with_api_version(mut self, api_version: String) -> Self {
        self.api_version = api_version;
        self
    }

    fn endpoint(&self) -> String {
        format!("{}/v1/messages", self.base_url)
    }

    async fn dispatch(&self, request: &MessagesRequest<'_>) -> Result<reqwest::Response> {
        crate::llm::send_with_retry(|| {
            self.client
                .post(self.endpoint())
                .header("x-api-key", &self.api_key)
                .header("anthropic-version", &self.api_version)
                .header("content-type", "application/json")
                .json(request)
        })
        .await
    }

    // The non-streaming path, used for compaction: the summary is not shown as it arrives, and
    // replaying the caller's own system prompt and tools keeps the call a genuine prefix of the
    // conversation, so it shares the cached tool and system breakpoints with the main loop.
    pub async fn send_message(
        &self,
        history: &[Message],
        tools: Option<&[ToolDefinition]>,
        system: Option<&str>,
    ) -> Result<Vec<ContentPart>> {
        let request = MessagesRequest::build(
            self.model.clone(),
            self.max_tokens,
            history,
            tools,
            system,
            false,
        );

        let response = self.dispatch(&request).await?;
        let body: MessagesResponse = response.json().await?;
        Ok(body.content)
    }

    pub async fn send_message_streaming(
        &self,
        history: &[Message],
        tools: Option<&[ToolDefinition]>,
        system: Option<&str>,
        update_tx: &mpsc::UnboundedSender<String>,
    ) -> Result<StreamOutcome> {
        let request = MessagesRequest::build(
            self.model.clone(),
            self.max_tokens,
            history,
            tools,
            system,
            true,
        );

        let response = self.dispatch(&request).await?;

        let mut reader = EventReader::new(StreamState::new(update_tx));
        reader.read(response).await?;
        Ok(reader.into_sink().into_outcome())
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn trailing_slash_in_base_url_does_not_double() {
        let client = ClaudeClient::new("k".to_string())
            .with_base_url("https://gateway.internal/".to_string());

        assert_eq!(client.endpoint(), "https://gateway.internal/v1/messages");
    }
}