evalscope 0.16.3__py3-none-any.whl → 0.17.1__py3-none-any.whl

evalscope/perf/plugin/api/custom_api.py

@@ -1,5 +1,6 @@
+import aiohttp
 import json
-from typing import Any, Dict, Iterator, List
+from typing import Any, AsyncGenerator, Dict, List, Tuple, Union
 
 from evalscope.perf.arguments import Arguments
 from evalscope.perf.plugin.api.base import ApiPluginBase
@@ -11,82 +12,238 @@ logger = get_logger()
 
 @register_api('custom')
 class CustomPlugin(ApiPluginBase):
-    """Support tensorrt-llm triton server
+    """Support custom API implementations.
+
+    This class serves as a template for users to implement their own API plugins.
+    By extending this class, users can connect to any LLM API with custom request
+    and response formats.
     """
 
-    def __init__(self, mode_path: str):
-        """Init the plugin
+    def __init__(self, param: Arguments):
+        """Initialize the plugin with the provided parameters.
 
         Args:
-            mode_path (str): The model path, we use the tokenizer
-                weight in the model to calculate the number of the
-                input and output tokens.
+            param (Arguments): Configuration parameters for the plugin, including:
+                - tokenizer_path: Path to the tokenizer for token counting
+                - model: Name of the model to use
+                - Other request parameters like max_tokens, temperature, etc.
         """
-        super().__init__(model_path=mode_path)
-        if mode_path is not None:
+        super().__init__(param=param)
+        if param.tokenizer_path is not None:
             from modelscope import AutoTokenizer
-            self.tokenizer = AutoTokenizer.from_pretrained(mode_path)
+            self.tokenizer = AutoTokenizer.from_pretrained(param.tokenizer_path)
         else:
             self.tokenizer = None
 
-    def build_request(self, messages: List[Dict], param: Arguments) -> Dict:
-        """Build the openai format request based on prompt, dataset
+    def build_request(self, messages: Union[List[Dict], str], param: Arguments = None) -> Dict:
+        """Build a custom API request body based on the input messages and parameters.
 
-        Args:
-            message (Dict): The basic message to generator query.
-            param (Arguments): The query parameters.
+        This method formats the input messages into the expected request format
+        for your custom API.
 
-        Raises:
-            Exception: NotImplemented
+        Args:
+            messages (Union[List[Dict], str]): The input messages to include in the request.
+                Could be a list of message dictionaries (for chat models) or a string (for completion models).
+            param (Arguments, optional): Request parameters. Defaults to self.param.
 
         Returns:
-            Dict: The request body. None if prompt format is error.
+            Dict: A properly formatted request body for your custom API.
         """
+        param = param or self.param
         try:
-            query = json.loads(param.query_template)
-            ApiPluginBase.replace_values(query, param.model, messages[0]['content'])
-            return query
+            # Create a default query format if no template is provided
+            if isinstance(messages, str):
+                query = {'input_text': messages}
+            else:
+                query = {'messages': messages}
+
+            # Add model parameters to the request
+            return self._add_parameters_to_request(query, param)
         except Exception as e:
             logger.exception(e)
-            logger.error('Prompt: %s invalidate!' % messages)
             return None
 
-    def parse_responses(self, responses, request: Any = None, **kwargs) -> Dict:
-        """Parser responses and return number of request and response tokens.
-           sample of the output delta:
-           {"id":"4","object":"chat.completion.chunk","created":1714030870,"model":"llama3","choices":[{"index":0,"delta":{"role":"assistant","content":""},"logprobs":null,"finish_reason":null}]}
+    def _add_parameters_to_request(self, payload: Dict, param: Arguments) -> Dict:
+        """Add model parameters to the request payload.
+
+        This helper method adds various parameters like temperature, max_tokens, etc.
+        to the request based on what your custom API supports.
+
+        Args:
+            payload (Dict): The base request payload.
+            param (Arguments): The parameters to add.
+
+        Returns:
+            Dict: The request payload with added parameters.
+        """
+        # Add the model name
+        payload['model'] = param.model
+
+        # Add various parameters if they are provided
+        if param.max_tokens is not None:
+            payload['max_tokens'] = param.max_tokens
+        if param.temperature is not None:
+            payload['temperature'] = param.temperature
+        if param.top_p is not None:
+            payload['top_p'] = param.top_p
+        if param.top_k is not None:
+            payload['top_k'] = param.top_k
+        if param.stream is not None:
+            payload['stream'] = param.stream
+            payload['stream_options'] = {'include_usage': True}
 
+        # Add any extra arguments passed via command line
+        if param.extra_args is not None:
+            payload.update(param.extra_args)
+
+        return payload
+
+    def parse_responses(self, responses: List[str], request: Any = None, **kwargs) -> Tuple[int, int]:
+        """Parse API responses and return token counts.
+
+        This method extracts the number of input and output tokens from the API responses.
+        Different APIs may return this information in different formats, or you may need
+        to calculate it using a tokenizer.
 
         Args:
-            responses (List[bytes]): List of http response body, for stream output,
-                there are multiple responses, for general only one.
-            kwargs: (Any): The command line --parameter content.
+            responses (List[str]): List of API response strings.
+            request (Any, optional): The original request, which might be needed for token calculation.
+            **kwargs: Additional arguments.
+
         Returns:
-            Tuple: Return number of prompt token and number of completion tokens.
+            Tuple[int, int]: (input_tokens, output_tokens) - The number of tokens in the prompt and completion.
+        """
+        try:
+            # Example 1: Try to get token counts from the API response
+            last_response = json.loads(responses[-1])
+
+            # If the API provides token usage information
+            if 'usage' in last_response and last_response['usage']:
+                input_tokens = last_response['usage'].get('prompt_tokens', 0)
+                output_tokens = last_response['usage'].get('completion_tokens', 0)
+                return input_tokens, output_tokens
+
+            # Example 2: Calculate tokens using the tokenizer if no usage info is available
+            if self.tokenizer is not None:
+                input_text = ''
+                output_text = ''
+
+                # Extract input text from the request
+                if request and 'messages' in request:
+                    # For chat API
+                    input_text = ' '.join([msg['content'] for msg in request['messages']])
+                elif request and 'input_text' in request:
+                    # For completion API
+                    input_text = request['input_text']
+
+                # Extract output text from the response
+                for response in responses:
+                    js = json.loads(response)
+                    if 'choices' in js:
+                        for choice in js['choices']:
+                            if 'message' in choice and 'content' in choice['message']:
+                                output_text += choice['message']['content']
+                            elif 'text' in choice:
+                                output_text += choice['text']
+
+                # Count tokens
+                input_tokens = len(self.tokenizer.encode(input_text))
+                output_tokens = len(self.tokenizer.encode(output_text))
+                return input_tokens, output_tokens
+
+            # If no usage information and no tokenizer, raise an error
+            raise ValueError(
+                'Cannot determine token counts: no usage information in response and no tokenizer provided.')
+
+        except Exception as e:
+            logger.error(f'Error parsing responses: {e}')
+            return 0, 0
+
+    async def process_request(self, client_session: aiohttp.ClientSession, url: str, headers: Dict,
+                              body: Dict) -> AsyncGenerator[Tuple[bool, int, str], None]:
+        """Process the HTTP request and handle the response.
+
+        This method handles sending the request to your API and processing the response,
+        including handling streaming responses if supported.
+
+        Args:
+            client_session (aiohttp.ClientSession): The aiohttp client session.
+            url (str): The API endpoint URL.
+            headers (Dict): The request headers.
+            body (Dict): The request body.
+
+        Yields:
+            Tuple[bool, int, str]: (is_error, status_code, response_data)
+                - is_error: Whether the response indicates an error
+                - status_code: HTTP status code
+                - response_data: Response content
         """
-        full_response_content = ''
-        delta_contents = {}
-        input_tokens = None
-        output_tokens = None
-        for response in responses:
-            data = json.loads(response)
-            # {"context_logits":0.0,"cum_log_probs":0.0,"generation_logits":0.0,"model_name":"ensemble",
-            # "model_version":"1","output_log_probs":[0.0,0.0,0.0,0.0,0.0],"sequence_end":false,"sequence_id":0,"sequence_start":false,"text_output":"性"}
-            if 'text_output' in data:
-                if 0 in delta_contents:
-                    delta_contents[0].append(data['text_output'])
+        try:
+            # Set content type header
+            headers = {'Content-Type': 'application/json', **headers}
+
+            # Convert body to JSON
+            data = json.dumps(body, ensure_ascii=False)
+
+            # Send the request
+            async with client_session.request(
+                'POST', url=url, data=data, headers=headers) as response:  # noqa: E125
+                # Get the status code
+                status_code = response.status
+
+                # Check if it's a streaming response
+                if 'text/event-stream' in response.content_type:
+                    # Handle streaming response
+                    async for line in response.content:
+                        line_str = line.decode('utf-8').strip()
+                        if not line_str:
+                            continue
+
+                        # Check for data prefix in server-sent events
+                        if line_str.startswith('data: '):
+                            data = line_str[6:]  # Remove 'data: ' prefix
+
+                            # Check if it's the end of the stream
+                            if data == '[DONE]':
+                                break
+
+                            try:
+                                # Parse the JSON data
+                                parsed_data = json.loads(data)
+                                yield (False, status_code, json.dumps(parsed_data))
+                            except json.JSONDecodeError:
+                                yield (True, status_code, f'Failed to parse JSON: {data}')
                 else:
-                    delta_contents[0] = [data['text_output']]
-        if input_tokens is None and output_tokens is None and self.tokenizer is not None:
-            input_tokens = 0
-            output_tokens = 0
-            for _, choice_contents in delta_contents.items():
-                full_response_content = ''.join([m for m in choice_contents])
-                input_tokens += len(self.tokenizer.encode(request['text_input']))
-                output_tokens += len(self.tokenizer.encode(full_response_content))
-        elif input_tokens is None and output_tokens is None:  # no usage info get.
-            input_tokens = 0
-            output_tokens = 0
-            logger.warning('No usage info get.')
-
-        return input_tokens, output_tokens
+                    # Handle regular response
+                    if 'application/json' in response.content_type:
+                        # JSON response
+                        content = await response.json()
+                        yield (status_code >= 400, status_code, json.dumps(content))
+                    else:
+                        # Text response
+                        content = await response.text()
+                        yield (status_code >= 400, status_code, content)
+
+        except Exception as e:
+            logger.error(f'Error in process_request: {e}')
+            yield (True, 500, str(e))
+
+
+if __name__ == '__main__':
+    # Example usage of the CustomPlugin
+    from dotenv import dotenv_values
+    env = dotenv_values('.env')
+
+    from evalscope.perf.arguments import Arguments
+    from evalscope.perf.main import run_perf_benchmark
+
+    args = Arguments(
+        model='qwen2.5-7b-instruct',
+        url='https://dashscope.aliyuncs.com/compatible-mode/v1/chat/completions',
+        api_key=env.get('DASHSCOPE_API_KEY'),
+        api='custom',  # Use the custom API plugin registered above
+        dataset='openqa',
+        number=1,
+        max_tokens=10)
+
+    run_perf_benchmark(args)

evalscope/perf/plugin/api/dashscope_api.py

@@ -13,17 +13,10 @@ logger = get_logger()
 @register_api('dashscope')
 class DashScopeApiPlugin(ApiPluginBase):
 
-    def __init__(self, mode_path: str):
-        """Init the plugin
+    def __init__(self, param: Arguments):
+        super().__init__(param)
 
-        Args:
-            mode_path (str): The model path, we use the tokenizer
-                weight in the model to calculate the number of the
-                input and output tokens.
-        """
-        super().__init__(model_path=mode_path)
-
-    def build_request(self, messages: List[Dict], param: Arguments) -> Dict:
+    def build_request(self, messages: List[Dict], param: Arguments = None) -> Dict:
         """Build the openai format request based on prompt, dataset
 
         Args:
@@ -36,6 +29,7 @@ class DashScopeApiPlugin(ApiPluginBase):
         Returns:
             Dict: The request body. None if prompt format is error.
         """
+        param = param or self.param
         try:
             if param.query_template is not None:
                 if param.query_template.startswith('@'):

evalscope/perf/plugin/api/default_api.py

@@ -0,0 +1,105 @@
+import aiohttp
+import json
+from http import HTTPStatus
+from typing import Any, AsyncGenerator, Dict, List, Tuple
+
+from evalscope.perf.arguments import Arguments
+from evalscope.perf.plugin.api.base import ApiPluginBase
+from evalscope.perf.utils.local_server import ServerSentEvent
+from evalscope.utils.logger import get_logger
+
+logger = get_logger()
+
+
+class DefaultApiPlugin(ApiPluginBase):
+    """Default implementation of API plugin with common HTTP handling methods."""
+
+    def __init__(self, param: Arguments):
+        super().__init__(param)
+
+    async def process_request(self, client_session: aiohttp.ClientSession, url: str, headers: Dict,
+                              body: Dict) -> AsyncGenerator[Tuple[bool, int, str], None]:
+        """Process the HTTP request and handle the response.
+
+        Args:
+            client_session: The aiohttp client session
+            url: The request URL
+            headers: The request headers
+            body: The request body
+
+        Yields:
+            Tuple[bool, int, str]: (is_error, status_code, response_data)
+        """
+        try:
+            headers = {'Content-Type': 'application/json', **headers}
+            data = json.dumps(body, ensure_ascii=False)  # serialize to JSON
+            async with client_session.request('POST', url=url, data=data, headers=headers) as response:
+                async for result in self._handle_response(response):
+                    yield result
+        except Exception as e:
+            logger.error(f'Error in process_request: {e}')
+            yield (True, None, str(e))
+
+    async def _handle_stream(self, response: aiohttp.ClientResponse) -> AsyncGenerator[Tuple[bool, int, str], None]:
+        """Handle streaming response from server-sent events.
+
+        Args:
+            response: The aiohttp response object containing a stream
+
+        Yields:
+            Tuple[bool, int, Any]: (is_error, status_code, data)
+        """
+        try:
+            async for chunk_bytes in response.content:
+                chunk_bytes = chunk_bytes.strip()
+                if not chunk_bytes:
+                    continue
+                chunk_bytes = chunk_bytes.decode('utf-8')
+                # NOTE: SSE comments (often used as pings) start with a colon.
+                # These are not JSON data payload and should be skipped.
+                if chunk_bytes.startswith(':'):
+                    continue
+
+                chunk = chunk_bytes.removeprefix('data: ')
+
+                if chunk != '[DONE]':
+                    data = json.loads(chunk)
+
+                    yield False, response.status, data
+
+        except Exception as e:
+            logger.error(f'Error in _handle_stream: {e}')
+            yield True, response.status, str(e)
+
+    async def _handle_response(self, response: aiohttp.ClientResponse) -> AsyncGenerator[Tuple[bool, int, str], None]:
+        """Handle the HTTP response based on content type and status.
+
+        Args:
+            response: The aiohttp response object
+
+        Yields:
+            Tuple[bool, int, str]: (is_error, status_code, response_data)
+        """
+        response_status = response.status
+        response_content_type = response.content_type
+        content_type_json = 'application/json'
+        content_type_stream = 'text/event-stream'
+        is_success = (response_status == HTTPStatus.OK)
+
+        if is_success:
+            # Handle successful response with 'text/event-stream' content type
+            if content_type_stream in response_content_type:
+                async for is_error, response_status, content in self._handle_stream(response):
+                    yield (is_error, response_status, content)
+            # Handle successful response with 'application/json' content type
+            elif content_type_json in response_content_type:
+                content = await response.json()
+                yield (False, response_status, json.dumps(content, ensure_ascii=False))
+            # Handle other successful responses
+            else:
+                content = await response.read()
+                yield (False, response_status, content.decode('utf-8'))
+        else:
+            # error is always in JSON format
+            error = await response.json()
+            yield (True, response_status, json.dumps(error, ensure_ascii=False))

evalscope/perf/plugin/api/openai_api.py

@@ -1,9 +1,9 @@
 import json
 import os
-from typing import Any, Dict, Iterator, List, Union
+from typing import Any, Dict, List, Tuple, Union
 
 from evalscope.perf.arguments import Arguments
-from evalscope.perf.plugin.api.base import ApiPluginBase
+from evalscope.perf.plugin.api.default_api import DefaultApiPlugin
 from evalscope.perf.plugin.registry import register_api
 from evalscope.utils.logger import get_logger
 
@@ -11,25 +11,25 @@ logger = get_logger()
 
 
 @register_api(['openai', 'local_vllm', 'local'])
-class OpenaiPlugin(ApiPluginBase):
+class OpenaiPlugin(DefaultApiPlugin):
     """Base of openai interface."""
 
-    def __init__(self, mode_path: str):
-        """Init the plugin
+    def __init__(self, param: Arguments):
+        """Initialize the OpenaiPlugin.
 
         Args:
-            mode_path (str): The model path, we use the tokenizer
-                weight in the model to calculate the number of the
-                input and output tokens.
+            param (Arguments): Configuration object containing parameters
+                such as the tokenizer path and model details. If a tokenizer
+                path is provided, it is used to initialize the tokenizer.
         """
-        super().__init__(model_path=mode_path)
-        if mode_path is not None:
+        super().__init__(param=param)
+        if param.tokenizer_path is not None:
             from modelscope import AutoTokenizer
-            self.tokenizer = AutoTokenizer.from_pretrained(mode_path)
+            self.tokenizer = AutoTokenizer.from_pretrained(param.tokenizer_path)
         else:
             self.tokenizer = None
 
-    def build_request(self, messages: Union[List[Dict], str], param: Arguments) -> Dict:
+    def build_request(self, messages: Union[List[Dict], str], param: Arguments = None) -> Dict:
         """Build the openai format request based on prompt, dataset
 
         Args:
@@ -42,6 +42,7 @@ class OpenaiPlugin(ApiPluginBase):
         Returns:
             Dict: The request body. None if prompt format is error.
         """
+        param = param or self.param
         try:
             if param.query_template is not None:
                 if param.query_template.startswith('@'):
@@ -54,8 +55,6 @@ class OpenaiPlugin(ApiPluginBase):
                 else:
                     query = json.loads(param.query_template)
 
-                if 'stream' in query.keys():
-                    param.stream = query['stream']
                 # replace template messages with input messages.
                 query['messages'] = messages
             elif isinstance(messages, str):
@@ -107,7 +106,7 @@ class OpenaiPlugin(ApiPluginBase):
 
         # when stream, the last response is the full usage
         # when non-stream, the last response is the first response
-        last_response_js = json.loads(responses[-1])
+        last_response_js = responses[-1]
         if 'usage' in last_response_js and last_response_js['usage']:
             input_tokens = last_response_js['usage']['prompt_tokens']
             output_tokens = last_response_js['usage']['completion_tokens']
@@ -116,11 +115,10 @@ class OpenaiPlugin(ApiPluginBase):
         # no usage information in the response, parse the response to get the tokens
         delta_contents = {}
         for response in responses:
-            js = json.loads(response)
-            if 'object' in js:
-                self.__process_response_object(js, delta_contents)
+            if 'object' in response:
+                self.__process_response_object(response, delta_contents)
             else:
-                self.__process_no_object(js, delta_contents)
+                self.__process_no_object(response, delta_contents)
 
         input_tokens, output_tokens = self.__calculate_tokens_from_content(request, delta_contents)
         return input_tokens, output_tokens

evalscope/perf/plugin/datasets/__init__.py

@@ -1,7 +1,10 @@
-from evalscope.perf.plugin.datasets.custom import CustomDatasetPlugin
-from evalscope.perf.plugin.datasets.flickr8k import FlickrDatasetPlugin
-from evalscope.perf.plugin.datasets.line_by_line import LineByLineDatasetPlugin
-from evalscope.perf.plugin.datasets.longalpaca import LongAlpacaDatasetPlugin
-from evalscope.perf.plugin.datasets.openqa import OpenqaDatasetPlugin
-from evalscope.perf.plugin.datasets.random_dataset import RandomDatasetPlugin
-from evalscope.perf.plugin.datasets.speed_benchmark import SpeedBenchmarkDatasetPlugin, SpeedBenchmarkLongDatasetPlugin
+from .base import DatasetPluginBase
+from .custom import CustomDatasetPlugin
+from .flickr8k import FlickrDatasetPlugin
+from .kontext_bench import KontextDatasetPlugin
+from .line_by_line import LineByLineDatasetPlugin
+from .longalpaca import LongAlpacaDatasetPlugin
+from .openqa import OpenqaDatasetPlugin
+from .random_dataset import RandomDatasetPlugin
+from .random_vl_dataset import RandomVLDatasetPlugin
+from .speed_benchmark import SpeedBenchmarkDatasetPlugin, SpeedBenchmarkLongDatasetPlugin

evalscope/perf/plugin/datasets/base.py

@@ -1,7 +1,7 @@
 import json
 import sys
 from abc import abstractmethod
-from typing import Any, Dict, Iterator, List, Tuple
+from typing import Any, Dict, Iterator, List, Tuple, Union
 
 from evalscope.perf.arguments import Arguments
 
@@ -64,3 +64,24 @@ class DatasetPluginBase:
         data = json.loads(content)
         for item in data:
             yield item
+
+    def create_message(self, text: str, image_urls: Union[List[str], str] = None, role: str = 'user') -> Dict:
+        """Create a message with text and optional image URLs.
+
+        Args:
+            text (str): The text content of the message.
+            image_urls (List[str], optional): List of image URLs. Defaults to None.
+            role (str, optional): The role of the message sender. Defaults to "user".
+
+        Returns:
+            Dict: A dictionary representing the message.
+        """
+        if image_urls is None:
+            message = {'role': role, 'content': text}
+        else:
+            message = {'role': role, 'content': [{'type': 'text', 'text': text}]}
+            if isinstance(image_urls, str):
+                image_urls = [image_urls]
+            for url in image_urls:
+                message['content'].append({'type': 'image_url', 'image_url': {'url': url}})
+        return message

evalscope/perf/plugin/datasets/custom.py

@@ -19,7 +19,8 @@ class CustomDatasetPlugin(DatasetPluginBase):
             if len(prompt) > self.query_parameters.min_prompt_length and len(
                     prompt) < self.query_parameters.max_prompt_length:
                 if self.query_parameters.apply_chat_template:
-                    yield [{'role': 'user', 'content': prompt}]
+                    message = self.create_message(prompt)
+                    yield [message]
                 else:
                     yield prompt
 

evalscope/perf/plugin/datasets/flickr8k.py

@@ -1,18 +1,9 @@
-import base64
-from io import BytesIO
-from PIL import Image
 from typing import Any, Dict, Iterator, List
 
 from evalscope.perf.arguments import Arguments
 from evalscope.perf.plugin.datasets.base import DatasetPluginBase
 from evalscope.perf.plugin.registry import register_dataset
-
-
-def PIL_to_base64(image: Image.Image) -> str:
-    buffered = BytesIO()
-    image.save(buffered, format='JPEG')
-    img_str = base64.b64encode(buffered.getvalue()).decode('utf-8')
-    return img_str
+from evalscope.utils.io_utils import PIL_to_base64
 
 
 @register_dataset('flickr8k')
@@ -31,21 +22,7 @@ class FlickrDatasetPlugin(DatasetPluginBase):
         for item in dataset:
             pil_image = item['jpg']
             text = item['txt']
-            base64_iamge = PIL_to_base64(pil_image)
+            base64_image = PIL_to_base64(pil_image)
 
-            yield [{
-                'role':
-                'user',
-                'content': [
-                    {
-                        'type': 'text',
-                        'text': text,
-                    },
-                    {
-                        'type': 'image_url',
-                        'image_url': {
-                            'url': f'data:image/jpeg;base64,{base64_iamge}',
-                        }
-                    },
-                ],
-            }]
+            message = self.create_message(text=text, image_url=f'data:image/jpeg;base64,{base64_image}')
+            yield [message]

evalscope/perf/plugin/datasets/kontext_bench.py

@@ -0,0 +1,28 @@
+from typing import Any, Dict, Iterator, List
+
+from evalscope.perf.arguments import Arguments
+from evalscope.perf.plugin.datasets.base import DatasetPluginBase
+from evalscope.perf.plugin.registry import register_dataset
+from evalscope.utils.io_utils import PIL_to_base64
+
+
+@register_dataset('kontext_bench')
+class KontextDatasetPlugin(DatasetPluginBase):
+    """Read dataset and return prompt.
+    Datasets: https://modelscope.cn/datasets/black-forest-labs/kontext-bench/dataPeview
+    """
+
+    def __init__(self, query_parameters: Arguments):
+        super().__init__(query_parameters)
+
+    def build_messages(self) -> Iterator[List[Dict]]:
+        from modelscope.msdatasets import MsDataset
+        dataset = MsDataset.load('black-forest-labs/kontext-bench', subset_name='default', split='test')
+
+        for item in dataset:
+            pil_image = item['image']
+            text = item['instruction']
+            base64_image = PIL_to_base64(pil_image)
+
+            message = self.create_message(text=text, image_url=f'data:image/jpeg;base64,{base64_image}')
+            yield [message]