Upgrade API to version 0.2.7

Author: ktiays

crates/cursor-core/src/conversation/chat/session.rs

@@ -1,20 +1,19 @@
 use futures::StreamExt;
 use node_bridge::prelude::*;
-use uuid::Uuid;
 use wasm_bindgen::JsValue;
 
 use crate::{
     conversation::{
-        make_conversation_request,
         models::{user_message::UserMessage, BotMessage, MessageType, RequestBody, UserRequest},
+        send_conversation_request,
     },
     GenerateInput,
 };
 
 #[derive(Debug)]
 pub struct Session {
     request_body: Option<RequestBody>,
-    conversation_id: String,
+    message_counter: usize,
 }
 
 impl Session {
@@ -34,42 +33,35 @@ impl Session {
     }
 
     fn push_bot_message(&mut self, message: String) {
-        let bot_message = BotMessage::new(
-            self.conversation_id.clone(),
-            MessageType::Markdown,
-            message,
-            "<|END_message|>".to_owned(),
-            self.request_body
-                .as_ref()
-                .map(|r| r.user_request.current_root_path.clone())
-                .unwrap_or_default(),
-            true,
-        );
+        let bot_message = BotMessage::new(message, self.message_counter);
         self.request_body
             .as_mut()
             .map(|r| r.bot_messages.push(bot_message));
+        self.message_counter += 1;
     }
 
-    fn push_user_message(&mut self, input: &GenerateInput) {
-        let user_message =
-            UserMessage::new_with_input(input, &self.conversation_id, MessageType::Freeform);
+    fn push_user_message(&mut self, message: String) {
+        let user_message = UserMessage::new(message, self.message_counter);
         self.request_body
             .as_mut()
             .map(|r| r.user_messages.push(user_message));
+        self.message_counter += 1;
     }
 }
 
 impl Session {
     pub fn new() -> Self {
         Self {
             request_body: None,
-            conversation_id: Uuid::new_v4().to_string(),
+            message_counter: 0,
         }
     }
 
     pub async fn send_message(&mut self, input: &GenerateInput) -> Result<(), JsValue> {
         let request_body = self.body_with_input(input);
-        let mut state = make_conversation_request("/conversation", request_body).await?;
+        #[cfg(debug_assertions)]
+        console::log_str(&serde_json::to_string(&request_body).unwrap());
+        let mut state = send_conversation_request("/conversation", request_body).await?;
 
         let mut message: String = "".to_owned();
 
@@ -87,7 +79,7 @@ impl Session {
 
         result_stream.end();
 
-        self.push_user_message(input);
+        self.push_user_message(input.prompt());
         self.push_bot_message(message);
 
         Ok(())

crates/cursor-core/src/conversation/generate/mod.rs

@@ -11,8 +11,8 @@ use wasm_bindgen::prelude::*;
 use crate::GenerateInput;
 
 use super::{
-    make_conversation_request,
     models::{MessageType, RequestBody},
+    send_conversation_request,
 };
 
 async fn generate_code_inner(input: &GenerateInput) -> Result<(), JsValue> {
@@ -29,7 +29,7 @@ async fn generate_code_inner(input: &GenerateInput) -> Result<(), JsValue> {
     #[cfg(debug_assertions)]
     console::log_str(&serde_json::to_string(&request_body).unwrap());
 
-    let mut state = make_conversation_request("/conversation", &request_body).await?;
+    let mut state = send_conversation_request("/conversation", &request_body).await?;
 
     #[cfg(debug_assertions)]
     console::log_str("response received");

crates/cursor-core/src/conversation/mod.rs

@@ -2,65 +2,28 @@ pub mod chat;
 pub mod generate;
 pub mod models;
 
-use futures::{stream, Stream, StreamExt};
-use node_bridge::{
-    http_client::{HttpMethod, HttpResponse},
-    prelude::console,
-};
 use wasm_bindgen::{JsError, JsValue};
 use wasm_bindgen_futures::spawn_local;
 
 use crate::{
     auth::account_token,
     context::get_extension_context,
-    request::{make_request, JsonSendable},
+    request::{
+        stream::{make_stream_request, StreamResponseState},
+        JsonSendable,
+    },
 };
 
 use self::models::RequestBody;
 
-struct ResponseState {
-    response: HttpResponse,
-}
-
-impl ResponseState {
-    fn new(response: HttpResponse) -> Self {
-        Self { response }
-    }
-
-    pub fn data_stream(&mut self) -> impl Stream<Item = String> + '_ {
-        self.response.body().flat_map(|chunk| {
-            let chunk = chunk.to_string("utf-8");
-            #[cfg(debug_assertions)]
-            console::log_str(&chunk);
-
-            let lines: Vec<_> = chunk
-                .split("\n")
-                .filter_map(|l| {
-                    if l.len() > 0 && l.starts_with("data: \"") {
-                        serde_json::from_str::<String>(&l["data: ".len()..]).ok()
-                    } else {
-                        None
-                    }
-                })
-                .filter(|s| s != "[DONE]")
-                .collect();
-            stream::iter(lines)
-        })
-    }
-
-    pub async fn complete(self) -> Result<(), JsValue> {
-        self.response.await
-    }
-}
-
 const SIGN_IN_ITEM: &str = "Sign In / Sign Up";
 const CONFIGURE_API_KEY_ITEM: &str = "Configure API Key";
 
-async fn make_conversation_request(
+async fn send_conversation_request(
     path: &str,
     body: &RequestBody,
-) -> Result<ResponseState, JsValue> {
-    let mut request = make_request(path, HttpMethod::Post);
+) -> Result<StreamResponseState, JsValue> {
+    let mut request = make_stream_request(path, body);
     if body.api_key.is_none() {
         if let Some(token) = account_token() {
             request =
@@ -105,5 +68,5 @@ async fn make_conversation_request(
         ))
         .into());
     }
-    Ok(ResponseState::new(response))
+    Ok(response.into())
 }

crates/cursor-core/src/conversation/models/bot_message.rs

@@ -1,68 +1,23 @@
 use serde::Serialize;
 
-use super::{request_body::MessageType, random};
-
 #[derive(Debug, Serialize, Clone)]
 pub struct BotMessage {
     #[serde(rename = "sender")]
     pub sender: String,
 
     #[serde(rename = "sentAt")]
-    pub sent_at: i64,
-
-    #[serde(rename = "conversationId")]
-    pub conversation_id: String,
-
-    #[serde(rename = "type")]
-    pub message_type: MessageType,
+    pub index: usize,
 
     #[serde(rename = "message")]
     pub message: String,
-
-    #[serde(rename = "lastToken")]
-    pub last_token: String,
-
-    #[serde(rename = "finished")]
-    pub finished: bool,
-
-    #[serde(rename = "currentFile")]
-    pub current_file: String,
-
-    #[serde(rename = "interrupted")]
-    pub interrupted: bool,
-
-    #[serde(rename = "maxOrigLine")]
-    pub max_original_line: i32,
-
-    #[serde(rename = "hitTokenLimit")]
-    pub hit_token_limit: bool,
-
-    #[serde(rename = "useDiagnostics")]
-    pub use_diagnostics: bool,
 }
 
 impl BotMessage {
-    pub fn new(
-        conversation_id: String,
-        message_type: MessageType,
-        message: String,
-        last_token: String,
-        current_file: String,
-        finished: bool,
-    ) -> Self {
+    pub fn new(message: String, index: usize) -> Self {
         Self {
             sender: "bot".to_owned(),
-            sent_at: chrono::Utc::now().timestamp_millis(),
-            conversation_id,
-            message_type,
+            index,
             message,
-            last_token,
-            finished,
-            current_file,
-            interrupted: !finished,
-            max_original_line: random(),
-            hit_token_limit: true,
-            use_diagnostics: false,
         }
     }
 }

crates/cursor-core/src/conversation/models/request_body.rs

@@ -1,4 +1,4 @@
-use serde::Serialize;
+use serde::{Serialize, Serializer};
 
 use crate::GenerateInput;
 
@@ -10,7 +10,6 @@ pub enum MessageType {
     Edit,
     Generate,
     Freeform,
-    Markdown,
 }
 
 #[derive(Debug, Serialize, Clone)]
@@ -24,9 +23,6 @@ pub struct RequestBody {
     #[serde(rename = "userMessages")]
     pub user_messages: Vec<UserMessage>,
 
-    #[serde(rename = "contextType")]
-    pub context_type: String,
-
     #[serde(rename = "rootPath")]
     pub root_path: String,
 
@@ -35,6 +31,17 @@ pub struct RequestBody {
 
     #[serde(rename = "customModel", skip_serializing_if = "Option::is_none")]
     pub gpt_model: Option<String>,
+
+    /// Allow Cursor to use code snippets for product improvements.
+    #[serde(rename = "noStorageMode", serialize_with = "serialize_invert_bool")]
+    pub telemetry: bool,
+}
+
+fn serialize_invert_bool<S>(value: &bool, serializer: S) -> Result<S::Ok, S::Error>
+where
+    S: Serializer,
+{
+    serializer.serialize_bool(!value)
 }
 
 impl RequestBody {
@@ -50,10 +57,10 @@ impl RequestBody {
             user_request,
             bot_messages,
             user_messages,
-            context_type: "copilot".to_owned(),
             root_path: root_path.unwrap_or_default(),
             api_key,
             gpt_model,
+            telemetry: true,
         }
     }