tjdify/api/controllers/console/explore/completion.py

import json
import logging
from collections.abc import Generator
from datetime import UTC, datetime

import requests
from flask import request
from flask_login import current_user  # type: ignore
from flask_restful import Resource, reqparse  # type: ignore
from werkzeug.exceptions import BadRequest, InternalServerError, NotFound

import services
from controllers.console.app.error import (
    AppUnavailableError,
    CompletionRequestError,
    ConversationCompletedError,
    ProviderModelCurrentlyNotSupportError,
    ProviderNotInitializeError,
    ProviderQuotaExceededError,
)
from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
from controllers.console.explore.wraps import InstalledAppResource
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from core.app.apps.base_app_queue_manager import AppQueueManager
from core.app.entities.app_invoke_entities import InvokeFrom
from core.errors.error import (
    ModelCurrentlyNotSupportError,
    ProviderTokenNotInitError,
    QuotaExceededError,
)
from core.model_runtime.errors.invoke import InvokeError
from extensions.ext_database import db
from extensions.ext_redis import redis_client
from libs import helper
from libs.helper import uuid_value, extract_remote_ip
from models.model import AppMode
from services.app_generate_service import AppGenerateService
from services.errors.llm import InvokeRateLimitError
from services.robot_account_service import RobotAccountService, ACCESS_TOKEN_EXPIRY


# define completion api for user
class CompletionApi(InstalledAppResource):
    def post(self, installed_app):
        app_model = installed_app.app
        if app_model.mode != "completion":
            raise NotCompletionAppError()

        parser = reqparse.RequestParser()
        parser.add_argument("inputs", type=dict, required=True, location="json")
        parser.add_argument("query", type=str, location="json", default="")
        parser.add_argument("files", type=list, required=False, location="json")
        parser.add_argument("response_mode", type=str, choices=["blocking", "streaming"], location="json")
        parser.add_argument("retriever_from", type=str, required=False, default="explore_app", location="json")
        args = parser.parse_args()

        streaming = args["response_mode"] == "streaming"
        args["auto_generate_name"] = False

        installed_app.last_used_at = datetime.now(UTC).replace(tzinfo=None)
        db.session.commit()

        try:
            response = AppGenerateService.generate(
                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.EXPLORE, streaming=streaming
            )

            return helper.compact_generate_response(response)
        except services.errors.conversation.ConversationNotExistsError:
            raise NotFound("Conversation Not Exists.")
        except services.errors.conversation.ConversationCompletedError:
            raise ConversationCompletedError()
        except services.errors.app_model_config.AppModelConfigBrokenError:
            logging.exception("App model config broken.")
            raise AppUnavailableError()
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
        except QuotaExceededError:
            raise ProviderQuotaExceededError()
        except ModelCurrentlyNotSupportError:
            raise ProviderModelCurrentlyNotSupportError()
        except InvokeError as e:
            raise CompletionRequestError(e.description)
        except ValueError as e:
            raise e
        except Exception:
            logging.exception("internal server error.")
            raise InternalServerError()


class CompletionStopApi(InstalledAppResource):
    def post(self, installed_app, task_id):
        app_model = installed_app.app
        if app_model.mode != "completion":
            raise NotCompletionAppError()

        AppQueueManager.set_stop_flag(task_id, InvokeFrom.EXPLORE, current_user.id)

        return {"result": "success"}, 200


class ChatApi(InstalledAppResource):
    def post(self, installed_app):
        app_model = installed_app.app
        app_mode = AppMode.value_of(app_model.mode)
        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
            raise NotChatAppError()

        parser = reqparse.RequestParser()
        parser.add_argument("inputs", type=dict, required=True, location="json")
        parser.add_argument("query", type=str, required=True, location="json")
        parser.add_argument("files", type=list, required=False, location="json")
        parser.add_argument("conversation_id", type=uuid_value, location="json")
        parser.add_argument("parent_message_id", type=uuid_value, required=False, location="json")
        parser.add_argument("retriever_from", type=str, required=False, default="explore_app", location="json")
        args = parser.parse_args()

        args["auto_generate_name"] = False

        installed_app.last_used_at = datetime.now(UTC).replace(tzinfo=None)
        db.session.commit()

        try:
            response = AppGenerateService.generate(
                app_model=app_model, user=current_user, args=args, invoke_from=InvokeFrom.EXPLORE, streaming=True
            )

            return helper.compact_generate_response(response)
        except services.errors.conversation.ConversationNotExistsError:
            raise NotFound("Conversation Not Exists.")
        except services.errors.conversation.ConversationCompletedError:
            raise ConversationCompletedError()
        except services.errors.app_model_config.AppModelConfigBrokenError:
            logging.exception("App model config broken.")
            raise AppUnavailableError()
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description)
        except QuotaExceededError:
            raise ProviderQuotaExceededError()
        except ModelCurrentlyNotSupportError:
            raise ProviderModelCurrentlyNotSupportError()
        except InvokeError as e:
            raise CompletionRequestError(e.description)
        except InvokeRateLimitError as ex:
            raise InvokeRateLimitHttpError(ex.description)
        except ValueError as e:
            raise e
        except Exception:
            logging.exception("internal server error.")
            raise InternalServerError()

class ChatApiForRobot(Resource):

    def post(self, installed_app_id):
        # 1) 解析机器人聊天接口参数
        parser = reqparse.RequestParser()
        parser.add_argument("id", type=str, required=True, location="json")
        parser.add_argument("enterprise_id", type=str, required=False, location="json")
        parser.add_argument("device_id", type=str, required=False, location="json")
        parser.add_argument("messages", type=list, required=True, location="json")
        parser.add_argument("max_tokens", type=int, required=True, location="json")
        parser.add_argument("stream", type=bool, required=True, location="json")
        args = parser.parse_args()

        # 2) 将机器人聊天请求参数转换为dify聊天请求参数
        messages = args["messages"]
        if messages is None or len(messages) == 0:
            raise BadRequest("messages is empty.")

        id = args["id"]
        query = messages[len(messages) - 1]["content"]
        response_mode = "streaming" if args["stream"] else "blocking"
        device_id = args["device_id"]
        data = {
            "inputs": {},
            "query": query,
            "response_mode": response_mode,
            "conversation_id": "",
            "user": device_id if device_id else "abc-123",
            "files": []
        }

        # 3) 获取用户token，封装请求头
        login_json = {
            "email": "suhh@mail.com.cn",
            "password": "tj123456",
        }

        # 3.1) 方案1:每次login
        access_token = RobotAccountService.login(login_json["email"], login_json["password"])

        # # 3.2) 方案2:login后将access_token写入redis，根据是否能够从redis取得内容判断
        # access_token = RobotAccountService.get_account_access_token(login_json["email"])
        # # access_token = None
        # if access_token is None:
        #     # 3.2.1) 方案2-1:调用登录接口，使用返回的access_token
        #     login_response = requests.post(f"{request.host_url}console/api/login", json=login_json)
        #     access_token = login_response.json()["data"]["access_token"]
        #     access_token_key = RobotAccountService._get_access_token_key(login_json["email"])
        #     redis_client.setex(access_token_key, ACCESS_TOKEN_EXPIRY, access_token)
        #
        #     # 3.2.2) 方案2-2:调用service层封装的login方法，使用返回的access_token
        #     access_token = RobotAccountService.login(login_json["email"], login_json["password"])

        headers = {
            "Content-Type": "application/json",
            "User-Agent": "Robot",
            "Accept": "text/stream",
            "Authorization": f'Bearer {access_token}',
            "Connection": "keep-alive",
        }

        logging.info(f"Robot request: {extract_remote_ip(request)}")

        # 4) 封装请求url并发送请求
        chat_message_url = f'{request.host_url}console/api/installed-apps/{installed_app_id}/chat-messages'
        logging.info("Sending request to %s", chat_message_url)
        response = requests.post(chat_message_url, data=json.dumps(data), headers=headers)

        # 5) 按照输出要求处理返回的流式数据
        if args["stream"]:
            def after_response_generator():
                i = 0
                for line in response.iter_lines():
                    line_str = line.decode("utf-8")
                    if not line_str.startswith('data:'):
                        continue

                    content = json.loads(line_str[6:])
                    event = content["event"]
                    if event not in ["message", "message_end"]:
                        continue

                    new_content = {
                        "id": id,
                        "model": "advanced-chat",
                        "created": content["created_at"],
                        "choices": [],
                    }

                    if i == 0:
                        choice = {
                            "index": 0,
                            "delta": {
                                "role": "assistant",
                                "content": ""
                            },
                            "finish_reason": None
                        }
                        new_content["choices"].append(choice)
                        yield f"id: {i}\ndata: {json.dumps(new_content)}\n\n"
                        new_content["choices"].pop()

                    i = i + 1
                    if content["event"] == "message":
                        choice = {
                            "index": 0,
                            "delta": {
                                "role": None,
                                "content": content["answer"]
                            },
                            "finish_reason": None
                        }
                        new_content["choices"].append(choice)
                    else:
                        choice = {
                            "index": 0,
                            "delta": {
                                "role": None,
                                "content": ""
                            },
                            "finish_reason": "stop"
                        }
                        new_content["choices"].append(choice)

                    yield f"id: {i}\ndata: {json.dumps(new_content)}\n\n"

            new_response = after_response_generator()

            def generate() -> Generator:
                yield from new_response

            return helper.compact_generate_response(generate())
        else:
            content = json.loads(response.text)
            new_response = {
                "id": id,
                "model": "advanced-chat",
                "created": content["created_at"],
                "answer": content["answer"],
            }
            return new_response

class ChatStopApi(InstalledAppResource):
    def post(self, installed_app, task_id):
        app_model = installed_app.app
        app_mode = AppMode.value_of(app_model.mode)
        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
            raise NotChatAppError()

        AppQueueManager.set_stop_flag(task_id, InvokeFrom.EXPLORE, current_user.id)

        return {"result": "success"}, 200