feature: 加入GPT4-Turbo和GPT4-Vision支持 #927 #929

ChuanhuChatbot.py

@@ -578,7 +578,7 @@ with gr.Blocks(theme=small_and_beautiful_theme) as demo:
 
     # submitBtn.click(auto_name_chat_history, [current_model, user_question, chatbot, user_name], [historySelectList], show_progress=False)
 
-    index_files.change(handle_file_upload, [current_model, index_files, chatbot, language_select_dropdown], [
+    index_files.upload(handle_file_upload, [current_model, index_files, chatbot, language_select_dropdown], [
                        index_files, chatbot, status_display])
     summarize_btn.click(handle_summarize_index, [
                         current_model, index_files, chatbot, language_select_dropdown], [chatbot, status_display])

modules/models/OpenAI.py

@@ -26,7 +26,7 @@ class OpenAIClient(BaseLLMModel):
         user_name=""
     ) -> None:
         super().__init__(
-            model_name=model_name,
+            model_name=MODEL_METADATA[model_name]["model_name"],
             temperature=temperature,
             top_p=top_p,
             system_prompt=system_prompt,

modules/models/OpenAIVision.py

@@ -0,0 +1,328 @@
+from __future__ import annotations
+
+import json
+import logging
+import traceback
+import base64
+
+import colorama
+import requests
+from io import BytesIO
+import uuid
+
+import requests
+from PIL import Image
+
+from .. import shared
+from ..config import retrieve_proxy, sensitive_id, usage_limit
+from ..index_func import *
+from ..presets import *
+from ..utils import *
+from .base_model import BaseLLMModel
+
+
+class OpenAIVisionClient(BaseLLMModel):
+    def __init__(
+        self,
+        model_name,
+        api_key,
+        system_prompt=INITIAL_SYSTEM_PROMPT,
+        temperature=1.0,
+        top_p=1.0,
+        user_name=""
+    ) -> None:
+        super().__init__(
+            model_name=MODEL_METADATA[model_name]["model_name"],
+            temperature=temperature,
+            top_p=top_p,
+            system_prompt=system_prompt,
+            user=user_name
+        )
+        self.api_key = api_key
+        self.need_api_key = True
+        self.max_generation_token = 4096
+        self.images = []
+        self._refresh_header()
+
+    def get_answer_stream_iter(self):
+        response = self._get_response(stream=True)
+        if response is not None:
+            iter = self._decode_chat_response(response)
+            partial_text = ""
+            for i in iter:
+                partial_text += i
+                yield partial_text
+        else:
+            yield STANDARD_ERROR_MSG + GENERAL_ERROR_MSG
+
+    def get_answer_at_once(self):
+        response = self._get_response()
+        response = json.loads(response.text)
+        content = response["choices"][0]["message"]["content"]
+        total_token_count = response["usage"]["total_tokens"]
+        return content, total_token_count
+
+    def try_read_image(self, filepath):
+        def is_image_file(filepath):
+            # 判断文件是否为图片
+            valid_image_extensions = [
+                ".jpg", ".jpeg", ".png", ".bmp", ".gif", ".tiff"]
+            file_extension = os.path.splitext(filepath)[1].lower()
+            return file_extension in valid_image_extensions
+        def image_to_base64(image_path):
+            # 打开并加载图片
+            img = Image.open(image_path)
+
+            # 获取图片的宽度和高度
+            width, height = img.size
+
+            # 计算压缩比例，以确保最长边小于4096像素
+            max_dimension = 2048
+            scale_ratio = min(max_dimension / width, max_dimension / height)
+
+            if scale_ratio < 1:
+                # 按压缩比例调整图片大小
+                new_width = int(width * scale_ratio)
+                new_height = int(height * scale_ratio)
+                img = img.resize((new_width, new_height), Image.ANTIALIAS)
+
+            # 将图片转换为jpg格式的二进制数据
+            buffer = BytesIO()
+            if img.mode == "RGBA":
+                img = img.convert("RGB")
+            img.save(buffer, format='JPEG')
+            binary_image = buffer.getvalue()
+
+            # 对二进制数据进行Base64编码
+            base64_image = base64.b64encode(binary_image).decode('utf-8')
+
+            return base64_image
+
+        if is_image_file(filepath):
+            logging.info(f"读取图片文件: {filepath}")
+            base64_image = image_to_base64(filepath)
+            self.images.append({
+                "path": filepath,
+                "base64": base64_image,
+            })
+
+    def handle_file_upload(self, files, chatbot, language):
+        """if the model accepts multi modal input, implement this function"""
+        if files:
+            for file in files:
+                if file.name:
+                    self.try_read_image(file.name)
+        if self.images is not None:
+                chatbot = chatbot + [([image["path"] for image in self.images], None)]
+        return None, chatbot, None
+
+    def prepare_inputs(self, real_inputs, use_websearch, files, reply_language, chatbot):
+        fake_inputs = real_inputs
+        display_append = ""
+        limited_context = False
+        return limited_context, fake_inputs, display_append, real_inputs, chatbot
+
+
+    def count_token(self, user_input):
+        input_token_count = count_token(construct_user(user_input))
+        if self.system_prompt is not None and len(self.all_token_counts) == 0:
+            system_prompt_token_count = count_token(
+                construct_system(self.system_prompt)
+            )
+            return input_token_count + system_prompt_token_count
+        return input_token_count
+
+    def billing_info(self):
+        try:
+            curr_time = datetime.datetime.now()
+            last_day_of_month = get_last_day_of_month(
+                curr_time).strftime("%Y-%m-%d")
+            first_day_of_month = curr_time.replace(day=1).strftime("%Y-%m-%d")
+            usage_url = f"{shared.state.usage_api_url}?start_date={first_day_of_month}&end_date={last_day_of_month}"
+            try:
+                usage_data = self._get_billing_data(usage_url)
+            except Exception as e:
+                # logging.error(f"获取API使用情况失败: " + str(e))
+                if "Invalid authorization header" in str(e):
+                    return i18n("**获取API使用情况失败**，需在填写`config.json`中正确填写sensitive_id")
+                elif "Incorrect API key provided: sess" in str(e):
+                    return i18n("**获取API使用情况失败**，sensitive_id错误或已过期")
+                return i18n("**获取API使用情况失败**")
+            # rounded_usage = "{:.5f}".format(usage_data["total_usage"] / 100)
+            rounded_usage = round(usage_data["total_usage"] / 100, 5)
+            usage_percent = round(usage_data["total_usage"] / usage_limit, 2)
+            from ..webui import get_html
+
+            # return i18n("**本月使用金额** ") + f"\u3000 ${rounded_usage}"
+            return get_html("billing_info.html").format(
+                    label = i18n("本月使用金额"),
+                    usage_percent = usage_percent,
+                    rounded_usage = rounded_usage,
+                    usage_limit = usage_limit
+                )
+        except requests.exceptions.ConnectTimeout:
+            status_text = (
+                STANDARD_ERROR_MSG + CONNECTION_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
+            )
+            return status_text
+        except requests.exceptions.ReadTimeout:
+            status_text = STANDARD_ERROR_MSG + READ_TIMEOUT_MSG + ERROR_RETRIEVE_MSG
+            return status_text
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            logging.error(i18n("获取API使用情况失败:") + str(e))
+            return STANDARD_ERROR_MSG + ERROR_RETRIEVE_MSG
+
+    def set_token_upper_limit(self, new_upper_limit):
+        pass
+
+    @shared.state.switching_api_key  # 在不开启多账号模式的时候，这个装饰器不会起作用
+    def _get_response(self, stream=False):
+        openai_api_key = self.api_key
+        system_prompt = self.system_prompt
+        history = self.history
+        if self.images:
+            self.history[-1]["content"] = [
+                {"type": "text", "text": self.history[-1]["content"]},
+                *[{"type": "image_url", "image_url": "data:image/jpeg;base64,"+image["base64"]} for image in self.images]
+            ]
+            self.images = []
+        logging.debug(colorama.Fore.YELLOW +
+                      f"{history}" + colorama.Fore.RESET)
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {openai_api_key}",
+        }
+
+        if system_prompt is not None:
+            history = [construct_system(system_prompt), *history]
+
+        payload = {
+            "model": self.model_name,
+            "messages": history,
+            "temperature": self.temperature,
+            "top_p": self.top_p,
+            "n": self.n_choices,
+            "stream": stream,
+            "presence_penalty": self.presence_penalty,
+            "frequency_penalty": self.frequency_penalty,
+        }
+
+        if self.max_generation_token is not None:
+            payload["max_tokens"] = self.max_generation_token
+        if self.stop_sequence is not None:
+            payload["stop"] = self.stop_sequence
+        if self.logit_bias is not None:
+            payload["logit_bias"] = self.logit_bias
+        if self.user_identifier:
+            payload["user"] = self.user_identifier
+
+        if stream:
+            timeout = TIMEOUT_STREAMING
+        else:
+            timeout = TIMEOUT_ALL
+
+        # 如果有自定义的api-host，使用自定义host发送请求，否则使用默认设置发送请求
+        if shared.state.chat_completion_url != CHAT_COMPLETION_URL:
+            logging.debug(f"使用自定义API URL: {shared.state.chat_completion_url}")
+
+        with retrieve_proxy():
+            try:
+                response = requests.post(
+                    shared.state.chat_completion_url,
+                    headers=headers,
+                    json=payload,
+                    stream=stream,
+                    timeout=timeout,
+                )
+            except:
+                traceback.print_exc()
+                return None
+        return response
+
+    def _refresh_header(self):
+        self.headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {sensitive_id}",
+        }
+
+
+    def _get_billing_data(self, billing_url):
+        with retrieve_proxy():
+            response = requests.get(
+                billing_url,
+                headers=self.headers,
+                timeout=TIMEOUT_ALL,
+            )
+
+        if response.status_code == 200:
+            data = response.json()
+            return data
+        else:
+            raise Exception(
+                f"API request failed with status code {response.status_code}: {response.text}"
+            )
+
+    def _decode_chat_response(self, response):
+        error_msg = ""
+        for chunk in response.iter_lines():
+            if chunk:
+                chunk = chunk.decode()
+                chunk_length = len(chunk)
+                try:
+                    chunk = json.loads(chunk[6:])
+                except:
+                    print(i18n("JSON解析错误,收到的内容: ") + f"{chunk}")
+                    error_msg += chunk
+                    continue
+                try:
+                    if chunk_length > 6 and "delta" in chunk["choices"][0]:
+                        if "finish_details" in chunk["choices"][0]:
+                            finish_reason = chunk["choices"][0]["finish_details"]
+                        else:
+                            finish_reason = chunk["finish_details"]
+                        if finish_reason == "stop":
+                            break
+                        try:
+                            yield chunk["choices"][0]["delta"]["content"]
+                        except Exception as e:
+                            # logging.error(f"Error: {e}")
+                            continue
+                except:
+                    traceback.print_exc()
+                    print(f"ERROR: {chunk}")
+                    continue
+        if error_msg and not error_msg=="data: [DONE]":
+            raise Exception(error_msg)
+
+    def set_key(self, new_access_key):
+        ret = super().set_key(new_access_key)
+        self._refresh_header()
+        return ret
+
+    def _single_query_at_once(self, history, temperature=1.0):
+        timeout = TIMEOUT_ALL
+        headers = {
+            "Content-Type": "application/json",
+            "Authorization": f"Bearer {self.api_key}",
+            "temperature": f"{temperature}",
+        }
+        payload = {
+            "model": self.model_name,
+            "messages": history,
+        }
+        # 如果有自定义的api-host，使用自定义host发送请求，否则使用默认设置发送请求
+        if shared.state.chat_completion_url != CHAT_COMPLETION_URL:
+            logging.debug(f"使用自定义API URL: {shared.state.chat_completion_url}")
+
+        with retrieve_proxy():
+            response = requests.post(
+                shared.state.chat_completion_url,
+                headers=headers,
+                json=payload,
+                stream=False,
+                timeout=timeout,
+            )
+
+        return response

modules/models/base_model.py

@@ -147,6 +147,7 @@ class ModelType(Enum):
     OpenAIInstruct = 13
     Claude = 14
     Qwen = 15
+    OpenAIVision = 16
 
     @classmethod
     def get_type(cls, model_name: str):
@@ -155,6 +156,8 @@ class ModelType(Enum):
         if "gpt" in model_name_lower:
             if "instruct" in model_name_lower:
                 model_type = ModelType.OpenAIInstruct
+            elif "vision" in model_name_lower:
+                model_type = ModelType.OpenAIVision
             else:
                 model_type = ModelType.OpenAI
         elif "chatglm" in model_name_lower:
@@ -210,7 +213,7 @@ class BaseLLMModel:
         self.model_name = model_name
         self.model_type = ModelType.get_type(model_name)
         try:
-            self.token_upper_limit = MODEL_TOKEN_LIMIT[model_name]
+            self.token_upper_limit = MODEL_METADATA[model_name]["token_limit"]
         except KeyError:
             self.token_upper_limit = DEFAULT_TOKEN_LIMIT
         self.interrupted = False
@@ -353,10 +356,12 @@ class BaseLLMModel:
         return chatbot, status
 
     def prepare_inputs(self, real_inputs, use_websearch, files, reply_language, chatbot, load_from_cache_if_possible=True):
-        fake_inputs = None
         display_append = []
         limited_context = False
-        fake_inputs = real_inputs
+        if type(real_inputs) == list:
+            fake_inputs = real_inputs[0]['text']
+        else:
+            fake_inputs = real_inputs
         if files:
             from langchain.embeddings.huggingface import HuggingFaceEmbeddings
             from langchain.vectorstores.base import VectorStoreRetriever
@@ -372,24 +377,32 @@ class BaseLLMModel:
                                                  "k": 6, "score_threshold": 0.5})
                 try:
                     relevant_documents = retriever.get_relevant_documents(
-                        real_inputs)
+                        fake_inputs)
                 except AssertionError:
-                    return self.prepare_inputs(real_inputs, use_websearch, files, reply_language, chatbot, load_from_cache_if_possible=False)
+                    return self.prepare_inputs(fake_inputs, use_websearch, files, reply_language, chatbot, load_from_cache_if_possible=False)
             reference_results = [[d.page_content.strip("�"), os.path.basename(
                 d.metadata["source"])] for d in relevant_documents]
             reference_results = add_source_numbers(reference_results)
             display_append = add_details(reference_results)
             display_append = "\n\n" + "".join(display_append)
-            real_inputs = (
-                replace_today(PROMPT_TEMPLATE)
-                .replace("{query_str}", real_inputs)
-                .replace("{context_str}", "\n\n".join(reference_results))
-                .replace("{reply_language}", reply_language)
-            )
+            if type(real_inputs) == list:
+                real_inputs[0]["text"] = (
+                    replace_today(PROMPT_TEMPLATE)
+                    .replace("{query_str}", fake_inputs)
+                    .replace("{context_str}", "\n\n".join(reference_results))
+                    .replace("{reply_language}", reply_language)
+                )
+            else:
+                real_inputs = (
+                    replace_today(PROMPT_TEMPLATE)
+                    .replace("{query_str}", real_inputs)
+                    .replace("{context_str}", "\n\n".join(reference_results))
+                    .replace("{reply_language}", reply_language)
+                )
         elif use_websearch:
             search_results = []
             with DDGS() as ddgs:
-                ddgs_gen = ddgs.text(real_inputs, backend="lite")
+                ddgs_gen = ddgs.text(fake_inputs, backend="lite")
                 for r in islice(ddgs_gen, 10):
                     search_results.append(r)
             reference_results = []
@@ -405,12 +418,20 @@ class BaseLLMModel:
             # display_append = "<ol>\n\n" + "".join(display_append) + "</ol>"
             display_append = '<div class = "source-a">' + \
                 "".join(display_append) + '</div>'
-            real_inputs = (
-                replace_today(WEBSEARCH_PTOMPT_TEMPLATE)
-                .replace("{query}", real_inputs)
-                .replace("{web_results}", "\n\n".join(reference_results))
-                .replace("{reply_language}", reply_language)
-            )
+            if type(real_inputs) == list:
+                real_inputs[0]["text"] = (
+                    replace_today(WEBSEARCH_PTOMPT_TEMPLATE)
+                    .replace("{query}", fake_inputs)
+                    .replace("{web_results}", "\n\n".join(reference_results))
+                    .replace("{reply_language}", reply_language)
+                )
+            else:
+                real_inputs = (
+                    replace_today(WEBSEARCH_PTOMPT_TEMPLATE)
+                    .replace("{query}", fake_inputs)
+                    .replace("{web_results}", "\n\n".join(reference_results))
+                    .replace("{reply_language}", reply_language)
+                )
         else:
             display_append = ""
         return limited_context, fake_inputs, display_append, real_inputs, chatbot
@@ -427,12 +448,21 @@ class BaseLLMModel:
     ):  # repetition_penalty, top_k
 
         status_text = "开始生成回答……"
-        logging.info(
-            "用户" + f"{self.user_identifier}" + "的输入为：" +
-            colorama.Fore.BLUE + f"{inputs}" + colorama.Style.RESET_ALL
-        )
+        if type(inputs) == list:
+                logging.info(
+                "用户" + f"{self.user_identifier}" + "的输入为：" +
+                colorama.Fore.BLUE + "(" + str(len(inputs)-1) + " images) " + f"{inputs[0]['text']}" + colorama.Style.RESET_ALL
+            )
+        else:
+            logging.info(
+                "用户" + f"{self.user_identifier}" + "的输入为：" +
+                colorama.Fore.BLUE + f"{inputs}" + colorama.Style.RESET_ALL
+            )
         if should_check_token_count:
-            yield chatbot + [(inputs, "")], status_text
+            if type(inputs) == list:
+                 yield chatbot + [(inputs[0]['text'], "")], status_text
+            else:
+                yield chatbot + [(inputs, "")], status_text
         if reply_language == "跟随问题语言（不稳定）":
             reply_language = "the same language as the question, such as English, 中文, 日本語, Español, Français, or Deutsch."
 
@@ -447,25 +477,28 @@ class BaseLLMModel:
         ):
             status_text = STANDARD_ERROR_MSG + NO_APIKEY_MSG
             logging.info(status_text)
-            chatbot.append((inputs, ""))
+            chatbot.append((fake_inputs, ""))
             if len(self.history) == 0:
-                self.history.append(construct_user(inputs))
+                self.history.append(construct_user(fake_inputs))
                 self.history.append("")
                 self.all_token_counts.append(0)
             else:
-                self.history[-2] = construct_user(inputs)
-            yield chatbot + [(inputs, "")], status_text
+                self.history[-2] = construct_user(fake_inputs)
+            yield chatbot + [(fake_inputs, "")], status_text
             return
-        elif len(inputs.strip()) == 0:
+        elif len(fake_inputs.strip()) == 0:
             status_text = STANDARD_ERROR_MSG + NO_INPUT_MSG
             logging.info(status_text)
-            yield chatbot + [(inputs, "")], status_text
+            yield chatbot + [(fake_inputs, "")], status_text
             return
 
         if self.single_turn:
             self.history = []
             self.all_token_counts = []
-        self.history.append(construct_user(inputs))
+        if type(inputs) == list:
+            self.history.append(inputs)
+        else:
+            self.history.append(construct_user(inputs))
 
         try:
             if stream:
@@ -492,7 +525,7 @@ class BaseLLMModel:
             status_text = STANDARD_ERROR_MSG + beautify_err_msg(str(e))
             yield chatbot, status_text
 
-        if len(self.history) > 1 and self.history[-1]["content"] != inputs:
+        if len(self.history) > 1 and self.history[-1]["content"] != fake_inputs:
             logging.info(
                 "回答为："
                 + colorama.Fore.BLUE
@@ -702,6 +735,8 @@ class BaseLLMModel:
     def auto_name_chat_history(self, name_chat_method, user_question, chatbot, user_name, single_turn_checkbox):
         if len(self.history) == 2 and not single_turn_checkbox:
             user_question = self.history[0]["content"]
+            if type(user_question) == list:
+                user_question = user_question[0]["text"]
             filename = replace_special_symbols(user_question)[:16] + ".json"
             return self.rename_chat_history(filename, chatbot, user_name)
         else:

modules/models/models.py

@@ -53,6 +53,12 @@ def get_model(
             access_key = os.environ.get("OPENAI_API_KEY", access_key)
             model = OpenAI_Instruct_Client(
                 model_name, api_key=access_key, user_name=user_name)
+        elif model_type == ModelType.OpenAIVision:
+            logging.info(f"正在加载OpenAI Vision模型: {model_name}")
+            from .OpenAIVision import OpenAIVisionClient
+            access_key = os.environ.get("OPENAI_API_KEY", access_key)
+            model = OpenAIVisionClient(
+                model_name, api_key=access_key, user_name=user_name)
         elif model_type == ModelType.ChatGLM:
             logging.info(f"正在加载ChatGLM模型: {model_name}")
             from .ChatGLM import ChatGLM_Client

modules/overwrites.py

@@ -44,32 +44,36 @@ def postprocess_chat_messages(
     ) -> str | dict | None:
         if chat_message is None:
             return None
-        elif isinstance(chat_message, (tuple, list)):
-            file_uri = chat_message[0]
-            if utils.validate_url(file_uri):
-                filepath = file_uri
-            else:
-                filepath = self.make_temp_copy_if_needed(file_uri)
-
-            mime_type = client_utils.get_mimetype(filepath)
-            return {
-                "name": filepath,
-                "mime_type": mime_type,
-                "alt_text": chat_message[1] if len(chat_message) > 1 else None,
-                "data": None,  # These last two fields are filled in by the frontend
-                "is_file": True,
-            }
-        elif isinstance(chat_message, str):
-            # chat_message = inspect.cleandoc(chat_message)
-            # escape html spaces
-            # chat_message = chat_message.replace(" ", " ")
-            if role == "bot":
-                chat_message = convert_bot_before_marked(chat_message)
-            elif role == "user":
-                chat_message = convert_user_before_marked(chat_message)
-            return chat_message
         else:
-            raise ValueError(f"Invalid message for Chatbot component: {chat_message}")
+            if isinstance(chat_message, (tuple, list)):
+                if len(chat_message) > 0 and "text" in chat_message[0]:
+                    chat_message = chat_message[0]["text"]
+                else:
+                    file_uri = chat_message[0]
+                    if utils.validate_url(file_uri):
+                        filepath = file_uri
+                    else:
+                        filepath = self.make_temp_copy_if_needed(file_uri)
+
+                    mime_type = client_utils.get_mimetype(filepath)
+                    return {
+                        "name": filepath,
+                        "mime_type": mime_type,
+                        "alt_text": chat_message[1] if len(chat_message) > 1 else None,
+                        "data": None,  # These last two fields are filled in by the frontend
+                        "is_file": True,
+                    }
+            if isinstance(chat_message, str):
+                # chat_message = inspect.cleandoc(chat_message)
+                # escape html spaces
+                # chat_message = chat_message.replace(" ", " ")
+                if role == "bot":
+                    chat_message = convert_bot_before_marked(chat_message)
+                elif role == "user":
+                    chat_message = convert_user_before_marked(chat_message)
+                return chat_message
+            else:
+                raise ValueError(f"Invalid message for Chatbot component: {chat_message}")
 
 
 
@@ -103,4 +107,3 @@ def BlockContext_init(self, *args, **kwargs):
 
 original_BlockContext_init = gr.blocks.BlockContext.__init__
 gr.blocks.BlockContext.__init__ = BlockContext_init
-

modules/presets.py

@@ -51,17 +51,15 @@ CHUANHU_DESCRIPTION = i18n("由Bilibili [土川虎虎虎](https://space.bilibili
 
 
 ONLINE_MODELS = [
-    "gpt-3.5-turbo",
-    "gpt-3.5-turbo-instruct",
-    "gpt-3.5-turbo-16k",
-    "gpt-4",
-    "gpt-3.5-turbo-0301",
-    "gpt-3.5-turbo-0613",
-    "gpt-4-0314",
-    "gpt-4-0613",
-    "gpt-4-32k",
-    "gpt-4-32k-0314",
-    "gpt-4-32k-0613",
+    "GPT3.5 Turbo",
+    "GPT3.5 Turbo Instruct",
+    "GPT3.5 Turbo 16K",
+    "GPT3.5 Turbo 0301",
+    "GPT3.5 Turbo 0613",
+    "GPT4",
+    "GPT4 32K",
+    "GPT4 Turbo",
+    "GPT4 Vision",
     "川虎助理",
     "川虎助理 Pro",
     "GooglePaLM",
@@ -92,7 +90,7 @@ LOCAL_MODELS = [
     "Qwen 14B"
 ]
 
-# Additional metadate for local models
+# Additional metadata for online and local models
 MODEL_METADATA = {
     "Llama-2-7B":{
         "repo_id": "TheBloke/Llama-2-7B-GGUF",
@@ -107,7 +105,47 @@ MODEL_METADATA = {
     },
     "Qwen 14B": {
         "repo_id": "Qwen/Qwen-14B-Chat-Int4",
-    }
+    },
+    "GPT3.5 Turbo": {
+        "model_name": "gpt-3.5-turbo",
+        "token_limit": 4096,
+    },
+    "GPT3.5 Turbo Instruct": {
+        "model_name": "gpt-3.5-turbo-instruct",
+        "token_limit": 4096,
+    },
+    "GPT3.5 Turbo 16K": {
+        "model_name": "gpt-3.5-turbo-16k",
+        "token_limit": 16384,
+    },
+    "GPT3.5 Turbo 0301": {
+        "model_name": "gpt-3.5-turbo-0301",
+        "token_limit": 4096,
+    },
+    "GPT3.5 Turbo 0613": {
+        "model_name": "gpt-3.5-turbo-0613",
+        "token_limit": 4096,
+    },
+    "GPT4": {
+        "model_name": "gpt-4",
+        "token_limit": 8192,
+    },
+    "GPT4 32K": {
+        "model_name": "gpt-4-32k",
+        "token_limit": 32768,
+    },
+    "GPT4 Turbo": {
+        "model_name": "gpt-4-1106-preview",
+        "token_limit": 128000,
+    },
+    "GPT4 Vision": {
+        "model_name": "gpt-4-vision-preview",
+        "token_limit": 128000,
+    },
+    "Claude": {
+        "model_name": "Claude",
+        "token_limit": 4096,
+    },
 }
 
 if os.environ.get('HIDE_LOCAL_MODELS', 'false') == 'true':
@@ -125,20 +163,6 @@ for dir_name in os.listdir("models"):
         if dir_name not in MODELS:
             MODELS.append(dir_name)
 
-MODEL_TOKEN_LIMIT = {
-    "gpt-3.5-turbo": 4096,
-    "gpt-3.5-turbo-16k": 16384,
-    "gpt-3.5-turbo-0301": 4096,
-    "gpt-3.5-turbo-0613": 4096,
-    "gpt-4": 8192,
-    "gpt-4-0314": 8192,
-    "gpt-4-0613": 8192,
-    "gpt-4-32k": 32768,
-    "gpt-4-32k-0314": 32768,
-    "gpt-4-32k-0613": 32768,
-    "Claude": 4096
-}
-
 TOKEN_OFFSET = 1000 # 模型的token上限减去这个值，得到软上限。到达软上限之后，自动尝试减少token占用。
 DEFAULT_TOKEN_LIMIT = 3000 # 默认的token上限
 REDUCE_TOKEN_FACTOR = 0.5 # 与模型token上限想乘，得到目标token数。减少token占用时，将token占用减少到目标token数以下。

web_assets/javascript/ChuanhuChat.js

@@ -45,7 +45,7 @@ let windowWidth = window.innerWidth; // 初始窗口宽度
 
 function addInit() {
     var needInit = {chatbotIndicator, uploaderIndicator};
-    
+
     chatbotIndicator = gradioApp().querySelector('#chuanhu-chatbot > div.wrap');
     uploaderIndicator = gradioApp().querySelector('#upload-index-file > div.wrap');
     chatListIndicator = gradioApp().querySelector('#history-select-dropdown > div.wrap');
@@ -60,7 +60,7 @@ function addInit() {
     chatbotObserver.observe(chatbotIndicator, { attributes: true, childList: true, subtree: true });
     chatListObserver.observe(chatListIndicator, { attributes: true });
     setUploader();
-    
+
     return true;
 }
 
@@ -124,7 +124,7 @@ function initialize() {
     // setHistroyPanel();
     // trainBody.classList.add('hide-body');
 
-    
+
 
     return true;
 }
@@ -213,7 +213,7 @@ function checkModel() {
     checkXMChat();
     function checkGPT() {
         modelValue = model.value;
-        if (modelValue.includes('gpt')) {
+        if (modelValue.toLowerCase().includes('gpt')) {
             gradioApp().querySelector('#header-btn-groups').classList.add('is-gpt');
         } else {
             gradioApp().querySelector('#header-btn-groups').classList.remove('is-gpt');
@@ -365,8 +365,8 @@ function chatbotContentChanged(attempt = 1, force = false) {
                     }
                 }, 200);
             }
-        
-            
+
+
         }, i === 0 ? 0 : 200);
     }
     // 理论上是不需要多次尝试执行的，可惜gradio的bug导致message可能没有渲染完毕，所以尝试500ms后再次执行
@@ -414,7 +414,7 @@ window.addEventListener('resize', ()=>{
     updateVH();
     windowWidth = window.innerWidth;
     setPopupBoxPosition();
-    adjustSide(); 
+    adjustSide();
 });
 window.addEventListener('orientationchange', (event) => {
     updateVH();
@@ -441,13 +441,13 @@ function makeML(str) {
     return l
 }
 let ChuanhuInfo = function () {
-    /* 
-   ________                      __             ________          __ 
+    /*
+   ________                      __             ________          __
   / ____/ /_  __  ______ _____  / /_  __  __   / ____/ /_  ____ _/ /_
  / /   / __ \/ / / / __ `/ __ \/ __ \/ / / /  / /   / __ \/ __ `/ __/
-/ /___/ / / / /_/ / /_/ / / / / / / / /_/ /  / /___/ / / / /_/ / /_  
-\____/_/ /_/\__,_/\__,_/_/ /_/_/ /_/\__,_/   \____/_/ /_/\__,_/\__/  
-                                                                     
+/ /___/ / / / /_/ / /_/ / / / / / / / /_/ /  / /___/ / / / /_/ / /_
+\____/_/ /_/\__,_/\__,_/_/ /_/_/ /_/\__,_/   \____/_/ /_/\__,_/\__/
+
    川虎Chat (Chuanhu Chat) - GUI for ChatGPT API and many LLMs
  */
 }