Refactor GeminiConfig (#5)

There are many config entries that were hardcoded, exposing all of them through the
old way would cause lots of code repetition, with this, the new GeminiConfig
has all the config entries with sane defaults.

Author: AlexITC

audio/src/main/scala/com/alexitc/geminilive4s/GeminiService.scala

@@ -189,71 +189,21 @@ object GeminiService {
 
   def make(
       apiKey: String,
-      promptSettings: GeminiPromptSettings,
-      functions: List[GeminiFunction],
-      customApiVersion: Option[GeminiCustomApi] = None
+      config: GeminiConfig
   ): fs2.Stream[IO, GeminiService] = {
     val wakeUpMessage =
-      if (promptSettings.language.string.startsWith("es")) "Hola" else "Hello"
+      if (config.language.string.startsWith("es")) "Hola"
+      else "Hello"
+
     for {
       gemini <- fs2.Stream.resource(
         GeminiIO.make(
           apiKey,
-          promptSettings,
-          functions.map(_.declaration),
-          makeGeminiConfig,
-          customApiVersion
+          config,
+          GeminiLiveConfigBuilder.make(config)
         )
       )
-    } yield new GeminiService(gemini, functions, wakeUpMessage)
-  }
-
-  def makeGeminiConfig(
-      configParams: GeminiConfigParams
-  ): genai.types.LiveConnectConfig = {
-    import configParams.*
-
-    val tool = genai.types.Tool
-      .builder()
-      .functionDeclarations(functionDefs*)
-      .build()
-
-    genai.types.LiveConnectConfig
-      .builder()
-      .inputAudioTranscription(
-        genai.types.AudioTranscriptionConfig.builder().build()
-      )
-      .outputAudioTranscription(
-        genai.types.AudioTranscriptionConfig.builder().build()
-      )
-      .responseModalities(genai.types.Modality.Known.AUDIO)
-      .systemInstruction(
-        genai.types.Content
-          .builder()
-          .parts(genai.types.Part.builder().text(prompt))
-          .build()
-      )
-      .speechConfig(
-        genai.types.SpeechConfig
-          .builder()
-          .voiceConfig(
-            genai.types.VoiceConfig
-              .builder()
-              .prebuiltVoiceConfig(
-                genai.types.PrebuiltVoiceConfig
-                  .builder()
-                  .voiceName(voiceName.string)
-              )
-          )
-          .languageCode(voiceLanguage.string)
-      )
-      .tools(tool)
-      .temperature(0.7f)
-      //      .enableAffectiveDialog(true) // not supported by a all models
-      //      .proactivity(
-      //        genai.types.ProactivityConfig.builder().proactiveAudio(true).build()
-      //      )
-      .build()
+    } yield new GeminiService(gemini, config.functions, wakeUpMessage)
   }
 
   private case class TaggedMessage(

audio/src/main/scala/com/alexitc/geminilive4s/internal/GeminiIO.scala

@@ -73,13 +73,11 @@ private[geminilive4s] object GeminiIO {
 
   def make(
       apiKey: String,
-      promptSettings: GeminiPromptSettings,
-      functionDefs: List[FunctionDeclaration],
-      makeGeminiConfig: GeminiConfigParams => LiveConnectConfig,
-      customApiVersion: Option[GeminiCustomApi]
+      config: GeminiConfig,
+      liveConfig: LiveConnectConfig
   ): Resource[IO, GeminiIO] = {
     def acquire(dispatcher: Dispatcher[IO]) = for {
-      client <- customApiVersion match {
+      client <- config.customApiVersion match {
         case None =>
           IO(Client.builder().apiKey(apiKey).build())
         case Some(version) =>
@@ -93,14 +91,7 @@ private[geminilive4s] object GeminiIO {
               .build()
           )
       }
-      configParams = GeminiConfigParams(
-        prompt = promptSettings.prompt,
-        voiceLanguage = promptSettings.language,
-        voiceName = promptSettings.voiceName,
-        functionDefs = functionDefs
-      )
-      config = makeGeminiConfig(configParams)
-      session <- makeSession(client, config, promptSettings.model)
+      session <- makeSession(client, liveConfig, config.model)
 
       _ <- IO.println("✅ Connected to Gemini Live API")
     } yield GeminiIO(session, dispatcher)

audio/src/main/scala/com/alexitc/geminilive4s/internal/GeminiLiveConfigBuilder.scala

@@ -0,0 +1,72 @@
+package com.alexitc.geminilive4s.internal
+
+import com.alexitc.geminilive4s.models.GeminiConfig
+import com.google.genai.types.*
+
+object GeminiLiveConfigBuilder {
+  def make(params: GeminiConfig): LiveConnectConfig = {
+    def transform(when: Boolean)(
+        f: LiveConnectConfig.Builder => LiveConnectConfig.Builder
+    )(builder: LiveConnectConfig.Builder): LiveConnectConfig.Builder = {
+      if (when) f(builder) else builder
+    }
+
+    val options = List(
+      transform(params.disableAutomaticActivityDetection)(builder =>
+        builder // TODO: Enable when the app supports handling this
+//        _.realtimeInputConfig(
+//          RealtimeInputConfig
+//            .builder()
+//            .automaticActivityDetection(
+//              AutomaticActivityDetection.builder().disabled(true).build()
+//            )
+//            .build()
+//        )
+      ),
+      transform(params.inputAudioTranscription)(
+        _.inputAudioTranscription(AudioTranscriptionConfig.builder().build())
+      ),
+      transform(params.outputAudioTranscription)(
+        _.outputAudioTranscription(AudioTranscriptionConfig.builder().build())
+      ),
+      transform(params.enableAffectiveDialog)(_.enableAffectiveDialog(true)),
+      transform(params.proactivity)(
+        _.proactivity(ProactivityConfig.builder().proactiveAudio(true).build())
+      )
+    )
+
+    val functionDefs = params.functions.map(_.declaration)
+    val tool = Tool
+      .builder()
+      .functionDeclarations(functionDefs*)
+      .build()
+
+    val base = LiveConnectConfig
+      .builder()
+      .responseModalities(Modality.Known.AUDIO)
+      .systemInstruction(
+        Content
+          .builder()
+          .parts(Part.builder().text(params.prompt))
+          .build()
+      )
+      .speechConfig(
+        SpeechConfig
+          .builder()
+          .voiceConfig(
+            VoiceConfig
+              .builder()
+              .prebuiltVoiceConfig(
+                PrebuiltVoiceConfig.builder().voiceName(params.voiceName.string)
+              )
+          )
+          .languageCode(params.language.string)
+      )
+      .tools(tool)
+      .temperature(params.temperature)
+
+    options
+      .foldLeft(base) { case (builder, apply) => apply(builder) }
+      .build()
+  }
+}

audio/src/main/scala/com/alexitc/geminilive4s/models/GeminiConfig.scala

@@ -0,0 +1,23 @@
+package com.alexitc.geminilive4s.models
+
+case class GeminiConfig(
+    prompt: String,
+    functions: List[GeminiFunction],
+    language: GeminiLanguage = GeminiLanguage.EnglishUS,
+    voiceName: GeminiVoice = GeminiVoice.random,
+    model: GeminiModel = GeminiModel.FlashPreview,
+    temperature: Float = 0.7f,
+    // Required when using experimental models
+    customApiVersion: Option[GeminiCustomApi] = None,
+    // When enabled, Gemini waits for messages to confirm when the voice starts/stops
+    // NOTE: This is not implemented yet
+    disableAutomaticActivityDetection: Boolean = false,
+    // When enabled, Gemini transcribes the input voice
+    inputAudioTranscription: Boolean = false,
+    // When enabled, Gemini transcribes the output voice
+    outputAudioTranscription: Boolean = false,
+    // Only a few models support this
+    enableAffectiveDialog: Boolean = false,
+    // Only a few models support this
+    proactivity: Boolean = false
+)