feat: Support reasoning content(WIP)

shaohuzhang1 · shaohuzhang1 · commit 0b7a93fd2be9 · 2025-02-08T20:19:00.000+08:00
diff --git a/apps/application/chat_pipeline/step/chat_step/i_chat_step.py b/apps/application/chat_pipeline/step/chat_step/i_chat_step.py
@@ -65,16 +65,21 @@ class InstanceSerializer(serializers.Serializer):
         post_response_handler = InstanceField(model_type=PostResponseHandler,
                                               error_messages=ErrMessage.base(_("Post-processor")))
         # 补全问题
-        padding_problem_text = serializers.CharField(required=False, error_messages=ErrMessage.base(_("Completion Question")))
+        padding_problem_text = serializers.CharField(required=False,
+                                                     error_messages=ErrMessage.base(_("Completion Question")))
         # 是否使用流的形式输出
         stream = serializers.BooleanField(required=False, error_messages=ErrMessage.base(_("Streaming Output")))
         client_id = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Client id")))
         client_type = serializers.CharField(required=True, error_messages=ErrMessage.char(_("Client Type")))
         # 未查询到引用分段
-        no_references_setting = NoReferencesSetting(required=True, error_messages=ErrMessage.base(_("No reference segment settings")))
+        no_references_setting = NoReferencesSetting(required=True,
+                                                    error_messages=ErrMessage.base(_("No reference segment settings")))
 
         user_id = serializers.UUIDField(required=True, error_messages=ErrMessage.uuid(_("User ID")))
 
+        model_setting = serializers.DictField(required=True, allow_null=True,
+                                              error_messages=ErrMessage.dict(_("Model settings")))
+
         model_params_setting = serializers.DictField(required=False, allow_null=True,
                                                      error_messages=ErrMessage.dict(_("Model parameter settings")))
 
@@ -101,5 +106,5 @@ def execute(self, message_list: List[BaseMessage],
                 paragraph_list=None,
                 manage: PipelineManage = None,
                 padding_problem_text: str = None, stream: bool = True, client_id=None, client_type=None,
-                no_references_setting=None, model_params_setting=None, **kwargs):
+                no_references_setting=None, model_params_setting=None, model_setting=None, **kwargs):
         pass
diff --git a/apps/application/chat_pipeline/step/chat_step/impl/base_chat_step.py b/apps/application/chat_pipeline/step/chat_step/impl/base_chat_step.py
@@ -24,6 +24,7 @@
 from application.chat_pipeline.I_base_chat_pipeline import ParagraphPipelineModel
 from application.chat_pipeline.pipeline_manage import PipelineManage
 from application.chat_pipeline.step.chat_step.i_chat_step import IChatStep, PostResponseHandler
+from application.flow.tools import Reasoning
 from application.models.api_key_model import ApplicationPublicAccessClient
 from common.constants.authentication_type import AuthenticationType
 from setting.models_provider.tools import get_model_instance_by_model_user_id
@@ -63,17 +64,37 @@ def event_content(response,
                   problem_text: str,
                   padding_problem_text: str = None,
                   client_id=None, client_type=None,
-                  is_ai_chat: bool = None):
+                  is_ai_chat: bool = None,
+                  model_setting=None):
+    if model_setting is None:
+        model_setting = {}
+    reasoning_content_enable = model_setting.get('reasoning_content_enable', False)
+    reasoning_content_start = model_setting.get('reasoning_content_start', '<think>')
+    reasoning_content_end = model_setting.get('reasoning_content_end', '</think>')
+    reasoning = Reasoning(reasoning_content_start,
+                          reasoning_content_end)
     all_text = ''
+    reasoning_content = ''
     try:
         for chunk in response:
-            all_text += chunk.content
+            reasoning_chunk = reasoning.get_reasoning_content(chunk)
+            content_chunk = reasoning_chunk.get('content')
+            if 'reasoning_content' in chunk.additional_kwargs:
+                reasoning_content_chunk = chunk.additional_kwargs.get('reasoning_content', '')
+            else:
+                reasoning_content_chunk = reasoning_chunk.get('reasoning_content')
+            all_text += content_chunk
+            if reasoning_content_chunk is None:
+                reasoning_content_chunk = ''
+            reasoning_content += reasoning_content_chunk
             yield manage.get_base_to_response().to_stream_chunk_response(chat_id, str(chat_record_id), 'ai-chat-node',
-                                                                         [], chunk.content,
+                                                                         [], content_chunk,
                                                                          False,
                                                                          0, 0, {'node_is_end': False,
                                                                                 'view_type': 'many_view',
-                                                                                'node_type': 'ai-chat-node'})
+                                                                                'node_type': 'ai-chat-node',
+                                                                                'real_node_id': 'ai-chat-node',
+                                                                                'reasoning_content': reasoning_content_chunk if reasoning_content_enable else ''})
         # 获取token
         if is_ai_chat:
             try:
@@ -87,7 +108,8 @@ def event_content(response,
             response_token = 0
         write_context(step, manage, request_token, response_token, all_text)
         post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                      all_text, manage, step, padding_problem_text, client_id)
+                                      all_text, manage, step, padding_problem_text, client_id,
+                                      reasoning_content=reasoning_content if reasoning_content_enable else '')
         yield manage.get_base_to_response().to_stream_chunk_response(chat_id, str(chat_record_id), 'ai-chat-node',
                                                                      [], '', True,
                                                                      request_token, response_token,
@@ -122,17 +144,20 @@ def execute(self, message_list: List[BaseMessage],
                 client_id=None, client_type=None,
                 no_references_setting=None,
                 model_params_setting=None,
+                model_setting=None,
                 **kwargs):
         chat_model = get_model_instance_by_model_user_id(model_id, user_id,
                                                          **model_params_setting) if model_id is not None else None
         if stream:
             return self.execute_stream(message_list, chat_id, problem_text, post_response_handler, chat_model,
                                        paragraph_list,
-                                       manage, padding_problem_text, client_id, client_type, no_references_setting)
+                                       manage, padding_problem_text, client_id, client_type, no_references_setting,
+                                       model_setting)
         else:
             return self.execute_block(message_list, chat_id, problem_text, post_response_handler, chat_model,
                                       paragraph_list,
-                                      manage, padding_problem_text, client_id, client_type, no_references_setting)
+                                      manage, padding_problem_text, client_id, client_type, no_references_setting,
+                                      model_setting)
 
     def get_details(self, manage, **kwargs):
         return {
@@ -187,14 +212,15 @@ def execute_stream(self, message_list: List[BaseMessage],
                        manage: PipelineManage = None,
                        padding_problem_text: str = None,
                        client_id=None, client_type=None,
-                       no_references_setting=None):
+                       no_references_setting=None,
+                       model_setting=None):
         chat_result, is_ai_chat = self.get_stream_result(message_list, chat_model, paragraph_list,
                                                          no_references_setting, problem_text)
         chat_record_id = uuid.uuid1()
         r = StreamingHttpResponse(
             streaming_content=event_content(chat_result, chat_id, chat_record_id, paragraph_list,
                                             post_response_handler, manage, self, chat_model, message_list, problem_text,
-                                            padding_problem_text, client_id, client_type, is_ai_chat),
+                                            padding_problem_text, client_id, client_type, is_ai_chat, model_setting),
             content_type='text/event-stream;charset=utf-8')
 
         r['Cache-Control'] = 'no-cache'
@@ -230,7 +256,13 @@ def execute_block(self, message_list: List[BaseMessage],
                       paragraph_list=None,
                       manage: PipelineManage = None,
                       padding_problem_text: str = None,
-                      client_id=None, client_type=None, no_references_setting=None):
+                      client_id=None, client_type=None, no_references_setting=None,
+                      model_setting=None):
+        reasoning_content_enable = model_setting.get('reasoning_content_enable', False)
+        reasoning_content_start = model_setting.get('reasoning_content_start', '<think>')
+        reasoning_content_end = model_setting.get('reasoning_content_end', '</think>')
+        reasoning = Reasoning(reasoning_content_start,
+                              reasoning_content_end)
         chat_record_id = uuid.uuid1()
         # 调用模型
         try:
@@ -243,14 +275,23 @@ def execute_block(self, message_list: List[BaseMessage],
                 request_token = 0
                 response_token = 0
             write_context(self, manage, request_token, response_token, chat_result.content)
+            reasoning.get_reasoning_content(chat_result)
+            reasoning_result = reasoning.get_reasoning_content(chat_result)
+            content = reasoning_result.get('content')
+            if 'reasoning_content' in chat_result.response_metadata:
+                reasoning_content = chat_result.response_metadata.get('reasoning_content', '')
+            else:
+                reasoning_content = reasoning_result.get('reasoning_content')
             post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                          chat_result.content, manage, self, padding_problem_text, client_id)
+                                          chat_result.content, manage, self, padding_problem_text, client_id,
+                                          reasoning_content=reasoning_content if reasoning_content_enable else '')
             add_access_num(client_id, client_type, manage.context.get('application_id'))
             return manage.get_base_to_response().to_block_response(str(chat_id), str(chat_record_id),
-                                                                   chat_result.content, True,
-                                                                   request_token, response_token)
+                                                                   content, True,
+                                                                   request_token, response_token,
+                                                                   {'reasoning_content': reasoning_content})
         except Exception as e:
-            all_text = '异常' + str(e)
+            all_text = 'Exception:' + str(e)
             write_context(self, manage, 0, 0, all_text)
             post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
                                           all_text, manage, self, padding_problem_text, client_id)
diff --git a/apps/application/flow/i_step_node.py b/apps/application/flow/i_step_node.py
@@ -63,7 +63,7 @@ def handler(self, chat_id,
                              'answer_tokens' in row and row.get('answer_tokens') is not None])
         answer_text_list = workflow.get_answer_text_list()
         answer_text = '\n\n'.join(
-            '\n\n'.join(["\n\n".join([a.get('reasoning_content'), a.get('content')]) for a in answer]) for answer in
+            '\n\n'.join([a.get('content') for a in answer]) for answer in
             answer_text_list)
         if workflow.chat_record is not None:
             chat_record = workflow.chat_record
@@ -159,9 +159,10 @@ def save_context(self, details, workflow_manage):
     def get_answer_list(self) -> List[Answer] | None:
         if self.answer_text is None:
             return None
+        reasoning_content_enable = self.context.get('model_setting', {}).get('reasoning_content_enable', False)
         return [
             Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], {},
-                   self.runtime_node_id, self.context.get('reasoning_content', ''))]
+                   self.runtime_node_id, self.context.get('reasoning_content', '') if reasoning_content_enable else '')]
 
     def __init__(self, node, workflow_params, workflow_manage, up_node_id_list=None,
                  get_node_params=lambda node: node.properties.get('node_data')):
diff --git a/apps/application/flow/step_node/ai_chat_step_node/impl/base_chat_node.py b/apps/application/flow/step_node/ai_chat_step_node/impl/base_chat_node.py
@@ -53,7 +53,8 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
     model_setting = node.context.get('model_setting',
                                      {'reasoning_content_enable': False, 'reasoning_content_end': '</think>',
                                       'reasoning_content_start': '<think>'})
-    reasoning = Reasoning(model_setting.get('reasoning_content_start'), model_setting.get('reasoning_content_end'))
+    reasoning = Reasoning(model_setting.get('reasoning_content_start', '<think>'),
+                          model_setting.get('reasoning_content_end', '</think>'))
     for chunk in response:
         reasoning_chunk = reasoning.get_reasoning_content(chunk)
         content_chunk = reasoning_chunk.get('content')
@@ -80,9 +81,17 @@ def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wor
     @param workflow:           工作流管理器
     """
     response = node_variable.get('result')
-    answer = response.content
-    reasoning_content = response.response_metadata.get('reasoning_content', '')
-    _write_context(node_variable, workflow_variable, node, workflow, answer, reasoning_content)
+    model_setting = node.context.get('model_setting',
+                                     {'reasoning_content_enable': False, 'reasoning_content_end': '</think>',
+                                      'reasoning_content_start': '<think>'})
+    reasoning = Reasoning(model_setting.get('reasoning_content_start'), model_setting.get('reasoning_content_end'))
+    reasoning_result = reasoning.get_reasoning_content(response)
+    content = reasoning_result.get('content')
+    if 'reasoning_content' in response.response_metadata:
+        reasoning_content = response.response_metadata.get('reasoning_content', '')
+    else:
+        reasoning_content = reasoning_result.get('reasoning_content')
+    _write_context(node_variable, workflow_variable, node, workflow, content, reasoning_content)
 
 
 def get_default_model_params_setting(model_id):
diff --git a/apps/application/flow/workflow_manage.py b/apps/application/flow/workflow_manage.py
@@ -522,7 +522,7 @@ def hand_event_node_result(self, current_node, node_result_future):
                                                                    self.params['chat_record_id'],
                                                                    current_node.id,
                                                                    current_node.up_node_id_list,
-                                                                   str(e), False, 0, 0,
+                                                                   'Exception:' + str(e), False, 0, 0,
                                                                    {'node_is_end': True,
                                                                     'runtime_node_id': current_node.runtime_node_id,
                                                                     'node_type': current_node.type,
diff --git a/apps/application/serializers/application_serializers.py b/apps/application/serializers/application_serializers.py
@@ -140,6 +140,13 @@ class ModelSettingSerializer(serializers.Serializer):
                                    error_messages=ErrMessage.char(_("Role prompts")))
     no_references_prompt = serializers.CharField(required=True, max_length=102400, allow_null=True, allow_blank=True,
                                                  error_messages=ErrMessage.char(_("No citation segmentation prompt")))
+    reasoning_content_enable = serializers.BooleanField(required=False,
+                                                        error_messages=ErrMessage.char(_("Thinking process switch")))
+    reasoning_content_start = serializers.CharField(required=False, allow_null=True, allow_blank=True, max_length=256,
+                                                    error_messages=ErrMessage.char(
+                                                        _("The thinking process begins to mark")))
+    reasoning_content_end = serializers.CharField(required=False, allow_null=True, allow_blank=True, max_length=256,
+                                                  error_messages=ErrMessage.char(_("End of thinking process marker")))
 
 
 class ApplicationWorkflowSerializer(serializers.Serializer):
diff --git a/apps/application/serializers/chat_message_serializers.py b/apps/application/serializers/chat_message_serializers.py
diff --git a/apps/setting/models_provider/impl/base_chat_open_ai.py b/apps/setting/models_provider/impl/base_chat_open_ai.py
diff --git a/ui/src/components/markdown/MdRenderer.vue b/ui/src/components/markdown/MdRenderer.vue
