fix wrong syntax of type definitions (#1678)

api/controllers/console/app/completion.py

             raise InternalServerError()
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/console/app/message.py

             raise InternalServerError()
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/console/explore/completion.py

         return {'result': 'success'}, 200
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/console/explore/message.py

             raise InternalServerError()
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/console/universal_chat/chat.py

         return {'result': 'success'}, 200
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/service_api/app/completion.py

         return {'result': 'success'}, 200
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/controllers/web/message.py

             raise InternalServerError()
 
 
-def compact_response(response: Union[dict | Generator]) -> Response:
+def compact_response(response: Union[dict, Generator]) -> Response:
     if isinstance(response, dict):
         return Response(response=json.dumps(response), status=200, mimetype='application/json')
     else:

api/core/agent/agent_executor.py

         self.configuration = configuration
         self.agent = self._init_agent()
 
-    def _init_agent(self) -> Union[BaseSingleActionAgent | BaseMultiActionAgent]:
+    def _init_agent(self) -> Union[BaseSingleActionAgent, BaseMultiActionAgent]:
         if self.configuration.strategy == PlanningStrategy.REACT:
             agent = AutoSummarizingStructuredChatAgent.from_llm_and_tools(
                 model_instance=self.configuration.model_instance,

api/core/conversation_message_task.py

 
 
 class PubHandler:
-    def __init__(self, user: Union[Account | EndUser], task_id: str,
+    def __init__(self, user: Union[Account, EndUser], task_id: str,
                  message: Message, conversation: Conversation,
                  chain_pub: bool = False, agent_thought_pub: bool = False):
         self._channel = PubHandler.generate_channel_name(user, task_id)
         self._agent_thought_pub = agent_thought_pub
 
     @classmethod
-    def generate_channel_name(cls, user: Union[Account | EndUser], task_id: str):
+    def generate_channel_name(cls, user: Union[Account, EndUser], task_id: str):
         if not user:
             raise ValueError("user is required")
 
         return "generate_result:{}-{}".format(user_str, task_id)
 
     @classmethod
-    def generate_stopped_cache_key(cls, user: Union[Account | EndUser], task_id: str):
+    def generate_stopped_cache_key(cls, user: Union[Account, EndUser], task_id: str):
         user_str = 'account-' + str(user.id) if isinstance(user, Account) else 'end-user-' + str(user.id)
         return "generate_result_stopped:{}-{}".format(user_str, task_id)
 
         redis_client.publish(self._channel, json.dumps(content))
 
     @classmethod
-    def pub_error(cls, user: Union[Account | EndUser], task_id: str, e):
+    def pub_error(cls, user: Union[Account, EndUser], task_id: str, e):
         content = {
             'error': type(e).__name__,
             'description': e.description if getattr(e, 'description', None) is not None else str(e)
         return redis_client.get(self._stopped_cache_key) is not None
 
     @classmethod
-    def ping(cls, user: Union[Account | EndUser], task_id: str):
+    def ping(cls, user: Union[Account, EndUser], task_id: str):
         content = {
             'event': 'ping'
         }
         redis_client.publish(channel, json.dumps(content))
 
     @classmethod
-    def stop(cls, user: Union[Account | EndUser], task_id: str):
+    def stop(cls, user: Union[Account, EndUser], task_id: str):
         stopped_cache_key = cls.generate_stopped_cache_key(user, task_id)
         redis_client.setex(stopped_cache_key, 600, 1)
 

api/services/conversation_service.py

 
 class ConversationService:
     @classmethod
-    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                               last_id: Optional[str], limit: int,
                               include_ids: Optional[list] = None, exclude_ids: Optional[list] = None,
                               exclude_debug_conversation: bool = False) -> InfiniteScrollPagination:
 
     @classmethod
     def rename(cls, app_model: App, conversation_id: str,
-               user: Optional[Union[Account | EndUser]], name: str, auto_generate: bool):
+               user: Optional[Union[Account, EndUser]], name: str, auto_generate: bool):
         conversation = cls.get_conversation(app_model, conversation_id, user)
 
         if auto_generate:
         return conversation
 
     @classmethod
-    def get_conversation(cls, app_model: App, conversation_id: str, user: Optional[Union[Account | EndUser]]):
+    def get_conversation(cls, app_model: App, conversation_id: str, user: Optional[Union[Account, EndUser]]):
         conversation = db.session.query(Conversation) \
             .filter(
             Conversation.id == conversation_id,
         return conversation
 
     @classmethod
-    def delete(cls, app_model: App, conversation_id: str, user: Optional[Union[Account | EndUser]]):
+    def delete(cls, app_model: App, conversation_id: str, user: Optional[Union[Account, EndUser]]):
         conversation = cls.get_conversation(app_model, conversation_id, user)
 
         conversation.is_deleted = True

api/services/message_service.py

 
 class MessageService:
     @classmethod
-    def pagination_by_first_id(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def pagination_by_first_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                                conversation_id: str, first_id: Optional[str], limit: int) -> InfiniteScrollPagination:
         if not user:
             return InfiniteScrollPagination(data=[], limit=limit, has_more=False)
         )
 
     @classmethod
-    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                               last_id: Optional[str], limit: int, conversation_id: Optional[str] = None,
                               include_ids: Optional[list] = None) -> InfiniteScrollPagination:
         if not user:
         )
 
     @classmethod
-    def create_feedback(cls, app_model: App, message_id: str, user: Optional[Union[Account | EndUser]],
+    def create_feedback(cls, app_model: App, message_id: str, user: Optional[Union[Account, EndUser]],
                         rating: Optional[str]) -> MessageFeedback:
         if not user:
             raise ValueError('user cannot be None')
         return feedback
 
     @classmethod
-    def get_message(cls, app_model: App, user: Optional[Union[Account | EndUser]], message_id: str):
+    def get_message(cls, app_model: App, user: Optional[Union[Account, EndUser]], message_id: str):
         message = db.session.query(Message).filter(
             Message.id == message_id,
             Message.app_id == app_model.id,
         return message
 
     @classmethod
-    def get_suggested_questions_after_answer(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def get_suggested_questions_after_answer(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                                              message_id: str, check_enabled: bool = True) -> List[Message]:
         if not user:
             raise ValueError('user cannot be None')

api/services/saved_message_service.py

 
 class SavedMessageService:
     @classmethod
-    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                               last_id: Optional[str], limit: int) -> InfiniteScrollPagination:
         saved_messages = db.session.query(SavedMessage).filter(
             SavedMessage.app_id == app_model.id,
         )
 
     @classmethod
-    def save(cls, app_model: App, user: Optional[Union[Account | EndUser]], message_id: str):
+    def save(cls, app_model: App, user: Optional[Union[Account, EndUser]], message_id: str):
         saved_message = db.session.query(SavedMessage).filter(
             SavedMessage.app_id == app_model.id,
             SavedMessage.message_id == message_id,
         db.session.commit()
 
     @classmethod
-    def delete(cls, app_model: App, user: Optional[Union[Account | EndUser]], message_id: str):
+    def delete(cls, app_model: App, user: Optional[Union[Account, EndUser]], message_id: str):
         saved_message = db.session.query(SavedMessage).filter(
             SavedMessage.app_id == app_model.id,
             SavedMessage.message_id == message_id,

api/services/web_conversation_service.py

 
 class WebConversationService:
     @classmethod
-    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account | EndUser]],
+    def pagination_by_last_id(cls, app_model: App, user: Optional[Union[Account, EndUser]],
                               last_id: Optional[str], limit: int, pinned: Optional[bool] = None,
                               exclude_debug_conversation: bool = False) -> InfiniteScrollPagination:
         include_ids = None
         )
 
     @classmethod
-    def pin(cls, app_model: App, conversation_id: str, user: Optional[Union[Account | EndUser]]):
+    def pin(cls, app_model: App, conversation_id: str, user: Optional[Union[Account, EndUser]]):
         pinned_conversation = db.session.query(PinnedConversation).filter(
             PinnedConversation.app_id == app_model.id,
             PinnedConversation.conversation_id == conversation_id,
         db.session.commit()
 
     @classmethod
-    def unpin(cls, app_model: App, conversation_id: str, user: Optional[Union[Account | EndUser]]):
+    def unpin(cls, app_model: App, conversation_id: str, user: Optional[Union[Account, EndUser]]):
         pinned_conversation = db.session.query(PinnedConversation).filter(
             PinnedConversation.app_id == app_model.id,
             PinnedConversation.conversation_id == conversation_id,