dify-oapi2 0.4.0__py3-none-any.whl → 1.0.0__py3-none-any.whl

dify_oapi/api/chatflow/v1/model/user_input_form.py

@@ -0,0 +1,141 @@
+from pydantic import BaseModel
+
+
+class TextInputControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+    @staticmethod
+    def builder() -> "TextInputControlBuilder":
+        return TextInputControlBuilder()
+
+
+class TextInputControlBuilder:
+    def __init__(self):
+        self._text_input_control = TextInputControl(label="", variable="", required=False)
+
+    def build(self) -> TextInputControl:
+        return self._text_input_control
+
+    def label(self, label: str) -> "TextInputControlBuilder":
+        self._text_input_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "TextInputControlBuilder":
+        self._text_input_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "TextInputControlBuilder":
+        self._text_input_control.required = required
+        return self
+
+    def default(self, default: str) -> "TextInputControlBuilder":
+        self._text_input_control.default = default
+        return self
+
+
+class ParagraphControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+
+    @staticmethod
+    def builder() -> "ParagraphControlBuilder":
+        return ParagraphControlBuilder()
+
+
+class ParagraphControlBuilder:
+    def __init__(self):
+        self._paragraph_control = ParagraphControl(label="", variable="", required=False)
+
+    def build(self) -> ParagraphControl:
+        return self._paragraph_control
+
+    def label(self, label: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "ParagraphControlBuilder":
+        self._paragraph_control.required = required
+        return self
+
+    def default(self, default: str) -> "ParagraphControlBuilder":
+        self._paragraph_control.default = default
+        return self
+
+
+class SelectControl(BaseModel):
+    label: str
+    variable: str
+    required: bool
+    default: str | None = None
+    options: list[str]
+
+    @staticmethod
+    def builder() -> "SelectControlBuilder":
+        return SelectControlBuilder()
+
+
+class SelectControlBuilder:
+    def __init__(self):
+        self._select_control = SelectControl(label="", variable="", required=False, options=[])
+
+    def build(self) -> SelectControl:
+        return self._select_control
+
+    def label(self, label: str) -> "SelectControlBuilder":
+        self._select_control.label = label
+        return self
+
+    def variable(self, variable: str) -> "SelectControlBuilder":
+        self._select_control.variable = variable
+        return self
+
+    def required(self, required: bool) -> "SelectControlBuilder":
+        self._select_control.required = required
+        return self
+
+    def default(self, default: str) -> "SelectControlBuilder":
+        self._select_control.default = default
+        return self
+
+    def options(self, options: list[str]) -> "SelectControlBuilder":
+        self._select_control.options = options
+        return self
+
+
+class UserInputFormItem(BaseModel):
+    text_input: TextInputControl | None = None
+    paragraph: ParagraphControl | None = None
+    select: SelectControl | None = None
+
+    @staticmethod
+    def builder() -> "UserInputFormItemBuilder":
+        return UserInputFormItemBuilder()
+
+
+class UserInputFormItemBuilder:
+    def __init__(self):
+        self._user_input_form_item = UserInputFormItem()
+
+    def build(self) -> UserInputFormItem:
+        return self._user_input_form_item
+
+    def text_input(self, text_input: TextInputControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.text_input = text_input
+        return self
+
+    def paragraph(self, paragraph: ParagraphControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.paragraph = paragraph
+        return self
+
+    def select(self, select: SelectControl) -> "UserInputFormItemBuilder":
+        self._user_input_form_item.select = select
+        return self

dify_oapi/api/chatflow/v1/model/webapp_settings.py

@@ -0,0 +1,88 @@
+from pydantic import BaseModel
+
+from .chatflow_types import ChatColorTheme, DefaultLanguage, IconType
+
+
+class WebAppSettings(BaseModel):
+    title: str | None = None
+    chat_color_theme: ChatColorTheme | None = None
+    chat_color_theme_inverted: bool | None = None
+    icon_type: IconType | None = None
+    icon: str | None = None
+    icon_background: str | None = None
+    icon_url: str | None = None
+    description: str | None = None
+    copyright: str | None = None
+    privacy_policy: str | None = None
+    custom_disclaimer: str | None = None
+    default_language: DefaultLanguage | None = None
+    show_workflow_steps: bool | None = None
+    use_icon_as_answer_icon: bool | None = None
+
+    @staticmethod
+    def builder() -> "WebAppSettingsBuilder":
+        return WebAppSettingsBuilder()
+
+
+class WebAppSettingsBuilder:
+    def __init__(self):
+        self._webapp_settings = WebAppSettings()
+
+    def build(self) -> WebAppSettings:
+        return self._webapp_settings
+
+    def title(self, title: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.title = title
+        return self
+
+    def chat_color_theme(self, chat_color_theme: ChatColorTheme) -> "WebAppSettingsBuilder":
+        self._webapp_settings.chat_color_theme = chat_color_theme
+        return self
+
+    def chat_color_theme_inverted(self, chat_color_theme_inverted: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.chat_color_theme_inverted = chat_color_theme_inverted
+        return self
+
+    def icon_type(self, icon_type: IconType) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_type = icon_type
+        return self
+
+    def icon(self, icon: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon = icon
+        return self
+
+    def icon_background(self, icon_background: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_background = icon_background
+        return self
+
+    def icon_url(self, icon_url: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.icon_url = icon_url
+        return self
+
+    def description(self, description: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.description = description
+        return self
+
+    def copyright(self, copyright: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.copyright = copyright
+        return self
+
+    def privacy_policy(self, privacy_policy: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.privacy_policy = privacy_policy
+        return self
+
+    def custom_disclaimer(self, custom_disclaimer: str) -> "WebAppSettingsBuilder":
+        self._webapp_settings.custom_disclaimer = custom_disclaimer
+        return self
+
+    def default_language(self, default_language: DefaultLanguage) -> "WebAppSettingsBuilder":
+        self._webapp_settings.default_language = default_language
+        return self
+
+    def show_workflow_steps(self, show_workflow_steps: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.show_workflow_steps = show_workflow_steps
+        return self
+
+    def use_icon_as_answer_icon(self, use_icon_as_answer_icon: bool) -> "WebAppSettingsBuilder":
+        self._webapp_settings.use_icon_as_answer_icon = use_icon_as_answer_icon
+        return self

dify_oapi/api/chatflow/v1/resource/annotation.py

@@ -0,0 +1,87 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.annotation_reply_settings_request import AnnotationReplySettingsRequest
+from ..model.annotation_reply_settings_response import AnnotationReplySettingsResponse
+from ..model.annotation_reply_status_request import AnnotationReplyStatusRequest
+from ..model.annotation_reply_status_response import AnnotationReplyStatusResponse
+from ..model.create_annotation_request import CreateAnnotationRequest
+from ..model.create_annotation_response import CreateAnnotationResponse
+from ..model.delete_annotation_request import DeleteAnnotationRequest
+from ..model.delete_annotation_response import DeleteAnnotationResponse
+from ..model.get_annotations_request import GetAnnotationsRequest
+from ..model.get_annotations_response import GetAnnotationsResponse
+from ..model.update_annotation_request import UpdateAnnotationRequest
+from ..model.update_annotation_response import UpdateAnnotationResponse
+
+
+class Annotation:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def list(self, request: GetAnnotationsRequest, request_option: RequestOption) -> GetAnnotationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetAnnotationsResponse, option=request_option)
+
+    async def alist(self, request: GetAnnotationsRequest, request_option: RequestOption) -> GetAnnotationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetAnnotationsResponse, option=request_option
+        )
+
+    def create(self, request: CreateAnnotationRequest, request_option: RequestOption) -> CreateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option)
+
+    async def acreate(
+        self, request: CreateAnnotationRequest, request_option: RequestOption
+    ) -> CreateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=CreateAnnotationResponse, option=request_option
+        )
+
+    def update(self, request: UpdateAnnotationRequest, request_option: RequestOption) -> UpdateAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option)
+
+    async def aupdate(
+        self, request: UpdateAnnotationRequest, request_option: RequestOption
+    ) -> UpdateAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=UpdateAnnotationResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteAnnotationRequest, request_option: RequestOption) -> DeleteAnnotationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option)
+
+    async def adelete(
+        self, request: DeleteAnnotationRequest, request_option: RequestOption
+    ) -> DeleteAnnotationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteAnnotationResponse, option=request_option
+        )
+
+    def reply_settings(
+        self, request: AnnotationReplySettingsRequest, request_option: RequestOption
+    ) -> AnnotationReplySettingsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    async def areply_settings(
+        self, request: AnnotationReplySettingsRequest, request_option: RequestOption
+    ) -> AnnotationReplySettingsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=AnnotationReplySettingsResponse, option=request_option
+        )
+
+    def reply_status(
+        self, request: AnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> AnnotationReplyStatusResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=AnnotationReplyStatusResponse, option=request_option
+        )
+
+    async def areply_status(
+        self, request: AnnotationReplyStatusRequest, request_option: RequestOption
+    ) -> AnnotationReplyStatusResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=AnnotationReplyStatusResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/resource/chatflow.py

@@ -0,0 +1,78 @@
+from collections.abc import AsyncGenerator, Generator
+from typing import Literal, overload
+
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.get_suggested_questions_request import GetSuggestedQuestionsRequest
+from ..model.get_suggested_questions_response import GetSuggestedQuestionsResponse
+from ..model.send_chat_message_request import SendChatMessageRequest
+from ..model.send_chat_message_response import SendChatMessageResponse
+from ..model.stop_chat_message_request import StopChatMessageRequest
+from ..model.stop_chat_message_response import StopChatMessageResponse
+
+
+class Chatflow:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    @overload
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[True],
+    ) -> Generator[bytes, None, None]: ...
+
+    @overload
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: Literal[False] = False,
+    ) -> SendChatMessageResponse: ...
+
+    def send(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> SendChatMessageResponse | Generator[bytes, None, None]:
+        if stream:
+            return Transport.execute(self.config, request, stream=True, option=request_option)
+        return Transport.execute(self.config, request, unmarshal_as=SendChatMessageResponse, option=request_option)
+
+    async def asend(
+        self,
+        request: SendChatMessageRequest,
+        request_option: RequestOption,
+        stream: bool = False,
+    ) -> SendChatMessageResponse | AsyncGenerator[bytes, None]:
+        if stream:
+            return await ATransport.aexecute(self.config, request, stream=True, option=request_option)
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=SendChatMessageResponse, option=request_option
+        )
+
+    def stop(self, request: StopChatMessageRequest, request_option: RequestOption) -> StopChatMessageResponse:
+        return Transport.execute(self.config, request, unmarshal_as=StopChatMessageResponse, option=request_option)
+
+    async def astop(self, request: StopChatMessageRequest, request_option: RequestOption) -> StopChatMessageResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=StopChatMessageResponse, option=request_option
+        )
+
+    def suggested(
+        self, request: GetSuggestedQuestionsRequest, request_option: RequestOption
+    ) -> GetSuggestedQuestionsResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )
+
+    async def asuggested(
+        self, request: GetSuggestedQuestionsRequest, request_option: RequestOption
+    ) -> GetSuggestedQuestionsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetSuggestedQuestionsResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/resource/conversation.py

@@ -0,0 +1,75 @@
+from dify_oapi.core.http.transport import ATransport, Transport
+from dify_oapi.core.model.config import Config
+from dify_oapi.core.model.request_option import RequestOption
+
+from ..model.delete_conversation_request import DeleteConversationRequest
+from ..model.delete_conversation_response import DeleteConversationResponse
+from ..model.get_conversation_messages_request import GetConversationMessagesRequest
+from ..model.get_conversation_messages_response import GetConversationMessagesResponse
+from ..model.get_conversation_variables_request import GetConversationVariablesRequest
+from ..model.get_conversation_variables_response import GetConversationVariablesResponse
+from ..model.get_conversations_request import GetConversationsRequest
+from ..model.get_conversations_response import GetConversationsResponse
+from ..model.rename_conversation_request import RenameConversationRequest
+from ..model.rename_conversation_response import RenameConversationResponse
+
+
+class Conversation:
+    def __init__(self, config: Config) -> None:
+        self.config = config
+
+    def messages(
+        self, request: GetConversationMessagesRequest, request_option: RequestOption
+    ) -> GetConversationMessagesResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetConversationMessagesResponse, option=request_option
+        )
+
+    async def amessages(
+        self, request: GetConversationMessagesRequest, request_option: RequestOption
+    ) -> GetConversationMessagesResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationMessagesResponse, option=request_option
+        )
+
+    def list(self, request: GetConversationsRequest, request_option: RequestOption) -> GetConversationsResponse:
+        return Transport.execute(self.config, request, unmarshal_as=GetConversationsResponse, option=request_option)
+
+    async def alist(self, request: GetConversationsRequest, request_option: RequestOption) -> GetConversationsResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationsResponse, option=request_option
+        )
+
+    def delete(self, request: DeleteConversationRequest, request_option: RequestOption) -> DeleteConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=DeleteConversationResponse, option=request_option)
+
+    async def adelete(
+        self, request: DeleteConversationRequest, request_option: RequestOption
+    ) -> DeleteConversationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=DeleteConversationResponse, option=request_option
+        )
+
+    def rename(self, request: RenameConversationRequest, request_option: RequestOption) -> RenameConversationResponse:
+        return Transport.execute(self.config, request, unmarshal_as=RenameConversationResponse, option=request_option)
+
+    async def arename(
+        self, request: RenameConversationRequest, request_option: RequestOption
+    ) -> RenameConversationResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=RenameConversationResponse, option=request_option
+        )
+
+    def variables(
+        self, request: GetConversationVariablesRequest, request_option: RequestOption
+    ) -> GetConversationVariablesResponse:
+        return Transport.execute(
+            self.config, request, unmarshal_as=GetConversationVariablesResponse, option=request_option
+        )
+
+    async def avariables(
+        self, request: GetConversationVariablesRequest, request_option: RequestOption
+    ) -> GetConversationVariablesResponse:
+        return await ATransport.aexecute(
+            self.config, request, unmarshal_as=GetConversationVariablesResponse, option=request_option
+        )

dify_oapi/api/chatflow/v1/version.py

@@ -0,0 +1,22 @@
+from dify_oapi.api.dify.v1.resource.audio import Audio
+from dify_oapi.api.dify.v1.resource.feedback import Feedback
+from dify_oapi.api.dify.v1.resource.file import File
+from dify_oapi.api.dify.v1.resource.info import Info
+from dify_oapi.core.model.config import Config
+
+from .resource.annotation import Annotation
+from .resource.chatflow import Chatflow
+from .resource.conversation import Conversation
+
+
+class V1:
+    def __init__(self, config: Config) -> None:
+        # Business-specific APIs
+        self.chatflow = Chatflow(config)
+        self.conversation = Conversation(config)
+        self.annotation = Annotation(config)
+        # System APIs - direct use of dify module
+        self.file = File(config)
+        self.tts = Audio(config)
+        self.application = Info(config)
+        self.feedback = Feedback(config)

dify_oapi/api/completion/v1/resource/__init__.py

@@ -1,6 +0,0 @@
-from .annotation import *  # noqa 403
-from .audio import *  # noqa 403
-from .completion import *  # noqa 403
-from .feedback import *  # noqa 403
-from .file import *  # noqa 403
-from .info import *  # noqa 403

dify_oapi/api/completion/v1/version.py

@@ -1,18 +1,20 @@
+from dify_oapi.api.dify.v1.resource.audio import Audio
+from dify_oapi.api.dify.v1.resource.feedback import Feedback
+from dify_oapi.api.dify.v1.resource.file import File
+from dify_oapi.api.dify.v1.resource.info import Info
 from dify_oapi.core.model.config import Config
 
 from .resource.annotation import Annotation
-from .resource.audio import Audio
 from .resource.completion import Completion
-from .resource.feedback import Feedback
-from .resource.file import File
-from .resource.info import Info
 
 
 class V1:
     def __init__(self, config: Config):
+        # Business-specific APIs
         self.completion: Completion = Completion(config)
+        self.annotation: Annotation = Annotation(config)
+        # System APIs - direct use of dify module
         self.file: File = File(config)
-        self.feedback: Feedback = Feedback(config)
         self.audio: Audio = Audio(config)
         self.info: Info = Info(config)
-        self.annotation: Annotation = Annotation(config)
+        self.feedback: Feedback = Feedback(config)

dify_oapi/api/{chat → dify}/v1/model/audio_to_text_request_body.py

@@ -4,7 +4,7 @@ from pydantic import BaseModel
 
 
 class AudioToTextRequestBody(BaseModel):
-    user: str | None = None
+    user: str
 
     @staticmethod
     def builder() -> AudioToTextRequestBodyBuilder:
@@ -13,7 +13,7 @@ class AudioToTextRequestBody(BaseModel):
 
 class AudioToTextRequestBodyBuilder:
     def __init__(self):
-        self._audio_to_text_request_body = AudioToTextRequestBody()
+        self._audio_to_text_request_body = AudioToTextRequestBody(user="")
 
     def build(self) -> AudioToTextRequestBody:
         return self._audio_to_text_request_body

dify_oapi/api/{completion/v1/model/feedback → dify/v1/model}/get_feedbacks_request.py

@@ -1,32 +1,32 @@
-from __future__ import annotations
-
 from dify_oapi.core.enum import HttpMethod
 from dify_oapi.core.model.base_request import BaseRequest
 
 
 class GetFeedbacksRequest(BaseRequest):
-    def __init__(self):
+    def __init__(self) -> None:
         super().__init__()
 
     @staticmethod
-    def builder() -> GetFeedbacksRequestBuilder:
+    def builder() -> "GetFeedbacksRequestBuilder":
         return GetFeedbacksRequestBuilder()
 
 
 class GetFeedbacksRequestBuilder:
-    def __init__(self):
+    def __init__(self) -> None:
         get_feedbacks_request = GetFeedbacksRequest()
         get_feedbacks_request.http_method = HttpMethod.GET
         get_feedbacks_request.uri = "/v1/app/feedbacks"
         self._get_feedbacks_request = get_feedbacks_request
 
-    def build(self) -> GetFeedbacksRequest:
-        return self._get_feedbacks_request
-
-    def page(self, page: str) -> GetFeedbacksRequestBuilder:
-        self._get_feedbacks_request.add_query("page", page)
+    def page(self, page: int | None) -> "GetFeedbacksRequestBuilder":
+        if page is not None:
+            self._get_feedbacks_request.add_query("page", str(page))
         return self
 
-    def limit(self, limit: str) -> GetFeedbacksRequestBuilder:
-        self._get_feedbacks_request.add_query("limit", limit)
+    def limit(self, limit: int | None) -> "GetFeedbacksRequestBuilder":
+        if limit is not None:
+            self._get_feedbacks_request.add_query("limit", str(limit))
         return self
+
+    def build(self) -> GetFeedbacksRequest:
+        return self._get_feedbacks_request

dify_oapi/api/dify/v1/model/get_feedbacks_response.py

@@ -0,0 +1,26 @@
+from pydantic import BaseModel
+
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class FeedbackInfo(BaseModel):
+    """Feedback information."""
+
+    id: str | None = None
+    username: str | None = None
+    phone: str | None = None
+    avatar: str | None = None
+    display_name: str | None = None
+    timestamp: int | None = None
+    rating: str | None = None
+    content: str | None = None
+
+
+class GetFeedbacksResponse(BaseResponse):
+    """Response for get feedbacks API."""
+
+    data: list[FeedbackInfo] | None = None
+    has_more: bool | None = None
+    limit: int | None = None
+    page: int | None = None
+    total: int | None = None

dify_oapi/api/{workflow → dify}/v1/model/get_parameters_request.py

@@ -22,3 +22,7 @@ class GetParametersRequestBuilder:
 
     def build(self) -> GetParametersRequest:
         return self._get_parameters_request
+
+    def user(self, user: str) -> GetParametersRequestBuilder:
+        self._get_parameters_request.add_query("user", user)
+        return self

dify_oapi/api/dify/v1/model/{get_parameter_response.py → get_parameters_response.py}

@@ -1,13 +1,17 @@
 from dify_oapi.core.model.base_response import BaseResponse
 
 
-class GetParameterResponse(BaseResponse):
+class GetParametersResponse(BaseResponse):
+    """Response for get application parameters API."""
+
     opening_statement: str | None = None
     suggested_questions: list[str] | None = None
-    suggested_questions_after_answer: dict | None = None
     speech_to_text: dict | None = None
+    text_to_speech: dict | None = None
     retriever_resource: dict | None = None
     annotation_reply: dict | None = None
+    more_like_this: dict | None = None
     user_input_form: list[dict] | None = None
+    sensitive_word_avoidance: dict | None = None
     file_upload: dict | None = None
     system_parameters: dict | None = None

dify_oapi/api/dify/v1/model/get_site_response.py

@@ -0,0 +1,17 @@
+from dify_oapi.core.model.base_response import BaseResponse
+
+
+class GetSiteResponse(BaseResponse):
+    """Response for get site settings API."""
+
+    title: str | None = None
+    icon: str | None = None
+    icon_background: str | None = None
+    description: str | None = None
+    default_language: str | None = None
+    customize_domain: str | None = None
+    customize_token_strategy: str | None = None
+    prompt_public: bool | None = None
+    copyright: str | None = None
+    privacy_policy: str | None = None
+    custom_disclaimer: str | None = None