code tidy up; 0.1.6->0.1.7

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fgpt"
-version = "0.1.6"
+version = "0.1.7"
 edition = "2021"
 description = "A free reverse proxy and cli tool for OpenAI GPT-3.5-turbo."
 authors = ["jinti <shenjindi@fourz.cn>"]

Dockerfile

@@ -7,7 +7,7 @@ RUN cargo build --release
 FROM debian:bookworm
 ENV DEBIAN_FRONTEND noninteractive
 ENV LANG C.UTF-8
-LABEL maintainer="shenjindi@ruzhila.cn"
+LABEL maintainer="shenjindi@fourz.cn"
 
 COPY --from=builder /build/target/release/fgpt /bin/
 

README.md

@@ -1,24 +1,23 @@
 # A free reverse proxy and CLI tool for OpenAI GPT-3.5-turbo
 
 It allows you to use the GPT-3.5 API without needing to sign up for an API key or pay for usage.
-> OpenAI GPT-3.5-turbo is free to use, without any account or API key
-> DON'T USE IN PRODUCTION, ONLY FOR PERSONAL USE/TESTING
+> 😄 OpenAI GPT-3.5-turbo is free to use, without any account or API key   
+> 🔔 DON'T USE IN PRODUCTION, ONLY FOR PERSONAL USE/TESTING
 
 ## Features
 
 - [x] **REPL** mode, you can input questions and get answers interactively
 - [x] **Reverse proxy mode**, you can use the OpenAI OpenAPI with a local server
 - [x] **CLI mode**, with shell pipe, file input, code output, etc.
-- [x] Support https proxy and socks5 proxy
+- [x] 🔏 Support https proxy and socks5 proxy
 
 ## Download precompiled binary
 
-- [Linux](https://github.com/shenjinti/fgpt/releases/download/v0.1.5/fgpt-linux-v0.1.5.tar.gz) executable binary
-- [Mac M1/M2](https://github.com/shenjinti/fgpt/releases/download/v0.1.5/fgpt-mac_aarch64-v0.1.5.tar.gz) executable binary
+- [Linux x64](https://github.com/shenjinti/fgpt/releases/download/v0.1.7/fgpt-linux_x64.tar.gz) executable binary
+- [Mac M1/M2](https://github.com/shenjinti/fgpt/releases/download/v0.1.7/fgpt-mac_aarch64.tar.gz) executable binary
 - Windows (Coming soon)
 - Or via [Docker](https://hub.docker.com/r/shenjinti/fgpt)
 - Or build from source (see below, cargo is required)
-
     ```bash
     cargo install fgpt
     ```
@@ -35,7 +34,7 @@ fgpt "How to get a domain's MX record on linux shell?"
 fgpt -c "Write python code to reverse a string"
 
 # With pipe
-git diff | fgpt "Write a git commit bief with follow diff"
+cat README.md | fgpt "summarize for reddit post"
 
 # With stdin
 fgpt "Convert the follow csv data to json, without any description" < contacts.csv
@@ -94,6 +93,7 @@ Your local server will now be running and accessible at: `http://127.0.0.1:4090/
 
 ```python
 import openai
+import sys
 openai.api_key = 'nothing'
 openai.base_url = "http://127.0.0.1:4090/v1/"
 
@@ -102,17 +102,27 @@ completion = openai.chat.completions.create(
     messages=[
         {"role": "user", "content": "Write a javascript simple code"},
     ],
+    stream=True,
 )
 
-print(completion.choices[0].message.content)
+for chunk in completion:
+    print(chunk.choices[0].delta.content, end='')
+    sys.stdout.flush()
+
+print()
 ```
 
 or test with curl:
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -d '{"model":"gpt-3.5-turbo","messages":[{"role":"user","content":"Write a javascript simple code"}], "stream":true}' http://127.0.0.1:4090/v1/chat/completions
+curl -X POST -H "Content-Type: application/json" -d '{"model":"gpt-3.5-turbo",
+"messages":[{"role":"user","content":"Write a javascript simple code"}], 
+"stream":true}' \
+http://127.0.0.1:4090/v1/chat/completions
  ```
 
 ```bash
-curl -X POST -H "Content-Type: application/json" -d '{"model":"gpt-3.5-turbo","messages":[{"role":"user","content":"Write a javascript simple code"}]}' http://127.0.0.1:4090/v1/chat/completions
+curl -X POST -H "Content-Type: application/json" -d '{"model":"gpt-3.5-turbo",
+"messages":[{"role":"user","content":"Write a javascript simple code"}]}' \
+http://127.0.0.1:4090/v1/chat/completions
  ```

src/cli.rs

@@ -7,6 +7,15 @@ use std::borrow::Cow;
 use std::io::Write;
 use std::io::{IsTerminal, Read};
 
+impl From<ReadlineError> for fgpt::Error {
+    fn from(e: ReadlineError) -> Self {
+        match e {
+            ReadlineError::Eof => fgpt::Error::Io("EOF".to_string()),
+            _ => fgpt::Error::Io(e.to_string()),
+        }
+    }
+}
+
 #[derive(Default)]
 struct PromptHighlighter {}
 
@@ -26,7 +35,7 @@ struct PromptHelper {
     highlighter: PromptHighlighter,
 }
 
-pub async fn run_repl(state: fgpt::StateRef) -> Result<(), fgpt::Error> {
+pub async fn run_repl(state: fgpt::AppStateRef) -> Result<(), fgpt::Error> {
     println!("free GPT-3.5 cli tools | 🪐 https://github.com/shenjinti/fgpt");
     println!("💖 To star the repository if you like \x1b[1;32mfgpt\x1b[0m!");
 
@@ -58,6 +67,7 @@ pub async fn run_repl(state: fgpt::StateRef) -> Result<(), fgpt::Error> {
                 let line = line.trim();
                 match line {
                     "/exit" => break,
+                    "/bye" => break,
                     "/help" => {
                         help_texts.iter().for_each(|text| println!("{}", text));
                         continue;
@@ -143,7 +153,7 @@ pub async fn run_repl(state: fgpt::StateRef) -> Result<(), fgpt::Error> {
     Ok(())
 }
 
-pub async fn run(state: fgpt::StateRef) -> Result<(), fgpt::Error> {
+pub async fn run(state: fgpt::AppStateRef) -> Result<(), fgpt::Error> {
     if state.repl || (state.qusetion.is_none() && state.input_file.is_none()) {
         return run_repl(state).await;
     }

src/fgpt.rs

@@ -10,7 +10,6 @@ use reqwest::{
     },
     Client, Proxy,
 };
-use rustyline::error::ReadlineError;
 use serde::{ser::SerializeStruct, Deserialize, Serialize, Serializer};
 use sha3::Digest;
 use std::cell::RefCell;
@@ -26,7 +25,9 @@ use std::{
 const OPENAI_ENDPOINT: &str = "https://chat.openai.com";
 const OPENAI_API_URL: &str = "https://chat.openai.com/backend-anon/conversation";
 const OPENAI_SENTINEL_URL: &str = "https://chat.openai.com/backend-anon/sentinel/chat-requirements";
-const UA: &str = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/123.0.0.0 Safari/537.36";
+const UA: &str = "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/121.0.0.0 Safari/537.36 Edg/121.0.0.0";
+const CH_UA: &str = r#""Not A(Brand";v="99", "Microsoft Edge";v="121", "Chromium";v="121""#;
+const CH_PLATFORM: &str = r#""macOS""#;
 
 #[derive(Clone)]
 pub struct AppState {
@@ -46,7 +47,7 @@ pub struct AppState {
     pub serve_addr: String,
 }
 
-pub type StateRef = Arc<AppState>;
+pub type AppStateRef = Arc<AppState>;
 
 #[derive(Debug)]
 pub enum Error {
@@ -73,16 +74,6 @@ impl From<serde_json::Error> for Error {
     }
 }
 
-#[cfg(feature = "cli")]
-impl From<ReadlineError> for Error {
-    fn from(e: ReadlineError) -> Self {
-        match e {
-            ReadlineError::Eof => Error::Io("EOF".to_string()),
-            _ => Error::Io(e.to_string()),
-        }
-    }
-}
-
 impl fmt::Display for Error {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         match self {
@@ -162,7 +153,7 @@ pub struct CompletionRequest {
 
 impl CompletionRequest {
     pub fn new(
-        state: StateRef,
+        state: AppStateRef,
         messages: Vec<Message>,
         conversation_id: Option<String>,
         parent_message_id: Option<String>,
@@ -188,7 +179,7 @@ impl CompletionRequest {
         }
     }
 
-    pub async fn stream(&self, state: StateRef) -> Result<CompletionStream, Error> {
+    pub async fn stream(&self, state: AppStateRef) -> Result<CompletionStream, Error> {
         let start_at = std::time::Instant::now();
         let session = alloc_session(state.clone()).await?;
         let builder = build_req(
@@ -457,7 +448,7 @@ fn build_req(
     token: Option<&str>,
     seed: Option<&str>,
     difficulty: Option<&str>,
-    state: StateRef,
+    state: AppStateRef,
 ) -> Result<reqwest::RequestBuilder, reqwest::Error> {
     let client = match state.proxy.as_ref() {
         Some(proxy) => match Proxy::all(proxy) {
@@ -486,12 +477,9 @@ fn build_req(
         .header(REFERER, OPENAI_ENDPOINT)
         .header(ORIGIN, OPENAI_ENDPOINT)
         .header(CONTENT_TYPE, "application/json")
-        .header(
-            "sec-ch-ua",
-            "\"Google Chrome\";v=\"123\", \"Not:A-Brand\";v=\"8\", \"Chromium\";v=\"123\"",
-        )
+        .header("sec-ch-ua", CH_UA)
         .header("sec-ch-ua-mobile", "?0")
-        .header("sec-ch-ua-platform", "\"Windows\"")
+        .header("sec-ch-ua-platform", CH_PLATFORM)
         .header("sec-fetch-dest", "empty")
         .header("sec-fetch-mode", "cors")
         .header("sec-fetch-site", "same-origin")
@@ -509,7 +497,7 @@ fn build_req(
     }
 }
 
-pub async fn alloc_session(state: StateRef) -> Result<Session, Error> {
+pub async fn alloc_session(state: AppStateRef) -> Result<Session, Error> {
     let start_at = SystemTime::now();
     let resp = build_req(
         OPENAI_SENTINEL_URL,

src/main.rs

@@ -150,7 +150,7 @@ pub async fn main() -> Result<(), crate::fgpt::Error> {
         init_log(&args.log_level, false, &args.log_file);
     }
 
-    let state: fgpt::StateRef = Arc::new(args.into());
+    let state: fgpt::AppStateRef = Arc::new(args.into());
 
     #[cfg(feature = "proxy")]
     if state.serve_addr != "" {

src/proxy.rs

@@ -1,4 +1,4 @@
-use crate::fgpt::{self, CompletionRequest, StateRef};
+use crate::fgpt::{self, AppStateRef, CompletionEvent, CompletionRequest, Message};
 use axum::{
     extract::State,
     response::{sse::Event, IntoResponse, Response, Sse},
@@ -16,12 +16,12 @@ use std::{
 
 #[derive(Deserialize, Debug, Serialize, Default)]
 struct OpenAPIClientRequest {
-    messages: Vec<crate::fgpt::Message>,
+    messages: Vec<Message>,
     stream: Option<bool>,
 }
 
 async fn proxy_completions(
-    State(state): State<StateRef>,
+    State(state): State<AppStateRef>,
     Json(params): Json<OpenAPIClientRequest>,
 ) -> Response {
     log::info!(
@@ -43,7 +43,7 @@ async fn proxy_completions(
 }
 
 async fn handle_proxy_completions(
-    State(state): State<StateRef>,
+    State(state): State<AppStateRef>,
     Json(params): Json<OpenAPIClientRequest>,
 ) -> Result<Response, fgpt::Error> {
     let stream_mode = params.stream.unwrap_or(false);
@@ -58,10 +58,10 @@ async fn handle_proxy_completions(
     if !stream_mode {
         while let Some(Ok(event)) = stream.next().await {
             match event {
-                crate::fgpt::CompletionEvent::Done => {
+                CompletionEvent::Done => {
                     break;
                 }
-                crate::fgpt::CompletionEvent::Error(reason) => {
+                CompletionEvent::Error(reason) => {
                     return Err(fgpt::Error::Io(reason));
                 }
                 _ => {}
@@ -104,7 +104,7 @@ async fn handle_proxy_completions(
         );
 
         log::info!(
-            "sync exec request_id:{} elapsed:{:.2}s throughput:{} tokens:{:.2}",
+            "sync exec request_id:{} elapsed:{:.2}s throughput:{:.2} tokens:{}",
             stream.request_id,
             stream.start_at.elapsed().unwrap().as_secs_f64(),
             *stream.completion_tokens.borrow() as f64
@@ -128,7 +128,7 @@ impl Stream for CompletionToSSEStream {
         let poll = stream.poll_next_unpin(cx);
         match poll {
             Poll::Ready(Some(Ok(event))) => match event {
-                crate::fgpt::CompletionEvent::Data(data) => {
+                CompletionEvent::Data(data) => {
                     let body = json!(
                         {
                             "id": stream.request_id,
@@ -154,7 +154,7 @@ impl Stream for CompletionToSSEStream {
                     let event = Event::default().data(body.to_string());
                     Poll::Ready(Some(Ok(event)))
                 }
-                crate::fgpt::CompletionEvent::Done => {
+                CompletionEvent::Done => {
                     let completion_tokens = *stream.completion_tokens.borrow();
                     let total_tokens = completion_tokens + stream.prompt_tokens;
                     log::info!(
@@ -166,11 +166,11 @@ impl Stream for CompletionToSSEStream {
                     );
                     Poll::Ready(None)
                 }
-                crate::fgpt::CompletionEvent::Error(reason) => {
+                CompletionEvent::Error(reason) => {
                     let body = json!(
                         {
                             "id": stream.request_id,
-                            "created": stream.start_at.duration_since(UNIX_EPOCH).unwrap(),
+                            "created": stream.start_at.duration_since(UNIX_EPOCH).unwrap().as_secs_f64(),
                             "model": "gpt-3.5-turbo",
                             "object": "chat.completion.chunk",
                             "choices": [
@@ -196,7 +196,7 @@ impl Stream for CompletionToSSEStream {
     }
 }
 
-pub async fn serve(state: StateRef) -> Result<(), crate::fgpt::Error> {
+pub async fn serve(state: AppStateRef) -> Result<(), fgpt::Error> {
     let app = Router::new()
         .nest(
             &state.prefix,