Message Prompts

[realdavidvega]

This PR brings HumanMessagePromptTemplate, SystemMessagePromptTemplate, AIMessagePromptTemplate and ChatMessagePromptTemplate with it's respective tests.

Ready to review @nomisRev @Yawolf @juanpedromoreno @franciscodr Thanks!

[nomisRev]

This PR looks good @realdavidvega but I had a couple of thoughts to streamline the types a bit more, and make things a bit more functional inspired to maximise reusability.

Looking at this PR I had a few thoughts:

• We could parameterise PromptTemplate over A, and the current implementation would be for String, and we can implement FunctorK or mapK to map A to a new type.

interface PromptTemplate<A> {
  val inputKeys: List<String>
  suspend fun format(variables: Map<String, String>): A

  fun <B> mapK(transform: (A) -> B): PromptTemplate<B> = object : PromptTemplate<B> {
    override val inputKeys: List<String> = this@PromptTemplate.inputKeys
    override suspend fun format(variables: Map<String, String>): B =
      transform(this@PromptTemplate.format(variables))
  }

  companion object {
    operator fun invoke(config: Config): PromptTemplate<String> = object : PromptTemplate<String> {
     ...
   }
 }    

• So the newly defined types would all be PromptTemplate but for different types, this would allow us to define more generic code using PromptTemplate instead of different types if needed. New smart-constructors defined in PromptTemplate.Companion.

    fun human(promptTemplate: PromptTemplate<String>): PromptTemplate<HumanMessage> =
      promptTemplate.mapK(::HumanMessage)

    fun ai(promptTemplate: PromptTemplate<String>): PromptTemplate<AIMessage> =
      promptTemplate.mapK(::AIMessage)

    fun system(promptTemplate: PromptTemplate<String>): PromptTemplate<SystemMessage> =
      promptTemplate.mapK(::SystemMessage)

    fun chat(promptTemplate: PromptTemplate<String>, role: String): PromptTemplate<ChatMessage> =
      promptTemplate.mapK { ChatMessage(it, role) }

nit: we can clean-up Message model a bit.

enum class Type {
  human, ai, system, chat
}

@Serializable
sealed class Message {
  abstract val content: String
  
  fun type(): Type =
    when (this) {
      is HumanMessage -> Type.human
      is AIMessage -> Type.ai
      is SystemMessage -> Type.system
      is ChatMessage -> Type.chat
    }
}

data class HumanMessage(override val content: String) : Message()
data class AIMessage(override val content: String) : Message()
data class SystemMessage(override val content: String) : Message()
data class ChatMessage(override val content: String, val role: String) : Message()

cc\ @Yawolf @juanpedromoreno @franciscodr

[realdavidvega]

I think that's a great idea @nomisRev, and it makes more sense. So our PromptTemplate<A> can now serve as a base, being easy to reuse, and avoids having to create even more interfaces/implementations. Looks really nice! 🚀

[franciscodr]

Great suggestions, @nomisRev! The code looks really neat

[juanpedromoreno]

This is great, thanks @realdavidvega @nomisRev 💯

[nomisRev]

Perfect, thank you @realdavidvega 🙌