diff --git a/swift/llm/__init__.py b/swift/llm/__init__.py
index acbcfb6aa..5a3a71bba 100644
--- a/swift/llm/__init__.py
+++ b/swift/llm/__init__.py
@@ -5,15 +5,15 @@
 
 if TYPE_CHECKING:
     # Recommend using `xxx_main`
-    from .infer import (VllmEngine, InferRequest, RequestConfig, InferStats, LmdeployEngine, PtEngine, infer_main,
-                        deploy_main, PtLoRARequest, InferClient)
+    from .infer import (VllmEngine, RequestConfig, InferStats, LmdeployEngine, PtEngine, infer_main, deploy_main,
+                        PtLoRARequest, InferClient)
     from .export import export_main, merge_lora
     from .eval import eval_main
     from .train import sft_main, pt_main, rlhf_main
     from .argument import (EvalArguments, InferArguments, SftArguments, ExportArguments, DeployArguments, RLHFArguments,
                            WebUIArguments, AppUIArguments)
     from .template import (TEMPLATE_MAPPING, Template, Word, get_template, TemplateType, register_template,
-                           TemplateInputs, Messages, TemplateMeta, get_template_meta)
+                           TemplateInputs, Messages, TemplateMeta, get_template_meta, InferRequest)
     from .model import (MODEL_MAPPING, ModelType, get_model_tokenizer, safe_snapshot_download, HfConfigFactory,
                         ModelInfo, ModelMeta, get_model_meta)
     from .dataset import (AlpacaPreprocessor, MessagesPreprocessor, AutoPreprocessor, DatasetName, DATASET_MAPPING,
@@ -29,8 +29,8 @@
     _import_structure = {
         'rlhf': ['rlhf_main'],
         'infer': [
-            'deploy_main', 'VllmEngine', 'InferRequest', 'RequestConfig', 'InferStats', 'LmdeployEngine', 'PtEngine',
-            'infer_main', 'PtLoRARequest', 'InferClient'
+            'deploy_main', 'VllmEngine', 'RequestConfig', 'InferStats', 'LmdeployEngine', 'PtEngine', 'infer_main',
+            'PtLoRARequest', 'InferClient'
         ],
         'export': ['export_main', 'merge_lora'],
         'eval': ['eval_main'],
@@ -41,7 +41,7 @@
         ],
         'template': [
             'TEMPLATE_MAPPING', 'Template', 'Word', 'get_template', 'TemplateType', 'register_template',
-            'TemplateInputs', 'Messages', 'TemplateMeta', 'get_template_meta'
+            'TemplateInputs', 'Messages', 'TemplateMeta', 'get_template_meta', 'InferRequest'
         ],
         'model': [
             'MODEL_MAPPING', 'ModelType', 'get_model_tokenizer', 'safe_snapshot_download', 'HfConfigFactory',
diff --git a/swift/llm/infer/__init__.py b/swift/llm/infer/__init__.py
index c3e3e27eb..fb59de556 100644
--- a/swift/llm/infer/__init__.py
+++ b/swift/llm/infer/__init__.py
@@ -6,7 +6,7 @@
 if TYPE_CHECKING:
     from .infer import infer_main
     from .deploy import deploy_main
-    from .protocol import InferRequest, RequestConfig
+    from .protocol import RequestConfig
     from .infer_engine import (InferEngine, VllmEngine, LmdeployEngine, PtEngine, InferStats, PtLoRARequest,
                                InferClient)
 else:
@@ -14,9 +14,9 @@
     _import_structure = {
         'deploy': ['deploy_main'],
         'infer': ['infer_main'],
-        'protocol': ['InferRequest', 'RequestConfig'],
-        'infer_engine': ['InferEngine', 'VllmEngine', 'LmdeployEngine', 'PtEngine', 'InferStats', 'PtLoRARequest',
-                         'InferClient'],
+        'protocol': ['RequestConfig'],
+        'infer_engine':
+        ['InferEngine', 'VllmEngine', 'LmdeployEngine', 'PtEngine', 'InferStats', 'PtLoRARequest', 'InferClient'],
     }
 
     import sys
diff --git a/swift/llm/infer/client_utils.py b/swift/llm/infer/client_utils.py
deleted file mode 100644
index 6a5eeedb2..000000000
--- a/swift/llm/infer/client_utils.py
+++ /dev/null
@@ -1,293 +0,0 @@
-import os
-import re
-from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Tuple, Union
-
-import aiohttp
-import json
-import requests
-from dacite import from_dict
-from requests.exceptions import HTTPError
-
-from swift.llm import History, Messages
-from swift.llm.infer.protocol import (ChatCompletionResponse, ChatCompletionStreamResponse, CompletionResponse,
-                                      CompletionStreamResponse, ModelList, XRequestConfig)
-
-
-def _get_request_kwargs(api_key: Optional[str] = None) -> Dict[str, Any]:
-    timeout = float(os.getenv('TIMEOUT', '300'))
-    request_kwargs = {}
-    if timeout > 0:
-        request_kwargs['timeout'] = timeout
-    if api_key is not None:
-        request_kwargs['headers'] = {'Authorization': f'Bearer {api_key}'}
-    return request_kwargs
-
-
-def get_model_list_client(host: str = '127.0.0.1', port: str = '8000', api_key: str = 'EMPTY', **kwargs) -> ModelList:
-    url = kwargs.pop('url', None)
-    if url is None:
-        url = f'http://{host}:{port}/v1'
-    url = url.rstrip('/')
-    url = f'{url}/models'
-    resp_obj = requests.get(url, **_get_request_kwargs(api_key)).json()
-    return from_dict(ModelList, resp_obj)
-
-
-async def get_model_list_client_async(host: str = '127.0.0.1',
-                                      port: str = '8000',
-                                      api_key: str = 'EMPTY',
-                                      **kwargs) -> ModelList:
-    url = kwargs.pop('url', None)
-    if url is None:
-        url = f'http://{host}:{port}/v1'
-    url = url.rstrip('/')
-    url = f'{url}/models'
-    async with aiohttp.ClientSession() as session:
-        async with session.get(url, **_get_request_kwargs(api_key)) as resp:
-            resp_obj = await resp.json()
-    return from_dict(ModelList, resp_obj)
-
-
-def _parse_stream_data(data: bytes) -> Optional[str]:
-    data = data.decode(encoding='utf-8')
-    data = data.strip()
-    if len(data) == 0:
-        return
-    assert data.startswith('data:'), f'data: {data}'
-    return data[5:].strip()
-
-
-def compat_openai(messages: Messages, request) -> None:
-    for message in messages:
-        content = message['content']
-        if isinstance(content, list):
-            text = ''
-            for line in content:
-                _type = line['type']
-                value = line[_type]
-                if _type == 'text':
-                    text += value
-                elif _type in {'image_url', 'audio_url', 'video_url'}:
-                    value = value['url']
-                    if value.startswith('data:'):
-                        match_ = re.match(r'data:(.+?);base64,(.+)', value)
-                        assert match_ is not None
-                        value = match_.group(2)
-                    if _type == 'image_url':
-                        text += '<image>'
-                        request.images.append(value)
-                    elif _type == 'audio_url':
-                        text += '<audio>'
-                        request.audios.append(value)
-                    else:
-                        text += '<video>'
-                        request.videos.append(value)
-                else:
-                    raise ValueError(f'line: {line}')
-            message['content'] = text
-
-
-def _pre_inference_client(model_type: str,
-                          query: str,
-                          messages: Optional[Messages] = None,
-                          system: Optional[str] = None,
-                          images: Optional[List[str]] = None,
-                          tools: Optional[List[Dict[str, Union[str, Dict]]]] = None,
-                          tool_choice: Optional[Union[str, Dict]] = 'auto',
-                          *,
-                          model_list: Optional[ModelList] = None,
-                          is_chat_request: Optional[bool] = None,
-                          is_multimodal: Optional[bool] = None,
-                          request_config: Optional[XRequestConfig] = None,
-                          host: str = '127.0.0.1',
-                          port: str = '8000',
-                          **kwargs) -> Tuple[str, Dict[str, Any], bool]:
-    if model_list is not None:
-        for model in model_list.data:
-            if model_type == model.id:
-                if is_chat_request is None:
-                    is_chat_request = model.is_chat
-                if is_multimodal is None:
-                    is_multimodal = model.is_multimodal
-                break
-        else:
-            raise ValueError(f'model_type: {model_type}, model_list: {[model.id for model in model_list.data]}')
-    assert is_chat_request is not None and is_multimodal is not None
-    data = {}
-    request_config_origin = XRequestConfig()
-    for k, v in request_config.__dict__.items():
-        v_origin = getattr(request_config_origin, k)
-        if v != v_origin:
-            data[k] = v
-    url = kwargs.pop('url', None)
-    if url is None:
-        url = f'http://{host}:{port}/v1'
-    url = url.rstrip('/')
-    if is_chat_request:
-        if is_multimodal:
-            messages = convert_to_base64(messages=messages)['messages']
-        data['messages'] = messages
-        url = f'{url}/chat/completions'
-    else:
-        assert system is None and history is None, (
-            'The chat template for text generation does not support system and history.')
-        if is_multimodal:
-            query = convert_to_base64(prompt=query)['prompt']
-        data['prompt'] = query
-        url = f'{url}/completions'
-    data['model'] = model_type
-    for media_key, medias in zip(['images', 'audios', 'videos'], [images, kwargs.get('audios'), kwargs.get('videos')]):
-        if medias:
-            medias = convert_to_base64(images=medias)['images']
-            data[media_key] = medias
-    if tools:
-        data['tools'] = tools
-    if tool_choice and tool_choice != 'auto':
-        data['tool_choice'] = tool_choice
-    return url, data, is_chat_request
-
-
-def inference_client(
-    model_type: str,
-    query: str,
-    history: Optional[History] = None,
-    system: Optional[str] = None,
-    images: Optional[List[str]] = None,
-    tools: Optional[List[Dict[str, Union[str, Dict]]]] = None,
-    tool_choice: Optional[Union[str, Dict]] = 'auto',
-    *,
-    is_chat_request: Optional[bool] = None,
-    is_multimodal: Optional[bool] = None,
-    request_config: Optional[XRequestConfig] = None,
-    host: str = '127.0.0.1',
-    port: str = '8000',
-    api_key: str = 'EMPTY',
-    **kwargs
-) -> Union[ChatCompletionResponse, CompletionResponse, Iterator[ChatCompletionStreamResponse],
-           Iterator[CompletionStreamResponse]]:
-    if request_config is None:
-        request_config = XRequestConfig()
-    model_list = None
-    is_chat_request = is_chat_request or kwargs.get('is_chat')
-    if is_chat_request is None or is_multimodal is None:
-        model_list = get_model_list_client(host, port, api_key=api_key, **kwargs)
-
-    url, data, is_chat_request = _pre_inference_client(
-        model_type,
-        query,
-        history,
-        system,
-        images,
-        tools,
-        tool_choice,
-        model_list=model_list,
-        is_chat_request=is_chat_request,
-        is_multimodal=is_multimodal,
-        request_config=request_config,
-        host=host,
-        port=port,
-        **kwargs)
-
-    if request_config.stream:
-        if is_chat_request:
-            ret_cls = ChatCompletionStreamResponse
-        else:
-            ret_cls = CompletionStreamResponse
-        resp = requests.post(url, json=data, stream=True, **_get_request_kwargs(api_key))
-
-        def _gen_stream() -> Union[Iterator[ChatCompletionStreamResponse], Iterator[CompletionStreamResponse]]:
-            for data in resp.iter_lines():
-                data = _parse_stream_data(data)
-                if data == '[DONE]':
-                    break
-                if data is not None:
-                    resp_obj = json.loads(data)
-                    if resp_obj['object'] == 'error':
-                        raise HTTPError(resp_obj['message'])
-                    yield from_dict(ret_cls, resp_obj)
-
-        return _gen_stream()
-    else:
-        resp_obj = requests.post(url, json=data, **_get_request_kwargs(api_key)).json()
-        if is_chat_request:
-            ret_cls = ChatCompletionResponse
-        else:
-            ret_cls = CompletionResponse
-        if resp_obj['object'] == 'error':
-            raise HTTPError(resp_obj['message'])
-        return from_dict(ret_cls, resp_obj)
-
-
-async def inference_client_async(
-    model_type: str,
-    query: str,
-    history: Optional[History] = None,
-    system: Optional[str] = None,
-    images: Optional[List[str]] = None,
-    tools: Optional[List[Dict[str, Union[str, Dict]]]] = None,
-    tool_choice: Optional[Union[str, Dict]] = 'auto',
-    *,
-    is_chat_request: Optional[bool] = None,
-    is_multimodal: Optional[bool] = None,
-    request_config: Optional[XRequestConfig] = None,
-    host: str = '127.0.0.1',
-    port: str = '8000',
-    api_key: str = 'EMPTY',
-    **kwargs
-) -> Union[ChatCompletionResponse, CompletionResponse, AsyncIterator[ChatCompletionStreamResponse],
-           AsyncIterator[CompletionStreamResponse]]:
-    if request_config is None:
-        request_config = XRequestConfig()
-    model_list = None
-    is_chat_request = is_chat_request or kwargs.get('is_chat')
-    if is_chat_request is None or is_multimodal is None:
-        model_list = await get_model_list_client_async(host, port, api_key=api_key, **kwargs)
-
-    url, data, is_chat_request = _pre_inference_client(
-        model_type,
-        query,
-        history,
-        system,
-        images,
-        tools,
-        tool_choice,
-        model_list=model_list,
-        is_chat_request=is_chat_request,
-        is_multimodal=is_multimodal,
-        request_config=request_config,
-        host=host,
-        port=port,
-        **kwargs)
-
-    if request_config.stream:
-        if is_chat_request:
-            ret_cls = ChatCompletionStreamResponse
-        else:
-            ret_cls = CompletionStreamResponse
-
-        async def _gen_stream(
-        ) -> Union[AsyncIterator[ChatCompletionStreamResponse], AsyncIterator[CompletionStreamResponse]]:
-            async with aiohttp.ClientSession() as session:
-                async with session.post(url, json=data, **_get_request_kwargs(api_key)) as resp:
-                    async for _data in resp.content:
-                        _data = _parse_stream_data(_data)
-                        if _data == '[DONE]':
-                            break
-                        if _data is not None:
-                            resp_obj = json.loads(_data)
-                            if resp_obj['object'] == 'error':
-                                raise HTTPError(resp_obj['message'])
-                            yield from_dict(ret_cls, resp_obj)
-
-        return _gen_stream()
-    else:
-        if is_chat_request:
-            ret_cls = ChatCompletionResponse
-        else:
-            ret_cls = CompletionResponse
-        async with aiohttp.ClientSession() as session:
-            async with session.post(url, json=data, **_get_request_kwargs(api_key)) as resp:
-                resp_obj = await resp.json()
-                if resp_obj['object'] == 'error':
-                    raise HTTPError(resp_obj['message'])
-                return from_dict(ret_cls, resp_obj)
diff --git a/swift/llm/infer/infer.py b/swift/llm/infer/infer.py
index 8cb87da8a..3e526e3b7 100644
--- a/swift/llm/infer/infer.py
+++ b/swift/llm/infer/infer.py
@@ -6,11 +6,11 @@
 
 import numpy as np
 
-from swift.llm import (HfDataset, InferArguments, Messages, SwiftPipeline, Template, get_template, load_dataset,
-                       merge_lora, sample_dataset)
+from swift.llm import (HfDataset, InferArguments, InferRequest, Messages, SwiftPipeline, Template, get_template,
+                       load_dataset, merge_lora, sample_dataset)
 from swift.utils import append_to_jsonl, get_logger
 from .infer_engine import InferEngine
-from .protocol import InferRequest, RequestConfig
+from .protocol import RequestConfig
 
 logger = get_logger()
 
@@ -131,8 +131,8 @@ def run(self) -> List[Dict[str, Any]]:
             result = self.infer_cli()
         else:
             result = self.infer_dataset()
-        if args.result_path is not None:
-            logger.info(f'The inference results have been saved to result_path: `{result_path}`.')
+        if self.result_path is not None:
+            logger.info(f'The inference results have been saved to result_path: `{self.result_path}`.')
         return result
 
     @staticmethod
diff --git a/swift/llm/infer/infer_engine/base.py b/swift/llm/infer/infer_engine/base.py
index 41bf2a1f9..870faae2b 100644
--- a/swift/llm/infer/infer_engine/base.py
+++ b/swift/llm/infer/infer_engine/base.py
@@ -2,8 +2,9 @@
 from abc import ABC, abstractmethod
 from typing import AsyncIterator, Iterator, List, Optional, Union
 
+from swift.llm import InferRequest
 from swift.plugin import Metric
-from ..protocol import ChatCompletionResponse, ChatCompletionStreamResponse, InferRequest, RequestConfig
+from ..protocol import ChatCompletionResponse, ChatCompletionStreamResponse, RequestConfig
 
 
 class BaseInferEngine(ABC):
diff --git a/swift/llm/infer/infer_engine/infer_client.py b/swift/llm/infer/infer_engine/infer_client.py
index 9d88e137c..5cebf11b8 100644
--- a/swift/llm/infer/infer_engine/infer_client.py
+++ b/swift/llm/infer/infer_engine/infer_client.py
@@ -2,6 +2,7 @@
 
 import asyncio
 from copy import deepcopy
+from dataclasses import asdict
 from typing import Any, AsyncIterator, Dict, Iterator, List, Optional, Union
 
 import aiohttp
@@ -10,7 +11,8 @@
 from requests.exceptions import HTTPError
 
 from swift.plugin import Metric
-from ..protocol import ChatCompletionResponse, ChatCompletionStreamResponse, InferRequest, ModelList, RequestConfig
+from ..protocol import (ChatCompletionRequest, ChatCompletionResponse, ChatCompletionStreamResponse, InferRequest,
+                        ModelList, RequestConfig)
 from .infer_engine import InferEngine
 
 
@@ -64,7 +66,7 @@ def infer(
 
     @staticmethod
     def _prepare_request_data(model: str, infer_request: InferRequest, request_config: RequestConfig) -> Dict[str, Any]:
-        pass
+        return asdict(ChatCompletionRequest(model, **asdict(infer_request), **asdict(request_config)))
 
     @staticmethod
     def _parse_stream_data(data: bytes) -> Optional[str]:
diff --git a/swift/llm/infer/infer_engine/infer_engine.py b/swift/llm/infer/infer_engine/infer_engine.py
index 57ed8c8a6..0be59f5d6 100644
--- a/swift/llm/infer/infer_engine/infer_engine.py
+++ b/swift/llm/infer/infer_engine/infer_engine.py
@@ -10,12 +10,12 @@
 from tqdm import tqdm
 from transformers import PreTrainedTokenizerBase
 
-from swift.llm import Template, TemplateInputs, get_model_tokenizer, get_template, load_dataset
+from swift.llm import InferRequest, Template, get_model_tokenizer, get_template
 from swift.llm.template import split_action_action_input
 from swift.plugin import Metric
 from swift.utils import get_logger
 from ..protocol import (ChatCompletionMessageToolCall, ChatCompletionResponse, ChatCompletionStreamResponse, Function,
-                        InferRequest, RequestConfig, UsageInfo)
+                        RequestConfig, UsageInfo)
 from .base import BaseInferEngine
 
 logger = get_logger()
diff --git a/swift/llm/infer/protocol.py b/swift/llm/infer/protocol.py
index ca7cb7a50..037eb4694 100644
--- a/swift/llm/infer/protocol.py
+++ b/swift/llm/infer/protocol.py
@@ -1,13 +1,16 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
+import base64
+import io
+import os
 import time
 import uuid
 from copy import deepcopy
 from dataclasses import asdict, dataclass, field, fields
-from http import HTTPStatus
 from typing import Any, Dict, List, Literal, Optional, Tuple, Union
 
-from swift.llm import TemplateInputs
-from swift.llm.template import Messages, Tool
+from PIL import Image
+
+from swift.llm.template import InferRequest, Messages, Tool
 
 
 def random_uuid() -> str:
@@ -92,12 +95,70 @@ def __post_init__(self):
 
 
 @dataclass
-class CompletionRequest(RequestConfig, CompletionRequestMixin):
+class MultiModalRequestMixin:
+    images: List[str] = field(default_factory=list)
+    audios: List[str] = field(default_factory=list)
+    videos: List[str] = field(default_factory=list)
+
+    @staticmethod
+    def _to_base64(mm_data: Union[str, Image.Image, bytes]) -> str:
+        if isinstance(mm_data, str) and not os.path.isfile(mm_data):
+            # base64 or url
+            return mm_data
+        if isinstance(mm_data, str):
+            # local_path
+            with open(mm_data, 'rb') as f:
+                bytes_ = f.read()
+        elif isinstance(mm_data, Image.Image):
+            bytes_io = io.BytesIO()
+            mm_data.save(bytes_io, format='png')
+            bytes_ = bytes_io.getvalue()
+        else:
+            bytes_ = mm_data
+        img_base64: str = base64.b64encode(bytes_).decode('utf-8')
+        return img_base64
+
+    def convert_to_base64(self):
+        for key in ['images', 'audios', 'videos']:
+            values = getattr(self, key)
+            for i, val in enumerate(values):
+                values[i] = self._to_base64(val)
+
+    def __post_init__(self):
+        self.convert_to_base64()
+
+
+@dataclass
+class CompletionRequest(RequestConfig, MultiModalRequestMixin, CompletionRequestMixin):
     pass
 
 
 @dataclass
-class ChatCompletionRequest(RequestConfig, ChatCompletionRequestMixin):
+class ChatCompletionRequest(RequestConfig, MultiModalRequestMixin, ChatCompletionRequestMixin):
+
+    def _messages_convert_to_base64(self):
+        for message in self.messages:
+            content = message['content']
+            if isinstance(content, str):
+                continue
+            for item in content:
+                key: str = item['type']
+                key_origin = key
+                value = item[key]
+                if key.endswith('_url'):
+                    key = key[:-len('_url')]
+                if isinstance(value, str) and os.path.isfile(value):
+                    suffix = os.path.splitext(value)[1].lower()
+                elif isinstance(value, Image.Image):
+                    suffix = 'jpeg'
+                else:
+                    raise ValueError(f'value: {value}')
+                mm_data_base64 = self._to_base64(value)
+                item[key_origin] = f'data:{key}/{suffix};base64,{mm_data_base64}'
+
+    def convert_to_base64(self):
+        super().convert_to_base64()
+        self._messages_convert_to_base64()
 
     def parse(self) -> Tuple['InferRequest', 'RequestConfig']:
         data = asdict(self)
@@ -239,12 +300,3 @@ class CompletionStreamResponse:
     id: str = field(default_factory=lambda: f'cmpl-{random_uuid()}')
     object: str = 'text_completion.chunk'
     created: int = field(default_factory=lambda: int(time.time()))
-
-
-@dataclass
-class InferRequest(TemplateInputs):
-
-    def remove_response(self):
-        last_role = self.messages[-1]['role']
-        if last_role == 'assistant':
-            self.messages.pop()
diff --git a/swift/llm/template/__init__.py b/swift/llm/template/__init__.py
index 323fd5d20..27b244af0 100644
--- a/swift/llm/template/__init__.py
+++ b/swift/llm/template/__init__.py
@@ -10,5 +10,5 @@
 from .base import Template
 from .constant import TemplateType
 from .register import TEMPLATE_MAPPING, TemplateMeta, get_template, get_template_meta, register_template
-from .template_inputs import Messages, TemplateInputs, Tool
+from .template_inputs import InferRequest, Messages, TemplateInputs, Tool
 from .utils import Word
diff --git a/swift/llm/template/base.py b/swift/llm/template/base.py
index e09eba4bb..c8ae7c462 100644
--- a/swift/llm/template/base.py
+++ b/swift/llm/template/base.py
@@ -1,5 +1,7 @@
 # Copyright (c) Alibaba, Inc. and its affiliates.
+import hashlib
 import inspect
+import os
 import re
 from contextlib import contextmanager
 from functools import partial, wraps
@@ -10,11 +12,11 @@
 import torch.nn.functional as F
 from modelscope import get_logger
 from peft import PeftModel
+from PIL import Image
 from torch.nn.utils.rnn import pad_sequence
 from transformers import PreTrainedTokenizerBase
 from transformers.integrations import is_deepspeed_zero3_enabled
 
-from ..utils import decode_base64
 from .agent import loss_scale_map, split_str_parts_by
 from .template_inputs import StdTemplateInputs, TemplateInputs
 from .utils import Context, ContextType, Prompt, Word, fetch_one, findall
@@ -170,10 +172,20 @@ def _preprocess_objects(self, inputs: StdTemplateInputs, objects: List[Dict[str,
         # Normalize grounding bboxes
         normalize_bbox(objects, images, to_type=self.grounding_type)
         if not self.load_medias:  # fix pt & qwen-vl
-            images = decode_base64(images=images)['images']  # PIL.Image/base64 -> local_path
+            for i, image in enumerate(images):
+                images[i] = self._save_pil_image(image)
         inputs.images = images
         inputs.objects = objects
 
+    @staticmethod
+    def _save_pil_image(image: Image.Image) -> str:
+        img_bytes = image.tobytes()
+        img_hash = hashlib.sha256(img_bytes).hexdigest()
+        img_path = os.path.join('tmp', f'{img_hash}.png')
+        if not os.path.exists(img_path):
+            image.save(img_path)
+        return img_path
+
     @staticmethod
     def _concat_context_list(
             context_list: List[Context],
diff --git a/swift/llm/template/template_inputs.py b/swift/llm/template/template_inputs.py
index b349724a0..7e91b9488 100644
--- a/swift/llm/template/template_inputs.py
+++ b/swift/llm/template/template_inputs.py
@@ -11,7 +11,7 @@
 
 
 @dataclass
-class TemplateInputs:
+class InferRequest:
     """
     messages: Input in messages format.
         Examples: [{
@@ -25,7 +25,6 @@ class TemplateInputs:
                 {"type": "text", "text": "<text>"},
             ],
         }]
-    objects: Used for grounding tasks in a general format.
     tools: Organize tools into the format of tools_prompt for system. for example, 'react_en'.
         Specifying this parameter will override system.
     """
@@ -35,9 +34,26 @@ class TemplateInputs:
     audios: List[str] = field(default_factory=list)
     videos: List[str] = field(default_factory=list)
 
-    objects: Union[str, None, List[Dict[str, Any]]] = None  # List[Dict[str, Any]]
     tools: Optional[List[Tool]] = None
 
+    def remove_response(self):
+        last_role = self.messages[-1]['role']
+        if last_role == 'assistant':
+            self.messages.pop()
+
+    def copy(self):
+        return self.__class__(
+            deepcopy(self.messages), self.images.copy(), self.audios.copy(), self.videos.copy(), deepcopy(self.tools))
+
+
+@dataclass
+class TemplateInputs(InferRequest):
+    """
+    objects: Used for grounding tasks in a general format.
+    """
+
+    objects: Union[str, None, List[Dict[str, Any]]] = None  # List[Dict[str, Any]]
+
     def __post_init__(self):
         # Format objects(groundings/refs) to json
         if isinstance(self.objects, str):
@@ -47,9 +63,9 @@ def __post_init__(self):
             self.objects = []
 
     def copy(self):
-        return self.__class__(
-            deepcopy(self.messages), self.images.copy(), self.audios.copy(), self.videos.copy(), deepcopy(self.objects),
-            deepcopy(self.tools))
+        infer_request = super().copy()
+        return self.__class__(infer_request.messages, infer_request.images, infer_request.audios, infer_request.videos,
+                              infer_request.tools, deepcopy(self.objects))
 
 
 @dataclass
diff --git a/swift/llm/utils/base64.py b/swift/llm/utils/base64.py
index 429ca5e55..0fb1bef37 100644
--- a/swift/llm/utils/base64.py
+++ b/swift/llm/utils/base64.py
@@ -24,24 +24,6 @@ def _decode_prompt(prompt: str, tmp_dir: str = 'tmp') -> str:
     return new_content
 
 
-def _to_base64(img_path: Union[str, Image.Image, bytes]) -> str:
-    if isinstance(img_path, str) and not os.path.isfile(img_path):
-        # base64
-        return img_path
-    if isinstance(img_path, str):
-        # local_path
-        with open(img_path, 'rb') as f:
-            _bytes = f.read()
-    elif isinstance(img_path, Image.Image):
-        bytes_io = BytesIO()
-        img_path.save(bytes_io, format='png')
-        _bytes = bytes_io.getvalue()
-    else:
-        _bytes = img_path
-    img_base64: str = base64.b64encode(_bytes).decode('utf-8')
-    return img_base64
-
-
 def _from_base64(img_base64: Union[str, Image.Image], tmp_dir: str = 'tmp') -> str:
     if isinstance(img_base64, Image.Image):
         img_base64 = _to_base64(img_base64)
@@ -80,42 +62,3 @@ def decode_base64(*,
             res_images.append(image)
         res['images'] = res_images
     return res
-
-
-def _encode_prompt(prompt: str) -> str:
-    pattern = r'<(?:img|audio|video)>(.+?)</(?:img|audio|video)>'
-    match_iter = re.finditer(pattern, prompt)
-    new_prompt = ''
-    idx = 0
-    for m in match_iter:
-        span = m.span(1)
-        path = m.group(1)
-        img_base64 = _to_base64(path)
-        new_prompt += prompt[idx:span[0]] + img_base64
-        idx = span[1]
-    new_prompt += prompt[idx:]
-    return new_prompt
-
-
-def convert_to_base64(*,
-                      messages: Optional['Messages'] = None,
-                      prompt: Optional[str] = None,
-                      images: Optional[List[str]] = None) -> Dict[str, Any]:
-    """local_path -> base64"""
-    res = {}
-    if messages is not None:
-        res_messages = []
-        for m in messages:
-            m_new = deepcopy(m)
-            m_new['content'] = _encode_prompt(m_new['content'])
-            res_messages.append(m_new)
-        res['messages'] = res_messages
-    if prompt is not None:
-        prompt = _encode_prompt(prompt)
-        res['prompt'] = prompt
-    if images is not None:
-        res_images = []
-        for image in images:
-            res_images.append(_to_base64(image))
-        res['images'] = res_images
-    return res