Added Optional Endpoints

gleam.toml

@@ -1,5 +1,5 @@
 name = "gloq"
-version = "1.3.2"
+version = "1.4.2"
 
 # Fill out these fields if you intend to generate HTML documentation or publish
 # your project to the Hex package manager.

src/gloq.gleam

@@ -2,27 +2,63 @@ import gleam/hackney
 import gleam/http
 import gleam/http/request
 import gleam/json
+import gleam/option.{type Option, None, Some}
 
 pub type GroqRequestBuilder {
-  GroqRequestBuilder(key: String, user: String, context: String, model: String)
+  GroqRequestBuilder(
+    key: String,
+    user: String,
+    context: String,
+    model: String,
+    frequency_penalty: Option(Float),
+    logprobs: Option(Bool),
+    max_tokens: Option(Int),
+    n: Option(Int),
+    parallel_tool_calls: Option(Bool),
+    presence_penalty: Option(Float),
+    seed: Option(Int),
+    stop: Option(String),
+    stream: Option(Bool),
+    temperature: Option(Float),
+    tool_choice: Option(String),
+    top_p: Option(Float),
+  )
 }
 
 /// Creates a new GroqRequestBuilder with default model and user values.
+/// Uses the default model `llama3-8b-8192` and user role `user`.
 pub fn default_groq_request() -> GroqRequestBuilder {
   GroqRequestBuilder(
     key: "",
     user: "user",
     context: "",
     model: "llama3-8b-8192",
+    frequency_penalty: Some(0.0),
+    logprobs: Some(False),
+    max_tokens: None,
+    n: Some(1),
+    parallel_tool_calls: Some(True),
+    presence_penalty: Some(0.0),
+    seed: None,
+    stop: None,
+    stream: Some(False),
+    temperature: Some(1.0),
+    tool_choice: None,
+    top_p: Some(1.0),
   )
 }
 
 /// Create a new GroqRequestBuilder with no default values. 
 pub fn new_groq_request() -> GroqRequestBuilder {
-  GroqRequestBuilder(key: "", user: "", context: "", model: "")
+  GroqRequestBuilder(
+    ..default_groq_request(),
+    key: "",
+    user: "",
+    context: "",
+    model: "",
+  )
 }
 
-/// Enum of all models available for the GroqRequestBuilder.
 /// Sets the API key for the GroqRequestBuilder.
 pub fn with_key(builder: GroqRequestBuilder, key: String) -> GroqRequestBuilder {
   GroqRequestBuilder(..builder, key: key)
@@ -52,6 +88,84 @@ pub fn with_model(
   GroqRequestBuilder(..builder, model: model)
 }
 
+pub fn with_frequency_penalty(
+  builder: GroqRequestBuilder,
+  frequency_penalty: Float,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, frequency_penalty: Some(frequency_penalty))
+}
+
+pub fn with_logprobs(
+  builder: GroqRequestBuilder,
+  logprobs: Bool,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, logprobs: Some(logprobs))
+}
+
+pub fn with_max_tokens(
+  builder: GroqRequestBuilder,
+  max_tokens: Int,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, max_tokens: Some(max_tokens))
+}
+
+pub fn with_n(builder: GroqRequestBuilder, n: Int) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, n: Some(n))
+}
+
+pub fn with_parallel_tool_calls(
+  builder: GroqRequestBuilder,
+  parallel_tool_calls: Bool,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, parallel_tool_calls: Some(parallel_tool_calls))
+}
+
+pub fn with_presence_penalty(
+  builder: GroqRequestBuilder,
+  presence_penalty: Float,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, presence_penalty: Some(presence_penalty))
+}
+
+pub fn with_seed(builder: GroqRequestBuilder, seed: Int) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, seed: Some(seed))
+}
+
+pub fn with_stop(
+  builder: GroqRequestBuilder,
+  stop: String,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, stop: Some(stop))
+}
+
+pub fn with_stream(
+  builder: GroqRequestBuilder,
+  stream: Bool,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, stream: Some(stream))
+}
+
+pub fn with_temperature(
+  builder: GroqRequestBuilder,
+  temperature: Float,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, temperature: Some(temperature))
+}
+
+pub fn with_tool_choice(
+  builder: GroqRequestBuilder,
+  tool_choice: String,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, tool_choice: Some(tool_choice))
+}
+
+pub fn with_top_p(
+  builder: GroqRequestBuilder,
+  top_p: Float,
+) -> GroqRequestBuilder {
+  GroqRequestBuilder(..builder, top_p: Some(top_p))
+}
+
 /// Builds the request body for the GroqCloud API that can be sent using the appropriate HTTP client.
 pub fn build(builder: GroqRequestBuilder) {
   let body =