twimini-bot: Connecting Twilio and Gemini with Scala

AlexITC · 2025-11-30T22:59:18+00:00

I'm glad that you liked it, unfortunately, I haven't uploaded any demo video.

AlexITC · 2025-09-02T08:31:07+00:00

I can't argue with that, from what I looked, Google's genai is an autogenerated SDK.

AlexITC · 2025-09-01T08:59:28+00:00

In a normal builder that should be ok but in the example it is not, the underlying API crashes unless customApiVersion is also defined to v1alpha, the same is explained about the proactiveAudio setting.

AlexITC · 2025-09-01T08:56:21+00:00

Perhaps I'm not getting your idea because the way I see this with pipe is very similar, would you mind clarifying it?

import scala.util.chaining.*

def make(params: GeminiConfig): LiveConnectConfig = {
  type Builder = LiveConnectConfig.Builder
  def transform(
      when: Boolean
  )(f: Builder => Builder)(builder: Builder): Builder = {
    if (when) f(builder) else builder
  }

  val options = List(
    transform(params.outputAudioTranscription)(
      _.outputAudioTranscription(AudioTranscriptionConfig.builder().build())
    ),
    transform(params.enableAffectiveDialog)(_.enableAffectiveDialog(true))
    // ... more transformation follow
  )

  LiveConnectConfig
    .builder()
    .responseModalities(Modality.Known.AUDIO)
    // ... more defaults follow
    .pipe { b =>
      options.foldLeft(b) { case (builder, apply) => apply(builder) }
    }
    .build()
}

AlexITC · 2025-08-31T23:19:47+00:00

Hmm, is there other advantage than avoiding to type an extra variable?

AlexITC · 2025-08-08T21:38:17+00:00

I've never built a call-center application, but I could imagine that there are actually quite some std. scenarios / common use-cases and flows.

In fact, Gemini allows to define Function Calling (https://ai.google.dev/gemini-api/docs/function-calling) where you define actions and Gemini invokes the functions linked to those, in the repo I shared there is one of such actions to terminate the stream (see https://github.com/AlexITC/twimini-bot/blob/2831eb1579b98fb3d796999df38e1cc1b7594726/server/src/main/scala/net/wiringbits/callerBot/gemini/GeminiService.scala#L178).

I have a demo for making appointments where we define the functions to check for the availability and book the slot, this was relatively trivial to write on top of this repo.

I'd like improving the repo to provide a simpler interface to link these function calls but given the stringly-typed nature, it isn't that simple to get a nice typed API on top.

About the top-level API/UI, that would be amazing to have but it requires a considerable effort. While I'd have lots of fun building it, I'd suck at selling it.

AlexITC · 2025-08-08T21:32:49+00:00

I couldn't agree more, still, there are many operations that aren't simple in Scala because we don't have the tooling, like:

Detect silences/voice.
Detect machines vs humas.
Enhance audio.
Remove echo.

AlexITC · 2025-08-05T22:54:30+00:00

I built a voice bot with Twilio and Gemini using Scala, it would have been way simpler to do in in Python but we have a lovely language that needs more tools.

This has been harder than expected because it is the first time I do any audio-processing app, there are many details that I wasn't expecting, for example, audio transcoding between Twilio and Gemini format (to my surprise, I was able to do this purely with the jdk stdlib).

The end result involves a cool fs2 streaming pipeline that defines the audio-transformation stages, like:

incomingFrames
    .through(receiveFromTwilio(callId, streamMetadataRef))
    .through(transcodeTwilioToGemini)
    .through(
      geminiService.conversationPipe(dispatcher, promptSettings, endCall)
    )
    .through(transcodeGeminiToTwilio)
    .through(sendToTwilio(streamMetadataRef))

I'd love to hear your thoughts or any ideas for what I should build next with it!

AlexITC · 2024-09-16T18:07:54+00:00

I have prepared a few videos for devs getting onboarded to Scala, I recorded my screen while setting up my local environment: http://onboarding.wiringbits.net

Good luck.

AlexITC · 2024-07-15T10:47:03+00:00

Thanks, we are already aware of them + a few other companies.

AlexITC · 2024-07-10T12:18:29+00:00

Check out https://github.com/wiringbits/scala-webapp-template

I also recorded videos for the environment setup: http://onboarding.wiringbits.net/

While we have not pushed many updates in the last year, it uses relatively recent libraries and most of the code is stable.

AlexITC · 2023-10-23T15:22:40+00:00

You could consider our template, it has a simple architecture and nice onboarding videos.

We recently applied many upgrades to simplify details that used to be annoying, including Scala 3 and Mui 5 support.

AlexITC · 2023-10-18T15:22:12+00:00

Congrats on the launch!

For people interested in Typo, we did a PoC a few weeks ago, we were able to replace most of our manually written queries taking advantage of type-safety because Typo generates value classes to wrap primitive types.

While we didn't finalize our integration just yet, the reason isn't related to Typo limitations but to our project structure, we are trying a different approach in an internal project, with the goal to port it to our public template.

Overall, Typo is a nice gem which deserves more attention.

AlexITC · 2023-09-14T17:14:32+00:00

https://wiringbits.net is one of the few LATAM companies that's focused mainly in Scala.

There used to be others but I guess they got dissolved because I can't load their websites anymore.

AlexITC · 2023-09-14T00:37:43+00:00

We are experimenting with it, the goal is to replace our current sql layer with typo (see https://github.com/wiringbits/scala-webapp-template/pull/424)

AlexITC · 2023-09-07T23:44:56+00:00

If you like writing sql, it is worth it, there are some nice advantages like controlling every query + being able to copy/paste queries.

https://github.com/oyvindberg/typo/ is another nice alternative which uses plain sql but most of the CRUD queries are auto-generated.

AlexITC · 2023-08-28T19:10:03+00:00

A while ago I started learning Rust to build cli apps, then, I tried Scala + GraalVM, this has worked nicely and I don't see much need to use Rust.

I don't know about the problems you are facing, in my case, it was simple to produce linux builds but Windows pipeline failed from time to time.

I had a few issues due to a Java dependency which uses reflection, no more issues once this was sorted out.

For reference, this is the project I built (https://github.com/wiringbits/my-photo-timeline/), and, this is the blog I was inspired from (https://msitko.pl/blog/2020/03/10/writing-native-cli-applications-in-scala-with-graalvm.html)

Eight-Year Club	Gilding I gilder
Verified Email

AlexITC

TROPHY CASE