Initial work on Vision support in text conversations and Image Editing

This is a huge patch which does some major refactoring like:

- renaming "Image Generation" to "Image Creation" in most places,
  to better match its new command (`!bai image create`)

- relocating image creation command (`!bai image` -> `!bai image create`),
  so it wouldn't conflict with the new image editing command (`!bai image edit`)

- introducing a new image editing command (`!bai image edit`), which
  is meant to work only with the OpenAI provider, but doesn't fully work yet
  due to https://github.com/64bit/async-openai/issues/364, though a next patch will fix it

- adding support for reading images off of Matrix conversations and forwarding them to
  text conversations. Works for OpenAI, but not for Anthropic yet
  (requires custom patches) and not for OpenAI-Compat (no support for
  images there)

- relocating some utils around (base64, mime)

src/agent/provider/anthropic/controller.rs

@@ -7,12 +7,14 @@ use anthropic::types::ContentBlock;
 use super::super::ControllerTrait;
 use crate::agent::AgentPurpose;
 use crate::agent::provider::entity::{
-    ImageGenerationResult, PingResult, TextGenerationParams, TextGenerationResult,
-    TextToSpeechParams, TextToSpeechResult,
+    ImageGenerationResult, ImageEditResult, ImageSource, PingResult, TextGenerationParams,
+    TextGenerationResult, TextToSpeechParams, TextToSpeechResult,
+};
+use crate::agent::provider::{
+    ImageGenerationParams, ImageEditParams, SpeechToTextParams, SpeechToTextResult,
 };
-use crate::agent::provider::{ImageGenerationParams, SpeechToTextParams, SpeechToTextResult};
 use crate::conversation::llm::{
-    Author as LLMAuthor, Conversation as LLMConversation, Message as LLMMessage,
+    Author as LLMAuthor, Conversation as LLMConversation, Message as LLMMessage, MessageContent as LLMMessageContent,
     shorten_messages_list_to_context_size,
 };
 use crate::strings;
@@ -69,7 +71,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
-            message_text: "Hello!".to_string(),
+            content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
 
@@ -106,7 +108,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
-                message_text: prompt_text,
+                content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })
         };
@@ -145,7 +147,9 @@ impl ControllerTrait for Controller {
             .unwrap_or(text_generation_config.temperature);
 
         if let Some(prompt_message) = prompt_message {
-            request.system = prompt_message.message_text;
+            if let LLMMessageContent::Text(text) = &prompt_message.content {
+                request.system = text.clone();
+            }
         }
 
         request.model = text_generation_config.model_id.clone();
@@ -213,6 +217,15 @@ impl ControllerTrait for Controller {
         Err(anyhow::anyhow!("Image generation not supported"))
     }
 
+    async fn create_image_edit(
+        &self,
+        _prompt: &str,
+        _images: Vec<ImageSource>,
+        _params: ImageEditParams,
+    ) -> anyhow::Result<ImageEditResult> {
+        Err(anyhow::anyhow!("Image editing is not supported"))
+    }
+
     async fn text_to_speech(
         &self,
         _input: &str,

src/agent/provider/anthropic/utils.rs

@@ -1,6 +1,6 @@
 use anthropic::types::{ContentBlock, Message, MessagesRequest, MessagesRequestBuilder, Role};
 
-use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage};
+use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage, MessageContent as LLMMessageContent};
 
 pub(super) fn create_anthropic_message_request(llm_messages: Vec<LLMMessage>) -> MessagesRequest {
     let mut messages = vec![];
@@ -14,13 +14,28 @@ pub(super) fn create_anthropic_message_request(llm_messages: Vec<LLMMessage>) ->
             }
         };
 
-        let content = vec![ContentBlock::Text {
-            text: message.message_text,
-        }];
+        let content = match &message.content {
+            LLMMessageContent::Text(text) => Some(vec![ContentBlock::Text { text: text.clone() }]),
+            LLMMessageContent::Image(_image_details) => {
+                // This cannot be implemented yet, because the Anthropic library does not support it.
+                // The code below requires the library to be forked and changed a bit.
+                // vec![ContentBlock::Image {
+                //     source: ImageSource {
+                //         r#type: "base64".to_string(),
+                //         media_type: mime_type.to_string(),
+                //         data: crate::utils::base64::base64_encode(image_details.data),
+                //     },
+                // }]
+                tracing::warn!("Image content is not supported by the Anthropic library yet. Skipping it.");
+                None
+            }
+        };
 
-        let message = Message { role, content };
+        if let Some(content) = content {
+            let message = Message { role, content };
 
-        messages.push(message);
+            messages.push(message);
+        }
     }
 
     MessagesRequestBuilder::default()

src/agent/provider/controller.rs

@@ -1,10 +1,10 @@
 use crate::{agent::AgentPurpose, conversation::llm::Conversation};
 
 use super::{
-    ImageGenerationParams, SpeechToTextParams, SpeechToTextResult,
+    ImageGenerationParams, ImageEditParams, SpeechToTextParams, SpeechToTextResult,
     entity::{
-        ImageGenerationResult, PingResult, TextGenerationParams, TextGenerationResult,
-        TextToSpeechParams, TextToSpeechResult,
+        ImageGenerationResult, ImageEditResult, ImageSource, PingResult, TextGenerationParams,
+        TextGenerationResult, TextToSpeechParams, TextToSpeechResult,
     },
 };
 
@@ -42,6 +42,13 @@ pub trait ControllerTrait {
         params: ImageGenerationParams,
     ) -> impl std::future::Future<Output = anyhow::Result<ImageGenerationResult>> + Send;
 
+    fn create_image_edit(
+        &self,
+        prompt: &str,
+        images: Vec<ImageSource>,
+        params: ImageEditParams,
+    ) -> impl std::future::Future<Output = anyhow::Result<ImageEditResult>> + Send;
+
     fn text_to_speech(
         &self,
         text: &str,
@@ -166,6 +173,23 @@ impl ControllerTrait for ControllerType {
         }
     }
 
+    async fn create_image_edit(
+        &self,
+        prompt: &str,
+        images: Vec<ImageSource>,
+        params: ImageEditParams,
+    ) -> anyhow::Result<ImageEditResult> {
+        match &self {
+            ControllerType::OpenAI(controller) => controller.create_image_edit(prompt, images, params).await,
+            ControllerType::OpenAICompat(controller) => {
+                controller.create_image_edit(prompt, images, params).await
+            }
+            ControllerType::Anthropic(controller) => {
+                controller.create_image_edit(prompt, images, params).await
+            }
+        }
+    }
+
     async fn text_to_speech(
         &self,
         text: &str,

src/agent/provider/entity/image.rs

@@ -0,0 +1,65 @@
+use mxlink::mime;
+
+#[derive(Default)]
+pub struct ImageGenerationParams {
+    pub size_override: Option<String>,
+
+    pub cheaper_model_switching_allowed: bool,
+
+    pub cheaper_quality_switching_allowed: bool,
+}
+
+impl ImageGenerationParams {
+    pub fn with_size_override(mut self, value: Option<String>) -> Self {
+        self.size_override = value;
+        self
+    }
+
+    pub fn with_cheaper_model_switching_allowed(mut self, value: bool) -> Self {
+        self.cheaper_model_switching_allowed = value;
+        self
+    }
+
+    pub fn with_cheaper_quality_switching_allowed(mut self, value: bool) -> Self {
+        self.cheaper_quality_switching_allowed = value;
+        self
+    }
+}
+
+pub struct ImageGenerationResult {
+    pub bytes: Vec<u8>,
+    pub mime_type: mime::Mime,
+    pub revised_prompt: Option<String>,
+}
+
+#[derive(Default)]
+pub struct ImageEditParams {
+}
+
+pub struct ImageEditResult {
+    pub bytes: Vec<u8>,
+    pub mime_type: mime::Mime,
+}
+
+pub struct ImageSource {
+    pub filename: String,
+    pub bytes: Vec<u8>,
+    pub mime_type: mime::Mime,
+}
+
+impl ImageSource {
+    pub fn new(filename: String, bytes: Vec<u8>, mime_type: mime::Mime) -> Self {
+        Self { filename, bytes, mime_type }
+    }
+}
+
+impl Into<async_openai::types::ImageInput> for ImageSource {
+    fn into(self) -> async_openai::types::ImageInput {
+        async_openai::types::ImageInput{
+            source: async_openai::types::InputSource::VecU8 {
+                filename: self.filename,
+                vec: self.bytes,
+            },
+        }
+    }
+}

src/agent/provider/entity/image_generation.rs

@@ -1,31 +0,0 @@
-#[derive(Default)]
-pub struct ImageGenerationParams {
-    pub size_override: Option<String>,
-
-    pub cheaper_model_switching_allowed: bool,
-
-    pub cheaper_quality_switching_allowed: bool,
-}
-
-impl ImageGenerationParams {
-    pub fn with_size_override(mut self, value: Option<String>) -> Self {
-        self.size_override = value;
-        self
-    }
-
-    pub fn with_cheaper_model_switching_allowed(mut self, value: bool) -> Self {
-        self.cheaper_model_switching_allowed = value;
-        self
-    }
-
-    pub fn with_cheaper_quality_switching_allowed(mut self, value: bool) -> Self {
-        self.cheaper_quality_switching_allowed = value;
-        self
-    }
-}
-
-pub struct ImageGenerationResult {
-    pub bytes: Vec<u8>,
-    pub mime_type: mxlink::mime::Mime,
-    pub revised_prompt: Option<String>,
-}

src/agent/provider/entity/mod.rs

@@ -1,12 +1,12 @@
 mod agent_provider;
-mod image_generation;
+mod image;
 mod ping;
 mod speech_to_text;
 mod text_generation;
 mod text_to_speech;
 
 pub use agent_provider::{AgentProvider, AgentProviderInfo};
-pub use image_generation::{ImageGenerationParams, ImageGenerationResult};
+pub use image::{ImageGenerationParams, ImageGenerationResult, ImageEditParams, ImageEditResult, ImageSource};
 pub use ping::PingResult;
 pub use speech_to_text::{SpeechToTextParams, SpeechToTextResult};
 pub use text_generation::{

src/agent/provider/mod.rs

@@ -20,6 +20,6 @@ pub use controller::{ControllerTrait, ControllerType};
 pub use config::ConfigTrait;
 
 pub use entity::{
-    AgentProvider, AgentProviderInfo, ImageGenerationParams, PingResult, SpeechToTextParams,
+    AgentProvider, AgentProviderInfo, ImageGenerationParams, ImageEditParams, ImageSource, PingResult, SpeechToTextParams,
     SpeechToTextResult, TextGenerationParams, TextGenerationPromptVariables, TextToSpeechParams,
 };

src/agent/provider/openai/controller.rs

@@ -5,7 +5,8 @@ use async_openai::{
     config::OpenAIConfig,
     types::{
         ChatCompletionRequestMessage, CreateChatCompletionRequestArgs, CreateImageRequestArgs,
-        CreateSpeechRequestArgs, CreateTranscriptionRequestArgs,
+        CreateSpeechRequestArgs, CreateTranscriptionRequestArgs, CreateImageEditRequestArgs,
+        ImageInput, ImageModel, DallE2ImageSize, ImageResponseFormat, Image,
     },
 };
 
@@ -14,24 +15,22 @@ use crate::{
     agent::{
         AgentPurpose,
         provider::{
-            entity::{ImageGenerationResult, PingResult, TextToSpeechParams, TextToSpeechResult},
+            entity::{ImageGenerationResult, ImageEditResult, ImageSource, PingResult, TextToSpeechParams, TextToSpeechResult},
             openai::utils::convert_string_to_enum,
         },
     },
     strings,
 };
 use crate::{
-    agent::{
-        provider::{
-            ImageGenerationParams, SpeechToTextParams, SpeechToTextResult,
-            entity::{TextGenerationParams, TextGenerationResult},
-        },
-        utils::base64_decode,
+    agent::provider::{
+        ImageGenerationParams, ImageEditParams, SpeechToTextParams, SpeechToTextResult,
+        entity::{TextGenerationParams, TextGenerationResult},
     },
     conversation::llm::{
         Author as LLMAuthor, Conversation as LLMConversation, Message as LLMMessage,
-        shorten_messages_list_to_context_size,
+        MessageContent as LLMMessageContent, shorten_messages_list_to_context_size,
     },
+    utils::base64::base64_decode,
 };
 
 use super::config::Config;
@@ -64,7 +63,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
-            message_text: "Hello!".to_string(),
+            content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
 
@@ -101,7 +100,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
-                message_text: prompt_text,
+                content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })
         };
@@ -290,11 +289,13 @@ impl ControllerTrait for Controller {
             .unwrap_or(image_generation_config.size);
 
         let response_format = match model.clone() {
-            async_openai::types::ImageModel::DallE2 => Some(async_openai::types::ImageResponseFormat::B64Json),
-            async_openai::types::ImageModel::DallE3 => Some(async_openai::types::ImageResponseFormat::B64Json),
-            async_openai::types::ImageModel::Other(model_str) => match model_str.as_str() {
+            ImageModel::DallE2 => Some(ImageResponseFormat::B64Json),
+            ImageModel::DallE3 => Some(ImageResponseFormat::B64Json),
+            ImageModel::Other(model_str) => match model_str.as_str() {
+                // gpt-image-1 only outputs base64 and we don't need to specify the response format.
+                // In fact, specifying the response format results in an error.
                 OPENAI_IMAGE_MODEL_GPT_IMAGE_1 => None,
-                _ => Some(async_openai::types::ImageResponseFormat::B64Json),
+                _ => Some(ImageResponseFormat::B64Json),
             },
         };
 
@@ -355,6 +356,96 @@ impl ControllerTrait for Controller {
         ))
     }
 
+    async fn create_image_edit(
+        &self,
+        prompt: &str,
+        images: Vec<ImageSource>,
+        _params: ImageEditParams,
+    ) -> anyhow::Result<ImageEditResult> {
+        let Some(image_generation_config) = &self.config.image_generation else {
+            return Err(anyhow::anyhow!(
+                strings::agent::no_configuration_for_purpose_so_cannot_be_used(
+                    &AgentPurpose::ImageGeneration
+                ),
+            ));
+        };
+
+        let Some(first_image) = images.into_iter().next() else {
+            return Err(anyhow::anyhow!("No image sources provided"));
+        };
+
+        let image_input: ImageInput = first_image.into();
+
+        let dalle2_size = match image_generation_config.size {
+            async_openai::types::ImageSize::S256x256 => Some(DallE2ImageSize::S256x256),
+            async_openai::types::ImageSize::S512x512 => Some(DallE2ImageSize::S512x512),
+            async_openai::types::ImageSize::S1024x1024 => Some(DallE2ImageSize::S1024x1024),
+            _ => None,
+        };
+
+        let model = image_generation_config
+            .model_id_as_openai_image_model()
+            .map_err(|err| anyhow::anyhow!(err))?;
+
+        let response_format = match model.clone() {
+            async_openai::types::ImageModel::DallE2 => Some(async_openai::types::ImageResponseFormat::B64Json),
+            async_openai::types::ImageModel::DallE3 => Some(async_openai::types::ImageResponseFormat::B64Json),
+            async_openai::types::ImageModel::Other(model_str) => match model_str.as_str() {
+                OPENAI_IMAGE_MODEL_GPT_IMAGE_1 => None,
+                _ => Some(async_openai::types::ImageResponseFormat::B64Json),
+            },
+        };
+
+        let mut request_builder = CreateImageEditRequestArgs::default();
+
+        request_builder
+            .image(image_input)
+            .prompt(prompt.to_owned())
+            .model(model);
+
+        if let Some(size) = dalle2_size {
+            request_builder.size(size);
+        }
+
+        if let Some(response_format) = response_format {
+            request_builder.response_format(response_format);
+        }
+
+        let request = request_builder.build()
+            .map_err(|e| anyhow::anyhow!("Failed to build CreateImageEditRequest: {}", e))?;
+
+        tracing::trace!(
+            model = format!("{:?}", request.model),
+            size = format!("{:?}", request.size),
+            response_format = format!("{:?}", request.response_format),
+            "Sending OpenAI image edit API request"
+        );
+
+        let response = self.client.images().create_edit(request).await?;
+
+        if let Some(image_data) = response.data.into_iter().next() {
+            match image_data.deref() {
+                Image::B64Json { b64_json, .. } => {
+                    let bytes = base64_decode(b64_json)?;
+                    return Ok(ImageEditResult {
+                        bytes,
+                        mime_type: mxlink::mime::IMAGE_PNG,
+                    });
+                }
+                Image::Url { url, .. } => {
+                    tracing::warn!(?url, "Received URL instead of B64Json for image edit");
+                    return Err(anyhow::anyhow!(
+                        "Unexpected image type (URL) when B64Json was requested"
+                    ));
+                }
+            }
+        }
+
+        Err(anyhow::anyhow!(
+            "The OpenAI image edit API returned no images"
+        ))
+    }
+
     async fn text_to_speech(
         &self,
         input: &str,

src/agent/provider/openai/utils.rs

@@ -1,9 +1,9 @@
 use async_openai::types::{
-    ChatCompletionRequestAssistantMessageArgs, ChatCompletionRequestMessage,
-    ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs,
+    ChatCompletionRequestAssistantMessageArgs, ChatCompletionRequestMessage, ChatCompletionRequestMessageContentPartImage, ChatCompletionRequestSystemMessageArgs, ChatCompletionRequestUserMessageArgs, ChatCompletionRequestUserMessageContent, ChatCompletionRequestUserMessageContentPart, ImageUrlArgs
 };
 
-use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage};
+use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage, MessageContent as LLMMessageContent};
+use crate::utils::base64::base64_encode;
 
 pub fn convert_llm_messages_to_openai_messages(
     conversation_messages: Vec<LLMMessage>,
@@ -12,29 +12,65 @@ pub fn convert_llm_messages_to_openai_messages(
         Vec::with_capacity(conversation_messages.len());
 
     for message in conversation_messages {
-        openai_conversation_messages.push(convert_llm_message_to_openai_message(message));
+        let openai_message = convert_llm_message_to_openai_message(message);
+        if let Some(openai_message) = openai_message {
+            openai_conversation_messages.push(openai_message);
+        }
     }
 
     openai_conversation_messages
 }
 
-fn convert_llm_message_to_openai_message(llm_message: LLMMessage) -> ChatCompletionRequestMessage {
-    match llm_message.author {
-        LLMAuthor::Prompt => ChatCompletionRequestSystemMessageArgs::default()
-            .content(llm_message.message_text)
-            .build()
-            .expect("Failed building OpenAI system message")
-            .into(),
-        LLMAuthor::Assistant => ChatCompletionRequestAssistantMessageArgs::default()
-            .content(llm_message.message_text)
-            .build()
-            .expect("Failed building OpenAI assistant message")
-            .into(),
-        LLMAuthor::User => ChatCompletionRequestUserMessageArgs::default()
-            .content(llm_message.message_text)
-            .build()
-            .expect("Failed building OpenAI user message")
-            .into(),
+fn convert_llm_message_to_openai_message(llm_message: LLMMessage) -> Option<ChatCompletionRequestMessage> {
+    match &llm_message.content {
+        LLMMessageContent::Text(text) => {
+            Some(match llm_message.author {
+                LLMAuthor::Prompt => ChatCompletionRequestSystemMessageArgs::default()
+                    .content(text.clone())
+                    .build()
+                    .expect("Failed building OpenAI system message")
+                    .into(),
+                LLMAuthor::Assistant => ChatCompletionRequestAssistantMessageArgs::default()
+                    .content(text.clone())
+                    .build()
+                    .expect("Failed building OpenAI assistant message")
+                    .into(),
+                LLMAuthor::User => ChatCompletionRequestUserMessageArgs::default()
+                    .content(text.clone())
+                    .build()
+                    .expect("Failed building OpenAI user message")
+                    .into(),
+            })
+        }
+        LLMMessageContent::Image(image_details) => {
+            let image_url = format!("data:{};base64,{}", image_details.mime, base64_encode(&image_details.data));
+
+            let part = ChatCompletionRequestUserMessageContentPart::ImageUrl(
+                ChatCompletionRequestMessageContentPartImage{
+                    image_url: ImageUrlArgs::default()
+                        .url(image_url)
+                        .build()
+                        .expect("Failed building OpenAI image url")
+                }
+            );
+
+            let message_content = ChatCompletionRequestUserMessageContent::Array(vec![part]);
+
+            match llm_message.author {
+                LLMAuthor::User => Some(ChatCompletionRequestUserMessageArgs::default()
+                    .content(message_content)
+                    .build()
+                    .expect("Failed building OpenAI user message")
+                    .into()),
+                _ => {
+                    tracing::warn!(
+                        "OpenAI API does not support image content for messages authored by {:?}. This message part will be skipped.",
+                        llm_message.author
+                    );
+                    None
+                }
+            }
+        }
     }
 }
 

src/agent/provider/openai_compat/controller.rs

@@ -4,22 +4,23 @@ use etke_openai_api_rust::images::{ImagesApi, ImagesBody};
 use etke_openai_api_rust::{Auth, Message, OpenAI};
 
 use super::super::ControllerTrait;
-use crate::agent::utils::base64_decode;
+use crate::utils::base64::base64_decode;
 use crate::{
     agent::provider::{
-        ImageGenerationParams, SpeechToTextParams, SpeechToTextResult,
+        ImageGenerationParams, ImageEditParams, ImageSource, SpeechToTextParams, SpeechToTextResult,
         entity::{TextGenerationParams, TextGenerationResult},
     },
     conversation::llm::{
         Author as LLMAuthor, Conversation as LLMConversation, Message as LLMMessage,
-        shorten_messages_list_to_context_size,
+        MessageContent as LLMMessageContent, shorten_messages_list_to_context_size,
     },
 };
 use crate::{
     agent::{
         AgentPurpose,
         provider::entity::{
-            ImageGenerationResult, PingResult, TextToSpeechParams, TextToSpeechResult,
+            ImageGenerationResult, ImageEditResult, PingResult, TextToSpeechParams,
+            TextToSpeechResult,
         },
     },
     strings,
@@ -60,7 +61,7 @@ impl ControllerTrait for Controller {
 
         let messages = vec![LLMMessage {
             author: LLMAuthor::User,
-            message_text: "Hello!".to_string(),
+            content: LLMMessageContent::Text("Hello!".to_string()),
             timestamp: chrono::Utc::now(),
         }];
 
@@ -97,7 +98,7 @@ impl ControllerTrait for Controller {
         } else {
             Some(LLMMessage {
                 author: LLMAuthor::Prompt,
-                message_text: prompt_text,
+                content: LLMMessageContent::Text(prompt_text),
                 timestamp: chrono::Utc::now(),
             })
         };
@@ -366,6 +367,17 @@ impl ControllerTrait for Controller {
         ))
     }
 
+    async fn create_image_edit(
+        &self,
+        _prompt: &str,
+        _images: Vec<ImageSource>,
+        _params: ImageEditParams,
+    ) -> anyhow::Result<ImageEditResult> {
+        Err(anyhow::anyhow!(
+            "The OpenAI image edit API is not supported by the OpenAI-compat provider"
+        ))
+    }
+
     async fn text_to_speech(
         &self,
         input: &str,

src/agent/provider/openai_compat/utils.rs

@@ -2,7 +2,7 @@ use etke_openai_api_rust::{Message, Role};
 
 use crate::agent::provider::openai::Config as OpenAIConfig;
 
-use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage};
+use crate::conversation::llm::{Author as LLMAuthor, Message as LLMMessage, MessageContent as LLMMessageContent};
 
 pub fn convert_llm_messages_to_openai_messages(
     conversation_messages: Vec<LLMMessage>,
@@ -11,22 +11,33 @@ pub fn convert_llm_messages_to_openai_messages(
         Vec::with_capacity(conversation_messages.len());
 
     for message in conversation_messages {
-        openai_conversation_messages.push(convert_llm_message_to_openai_message(message));
+        let openai_message = convert_llm_message_to_openai_message(message);
+        if let Some(openai_message) = openai_message {
+            openai_conversation_messages.push(openai_message);
+        }
     }
 
     openai_conversation_messages
 }
 
-fn convert_llm_message_to_openai_message(llm_message: LLMMessage) -> Message {
+fn convert_llm_message_to_openai_message(llm_message: LLMMessage) -> Option<Message> {
     let role = match llm_message.author {
         LLMAuthor::Prompt => Role::System,
         LLMAuthor::Assistant => Role::Assistant,
         LLMAuthor::User => Role::User,
     };
 
-    Message {
-        role,
-        content: llm_message.message_text,
+    match &llm_message.content {
+        LLMMessageContent::Text(text) => {
+            Some(Message {
+                role,
+                content: text.clone(),
+            })
+        },
+        LLMMessageContent::Image(_image_details) => {
+            tracing::warn!("The OpenAI-compat provider's library does not support image content. This image message will be skipped.");
+            None
+        },
     }
 }