From 6728c2fd6c79ef4515d4a0326ccfdb19111a7cef Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 14:22:02 -0300
Subject: [PATCH 01/13] Refactor rust versions

---
 Cargo.toml                       | 52 +++++++++++++++++++++++++++-----
 crates/fluent-cli/Cargo.toml     | 24 +++++++--------
 crates/fluent-core/Cargo.toml    | 38 +++++++++++------------
 crates/fluent-engines/Cargo.toml | 41 ++++++++++---------------
 crates/fluent-lambda/Cargo.toml  | 16 +++++-----
 5 files changed, 100 insertions(+), 71 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 941fb28..22ef3b7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -17,16 +17,54 @@ fluent-cli = { path = "crates/fluent-cli" }
 fluent-core = { path = "crates/fluent-core" }
 fluent-engines = { path = "crates/fluent-engines" }
 fluent-storage = { path = "crates/fluent-storage" }
-tokio = { version = "1", features = ["full"] }
-clap = { version = "4.5.8", features = ["derive"] }
-anyhow = "1.0"
-env_logger = "0.11.3"
-neo4rs = "0.8.0"
-chrono = { version = "0.4", features = ["serde"] }
-uuid = { version = "1.3", features = ["v4", "serde"] }
+tokio = { workspace = true, features = ["full"] }
+clap = { workspace = true, features = ["derive"] }
+anyhow = { workspace = true }
+env_logger = { workspace = true }
+neo4rs = { workspace = true }
+chrono = { workspace = true, features = ["serde"] }
+uuid = { workspace = true, features = ["v4", "serde"] }
 
 [workspace.dependencies]
+reqwest = { version = "^0.12", default-features = false, features = [
+    "json",
+    "stream",
+    "multipart",
+    "rustls-tls",
+] }
 fluent-cli = { path = "crates/fluent-cli" }
 fluent-core = { path = "crates/fluent-core" }
 fluent-engines = { path = "crates/fluent-engines" }
 fluent-storage = { path = "crates/fluent-storage" }
+serde = { version = "^1.0" }
+lambda_runtime = "^0.13"
+serde_json = "^1.0"
+tracing-subscriber = "^0.3"
+tracing = "^0.1"
+tokio = { version = "^1" }
+anyhow = { version = "^1.0" }
+strum = { version = "^0.26" }
+clap = { version = "^4.5" }
+env_logger = { version = "^0.11" }
+neo4rs = { version = "^0.8" }
+chrono = { version = "^0.4" }
+uuid = { version = "^1.3" }
+indicatif = "^0.17"
+owo-colors = "^4.0"
+regex = "^1.10"
+serde_yaml = "^0.9"
+async-trait = "^0.1"
+log = "^0.4"
+unicode-segmentation = "1.11.0"
+rust-stemmers = "1.2.0"
+stop-words = "0.8.0"
+base64 = "0.22.1"
+url = "^2.5"
+termimad = "^0.29"
+syntect = "^5.2"
+pdf-extract = "^0.7"
+tokio-util = { version = "^0.7" }
+mime_guess = { version = "^2.0" }
+futures-util = { version = "^0.3" }
+tempfile = "^3.10"
+futures = "^0.3"
diff --git a/crates/fluent-cli/Cargo.toml b/crates/fluent-cli/Cargo.toml
index a02573d..fde0e8d 100644
--- a/crates/fluent-cli/Cargo.toml
+++ b/crates/fluent-cli/Cargo.toml
@@ -6,18 +6,18 @@ default-run = "fluent-cli"
 
 
 [dependencies]
-clap = { version = "4.5.8", features = ["derive"] }
-fluent-core = { path = "../fluent-core" }
-fluent-engines = { path = "../fluent-engines" }
-tokio = { version = "1", features = ["full"] }
-anyhow = "1.0"
-log = "0.4.22"
-uuid = { version = "1.9.1", features = ["v4"] }
-serde_json = "1.0.120"
-indicatif = "0.17.8"
-owo-colors = "4.0.0"
-regex = "1.10.5"
-serde_yaml = "0.9.34"
+clap = { workspace = true, features = ["derive"] }
+fluent-core = { workspace = true }
+fluent-engines = { workspace = true }
+tokio = { workspace = true, features = ["full"] }
+anyhow = { workspace = true }
+log = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
+serde_json = { workspace = true }
+indicatif = { workspace = true }
+owo-colors = { workspace = true }
+regex = { workspace = true }
+serde_yaml = { workspace = true }
 #fluent-storage = { path = "../fluent-storage" }  # is not used
 #clap_complete = "4.5.1"  #is not used
 #atty = "0.2.14" "use standard std::io::IsTerminal"
diff --git a/crates/fluent-core/Cargo.toml b/crates/fluent-core/Cargo.toml
index 89bf422..4f249ac 100644
--- a/crates/fluent-core/Cargo.toml
+++ b/crates/fluent-core/Cargo.toml
@@ -5,29 +5,29 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
+neo4rs = { workspace = true }
 reqwest = { version = "0.12.5", default-features = false, features = [
     "json",
     "rustls-tls",
 ] }
-serde = { version = "1.0", features = ["derive"] }
-anyhow = "1.0"
-serde_json = "1.0.120"
-async-trait = "0.1.80"
-log = "0.4.22"
-chrono = "0.4.38"
-uuid = { version = "1.9.1", features = ["v4"] }
-neo4rs = "0.7.1"
-unicode-segmentation = "1.11.0"
-rust-stemmers = "1.2.0"
-stop-words = "0.8.0"
-base64 = "0.22.1"
-tokio = "1.39.2"
-regex = "1.10.6"
-url = "2.5.2"
-termimad = "0.29.4"
-syntect = "5.2.0"
-owo-colors = "4.0.0"
-pdf-extract = "0.7.7"
+serde = { workspace = true, features = ["derive"] }
+anyhow = { workspace = true }
+serde_json = { workspace = true }
+async-trait = { workspace = true }
+log = { workspace = true }
+chrono = { workspace = true }
+uuid = { workspace = true, features = ["v4"] }
+unicode-segmentation = { workspace = true }
+rust-stemmers = { workspace = true }
+stop-words = { workspace = true }
+base64 = { workspace = true }
+tokio = { workspace = true }
+regex = { workspace = true }
+url = { workspace = true }
+termimad = { workspace = true }
+syntect = { workspace = true }
+owo-colors = { workspace = true }
+pdf-extract = { workspace = true }
 
 
 #rust-bert = {  version = "0.18.0"  }  #Is not used
diff --git a/crates/fluent-engines/Cargo.toml b/crates/fluent-engines/Cargo.toml
index e953b5b..a9e448c 100644
--- a/crates/fluent-engines/Cargo.toml
+++ b/crates/fluent-engines/Cargo.toml
@@ -5,28 +5,19 @@ version = "0.1.0"
 edition = "2021"
 
 [dependencies]
-fluent-core = { path = "../fluent-core" }
-reqwest = { version = "0.12.5", default-features = false, features = [
-    "json",
-    "stream",
-    "multipart",
-    "rustls-tls",
-] }
-serde_json = "1.0.120"
-anyhow = "1.0.86"
-async-trait = "0.1.80"
-log = "0.4.22"
-tokio = "1.38.0"
-tokio-util = "0.7.11"
-base64 = "0.22.1"
-mime_guess = "2.0.3"
-serde = { version = "1.0.204", features = ["derive"] }
-uuid = "1.9.1"
-futures-util = "0.3.30"
-tempfile = "3.10.1"
-futures = "0.3.30"
-strum = { version = "0.26.3", features = ["derive"] }
-
-
-#indicatif = "0.17.8"
-#clap = "4.5.8"
+fluent-core = { workspace = true }
+reqwest = { workspace = true }
+serde_json = { workspace = true }
+anyhow = { workspace = true }
+async-trait = { workspace = true }
+log = { workspace = true }
+tokio = { workspace = true }
+tokio-util = { workspace = true }
+base64 = { workspace = true }
+mime_guess = { workspace = true }
+serde = { workspace = true, features = ["derive"] }
+uuid = { workspace = true }
+futures-util = { workspace = true }
+tempfile = { workspace = true }
+futures = { workspace = true }
+strum = { workspace = true, features = ["derive"] }
diff --git a/crates/fluent-lambda/Cargo.toml b/crates/fluent-lambda/Cargo.toml
index 97f9903..4245efb 100644
--- a/crates/fluent-lambda/Cargo.toml
+++ b/crates/fluent-lambda/Cargo.toml
@@ -5,13 +5,13 @@ edition = "2021"
 
 
 [dependencies]
+tokio = { workspace = true, features = ["macros"] }
+anyhow = { workspace = true }
 fluent-core.workspace = true
 fluent-engines.workspace = true
-serde = { version = "1.0" }
-lambda_runtime = "0.13.0"
-serde_json = "1.0.122"
-tracing-subscriber = "0.3.18"
-tracing = "0.1.40"
-tokio = { version = "1", features = ["macros"] }
-anyhow = "1.0.86"
-strum = { version = "0.26.3", features = ["derive"] }
+serde = { workspace = true }
+lambda_runtime = { workspace = true }
+serde_json = { workspace = true }
+tracing-subscriber = { workspace = true }
+tracing = { workspace = true }
+strum = { workspace = true, features = ["derive"] }

From 4d0c1c166492616d9941804b1e7b8bdb9e547288 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 14:52:26 -0300
Subject: [PATCH 02/13] Simplifies parameters overriding

---
 crates/fluent-lambda/src/lib.rs | 19 +++++++------------
 1 file changed, 7 insertions(+), 12 deletions(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 9506a14..5a9127e 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -14,12 +14,7 @@ pub async fn run(request: Request) -> anyhow::Result<Response> {
 
     let config_content = include_str!("config.json");
 
-    let overrides = request
-        .overrides
-        .unwrap_or_default()
-        .into_iter()
-        .map(|kv| (kv.key, kv.value))
-        .collect::<HashMap<String, Value>>();
+    let overrides = request.overrides.unwrap_or_default();
 
     let credentials = request
         .credentials
@@ -30,7 +25,7 @@ pub async fn run(request: Request) -> anyhow::Result<Response> {
 
     let user_prompt = request
         .request
-        .ok_or_else(|| anyhow!("Prompt is required"))?;
+        .ok_or_else(|| anyhow!("Request is required"))?;
 
     let engine_config = load_engine_config(config_content, &engine_name, &overrides, &credentials)?;
 
@@ -193,19 +188,19 @@ pub enum Template {
 #[derive(Debug, Deserialize, Serialize)]
 pub struct Request {
     // The template to use (openai or anthropic)
-    engine: Option<Template>,
+    pub engine: Option<Template>,
 
     // The credentials to be used on the request
-    credentials: Option<Vec<KeyValue>>,
+    pub credentials: Option<Vec<KeyValue>>,
 
     //Overrides for the configuration parameters
-    overrides: Option<Vec<OverrideValue>>,
+    pub overrides: Option<HashMap<String, Value>>,
 
     // The user prompt to process
-    request: Option<String>,
+    pub request: Option<String>,
 
     // Parse and display code blocks from the output
-    parse_code: Option<bool>,
+    pub parse_code: Option<bool>,
 }
 
 #[derive(Debug, Deserialize, Serialize)]

From 93acb0975d1c080b82220c79a25358ac57c3b996 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 16:38:39 -0300
Subject: [PATCH 03/13] Add clone support for request

---
 crates/fluent-lambda/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 5a9127e..962ede4 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -60,7 +60,7 @@ pub async fn run(request: Request) -> anyhow::Result<Response> {
     })
 }
 
-#[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display)]
+#[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display, Clone)]
 pub enum Template {
     #[strum(ascii_case_insensitive, to_string = "openai")]
     #[serde(alias = "openai")]
@@ -185,7 +185,7 @@ pub enum Template {
     DalleHorizontal,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct Request {
     // The template to use (openai or anthropic)
     pub engine: Option<Template>,
@@ -203,7 +203,7 @@ pub struct Request {
     pub parse_code: Option<bool>,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct KeyValue {
     pub key: String,
     pub value: String,

From ac6f78e77472c3543c3550ba0bc5b3bde3048e79 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 16:51:39 -0300
Subject: [PATCH 04/13] Change Template to EngineTemplate

---
 crates/fluent-lambda/src/lib.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 962ede4..0211835 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -61,7 +61,7 @@ pub async fn run(request: Request) -> anyhow::Result<Response> {
 }
 
 #[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display, Clone)]
-pub enum Template {
+pub enum EngineTemplate {
     #[strum(ascii_case_insensitive, to_string = "openai")]
     #[serde(alias = "openai")]
     OpenAI,
@@ -188,7 +188,7 @@ pub enum Template {
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct Request {
     // The template to use (openai or anthropic)
-    pub engine: Option<Template>,
+    pub engine: Option<EngineTemplate>,
 
     // The credentials to be used on the request
     pub credentials: Option<Vec<KeyValue>>,

From 76108cbcd4072b46e37732b60d783f1c19665a9d Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 16:59:39 -0300
Subject: [PATCH 05/13] Add from method for KeyValue

---
 crates/fluent-lambda/src/lib.rs | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 0211835..2207507 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -208,7 +208,14 @@ pub struct KeyValue {
     pub key: String,
     pub value: String,
 }
-
+impl KeyValue {
+    pub fn new(key: &str, value: &str) -> Self {
+        Self {
+            key: key.to_string(),
+            value: value.to_string(),
+        }
+    }
+}
 #[derive(Debug, Deserialize, Serialize)]
 pub struct OverrideValue {
     pub key: String,

From b73715f67e48bbbc828ce3133c10835447a5218b Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Fri, 9 Aug 2024 17:40:50 -0300
Subject: [PATCH 06/13] Refactor LambdaRequest

---
 crates/fluent-lambda/src/lib.rs  | 61 ++++++++++++++++++++++++++++++--
 crates/fluent-lambda/src/main.rs |  6 ++--
 2 files changed, 61 insertions(+), 6 deletions(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 2207507..760cdf8 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -2,11 +2,12 @@ use anyhow::anyhow;
 use fluent_core::config::load_engine_config;
 use fluent_engines::create_engine;
 use serde::{Deserialize, Serialize};
-use serde_json::Value;
+use serde_json::{json, Value};
 use std::{collections::HashMap, pin::Pin};
 use strum::{Display, EnumString};
 
-pub async fn run(request: Request) -> anyhow::Result<Response> {
+pub async fn run(request: impl Into<LambdaRequest>) -> anyhow::Result<Response> {
+    let request: LambdaRequest = request.into();
     let engine_name = request
         .engine
         .map(|t| t.to_string())
@@ -60,6 +61,50 @@ pub async fn run(request: Request) -> anyhow::Result<Response> {
     })
 }
 
+pub struct OpenAIRequest {
+    pub prompt: String,
+    pub openai_api_key: String,
+    pub response_format: Option<Value>,
+    pub temperature: Option<f64>,
+    pub max_tokens: Option<i64>,
+    pub top_p: Option<f64>,
+    pub frequency_penalty: Option<f64>,
+    pub presence_penalty: Option<f64>,
+}
+impl From<OpenAIRequest> for LambdaRequest {
+    fn from(request: OpenAIRequest) -> Self {
+        let mut overrides = vec![];
+        if let Some(response_format) = request.response_format {
+            overrides.push(("response_format".to_string(), response_format));
+        }
+        if let Some(temperature) = request.temperature {
+            overrides.push(("temperature".to_string(), json!(temperature)));
+        }
+        if let Some(max_tokens) = request.max_tokens {
+            overrides.push(("max_tokens".to_string(), json!(max_tokens)));
+        }
+        if let Some(top_p) = request.top_p {
+            overrides.push(("top_p".to_string(), json!(top_p)));
+        }
+        if let Some(frequency_penalty) = request.frequency_penalty {
+            overrides.push(("frequency_penalty".to_string(), json!(frequency_penalty)));
+        }
+        if let Some(presence_penalty) = request.presence_penalty {
+            overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
+        }
+        LambdaRequest {
+            request: Some(request.prompt),
+            engine: Some(EngineTemplate::OpenAI),
+            credentials: Some(vec![KeyValue::new(
+                "OPENAI_API_KEY",
+                &request.openai_api_key,
+            )]),
+            overrides: Some(overrides.into_iter().collect()),
+            parse_code: None,
+        }
+    }
+}
+
 #[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display, Clone)]
 pub enum EngineTemplate {
     #[strum(ascii_case_insensitive, to_string = "openai")]
@@ -186,7 +231,7 @@ pub enum EngineTemplate {
 }
 
 #[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct Request {
+pub struct LambdaRequest {
     // The template to use (openai or anthropic)
     pub engine: Option<EngineTemplate>,
 
@@ -216,6 +261,16 @@ impl KeyValue {
         }
     }
 }
+
+impl<K: Into<String>, V: Into<String>> From<(K, V)> for KeyValue {
+    fn from(kv: (K, V)) -> Self {
+        Self {
+            key: kv.0.into(),
+            value: kv.1.into(),
+        }
+    }
+}
+
 #[derive(Debug, Deserialize, Serialize)]
 pub struct OverrideValue {
     pub key: String,
diff --git a/crates/fluent-lambda/src/main.rs b/crates/fluent-lambda/src/main.rs
index 89c4257..cafbfb1 100644
--- a/crates/fluent-lambda/src/main.rs
+++ b/crates/fluent-lambda/src/main.rs
@@ -1,4 +1,4 @@
-use fluent_lambda::{run, Request, Response};
+use fluent_lambda::{run, LambdaRequest, Response};
 use lambda_runtime::{service_fn, Error, LambdaEvent};
 
 #[tokio::main]
@@ -8,13 +8,13 @@ async fn main() -> Result<(), Error> {
         .with_target(false)
         .without_time()
         .init();
-    lambda_runtime::run(service_fn(|event: LambdaEvent<Request>| async {
+    lambda_runtime::run(service_fn(|event: LambdaEvent<LambdaRequest>| async {
         lambda_handler(event).await
     }))
     .await
 }
 
 #[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]
-async fn lambda_handler(event: LambdaEvent<Request>) -> Result<Response, Error> {
+async fn lambda_handler(event: LambdaEvent<LambdaRequest>) -> Result<Response, Error> {
     run(event.payload).await.map_err(Error::from)
 }

From 340e43e251a0c6fa95252414227f9b59e690a8f9 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Sat, 10 Aug 2024 11:47:36 -0300
Subject: [PATCH 07/13] Create the FluentOpenAIRequest

---
 crates/fluent-lambda/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-lambda/src/lib.rs
index 760cdf8..ea89626 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-lambda/src/lib.rs
@@ -61,7 +61,7 @@ pub async fn run(request: impl Into<LambdaRequest>) -> anyhow::Result<Response>
     })
 }
 
-pub struct OpenAIRequest {
+pub struct FluentOpenAIRequest {
     pub prompt: String,
     pub openai_api_key: String,
     pub response_format: Option<Value>,
@@ -71,8 +71,8 @@ pub struct OpenAIRequest {
     pub frequency_penalty: Option<f64>,
     pub presence_penalty: Option<f64>,
 }
-impl From<OpenAIRequest> for LambdaRequest {
-    fn from(request: OpenAIRequest) -> Self {
+impl From<FluentOpenAIRequest> for LambdaRequest {
+    fn from(request: FluentOpenAIRequest) -> Self {
         let mut overrides = vec![];
         if let Some(response_format) = request.response_format {
             overrides.push(("response_format".to_string(), response_format));

From 773f5ae27f4ee13fc14dbf3fd2a06c347db93d7c Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 10:53:59 -0300
Subject: [PATCH 08/13] Create fluent-sdk

Creates the fluent-sdk for other rust projects to use fluent-core
features.

fluent-lambda now uses fluent-sdk
---
 Cargo.toml                                    |   3 +
 crates/fluent-lambda/Cargo.toml               |   1 +
 crates/fluent-lambda/src/main.rs              |  19 +-
 crates/fluent-sdk/.gitignore                  |   1 +
 crates/fluent-sdk/Cargo.toml                  |  15 ++
 .../src/config.json                           |   3 +-
 .../{fluent-lambda => fluent-sdk}/src/lib.rs  | 179 +++++++++---------
 7 files changed, 131 insertions(+), 90 deletions(-)
 create mode 100644 crates/fluent-sdk/.gitignore
 create mode 100644 crates/fluent-sdk/Cargo.toml
 rename crates/{fluent-lambda => fluent-sdk}/src/config.json (99%)
 rename crates/{fluent-lambda => fluent-sdk}/src/lib.rs (62%)

diff --git a/Cargo.toml b/Cargo.toml
index 22ef3b7..90e8c32 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,6 +9,7 @@ members = [
     "crates/fluent-core",
     "crates/fluent-engines",
     "crates/fluent-storage",
+    "crates/fluent-sdk",
     "crates/fluent-lambda",
 ]
 
@@ -17,6 +18,7 @@ fluent-cli = { path = "crates/fluent-cli" }
 fluent-core = { path = "crates/fluent-core" }
 fluent-engines = { path = "crates/fluent-engines" }
 fluent-storage = { path = "crates/fluent-storage" }
+fluent-sdk = { path = "crates/fluent-sdk" }
 tokio = { workspace = true, features = ["full"] }
 clap = { workspace = true, features = ["derive"] }
 anyhow = { workspace = true }
@@ -36,6 +38,7 @@ fluent-cli = { path = "crates/fluent-cli" }
 fluent-core = { path = "crates/fluent-core" }
 fluent-engines = { path = "crates/fluent-engines" }
 fluent-storage = { path = "crates/fluent-storage" }
+fluent-sdk = { path = "crates/fluent-sdk" }
 serde = { version = "^1.0" }
 lambda_runtime = "^0.13"
 serde_json = "^1.0"
diff --git a/crates/fluent-lambda/Cargo.toml b/crates/fluent-lambda/Cargo.toml
index 4245efb..5de952a 100644
--- a/crates/fluent-lambda/Cargo.toml
+++ b/crates/fluent-lambda/Cargo.toml
@@ -9,6 +9,7 @@ tokio = { workspace = true, features = ["macros"] }
 anyhow = { workspace = true }
 fluent-core.workspace = true
 fluent-engines.workspace = true
+fluent-sdk.workspace = true
 serde = { workspace = true }
 lambda_runtime = { workspace = true }
 serde_json = { workspace = true }
diff --git a/crates/fluent-lambda/src/main.rs b/crates/fluent-lambda/src/main.rs
index cafbfb1..8aaa9c0 100644
--- a/crates/fluent-lambda/src/main.rs
+++ b/crates/fluent-lambda/src/main.rs
@@ -1,5 +1,11 @@
-use fluent_lambda::{run, LambdaRequest, Response};
+use fluent_sdk::FluentRequest;
 use lambda_runtime::{service_fn, Error, LambdaEvent};
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Response {
+    pub data: fluent_core::types::Response,
+}
 
 #[tokio::main]
 async fn main() -> Result<(), Error> {
@@ -8,13 +14,18 @@ async fn main() -> Result<(), Error> {
         .with_target(false)
         .without_time()
         .init();
-    lambda_runtime::run(service_fn(|event: LambdaEvent<LambdaRequest>| async {
+    lambda_runtime::run(service_fn(|event: LambdaEvent<FluentRequest>| async {
         lambda_handler(event).await
     }))
     .await
 }
 
 #[tracing::instrument(skip(event), fields(req_id = %event.context.request_id))]
-async fn lambda_handler(event: LambdaEvent<LambdaRequest>) -> Result<Response, Error> {
-    run(event.payload).await.map_err(Error::from)
+async fn lambda_handler(event: LambdaEvent<FluentRequest>) -> Result<Response, Error> {
+    event
+        .payload
+        .run()
+        .await
+        .map_err(Error::from)
+        .map(|r| Response { data: r.data })
 }
diff --git a/crates/fluent-sdk/.gitignore b/crates/fluent-sdk/.gitignore
new file mode 100644
index 0000000..c41cc9e
--- /dev/null
+++ b/crates/fluent-sdk/.gitignore
@@ -0,0 +1 @@
+/target
\ No newline at end of file
diff --git a/crates/fluent-sdk/Cargo.toml b/crates/fluent-sdk/Cargo.toml
new file mode 100644
index 0000000..51ac68a
--- /dev/null
+++ b/crates/fluent-sdk/Cargo.toml
@@ -0,0 +1,15 @@
+[package]
+name = "fluent-sdk"
+version = "0.1.0"
+edition = "2021"
+
+
+[dependencies]
+tokio = { workspace = true, features = ["macros"] }
+anyhow = { workspace = true }
+fluent-core.workspace = true
+fluent-engines.workspace = true
+serde = { workspace = true }
+serde_json = { workspace = true }
+strum = { workspace = true, features = ["derive"] }
+async-trait = { workspace = true }
diff --git a/crates/fluent-lambda/src/config.json b/crates/fluent-sdk/src/config.json
similarity index 99%
rename from crates/fluent-lambda/src/config.json
rename to crates/fluent-sdk/src/config.json
index 8e5ce67..6c37fb7 100644
--- a/crates/fluent-lambda/src/config.json
+++ b/crates/fluent-sdk/src/config.json
@@ -1,7 +1,7 @@
 {
   "engines": [
     {
-      "name": "openai",
+      "name": "openai-chat-completions",
       "engine": "openai",
       "connection": {
         "protocol": "https",
@@ -17,6 +17,7 @@
         "temperature": 1.0,
         "top_p": 1,
         "n": 1,
+        "stop": null,
         "stream": false,
         "presence_penalty": 0,
         "frequency_penalty": 0
diff --git a/crates/fluent-lambda/src/lib.rs b/crates/fluent-sdk/src/lib.rs
similarity index 62%
rename from crates/fluent-lambda/src/lib.rs
rename to crates/fluent-sdk/src/lib.rs
index ea89626..d103623 100644
--- a/crates/fluent-lambda/src/lib.rs
+++ b/crates/fluent-sdk/src/lib.rs
@@ -1,78 +1,99 @@
 use anyhow::anyhow;
-use fluent_core::config::load_engine_config;
-use fluent_engines::create_engine;
 use serde::{Deserialize, Serialize};
 use serde_json::{json, Value};
-use std::{collections::HashMap, pin::Pin};
+use std::collections::HashMap;
 use strum::{Display, EnumString};
 
-pub async fn run(request: impl Into<LambdaRequest>) -> anyhow::Result<Response> {
-    let request: LambdaRequest = request.into();
-    let engine_name = request
-        .engine
-        .map(|t| t.to_string())
-        .ok_or_else(|| anyhow!("Engine is required"))?;
-
-    let config_content = include_str!("config.json");
-
-    let overrides = request.overrides.unwrap_or_default();
-
-    let credentials = request
-        .credentials
-        .unwrap_or_default()
-        .into_iter()
-        .map(|kv| (kv.key, kv.value))
-        .collect::<HashMap<String, String>>();
-
-    let user_prompt = request
-        .request
-        .ok_or_else(|| anyhow!("Request is required"))?;
-
-    let engine_config = load_engine_config(config_content, &engine_name, &overrides, &credentials)?;
-
-    let max_tokens = engine_config
-        .parameters
-        .get("max_tokens")
-        .and_then(|v| v.as_i64());
-
-    //TODO: Add support for other extended input
-    let mut combined_request = user_prompt;
+#[async_trait::async_trait]
+pub trait FluentSdkRequest: Into<FluentRequest> + Clone {
+    fn as_request(&self) -> FluentRequest {
+        self.clone().into()
+    }
+    async fn run(&self) -> anyhow::Result<Response> {
+        self.as_request().run().await
+    }
+}
 
-    if let Some(max_tokens) = max_tokens {
-        if combined_request.len() > max_tokens as usize {
-            combined_request.truncate(max_tokens as usize);
-            combined_request += "... [truncated]";
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FluentRequest {
+    // The template to use (openai or anthropic)
+    pub engine: Option<EngineTemplate>,
+    // The credentials to be used on the request
+    pub credentials: Option<Vec<KeyValue>>,
+    //Overrides for the configuration parameters
+    pub overrides: Option<HashMap<String, Value>>,
+    // The user prompt to process
+    pub request: Option<String>,
+    // Parse and display code blocks from the output
+    pub parse_code: Option<bool>,
+}
+impl FluentRequest {
+    pub async fn run(&self) -> anyhow::Result<Response> {
+        // Convert the implementing type into a FluentRequest
+        let request: FluentRequest = self.clone();
+        // Perform the run logic that was previously in the `run` function
+        let engine_name = request
+            .engine
+            .map(|t| t.to_string())
+            .ok_or_else(|| anyhow!("Engine is required"))?;
+        let config_content = include_str!("config.json");
+        let overrides = request.overrides.unwrap_or_default();
+        let credentials = request
+            .credentials
+            .unwrap_or_default()
+            .into_iter()
+            .map(|kv| (kv.key, kv.value))
+            .collect::<std::collections::HashMap<String, String>>();
+        let user_prompt = request
+            .request
+            .ok_or_else(|| anyhow!("Request is required"))?;
+        let engine_config = fluent_core::config::load_engine_config(
+            config_content,
+            &engine_name,
+            &overrides,
+            &credentials,
+        )?;
+        let max_tokens = engine_config
+            .parameters
+            .get("max_tokens")
+            .and_then(|v| v.as_i64());
+        // Prepare the combined request
+        let mut combined_request = user_prompt;
+        if let Some(max_tokens) = max_tokens {
+            if combined_request.len() > max_tokens as usize {
+                combined_request.truncate(max_tokens as usize);
+                combined_request += "... [truncated]";
+            }
         }
+        let engine = fluent_engines::create_engine(&engine_config).await?;
+        let fluent_core_request = fluent_core::types::Request {
+            flowname: engine_name,
+            payload: combined_request,
+        };
+        let fluent_core_response =
+            std::pin::Pin::from(engine.execute(&fluent_core_request)).await?;
+        Ok(Response {
+            data: fluent_core_response,
+        })
     }
-
-    let engine = create_engine(&engine_config).await?;
-
-    let fluent_request = fluent_core::types::Request {
-        flowname: engine_name,
-        payload: combined_request,
-    };
-
-    let fluent_response = Pin::from(engine.execute(&fluent_request)).await?;
-
-    //TODO: Add support for other extended output
-
-    Ok(Response {
-        data: fluent_response,
-    })
 }
 
-pub struct FluentOpenAIRequest {
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FluentOpenAIChatRequest {
     pub prompt: String,
-    pub openai_api_key: String,
+    pub openai_key: String,
+    pub model: Option<String>,
     pub response_format: Option<Value>,
     pub temperature: Option<f64>,
     pub max_tokens: Option<i64>,
     pub top_p: Option<f64>,
+    pub n: Option<i8>,
+    pub stop: Option<Vec<String>>,
     pub frequency_penalty: Option<f64>,
     pub presence_penalty: Option<f64>,
 }
-impl From<FluentOpenAIRequest> for LambdaRequest {
-    fn from(request: FluentOpenAIRequest) -> Self {
+impl From<FluentOpenAIChatRequest> for FluentRequest {
+    fn from(request: FluentOpenAIChatRequest) -> Self {
         let mut overrides = vec![];
         if let Some(response_format) = request.response_format {
             overrides.push(("response_format".to_string(), response_format));
@@ -92,24 +113,31 @@ impl From<FluentOpenAIRequest> for LambdaRequest {
         if let Some(presence_penalty) = request.presence_penalty {
             overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
         }
-        LambdaRequest {
+        if let Some(model_name) = request.model {
+            overrides.push(("modelName".to_string(), json!(model_name)));
+        }
+        if let Some(n) = request.n {
+            overrides.push(("n".to_string(), json!(n)));
+        }
+        if let Some(stop) = request.stop {
+            overrides.push(("stop".to_string(), json!(stop)));
+        }
+        FluentRequest {
             request: Some(request.prompt),
-            engine: Some(EngineTemplate::OpenAI),
-            credentials: Some(vec![KeyValue::new(
-                "OPENAI_API_KEY",
-                &request.openai_api_key,
-            )]),
+            engine: Some(EngineTemplate::OpenAIChatCompletions),
+            credentials: Some(vec![KeyValue::new("OPENAI_API_KEY", &request.openai_key)]),
             overrides: Some(overrides.into_iter().collect()),
             parse_code: None,
         }
     }
 }
+impl FluentSdkRequest for FluentOpenAIChatRequest {}
 
 #[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display, Clone)]
 pub enum EngineTemplate {
-    #[strum(ascii_case_insensitive, to_string = "openai")]
-    #[serde(alias = "openai")]
-    OpenAI,
+    #[strum(ascii_case_insensitive, to_string = "openai-chat-completions")]
+    #[serde(alias = "openai-chat-completions", alias = "openai")]
+    OpenAIChatCompletions,
 
     #[strum(ascii_case_insensitive, to_string = "anthropic")]
     #[serde(alias = "anthropic")]
@@ -229,25 +257,6 @@ pub enum EngineTemplate {
     #[strum(ascii_case_insensitive)]
     DalleHorizontal,
 }
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct LambdaRequest {
-    // The template to use (openai or anthropic)
-    pub engine: Option<EngineTemplate>,
-
-    // The credentials to be used on the request
-    pub credentials: Option<Vec<KeyValue>>,
-
-    //Overrides for the configuration parameters
-    pub overrides: Option<HashMap<String, Value>>,
-
-    // The user prompt to process
-    pub request: Option<String>,
-
-    // Parse and display code blocks from the output
-    pub parse_code: Option<bool>,
-}
-
 #[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct KeyValue {
     pub key: String,

From 42ccbf292c99cd3ceaf11610f87a4ce6d481bc95 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 11:14:06 -0300
Subject: [PATCH 09/13] Add a builder fot the OpenAiRequest

---
 crates/fluent-sdk/src/lib.rs         | 188 +++++++++++++++++++--------
 crates/fluent-sdk/src/openai-chat.rs |   0
 2 files changed, 133 insertions(+), 55 deletions(-)
 create mode 100644 crates/fluent-sdk/src/openai-chat.rs

diff --git a/crates/fluent-sdk/src/lib.rs b/crates/fluent-sdk/src/lib.rs
index d103623..df574c6 100644
--- a/crates/fluent-sdk/src/lib.rs
+++ b/crates/fluent-sdk/src/lib.rs
@@ -78,61 +78,6 @@ impl FluentRequest {
     }
 }
 
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct FluentOpenAIChatRequest {
-    pub prompt: String,
-    pub openai_key: String,
-    pub model: Option<String>,
-    pub response_format: Option<Value>,
-    pub temperature: Option<f64>,
-    pub max_tokens: Option<i64>,
-    pub top_p: Option<f64>,
-    pub n: Option<i8>,
-    pub stop: Option<Vec<String>>,
-    pub frequency_penalty: Option<f64>,
-    pub presence_penalty: Option<f64>,
-}
-impl From<FluentOpenAIChatRequest> for FluentRequest {
-    fn from(request: FluentOpenAIChatRequest) -> Self {
-        let mut overrides = vec![];
-        if let Some(response_format) = request.response_format {
-            overrides.push(("response_format".to_string(), response_format));
-        }
-        if let Some(temperature) = request.temperature {
-            overrides.push(("temperature".to_string(), json!(temperature)));
-        }
-        if let Some(max_tokens) = request.max_tokens {
-            overrides.push(("max_tokens".to_string(), json!(max_tokens)));
-        }
-        if let Some(top_p) = request.top_p {
-            overrides.push(("top_p".to_string(), json!(top_p)));
-        }
-        if let Some(frequency_penalty) = request.frequency_penalty {
-            overrides.push(("frequency_penalty".to_string(), json!(frequency_penalty)));
-        }
-        if let Some(presence_penalty) = request.presence_penalty {
-            overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
-        }
-        if let Some(model_name) = request.model {
-            overrides.push(("modelName".to_string(), json!(model_name)));
-        }
-        if let Some(n) = request.n {
-            overrides.push(("n".to_string(), json!(n)));
-        }
-        if let Some(stop) = request.stop {
-            overrides.push(("stop".to_string(), json!(stop)));
-        }
-        FluentRequest {
-            request: Some(request.prompt),
-            engine: Some(EngineTemplate::OpenAIChatCompletions),
-            credentials: Some(vec![KeyValue::new("OPENAI_API_KEY", &request.openai_key)]),
-            overrides: Some(overrides.into_iter().collect()),
-            parse_code: None,
-        }
-    }
-}
-impl FluentSdkRequest for FluentOpenAIChatRequest {}
-
 #[derive(Debug, PartialEq, EnumString, Serialize, Deserialize, Display, Clone)]
 pub enum EngineTemplate {
     #[strum(ascii_case_insensitive, to_string = "openai-chat-completions")]
@@ -290,3 +235,136 @@ pub struct OverrideValue {
 pub struct Response {
     pub data: fluent_core::types::Response,
 }
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FluentOpenAIChatRequest {
+    pub prompt: String,
+    pub openai_key: String,
+    pub model: Option<String>,
+    pub response_format: Option<Value>,
+    pub temperature: Option<f64>,
+    pub max_tokens: Option<i64>,
+    pub top_p: Option<f64>,
+    pub n: Option<i8>,
+    pub stop: Option<Vec<String>>,
+    pub frequency_penalty: Option<f64>,
+    pub presence_penalty: Option<f64>,
+}
+impl From<FluentOpenAIChatRequest> for FluentRequest {
+    fn from(request: FluentOpenAIChatRequest) -> Self {
+        let mut overrides = vec![];
+        if let Some(response_format) = request.response_format {
+            overrides.push(("response_format".to_string(), response_format));
+        }
+        if let Some(temperature) = request.temperature {
+            overrides.push(("temperature".to_string(), json!(temperature)));
+        }
+        if let Some(max_tokens) = request.max_tokens {
+            overrides.push(("max_tokens".to_string(), json!(max_tokens)));
+        }
+        if let Some(top_p) = request.top_p {
+            overrides.push(("top_p".to_string(), json!(top_p)));
+        }
+        if let Some(frequency_penalty) = request.frequency_penalty {
+            overrides.push(("frequency_penalty".to_string(), json!(frequency_penalty)));
+        }
+        if let Some(presence_penalty) = request.presence_penalty {
+            overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
+        }
+        if let Some(model_name) = request.model {
+            overrides.push(("modelName".to_string(), json!(model_name)));
+        }
+        if let Some(n) = request.n {
+            overrides.push(("n".to_string(), json!(n)));
+        }
+        if let Some(stop) = request.stop {
+            overrides.push(("stop".to_string(), json!(stop)));
+        }
+        FluentRequest {
+            request: Some(request.prompt),
+            engine: Some(EngineTemplate::OpenAIChatCompletions),
+            credentials: Some(vec![KeyValue::new("OPENAI_API_KEY", &request.openai_key)]),
+            overrides: Some(overrides.into_iter().collect()),
+            parse_code: None,
+        }
+    }
+}
+impl FluentSdkRequest for FluentOpenAIChatRequest {}
+
+pub struct FluentOpenAIChatRequestBuilder {
+    request: FluentOpenAIChatRequest,
+}
+
+#[allow(clippy::new_without_default)]
+impl FluentOpenAIChatRequestBuilder {
+    pub fn new() -> Self {
+        Self {
+            request: FluentOpenAIChatRequest {
+                prompt: String::new(),
+                openai_key: String::new(),
+                response_format: None,
+                temperature: None,
+                max_tokens: None,
+                top_p: None,
+                frequency_penalty: None,
+                presence_penalty: None,
+                model: None,
+                n: None,
+                stop: None,
+            },
+        }
+    }
+    pub fn prompt(mut self, prompt: String) -> Self {
+        self.request.prompt = prompt;
+        self
+    }
+    pub fn openai_key(mut self, openai_key: String) -> Self {
+        self.request.openai_key = openai_key;
+        self
+    }
+    pub fn response_format(mut self, response_format: Value) -> Self {
+        self.request.response_format = Some(response_format);
+        self
+    }
+    pub fn temperature(mut self, temperature: f64) -> Self {
+        self.request.temperature = Some(temperature);
+        self
+    }
+    pub fn max_tokens(mut self, max_tokens: i64) -> Self {
+        self.request.max_tokens = Some(max_tokens);
+        self
+    }
+    pub fn top_p(mut self, top_p: f64) -> Self {
+        self.request.top_p = Some(top_p);
+        self
+    }
+    pub fn frequency_penalty(mut self, frequency_penalty: f64) -> Self {
+        self.request.frequency_penalty = Some(frequency_penalty);
+        self
+    }
+    pub fn presence_penalty(mut self, presence_penalty: f64) -> Self {
+        self.request.presence_penalty = Some(presence_penalty);
+        self
+    }
+    pub fn model(mut self, model: String) -> Self {
+        self.request.model = Some(model);
+        self
+    }
+    pub fn n(mut self, n: i8) -> Self {
+        self.request.n = Some(n);
+        self
+    }
+    pub fn stop(mut self, stop: Vec<String>) -> Self {
+        self.request.stop = Some(stop);
+        self
+    }
+    pub fn build(self) -> Result<FluentOpenAIChatRequest, String> {
+        if self.request.prompt.is_empty() {
+            return Err("Prompt is required".into());
+        }
+        if self.request.openai_key.is_empty() {
+            return Err("OpenAI key is required".into());
+        }
+        Ok(self.request)
+    }
+}
diff --git a/crates/fluent-sdk/src/openai-chat.rs b/crates/fluent-sdk/src/openai-chat.rs
new file mode 100644
index 0000000..e69de29

From 59c358844276122a4b5c58dfca3d663801710c66 Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 11:18:05 -0300
Subject: [PATCH 10/13] Use anyhow for errors

---
 crates/fluent-sdk/src/lib.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/crates/fluent-sdk/src/lib.rs b/crates/fluent-sdk/src/lib.rs
index df574c6..e9b10eb 100644
--- a/crates/fluent-sdk/src/lib.rs
+++ b/crates/fluent-sdk/src/lib.rs
@@ -358,12 +358,12 @@ impl FluentOpenAIChatRequestBuilder {
         self.request.stop = Some(stop);
         self
     }
-    pub fn build(self) -> Result<FluentOpenAIChatRequest, String> {
+    pub fn build(self) -> anyhow::Result<FluentOpenAIChatRequest> {
         if self.request.prompt.is_empty() {
-            return Err("Prompt is required".into());
+            return Err(anyhow!("Prompt is required"));
         }
         if self.request.openai_key.is_empty() {
-            return Err("OpenAI key is required".into());
+            return Err(anyhow!("OpenAI key is required"));
         }
         Ok(self.request)
     }

From db22e4a1e5de248a7cc25fc5f6d34490cab0ec7e Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 11:22:03 -0300
Subject: [PATCH 11/13] Implement a default method for the builder

---
 crates/fluent-sdk/src/lib.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/crates/fluent-sdk/src/lib.rs b/crates/fluent-sdk/src/lib.rs
index e9b10eb..13dec95 100644
--- a/crates/fluent-sdk/src/lib.rs
+++ b/crates/fluent-sdk/src/lib.rs
@@ -291,13 +291,12 @@ impl From<FluentOpenAIChatRequest> for FluentRequest {
 }
 impl FluentSdkRequest for FluentOpenAIChatRequest {}
 
+#[derive(Debug, Deserialize, Serialize, Clone)]
 pub struct FluentOpenAIChatRequestBuilder {
     request: FluentOpenAIChatRequest,
 }
-
-#[allow(clippy::new_without_default)]
-impl FluentOpenAIChatRequestBuilder {
-    pub fn new() -> Self {
+impl Default for FluentOpenAIChatRequestBuilder {
+    fn default() -> Self {
         Self {
             request: FluentOpenAIChatRequest {
                 prompt: String::new(),
@@ -314,6 +313,9 @@ impl FluentOpenAIChatRequestBuilder {
             },
         }
     }
+}
+
+impl FluentOpenAIChatRequestBuilder {
     pub fn prompt(mut self, prompt: String) -> Self {
         self.request.prompt = prompt;
         self

From ec51c2277ed30148ce48744fee042368b1c57e6f Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 11:42:37 -0300
Subject: [PATCH 12/13] Update dependencies

---
 Cargo.toml                    | 10 +++++-----
 crates/fluent-core/Cargo.toml |  2 +-
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 90e8c32..28f8015 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -58,12 +58,12 @@ regex = "^1.10"
 serde_yaml = "^0.9"
 async-trait = "^0.1"
 log = "^0.4"
-unicode-segmentation = "1.11.0"
-rust-stemmers = "1.2.0"
-stop-words = "0.8.0"
-base64 = "0.22.1"
+unicode-segmentation = "^1.11"
+rust-stemmers = "^1.2"
+stop-words = "^0.8"
+base64 = "^0.22"
 url = "^2.5"
-termimad = "^0.29"
+termimad = "^0.30"
 syntect = "^5.2"
 pdf-extract = "^0.7"
 tokio-util = { version = "^0.7" }
diff --git a/crates/fluent-core/Cargo.toml b/crates/fluent-core/Cargo.toml
index 4f249ac..60228a8 100644
--- a/crates/fluent-core/Cargo.toml
+++ b/crates/fluent-core/Cargo.toml
@@ -6,7 +6,7 @@ edition = "2021"
 
 [dependencies]
 neo4rs = { workspace = true }
-reqwest = { version = "0.12.5", default-features = false, features = [
+reqwest = { workspace = true, default-features = false, features = [
     "json",
     "rustls-tls",
 ] }

From ea8e26e8596dd2267c537c7ad74395f1eda63a4c Mon Sep 17 00:00:00 2001
From: gracig <15052330+gracig@users.noreply.github.com>
Date: Mon, 12 Aug 2024 13:46:08 -0300
Subject: [PATCH 13/13] Create a prelude for the fluent_sdk

---
 crates/fluent-sdk/src/lib.rs         | 154 +++------------------------
 crates/fluent-sdk/src/openai-chat.rs |   0
 crates/fluent-sdk/src/openai.rs      | 141 ++++++++++++++++++++++++
 3 files changed, 153 insertions(+), 142 deletions(-)
 delete mode 100644 crates/fluent-sdk/src/openai-chat.rs
 create mode 100644 crates/fluent-sdk/src/openai.rs

diff --git a/crates/fluent-sdk/src/lib.rs b/crates/fluent-sdk/src/lib.rs
index 13dec95..aa84fce 100644
--- a/crates/fluent-sdk/src/lib.rs
+++ b/crates/fluent-sdk/src/lib.rs
@@ -1,9 +1,19 @@
 use anyhow::anyhow;
 use serde::{Deserialize, Serialize};
-use serde_json::{json, Value};
+use serde_json::Value;
 use std::collections::HashMap;
 use strum::{Display, EnumString};
+pub mod openai;
 
+pub mod prelude {
+    pub use crate::openai::*;
+    pub use crate::{FluentRequest, FluentSdkRequest, KeyValue};
+}
+
+#[derive(Debug, Deserialize, Serialize)]
+pub struct Response {
+    pub data: fluent_core::types::Response,
+}
 #[async_trait::async_trait]
 pub trait FluentSdkRequest: Into<FluentRequest> + Clone {
     fn as_request(&self) -> FluentRequest {
@@ -30,7 +40,7 @@ pub struct FluentRequest {
 impl FluentRequest {
     pub async fn run(&self) -> anyhow::Result<Response> {
         // Convert the implementing type into a FluentRequest
-        let request: FluentRequest = self.clone();
+        let request = self.clone();
         // Perform the run logic that was previously in the `run` function
         let engine_name = request
             .engine
@@ -230,143 +240,3 @@ pub struct OverrideValue {
     pub key: String,
     pub value: Value,
 }
-
-#[derive(Debug, Deserialize, Serialize)]
-pub struct Response {
-    pub data: fluent_core::types::Response,
-}
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct FluentOpenAIChatRequest {
-    pub prompt: String,
-    pub openai_key: String,
-    pub model: Option<String>,
-    pub response_format: Option<Value>,
-    pub temperature: Option<f64>,
-    pub max_tokens: Option<i64>,
-    pub top_p: Option<f64>,
-    pub n: Option<i8>,
-    pub stop: Option<Vec<String>>,
-    pub frequency_penalty: Option<f64>,
-    pub presence_penalty: Option<f64>,
-}
-impl From<FluentOpenAIChatRequest> for FluentRequest {
-    fn from(request: FluentOpenAIChatRequest) -> Self {
-        let mut overrides = vec![];
-        if let Some(response_format) = request.response_format {
-            overrides.push(("response_format".to_string(), response_format));
-        }
-        if let Some(temperature) = request.temperature {
-            overrides.push(("temperature".to_string(), json!(temperature)));
-        }
-        if let Some(max_tokens) = request.max_tokens {
-            overrides.push(("max_tokens".to_string(), json!(max_tokens)));
-        }
-        if let Some(top_p) = request.top_p {
-            overrides.push(("top_p".to_string(), json!(top_p)));
-        }
-        if let Some(frequency_penalty) = request.frequency_penalty {
-            overrides.push(("frequency_penalty".to_string(), json!(frequency_penalty)));
-        }
-        if let Some(presence_penalty) = request.presence_penalty {
-            overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
-        }
-        if let Some(model_name) = request.model {
-            overrides.push(("modelName".to_string(), json!(model_name)));
-        }
-        if let Some(n) = request.n {
-            overrides.push(("n".to_string(), json!(n)));
-        }
-        if let Some(stop) = request.stop {
-            overrides.push(("stop".to_string(), json!(stop)));
-        }
-        FluentRequest {
-            request: Some(request.prompt),
-            engine: Some(EngineTemplate::OpenAIChatCompletions),
-            credentials: Some(vec![KeyValue::new("OPENAI_API_KEY", &request.openai_key)]),
-            overrides: Some(overrides.into_iter().collect()),
-            parse_code: None,
-        }
-    }
-}
-impl FluentSdkRequest for FluentOpenAIChatRequest {}
-
-#[derive(Debug, Deserialize, Serialize, Clone)]
-pub struct FluentOpenAIChatRequestBuilder {
-    request: FluentOpenAIChatRequest,
-}
-impl Default for FluentOpenAIChatRequestBuilder {
-    fn default() -> Self {
-        Self {
-            request: FluentOpenAIChatRequest {
-                prompt: String::new(),
-                openai_key: String::new(),
-                response_format: None,
-                temperature: None,
-                max_tokens: None,
-                top_p: None,
-                frequency_penalty: None,
-                presence_penalty: None,
-                model: None,
-                n: None,
-                stop: None,
-            },
-        }
-    }
-}
-
-impl FluentOpenAIChatRequestBuilder {
-    pub fn prompt(mut self, prompt: String) -> Self {
-        self.request.prompt = prompt;
-        self
-    }
-    pub fn openai_key(mut self, openai_key: String) -> Self {
-        self.request.openai_key = openai_key;
-        self
-    }
-    pub fn response_format(mut self, response_format: Value) -> Self {
-        self.request.response_format = Some(response_format);
-        self
-    }
-    pub fn temperature(mut self, temperature: f64) -> Self {
-        self.request.temperature = Some(temperature);
-        self
-    }
-    pub fn max_tokens(mut self, max_tokens: i64) -> Self {
-        self.request.max_tokens = Some(max_tokens);
-        self
-    }
-    pub fn top_p(mut self, top_p: f64) -> Self {
-        self.request.top_p = Some(top_p);
-        self
-    }
-    pub fn frequency_penalty(mut self, frequency_penalty: f64) -> Self {
-        self.request.frequency_penalty = Some(frequency_penalty);
-        self
-    }
-    pub fn presence_penalty(mut self, presence_penalty: f64) -> Self {
-        self.request.presence_penalty = Some(presence_penalty);
-        self
-    }
-    pub fn model(mut self, model: String) -> Self {
-        self.request.model = Some(model);
-        self
-    }
-    pub fn n(mut self, n: i8) -> Self {
-        self.request.n = Some(n);
-        self
-    }
-    pub fn stop(mut self, stop: Vec<String>) -> Self {
-        self.request.stop = Some(stop);
-        self
-    }
-    pub fn build(self) -> anyhow::Result<FluentOpenAIChatRequest> {
-        if self.request.prompt.is_empty() {
-            return Err(anyhow!("Prompt is required"));
-        }
-        if self.request.openai_key.is_empty() {
-            return Err(anyhow!("OpenAI key is required"));
-        }
-        Ok(self.request)
-    }
-}
diff --git a/crates/fluent-sdk/src/openai-chat.rs b/crates/fluent-sdk/src/openai-chat.rs
deleted file mode 100644
index e69de29..0000000
diff --git a/crates/fluent-sdk/src/openai.rs b/crates/fluent-sdk/src/openai.rs
new file mode 100644
index 0000000..55fb9c3
--- /dev/null
+++ b/crates/fluent-sdk/src/openai.rs
@@ -0,0 +1,141 @@
+use anyhow::anyhow;
+use serde::{Deserialize, Serialize};
+use serde_json::{json, Value};
+
+use crate::{EngineTemplate, FluentRequest, FluentSdkRequest, KeyValue};
+
+impl FluentSdkRequest for FluentOpenAIChatRequest {}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FluentOpenAIChatRequest {
+    pub prompt: String,
+    pub openai_key: String,
+    pub model: Option<String>,
+    pub response_format: Option<Value>,
+    pub temperature: Option<f64>,
+    pub max_tokens: Option<i64>,
+    pub top_p: Option<f64>,
+    pub n: Option<i8>,
+    pub stop: Option<Vec<String>>,
+    pub frequency_penalty: Option<f64>,
+    pub presence_penalty: Option<f64>,
+}
+impl From<FluentOpenAIChatRequest> for FluentRequest {
+    fn from(request: FluentOpenAIChatRequest) -> Self {
+        let mut overrides = vec![];
+        if let Some(response_format) = request.response_format {
+            overrides.push(("response_format".to_string(), response_format));
+        }
+        if let Some(temperature) = request.temperature {
+            overrides.push(("temperature".to_string(), json!(temperature)));
+        }
+        if let Some(max_tokens) = request.max_tokens {
+            overrides.push(("max_tokens".to_string(), json!(max_tokens)));
+        }
+        if let Some(top_p) = request.top_p {
+            overrides.push(("top_p".to_string(), json!(top_p)));
+        }
+        if let Some(frequency_penalty) = request.frequency_penalty {
+            overrides.push(("frequency_penalty".to_string(), json!(frequency_penalty)));
+        }
+        if let Some(presence_penalty) = request.presence_penalty {
+            overrides.push(("presence_penalty".to_string(), json!(presence_penalty)));
+        }
+        if let Some(model_name) = request.model {
+            overrides.push(("modelName".to_string(), json!(model_name)));
+        }
+        if let Some(n) = request.n {
+            overrides.push(("n".to_string(), json!(n)));
+        }
+        if let Some(stop) = request.stop {
+            overrides.push(("stop".to_string(), json!(stop)));
+        }
+        FluentRequest {
+            request: Some(request.prompt),
+            engine: Some(EngineTemplate::OpenAIChatCompletions),
+            credentials: Some(vec![KeyValue::new("OPENAI_API_KEY", &request.openai_key)]),
+            overrides: Some(overrides.into_iter().collect()),
+            parse_code: None,
+        }
+    }
+}
+
+#[derive(Debug, Deserialize, Serialize, Clone)]
+pub struct FluentOpenAIChatRequestBuilder {
+    request: FluentOpenAIChatRequest,
+}
+impl Default for FluentOpenAIChatRequestBuilder {
+    fn default() -> Self {
+        Self {
+            request: FluentOpenAIChatRequest {
+                prompt: String::new(),
+                openai_key: String::new(),
+                response_format: None,
+                temperature: None,
+                max_tokens: None,
+                top_p: None,
+                frequency_penalty: None,
+                presence_penalty: None,
+                model: None,
+                n: None,
+                stop: None,
+            },
+        }
+    }
+}
+
+impl FluentOpenAIChatRequestBuilder {
+    pub fn prompt(mut self, prompt: String) -> Self {
+        self.request.prompt = prompt;
+        self
+    }
+    pub fn openai_key(mut self, openai_key: String) -> Self {
+        self.request.openai_key = openai_key;
+        self
+    }
+    pub fn response_format(mut self, response_format: Value) -> Self {
+        self.request.response_format = Some(response_format);
+        self
+    }
+    pub fn temperature(mut self, temperature: f64) -> Self {
+        self.request.temperature = Some(temperature);
+        self
+    }
+    pub fn max_tokens(mut self, max_tokens: i64) -> Self {
+        self.request.max_tokens = Some(max_tokens);
+        self
+    }
+    pub fn top_p(mut self, top_p: f64) -> Self {
+        self.request.top_p = Some(top_p);
+        self
+    }
+    pub fn frequency_penalty(mut self, frequency_penalty: f64) -> Self {
+        self.request.frequency_penalty = Some(frequency_penalty);
+        self
+    }
+    pub fn presence_penalty(mut self, presence_penalty: f64) -> Self {
+        self.request.presence_penalty = Some(presence_penalty);
+        self
+    }
+    pub fn model(mut self, model: String) -> Self {
+        self.request.model = Some(model);
+        self
+    }
+    pub fn n(mut self, n: i8) -> Self {
+        self.request.n = Some(n);
+        self
+    }
+    pub fn stop(mut self, stop: Vec<String>) -> Self {
+        self.request.stop = Some(stop);
+        self
+    }
+    pub fn build(self) -> anyhow::Result<FluentOpenAIChatRequest> {
+        if self.request.prompt.is_empty() {
+            return Err(anyhow!("Prompt is required"));
+        }
+        if self.request.openai_key.is_empty() {
+            return Err(anyhow!("OpenAI key is required"));
+        }
+        Ok(self.request)
+    }
+}