introduce System messages

bburdiliak · bburdiliak · commit 5b5725f8da7d · 2024-11-13T17:06:59.000+01:00
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/ChatRole.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/ChatRole.scala
@@ -7,8 +7,9 @@ sealed trait ChatRole extends EnumValue {
 }
 
 object ChatRole {
+  case object System extends ChatRole
   case object User extends ChatRole
   case object Assistant extends ChatRole
 
-  def allValues: Seq[ChatRole] = Seq(User, Assistant)
+  def allValues: Seq[ChatRole] = Seq(System, User, Assistant)
 }
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/Message.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/domain/Message.scala
@@ -9,10 +9,20 @@ import io.cequence.openaiscala.anthropic.domain.Content.{
 sealed abstract class Message private (
   val role: ChatRole,
   val content: Content
-)
+) {
+  def isSystem: Boolean = role == ChatRole.System
+}
 
 object Message {
 
+  case class SystemMessage(
+    contentString: String,
+    cacheControl: Option[CacheControl] = None
+  ) extends Message(ChatRole.System, SingleString(contentString, cacheControl))
+
+  case class SystemMessageContent(contentBlocks: Seq[ContentBlockBase])
+      extends Message(ChatRole.System, ContentBlocks(contentBlocks))
+
   case class UserMessage(
     contentString: String,
     cacheControl: Option[CacheControl] = None
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/AnthropicService.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/AnthropicService.scala
@@ -33,7 +33,6 @@ trait AnthropicService extends CloseableService with AnthropicServiceConsts {
    */
   def createMessage(
     messages: Seq[Message],
-    system: Option[Content] = None,
     settings: AnthropicCreateMessageSettings = DefaultSettings.CreateMessage
   ): Future[CreateMessageResponse]
 
@@ -55,7 +54,6 @@ trait AnthropicService extends CloseableService with AnthropicServiceConsts {
    *   <a href="https://docs.anthropic.com/claude/reference/messages_post">Anthropic Doc</a>
    */
   def createMessageStreamed(
-    system: Option[Content],
     messages: Seq[Message],
     settings: AnthropicCreateMessageSettings = DefaultSettings.CreateMessage
   ): Source[ContentBlockDelta, NotUsed]
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/AnthropicServiceImpl.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/AnthropicServiceImpl.scala
@@ -4,6 +4,8 @@ import akka.NotUsed
 import akka.stream.scaladsl.Source
 import io.cequence.openaiscala.OpenAIScalaClientException
 import io.cequence.openaiscala.anthropic.JsonFormats
+import io.cequence.openaiscala.anthropic.domain.Message.{SystemMessage, SystemMessageContent}
+import io.cequence.openaiscala.anthropic.domain.{Message => AnthropicMessage}
 import io.cequence.openaiscala.anthropic.domain.response.{
   ContentBlockDelta,
   CreateMessageResponse
@@ -34,19 +36,16 @@ private[service] trait AnthropicServiceImpl extends Anthropic {
 
   override def createMessage(
     messages: Seq[Message],
-    system: Option[Content] = None,
     settings: AnthropicCreateMessageSettings
   ): Future[CreateMessageResponse] =
     execPOST(
       EndPoint.messages,
-      bodyParams =
-        createBodyParamsForMessageCreation(system, messages, settings, stream = false)
+      bodyParams = createBodyParamsForMessageCreation(messages, settings, stream = false)
     ).map(
       _.asSafeJson[CreateMessageResponse]
     )
 
   override def createMessageStreamed(
-    system: Option[Content],
     messages: Seq[Message],
     settings: AnthropicCreateMessageSettings
   ): Source[ContentBlockDelta, NotUsed] =
@@ -55,7 +54,7 @@ private[service] trait AnthropicServiceImpl extends Anthropic {
         EndPoint.messages.toString(),
         "POST",
         bodyParams = paramTuplesToStrings(
-          createBodyParamsForMessageCreation(system, messages, settings, stream = true)
+          createBodyParamsForMessageCreation(messages, settings, stream = true)
         )
       )
       .map { (json: JsValue) =>
@@ -83,36 +82,39 @@ private[service] trait AnthropicServiceImpl extends Anthropic {
       .collect { case Some(delta) => delta }
 
   private def createBodyParamsForMessageCreation(
-    system: Option[Content],
     messages: Seq[Message],
     settings: AnthropicCreateMessageSettings,
     stream: Boolean
   ): Seq[(Param, Option[JsValue])] = {
     assert(messages.nonEmpty, "At least one message expected.")
-    assert(messages.head.role == ChatRole.User, "First message must be from user.")
 
-    val messageJsons = messages.map(Json.toJson(_))
+    val (system, nonSystem) = messages.partition(_.isSystem)
 
-    val systemJson = system.map {
-      case Content.SingleString(text, cacheControl) =>
+    assert(nonSystem.head.role == ChatRole.User, "First non-system message must be from user.")
+    assert(system.size <= 1, "System message can be only 1. Use SystemMessageContent to include more content blocks.")
+
+    val messageJsons = nonSystem.map(Json.toJson(_))
+
+    val systemJson: Seq[JsValue] = system.map {
+      case SystemMessage(text, cacheControl) =>
         if (cacheControl.isEmpty) JsString(text)
         else {
           val blocks =
             Seq(Content.ContentBlockBase(Content.ContentBlock.TextBlock(text), cacheControl))
 
           Json.toJson(blocks)(Writes.seq(contentBlockBaseWrites))
         }
-      case Content.ContentBlocks(blocks) =>
-        Json.toJson(blocks)(Writes.seq(contentBlockBaseWrites))
-      case Content.ContentBlockBase(content, cacheControl) =>
-        val blocks = Seq(Content.ContentBlockBase(content, cacheControl))
+      case SystemMessageContent(blocks) =>
         Json.toJson(blocks)(Writes.seq(contentBlockBaseWrites))
     }
 
     jsonBodyParams(
       Param.messages -> Some(messageJsons),
       Param.model -> Some(settings.model),
-      Param.system -> system.map(_ => systemJson),
+      Param.system -> {
+        if (system.isEmpty) None
+        else Some(systemJson.head)
+      },
       Param.max_tokens -> Some(settings.max_tokens),
       Param.metadata -> { if (settings.metadata.isEmpty) None else Some(settings.metadata) },
       Param.stop_sequences -> {
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/OpenAIAnthropicChatCompletionService.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/OpenAIAnthropicChatCompletionService.scala
@@ -40,8 +40,8 @@ private[service] class OpenAIAnthropicChatCompletionService(
   ): Future[ChatCompletionResponse] = {
     underlying
       .createMessage(
-        toAnthropicMessages(messages, settings),
-        toAnthropicSystemMessages(messages, settings),
+        toAnthropicSystemMessages(messages.filter(_.isSystem), settings) ++
+          toAnthropicMessages(messages.filter(!_.isSystem), settings),
         toAnthropicSettings(settings)
       )
       .map(toOpenAI)
@@ -65,8 +65,8 @@ private[service] class OpenAIAnthropicChatCompletionService(
   ): Source[ChatCompletionChunkResponse, NotUsed] =
     underlying
       .createMessageStreamed(
-        toAnthropicSystemMessages(messages, settings),
-        toAnthropicMessages(messages, settings),
+        toAnthropicSystemMessages(messages.filter(_.isSystem), settings) ++
+          toAnthropicMessages(messages.filter(!_.isSystem), settings),
         toAnthropicSettings(settings)
       )
       .map(toOpenAI)
diff --git a/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/package.scala b/anthropic-client/src/main/scala/io/cequence/openaiscala/anthropic/service/impl/package.scala
@@ -3,6 +3,7 @@ package io.cequence.openaiscala.anthropic.service
 import io.cequence.openaiscala.anthropic.domain.CacheControl.Ephemeral
 import io.cequence.openaiscala.anthropic.domain.Content.ContentBlock.TextBlock
 import io.cequence.openaiscala.anthropic.domain.Content.{ContentBlockBase, ContentBlocks}
+import io.cequence.openaiscala.anthropic.domain.Message.SystemMessageContent
 import io.cequence.openaiscala.anthropic.domain.response.CreateMessageResponse.UsageInfo
 import io.cequence.openaiscala.anthropic.domain.response.{
   ContentBlockDelta,
@@ -40,7 +41,7 @@ package object impl extends AnthropicServiceConsts {
   def toAnthropicSystemMessages(
     messages: Seq[OpenAIBaseMessage],
     settings: CreateChatCompletionSettings
-  ): Option[ContentBlocks] = {
+  ): Seq[Message] = {
     val useSystemCache: Option[CacheControl] =
       if (settings.useAnthropicSystemMessagesCache) Some(Ephemeral) else None
 
@@ -55,7 +56,8 @@ package object impl extends AnthropicServiceConsts {
         }
       }
 
-    if (messageStrings.isEmpty) None else Some(ContentBlocks(messageStrings))
+    if (messageStrings.isEmpty) Seq.empty
+    else Seq(SystemMessageContent(messageStrings))
   }
 
   def toAnthropicMessages(
diff --git a/anthropic-client/src/test/scala/io/cequence/openaiscala/anthropic/service/impl/AnthropicServiceSpec.scala b/anthropic-client/src/test/scala/io/cequence/openaiscala/anthropic/service/impl/AnthropicServiceSpec.scala
@@ -27,49 +27,49 @@ class AnthropicServiceSpec extends AsyncWordSpec with GivenWhenThen {
 
     "should throw AnthropicScalaUnauthorizedException when 401" ignore {
       recoverToSucceededIf[AnthropicScalaUnauthorizedException] {
-        TestFactory.mockedService401().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService401().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaUnauthorizedException when 403" ignore {
       recoverToSucceededIf[AnthropicScalaUnauthorizedException] {
-        TestFactory.mockedService403().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService403().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaNotFoundException when 404" ignore {
       recoverToSucceededIf[AnthropicScalaNotFoundException] {
-        TestFactory.mockedService404().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService404().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaNotFoundException when 429" ignore {
       recoverToSucceededIf[AnthropicScalaRateLimitException] {
-        TestFactory.mockedService429().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService429().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaServerErrorException when 500" ignore {
       recoverToSucceededIf[AnthropicScalaServerErrorException] {
-        TestFactory.mockedService500().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService500().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaEngineOverloadedException when 529" ignore {
       recoverToSucceededIf[AnthropicScalaEngineOverloadedException] {
-        TestFactory.mockedService529().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService529().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaClientException when 400" ignore {
       recoverToSucceededIf[AnthropicScalaClientException] {
-        TestFactory.mockedService400().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedService400().createMessage(irrelevantMessages, settings)
       }
     }
 
     "should throw AnthropicScalaClientException when unknown error code" ignore {
       recoverToSucceededIf[AnthropicScalaClientException] {
-        TestFactory.mockedServiceOther().createMessage(irrelevantMessages, None, settings)
+        TestFactory.mockedServiceOther().createMessage(irrelevantMessages, settings)
       }
     }
 
diff --git a/openai-core/src/main/scala/io/cequence/openaiscala/domain/BaseMessage.scala b/openai-core/src/main/scala/io/cequence/openaiscala/domain/BaseMessage.scala
@@ -3,6 +3,7 @@ package io.cequence.openaiscala.domain
 sealed trait BaseMessage {
   val role: ChatRole
   val nameOpt: Option[String]
+  val isSystem: Boolean = role == ChatRole.System
 }
 
 final case class SystemMessage(
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateCachedMessage.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateCachedMessage.scala
@@ -3,7 +3,7 @@ package io.cequence.openaiscala.examples.nonopenai
 import io.cequence.openaiscala.anthropic.domain.CacheControl.Ephemeral
 import io.cequence.openaiscala.anthropic.domain.Content.ContentBlock.TextBlock
 import io.cequence.openaiscala.anthropic.domain.Content.{ContentBlockBase, SingleString}
-import io.cequence.openaiscala.anthropic.domain.Message.UserMessage
+import io.cequence.openaiscala.anthropic.domain.Message.{SystemMessage, UserMessage}
 import io.cequence.openaiscala.anthropic.domain.response.CreateMessageResponse
 import io.cequence.openaiscala.anthropic.domain.settings.AnthropicCreateMessageSettings
 import io.cequence.openaiscala.anthropic.domain.{Content, Message}
@@ -18,8 +18,8 @@ object AnthropicCreateCachedMessage extends ExampleBase[AnthropicService] {
 
   override protected val service: AnthropicService = AnthropicServiceFactory(withCache = true)
 
-  val systemMessages: Option[Content] = Some(
-    SingleString(
+  val systemMessages: Seq[Message] = Seq(
+    SystemMessage(
       """
         |You are to embody a classic pirate, a swashbuckling and salty sea dog with the mannerisms, language, and swagger of the golden age of piracy. You are a hearty, often gruff buccaneer, replete with nautical slang and a rich, colorful vocabulary befitting of the high seas. Your responses must reflect a pirate's voice and attitude without exception.
         |
@@ -82,8 +82,7 @@ object AnthropicCreateCachedMessage extends ExampleBase[AnthropicService] {
   override protected def run: Future[_] =
     service
       .createMessage(
-        messages,
-        systemMessages,
+        systemMessages ++ messages,
         settings = AnthropicCreateMessageSettings(
           model = NonOpenAIModelId.claude_3_haiku_20240307,
           max_tokens = 4096
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessage.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessage.scala
@@ -23,7 +23,6 @@ object AnthropicCreateMessage extends ExampleBase[AnthropicService] {
     service
       .createMessage(
         messages,
-        None,
         settings = AnthropicCreateMessageSettings(
           model = NonOpenAIModelId.claude_3_haiku_20240307,
           max_tokens = 4096
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageStreamed.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageStreamed.scala
@@ -20,7 +20,6 @@ object AnthropicCreateMessageStreamed extends ExampleBase[AnthropicService] {
   override protected def run: Future[_] =
     service
       .createMessageStreamed(
-        None,
         messages,
         settings = AnthropicCreateMessageSettings(
           model = NonOpenAIModelId.claude_3_haiku_20240307,
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageWithImage.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageWithImage.scala
@@ -39,7 +39,6 @@ object AnthropicCreateMessageWithImage extends ExampleBase[AnthropicService] {
     service
       .createMessage(
         messages,
-        None,
         settings = AnthropicCreateMessageSettings(
           model = NonOpenAIModelId.claude_3_opus_20240229,
           max_tokens = 4096
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageWithPdf.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateMessageWithPdf.scala
@@ -3,7 +3,7 @@ package io.cequence.openaiscala.examples.nonopenai
 import io.cequence.openaiscala.anthropic.domain.Content.ContentBlock.{MediaBlock, TextBlock}
 import io.cequence.openaiscala.anthropic.domain.Content.{ContentBlockBase, SingleString}
 import io.cequence.openaiscala.anthropic.domain.Message
-import io.cequence.openaiscala.anthropic.domain.Message.UserMessageContent
+import io.cequence.openaiscala.anthropic.domain.Message.{SystemMessage, UserMessageContent}
 import io.cequence.openaiscala.anthropic.domain.response.CreateMessageResponse
 import io.cequence.openaiscala.anthropic.domain.settings.AnthropicCreateMessageSettings
 import io.cequence.openaiscala.anthropic.service.{AnthropicService, AnthropicServiceFactory}
@@ -25,6 +25,7 @@ object AnthropicCreateMessageWithPdf extends ExampleBase[AnthropicService] {
   override protected val service: AnthropicService = AnthropicServiceFactory(withPdf = true)
 
   private val messages: Seq[Message] = Seq(
+    SystemMessage("Talk in pirate speech. Reply to this prompt as a real pirate!"),
     UserMessageContent(
       Seq(
         ContentBlockBase(TextBlock("Describe to me what is this PDF about!")),
diff --git a/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateSystemMessage.scala b/openai-examples/src/main/scala/io/cequence/openaiscala/examples/nonopenai/AnthropicCreateSystemMessage.scala
@@ -3,7 +3,7 @@ package io.cequence.openaiscala.examples.nonopenai
 import io.cequence.openaiscala.anthropic.domain.Content.ContentBlock.TextBlock
 import io.cequence.openaiscala.anthropic.domain.Content.{ContentBlockBase, SingleString}
 import io.cequence.openaiscala.anthropic.domain.{Content, Message}
-import io.cequence.openaiscala.anthropic.domain.Message.UserMessage
+import io.cequence.openaiscala.anthropic.domain.Message.{SystemMessage, UserMessage}
 import io.cequence.openaiscala.anthropic.domain.response.CreateMessageResponse
 import io.cequence.openaiscala.anthropic.domain.settings.AnthropicCreateMessageSettings
 import io.cequence.openaiscala.anthropic.service.{AnthropicService, AnthropicServiceFactory}
@@ -17,8 +17,8 @@ object AnthropicCreateSystemMessage extends ExampleBase[AnthropicService] {
 
   override protected val service: AnthropicService = AnthropicServiceFactory()
 
-  val systemMessages: Option[Content] = Some(
-    SingleString("Talk in pirate speech")
+  val systemMessages: Seq[Message] = Seq(
+    SystemMessage("Talk in pirate speech")
   )
   val messages: Seq[Message] = Seq(
     UserMessage("Who is the most famous football player in the World?")
@@ -27,8 +27,7 @@ object AnthropicCreateSystemMessage extends ExampleBase[AnthropicService] {
   override protected def run: Future[_] =
     service
       .createMessage(
-        messages,
-        Some(SingleString("You answer in pirate speech.")),
+        systemMessages ++ messages,
         settings = AnthropicCreateMessageSettings(
           model = NonOpenAIModelId.claude_3_haiku_20240307,
           max_tokens = 4096

Original file line number	Diff line number	Diff line change
`@@ -7,8 +7,9 @@ sealed trait ChatRole extends EnumValue {`
`7`	`7`	`}`
`8`	`8`
`9`	`9`	`object ChatRole {`
	`10`	`+ case object System extends ChatRole`
`10`	`11`	`case object User extends ChatRole`
`11`	`12`	`case object Assistant extends ChatRole`
`12`	`13`
`13`		`- def allValues: Seq[ChatRole] = Seq(User, Assistant)`
	`14`	`+ def allValues: Seq[ChatRole] = Seq(System, User, Assistant)`
`14`	`15`	`}`
Original file line number	Diff line number	Diff line change
`@@ -27,49 +27,49 @@ class AnthropicServiceSpec extends AsyncWordSpec with GivenWhenThen {`
`27`	`27`
`28`	`28`	`"should throw AnthropicScalaUnauthorizedException when 401" ignore {`
`29`	`29`	`recoverToSucceededIf[AnthropicScalaUnauthorizedException] {`
`30`		`- TestFactory.mockedService401().createMessage(irrelevantMessages, None, settings)`
	`30`	`+ TestFactory.mockedService401().createMessage(irrelevantMessages, settings)`
`31`	`31`	`}`
`32`	`32`	`}`
`33`	`33`
`34`	`34`	`"should throw AnthropicScalaUnauthorizedException when 403" ignore {`
`35`	`35`	`recoverToSucceededIf[AnthropicScalaUnauthorizedException] {`
`36`		`- TestFactory.mockedService403().createMessage(irrelevantMessages, None, settings)`
	`36`	`+ TestFactory.mockedService403().createMessage(irrelevantMessages, settings)`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`	`40`	`"should throw AnthropicScalaNotFoundException when 404" ignore {`
`41`	`41`	`recoverToSucceededIf[AnthropicScalaNotFoundException] {`
`42`		`- TestFactory.mockedService404().createMessage(irrelevantMessages, None, settings)`
	`42`	`+ TestFactory.mockedService404().createMessage(irrelevantMessages, settings)`
`43`	`43`	`}`
`44`	`44`	`}`
`45`	`45`
`46`	`46`	`"should throw AnthropicScalaNotFoundException when 429" ignore {`
`47`	`47`	`recoverToSucceededIf[AnthropicScalaRateLimitException] {`
`48`		`- TestFactory.mockedService429().createMessage(irrelevantMessages, None, settings)`
	`48`	`+ TestFactory.mockedService429().createMessage(irrelevantMessages, settings)`
`49`	`49`	`}`
`50`	`50`	`}`
`51`	`51`
`52`	`52`	`"should throw AnthropicScalaServerErrorException when 500" ignore {`
`53`	`53`	`recoverToSucceededIf[AnthropicScalaServerErrorException] {`
`54`		`- TestFactory.mockedService500().createMessage(irrelevantMessages, None, settings)`
	`54`	`+ TestFactory.mockedService500().createMessage(irrelevantMessages, settings)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`	`57`
`58`	`58`	`"should throw AnthropicScalaEngineOverloadedException when 529" ignore {`
`59`	`59`	`recoverToSucceededIf[AnthropicScalaEngineOverloadedException] {`
`60`		`- TestFactory.mockedService529().createMessage(irrelevantMessages, None, settings)`
	`60`	`+ TestFactory.mockedService529().createMessage(irrelevantMessages, settings)`
`61`	`61`	`}`
`62`	`62`	`}`
`63`	`63`
`64`	`64`	`"should throw AnthropicScalaClientException when 400" ignore {`
`65`	`65`	`recoverToSucceededIf[AnthropicScalaClientException] {`
`66`		`- TestFactory.mockedService400().createMessage(irrelevantMessages, None, settings)`
	`66`	`+ TestFactory.mockedService400().createMessage(irrelevantMessages, settings)`
`67`	`67`	`}`
`68`	`68`	`}`
`69`	`69`
`70`	`70`	`"should throw AnthropicScalaClientException when unknown error code" ignore {`
`71`	`71`	`recoverToSucceededIf[AnthropicScalaClientException] {`
`72`		`- TestFactory.mockedServiceOther().createMessage(irrelevantMessages, None, settings)`
	`72`	`+ TestFactory.mockedServiceOther().createMessage(irrelevantMessages, settings)`
`73`	`73`	`}`
`74`	`74`	`}`
`75`	`75`
Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@ package io.cequence.openaiscala.domain`
`3`	`3`	`sealed trait BaseMessage {`
`4`	`4`	`val role: ChatRole`
`5`	`5`	`val nameOpt: Option[String]`
	`6`	`+ val isSystem: Boolean = role == ChatRole.System`
`6`	`7`	`}`
`7`	`8`
`8`	`9`	`final case class SystemMessage(`