feat(core): APP use new SDK component (#1050)

dbgpt/app/openapi/api_v1/api_v1.py

@@ -1,50 +1,39 @@
-import json
-import uuid
 import asyncio
-import os
-import aiofiles
 import logging
-from fastapi import (
-    APIRouter,
-    File,
-    UploadFile,
-    Body,
-    Depends,
-)
-
-from fastapi.responses import StreamingResponse
-from typing import List, Optional
+import os
+import uuid
 from concurrent.futures import Executor
+from typing import List, Optional
+
+import aiofiles
+from fastapi import APIRouter, Body, Depends, File, UploadFile
+from fastapi.responses import StreamingResponse
 
-from dbgpt.component import ComponentType
-from dbgpt.app.openapi.api_view_model import (
-    Result,
-    ConversationVo,
-    MessageVo,
-    ChatSceneVo,
-    ChatCompletionResponseStreamChoice,
-    DeltaMessage,
-    ChatCompletionStreamResponse,
-)
-from dbgpt.datasource.db_conn_info import DBConfig, DbTypeInfo
 from dbgpt._private.config import Config
-from dbgpt.app.knowledge.service import KnowledgeService
 from dbgpt.app.knowledge.request.request import KnowledgeSpaceRequest
-
-from dbgpt.app.scene import BaseChat, ChatScene, ChatFactory
-from dbgpt.core.interface.message import OnceConversation
+from dbgpt.app.knowledge.service import KnowledgeService
+from dbgpt.app.openapi.api_view_model import (
+    ChatCompletionResponseStreamChoice,
+    ChatCompletionStreamResponse,
+    ChatSceneVo,
+    ConversationVo,
+    DeltaMessage,
+    MessageVo,
+    Result,
+)
+from dbgpt.app.scene import BaseChat, ChatFactory, ChatScene
+from dbgpt.component import ComponentType
 from dbgpt.configs.model_config import KNOWLEDGE_UPLOAD_ROOT_PATH
-from dbgpt.rag.summary.db_summary_client import DBSummaryClient
-from dbgpt.storage.chat_history.chat_hisotry_factory import ChatHistory
-from dbgpt.model.cluster import BaseModelController, WorkerManager, WorkerManagerFactory
+from dbgpt.datasource.db_conn_info import DBConfig, DbTypeInfo
 from dbgpt.model.base import FlatSupportedModel
-from dbgpt.util.tracer import root_tracer, SpanType
+from dbgpt.model.cluster import BaseModelController, WorkerManager, WorkerManagerFactory
+from dbgpt.rag.summary.db_summary_client import DBSummaryClient
 from dbgpt.util.executor_utils import (
+    DefaultExecutorFactory,
     ExecutorFactory,
     blocking_func_to_async,
-    DefaultExecutorFactory,
 )
-
+from dbgpt.util.tracer import SpanType, root_tracer
 
 router = APIRouter()
 CFG = Config()
@@ -201,47 +190,6 @@ async def db_support_types():
     return Result[DbTypeInfo].succ(db_type_infos)
 
 
-@router.get("/v1/chat/dialogue/list", response_model=Result[ConversationVo])
-async def dialogue_list(
-    user_name: str = None, user_id: str = None, sys_code: str = None
-):
-    dialogues: List = []
-    chat_history_service = ChatHistory()
-    # TODO Change the synchronous call to the asynchronous call
-    user_name = user_name or user_id
-    datas = chat_history_service.get_store_cls().conv_list(user_name, sys_code)
-    for item in datas:
-        conv_uid = item.get("conv_uid")
-        summary = item.get("summary")
-        chat_mode = item.get("chat_mode")
-        model_name = item.get("model_name", CFG.LLM_MODEL)
-        user_name = item.get("user_name")
-        sys_code = item.get("sys_code")
-        if not item.get("messages"):
-            # Skip the empty messages
-            # TODO support new conversation and message mode
-            continue
-
-        messages = json.loads(item.get("messages"))
-        last_round = max(messages, key=lambda x: x["chat_order"])
-        if "param_value" in last_round:
-            select_param = last_round["param_value"]
-        else:
-            select_param = ""
-        conv_vo: ConversationVo = ConversationVo(
-            conv_uid=conv_uid,
-            user_input=summary,
-            chat_mode=chat_mode,
-            model_name=model_name,
-            select_param=select_param,
-            user_name=user_name,
-            sys_code=sys_code,
-        )
-        dialogues.append(conv_vo)
-
-    return Result[ConversationVo].succ(dialogues[:10])
-
-
 @router.post("/v1/chat/dialogue/scenes", response_model=Result[List[ChatSceneVo]])
 async def dialogue_scenes():
     scene_vos: List[ChatSceneVo] = []
@@ -265,19 +213,6 @@ async def dialogue_scenes():
     return Result.succ(scene_vos)
 
 
-@router.post("/v1/chat/dialogue/new", response_model=Result[ConversationVo])
-async def dialogue_new(
-    chat_mode: str = ChatScene.ChatNormal.value(),
-    user_name: str = None,
-    # TODO remove user id
-    user_id: str = None,
-    sys_code: str = None,
-):
-    user_name = user_name or user_id
-    conv_vo = __new_conversation(chat_mode, user_name, sys_code)
-    return Result.succ(conv_vo)
-
-
 @router.post("/v1/chat/mode/params/list", response_model=Result[dict])
 async def params_list(chat_mode: str = ChatScene.ChatNormal.value()):
     if ChatScene.ChatWithDbQA.value() == chat_mode:
@@ -334,37 +269,11 @@ async def params_load(
         return Result.failed(code="E000X", msg=f"File Load Error {str(e)}")
 
 
-@router.post("/v1/chat/dialogue/delete")
-async def dialogue_delete(con_uid: str):
-    history_fac = ChatHistory()
-    history_mem = history_fac.get_store_instance(con_uid)
-    # TODO Change the synchronous call to the asynchronous call
-    history_mem.delete()
-    return Result.succ(None)
-
-
 def get_hist_messages(conv_uid: str):
-    message_vos: List[MessageVo] = []
-    history_fac = ChatHistory()
-    history_mem = history_fac.get_store_instance(conv_uid)
+    from dbgpt.serve.conversation.serve import Service as ConversationService
 
-    history_messages: List[OnceConversation] = history_mem.get_messages()
-    if history_messages:
-        for once in history_messages:
-            model_name = once.get("model_name", CFG.LLM_MODEL)
-            once_message_vos = [
-                message2Vo(element, once["chat_order"], model_name)
-                for element in once["messages"]
-            ]
-            message_vos.extend(once_message_vos)
-    return message_vos
-
-
-@router.get("/v1/chat/dialogue/messages/history", response_model=Result[MessageVo])
-async def dialogue_history_messages(con_uid: str):
-    print(f"dialogue_history_messages:{con_uid}")
-    # TODO Change the synchronous call to the asynchronous call
-    return Result.succ(get_hist_messages(con_uid))
+    instance: ConversationService = ConversationService.get_instance(CFG.SYSTEM_APP)
+    return instance.get_history_messages({"conv_uid": conv_uid})
 
 
 async def get_chat_instance(dialogue: ConversationVo = Body()) -> BaseChat:
@@ -378,9 +287,7 @@ async def get_chat_instance(dialogue: ConversationVo = Body()) -> BaseChat:
         dialogue.conv_uid = conv_vo.conv_uid
 
     if not ChatScene.is_valid_mode(dialogue.chat_mode):
-        raise StopAsyncIteration(
-            Result.failed("Unsupported Chat Mode," + dialogue.chat_mode + "!")
-        )
+        raise StopAsyncIteration(f"Unsupported Chat Mode,{dialogue.chat_mode}!")
 
     chat_param = {
         "chat_session_id": dialogue.conv_uid,
@@ -405,7 +312,7 @@ async def chat_prepare(dialogue: ConversationVo = Body()):
     logger.info(f"chat_prepare:{dialogue}")
     ## check conv_uid
     chat: BaseChat = await get_chat_instance(dialogue)
-    if len(chat.history_message) > 0:
+    if chat.has_history_messages():
         return Result.succ(None)
     resp = await chat.prepare()
     return Result.succ(resp)