Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

11.2 KB
Raw Blame
import logging
from http import HTTPStatus
from typing import Any, Literal
from uuid import UUID

from flask import Response
from flask_restx import Resource
from pydantic import BaseModel, Field, field_validator

import services
from controllers.common.errors import InternalServerError, NotFoundError, UnauthorizedError
from controllers.common.fields import SimpleResultResponse
from controllers.common.schema import register_response_schema_models, register_schema_models
from controllers.console import console_ns
from controllers.console.app.error import (
    AppUnavailableError,
    CompletionRequestError,
    ConversationCompletedError,
    ProviderModelCurrentlyNotSupportError,
    ProviderNotInitializeError,
    ProviderQuotaExceededError,
)
from controllers.console.explore.error import NotChatAppError, NotCompletionAppError
from controllers.console.explore.installed_app_admission import get_installed_app
from controllers.console.flask_admission import console_account_admission
from controllers.console.wraps import model_validate
from controllers.web.error import InvokeRateLimitError as InvokeRateLimitHttpError
from core.app.entities.app_invoke_entities import InvokeFrom
from core.errors.error import (
    ModelCurrentlyNotSupportError,
    ProviderTokenNotInitError,
    QuotaExceededError,
)
from extensions.ext_application_services import application_services
from graphon.model_runtime.errors.invoke import InvokeError
from libs import helper
from libs.external_api import error_responses
from machinery.context import RequestContext
from models.enums import CreatorUserRole
from models.model import AppMode
from services.account_errors import AccountNotFoundError
from services.app_definition_query_service import AppDefinitionUnavailableError
from services.errors.llm import InvokeRateLimitError
from services.installed_app_access_service import InstalledAppNotFoundError, InstalledAppRef
from services.installed_app_generation_service import InstalledAppNotChatError, InstalledAppNotCompletionError

logger = logging.getLogger(__name__)


class CompletionMessageExplorePayload(BaseModel):
    inputs: dict[str, Any]
    query: str = ""
    files: list[dict[str, Any]] | None = Field(default=None)
    response_mode: Literal["blocking", "streaming"] | None = None
    retriever_from: str = Field(default="explore_app")


class ChatMessageExplorePayload(BaseModel):
    inputs: dict[str, Any]
    query: str
    files: list[dict[str, Any]] | None = Field(default=None)
    conversation_id: str | None = None
    parent_message_id: str | None = None
    retriever_from: str = Field(default="explore_app")

    @field_validator("conversation_id", "parent_message_id", mode="before")
    @classmethod
    def normalize_uuid(cls, value: str | UUID | None) -> str | None:
        """
        Accept blank IDs and validate UUID format when provided.
        """
        if not value:
            return None

        try:
            return helper.uuid_value(value)
        except ValueError as exc:
            raise ValueError("must be a valid UUID") from exc


register_schema_models(console_ns, CompletionMessageExplorePayload, ChatMessageExplorePayload)
register_response_schema_models(console_ns, SimpleResultResponse)


# define completion api for user
@console_ns.route(
    "/installed-apps/<uuid:installed_app_id>/completion-messages",
    endpoint="installed_app_completion",
)
class CompletionApi(Resource):
    @error_responses(
        AppUnavailableError,
        CompletionRequestError,
        NotCompletionAppError,
        ProviderModelCurrentlyNotSupportError,
        ProviderNotInitializeError,
        ProviderQuotaExceededError,
    )
    @console_ns.expect(console_ns.models[CompletionMessageExplorePayload.__name__])
    @console_ns.response(HTTPStatus.OK, "Success")
    @console_account_admission()
    @get_installed_app
    @model_validate(CompletionMessageExplorePayload)
    def post(
        self,
        req_data: CompletionMessageExplorePayload,
        request_context: RequestContext,
        installed_app: InstalledAppRef,
    ) -> Response:
        try:
            response = application_services().installed_apps.generation.generate_completion(
                installed_app=installed_app,
                account_id=request_context.account_id,
                args=req_data.model_dump(exclude_none=True),
            )

            # response-contract:ignore compact_generate_response
            return helper.compact_generate_response(response)
        except AppDefinitionUnavailableError:
            raise AppUnavailableError() from None
        except InstalledAppNotCompletionError:
            raise NotCompletionAppError() from None
        except InstalledAppNotFoundError:
            raise NotFoundError("Installed app not found") from None
        except AccountNotFoundError:
            raise UnauthorizedError("Account no longer exists.") from None
        except services.errors.conversation.ConversationNotExistsError as caught_error:
            raise NotFoundError("Conversation Not Exists.") from caught_error
        except services.errors.conversation.ConversationCompletedError as caught_error:
            raise ConversationCompletedError() from caught_error
        except services.errors.app_model_config.AppModelConfigBrokenError as caught_error:
            logger.exception("App model config broken.")
            raise AppUnavailableError() from caught_error
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description) from ex
        except QuotaExceededError as caught_error:
            raise ProviderQuotaExceededError() from caught_error
        except ModelCurrentlyNotSupportError as caught_error:
            raise ProviderModelCurrentlyNotSupportError() from caught_error
        except InvokeError as e:
            raise CompletionRequestError(e.description) from e
        except ValueError as e:
            raise e
        except Exception as caught_error:
            logger.exception("internal server error.")
            raise InternalServerError() from caught_error


@console_ns.route(
    "/installed-apps/<uuid:installed_app_id>/completion-messages/<string:task_id>/stop",
    endpoint="installed_app_stop_completion",
)
class CompletionStopApi(Resource):
    @error_responses(NotCompletionAppError)
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__])
    @console_account_admission()
    @get_installed_app
    def post(
        self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str
    ) -> tuple[dict[str, object], int]:
        app_mode = installed_app.app_mode
        if app_mode != AppMode.COMPLETION:
            raise NotCompletionAppError()

        application_services().app_tasks.stop_task(
            task_id=task_id,
            invoke_from=InvokeFrom.EXPLORE,
            user_id=request_context.account_id,
        )

        return SimpleResultResponse(result="success").model_dump(mode="json"), HTTPStatus.OK


@console_ns.route(
    "/installed-apps/<uuid:installed_app_id>/chat-messages",
    endpoint="installed_app_chat_completion",
)
class ChatApi(Resource):
    @error_responses(
        AppUnavailableError,
        CompletionRequestError,
        InvokeRateLimitHttpError,
        NotChatAppError,
        ProviderModelCurrentlyNotSupportError,
        ProviderNotInitializeError,
        ProviderQuotaExceededError,
    )
    @console_ns.expect(console_ns.models[ChatMessageExplorePayload.__name__])
    @console_ns.response(HTTPStatus.OK, "Success")
    @console_account_admission()
    @get_installed_app
    @model_validate(ChatMessageExplorePayload)
    def post(
        self,
        req_data: ChatMessageExplorePayload,
        request_context: RequestContext,
        installed_app: InstalledAppRef,
    ) -> Response:
        try:
            response = application_services().installed_apps.generation.generate_chat(
                installed_app=installed_app,
                account_id=request_context.account_id,
                args=req_data.model_dump(exclude_none=True),
            )

            # response-contract:ignore compact_generate_response
            return helper.compact_generate_response(response)
        except AppDefinitionUnavailableError:
            raise AppUnavailableError() from None
        except InstalledAppNotChatError:
            raise NotChatAppError() from None
        except InstalledAppNotFoundError:
            raise NotFoundError("Installed app not found") from None
        except AccountNotFoundError:
            raise UnauthorizedError("Account no longer exists.") from None
        except services.errors.conversation.ConversationNotExistsError as caught_error:
            raise NotFoundError("Conversation Not Exists.") from caught_error
        except services.errors.conversation.ConversationCompletedError as caught_error:
            raise ConversationCompletedError() from caught_error
        except services.errors.app_model_config.AppModelConfigBrokenError as caught_error:
            logger.exception("App model config broken.")
            raise AppUnavailableError() from caught_error
        except ProviderTokenNotInitError as ex:
            raise ProviderNotInitializeError(ex.description) from ex
        except QuotaExceededError as caught_error:
            raise ProviderQuotaExceededError() from caught_error
        except ModelCurrentlyNotSupportError as caught_error:
            raise ProviderModelCurrentlyNotSupportError() from caught_error
        except InvokeError as e:
            raise CompletionRequestError(e.description) from e
        except InvokeRateLimitError as ex:
            raise InvokeRateLimitHttpError(ex.description) from ex
        except ValueError as e:
            raise e
        except Exception as caught_error:
            logger.exception("internal server error.")
            raise InternalServerError() from caught_error


@console_ns.route(
    "/installed-apps/<uuid:installed_app_id>/chat-messages/<string:task_id>/stop",
    endpoint="installed_app_stop_chat_completion",
)
class ChatStopApi(Resource):
    @error_responses(NotChatAppError)
    @console_ns.response(HTTPStatus.OK, "Success", console_ns.models[SimpleResultResponse.__name__])
    @console_account_admission()
    @get_installed_app
    def post(
        self, request_context: RequestContext, installed_app: InstalledAppRef, task_id: str
    ) -> tuple[dict[str, object], int]:
        app_mode = AppMode.value_of(installed_app.app_mode)
        if app_mode not in {AppMode.CHAT, AppMode.AGENT_CHAT, AppMode.ADVANCED_CHAT}:
            raise NotChatAppError()

        if app_mode == AppMode.ADVANCED_CHAT:
            application_services().app_tasks.stop_workflow_task(
                tenant_id=installed_app.app_owner_tenant_id,
                app_id=installed_app.app_id,
                task_id=task_id,
                app_mode=app_mode,
                owner=(CreatorUserRole.ACCOUNT, request_context.account_id),
            )
        else:
            application_services().app_tasks.stop_task(
                task_id=task_id,
                invoke_from=InvokeFrom.EXPLORE,
                user_id=request_context.account_id,
            )

        return SimpleResultResponse(result="success").model_dump(mode="json"), HTTPStatus.OK