feat: Support reasoning content(WIP)

Author: shaohuzhang1

apps/application/flow/common.py

@@ -9,18 +9,22 @@
 
 
 class Answer:
-    def __init__(self, content, view_type, runtime_node_id, chat_record_id, child_node, reasoning_content=None):
+    def __init__(self, content, view_type, runtime_node_id, chat_record_id, child_node, real_node_id,
+                 reasoning_content):
         self.view_type = view_type
         self.content = content
         self.reasoning_content = reasoning_content
         self.runtime_node_id = runtime_node_id
         self.chat_record_id = chat_record_id
         self.child_node = child_node
+        self.real_node_id = real_node_id
 
     def to_dict(self):
         return {'view_type': self.view_type, 'content': self.content, 'runtime_node_id': self.runtime_node_id,
-                'chat_record_id': self.chat_record_id, 'child_node': self.child_node,
-                'reasoning_content': self.reasoning_content}
+                'chat_record_id': self.chat_record_id,
+                'child_node': self.child_node,
+                'reasoning_content': self.reasoning_content,
+                'real_node_id': self.real_node_id}
 
 
 class NodeChunk:

apps/application/flow/i_step_node.py

@@ -158,7 +158,8 @@ def get_answer_list(self) -> List[Answer] | None:
         if self.answer_text is None:
             return None
         return [
-            Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], {})]
+            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'))]
 
     def __init__(self, node, workflow_params, workflow_manage, up_node_id_list=None,
                  get_node_params=lambda node: node.properties.get('node_data')):

apps/application/flow/step_node/ai_chat_step_node/impl/base_chat_node.py

@@ -69,7 +69,8 @@ def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wor
     """
     response = node_variable.get('result')
     answer = response.content
-    _write_context(node_variable, workflow_variable, node, workflow, answer)
+    reasoning_content = response.response_metadata.get('reasoning_content', '')
+    _write_context(node_variable, workflow_variable, node, workflow, answer, reasoning_content)
 
 
 def get_default_model_params_setting(model_id):
@@ -103,13 +104,6 @@ def save_context(self, details, workflow_manage):
         self.context['reasoning_content'] = details.get('reasoning_content')
         self.answer_text = details.get('answer')
 
-    def get_answer_list(self) -> List[Answer] | None:
-        if self.answer_text is None:
-            return None
-        return [
-            Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], {},
-                   self.context.get('reasoning_content'))]
-
     def execute(self, model_id, system, prompt, dialogue_number, history_chat_record, stream, chat_id, chat_record_id,
                 model_params_setting=None,
                 dialogue_type=None,

apps/application/flow/step_node/application_node/impl/base_application_node.py

@@ -19,7 +19,8 @@ def _is_interrupt_exec(node, node_variable: Dict, workflow_variable: Dict):
     return node_variable.get('is_interrupt_exec', False)
 
 
-def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str):
+def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow, answer: str,
+                   reasoning_content: str):
     result = node_variable.get('result')
     node.context['application_node_dict'] = node_variable.get('application_node_dict')
     node.context['node_dict'] = node_variable.get('node_dict', {})
@@ -28,6 +29,7 @@ def _write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wo
     node.context['answer_tokens'] = result.get('usage', {}).get('completion_tokens', 0)
     node.context['answer'] = answer
     node.context['result'] = answer
+    node.context['reasoning_content'] = reasoning_content
     node.context['question'] = node_variable['question']
     node.context['run_time'] = time.time() - node.context['start_time']
     if workflow.is_result(node, NodeResult(node_variable, workflow_variable)):
@@ -44,6 +46,7 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
     """
     response = node_variable.get('result')
     answer = ''
+    reasoning_content = ''
     usage = {}
     node_child_node = {}
     application_node_dict = node.context.get('application_node_dict', {})
@@ -60,9 +63,11 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
         node_type = response_content.get('node_type')
         real_node_id = response_content.get('real_node_id')
         node_is_end = response_content.get('node_is_end', False)
+        _reasoning_content = response_content.get('reasoning_content', '')
         if node_type == 'form-node':
             is_interrupt_exec = True
         answer += content
+        reasoning_content += _reasoning_content
         node_child_node = {'runtime_node_id': runtime_node_id, 'chat_record_id': chat_record_id,
                            'child_node': child_node}
 
@@ -75,13 +80,16 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
                                                        'chat_record_id': chat_record_id,
                                                        'child_node': child_node,
                                                        'index': len(application_node_dict),
-                                                       'view_type': view_type}
+                                                       'view_type': view_type,
+                                                       'reasoning_content': _reasoning_content}
             else:
                 application_node['content'] += content
+                application_node['reasoning_content'] += _reasoning_content
 
         yield {'content': content,
                'node_type': node_type,
                'runtime_node_id': runtime_node_id, 'chat_record_id': chat_record_id,
+               'reasoning_content': _reasoning_content,
                'child_node': child_node,
                'real_node_id': real_node_id,
                'node_is_end': node_is_end,
@@ -91,7 +99,7 @@ def write_context_stream(node_variable: Dict, workflow_variable: Dict, node: INo
     node_variable['is_interrupt_exec'] = is_interrupt_exec
     node_variable['child_node'] = node_child_node
     node_variable['application_node_dict'] = application_node_dict
-    _write_context(node_variable, workflow_variable, node, workflow, answer)
+    _write_context(node_variable, workflow_variable, node, workflow, answer, reasoning_content)
 
 
 def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, workflow):
@@ -106,7 +114,8 @@ def write_context(node_variable: Dict, workflow_variable: Dict, node: INode, wor
     node_variable['result'] = {'usage': {'completion_tokens': response.get('completion_tokens'),
                                          'prompt_tokens': response.get('prompt_tokens')}}
     answer = response.get('content', '') or "抱歉，没有查找到相关内容，请重新描述您的问题或提供更多信息。"
-    _write_context(node_variable, workflow_variable, node, workflow, answer)
+    reasoning_content = response.get('reasoning_content', '')
+    _write_context(node_variable, workflow_variable, node, workflow, answer, reasoning_content)
 
 
 def reset_application_node_dict(application_node_dict, runtime_node_id, node_data):
@@ -139,18 +148,21 @@ def get_answer_list(self) -> List[Answer] | None:
         if application_node_dict is None or len(application_node_dict) == 0:
             return [
                 Answer(self.answer_text, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'],
-                       self.context.get('child_node'))]
+                       self.context.get('child_node'), self.runtime_node_id, '')]
         else:
             return [Answer(n.get('content'), n.get('view_type'), self.runtime_node_id,
                            self.workflow_params['chat_record_id'], {'runtime_node_id': n.get('runtime_node_id'),
                                                                     'chat_record_id': n.get('chat_record_id')
-                               , 'child_node': n.get('child_node')}) for n in
+                               , 'child_node': n.get('child_node')}, n.get('real_node_id'), n.get('reasoning_content'))
+                    for n in
                     sorted(application_node_dict.values(), key=lambda item: item.get('index'))]
 
     def save_context(self, details, workflow_manage):
         self.context['answer'] = details.get('answer')
+        self.context['result'] = details.get('answer')
         self.context['question'] = details.get('question')
         self.context['type'] = details.get('type')
+        self.context['reasoning_content'] = details.get('reasoning_content')
         self.answer_text = details.get('answer')
 
     def execute(self, application_id, message, chat_id, chat_record_id, stream, re_chat, client_id, client_type,
@@ -229,6 +241,7 @@ def get_details(self, index: int, **kwargs):
             'run_time': self.context.get('run_time'),
             'question': self.context.get('question'),
             'answer': self.context.get('answer'),
+            'reasoning_content': self.context.get('reasoning_content'),
             'type': self.node.type,
             'message_tokens': self.context.get('message_tokens'),
             'answer_tokens': self.context.get('answer_tokens'),

apps/application/flow/step_node/form_node/impl/base_form_node.py

@@ -75,7 +75,8 @@ def get_answer_list(self) -> List[Answer] | None:
         form_content_format = self.workflow_manage.reset_prompt(form_content_format)
         prompt_template = PromptTemplate.from_template(form_content_format, template_format='jinja2')
         value = prompt_template.format(form=form, context=context)
-        return [Answer(value, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], None)]
+        return [Answer(value, self.view_type, self.runtime_node_id, self.workflow_params['chat_record_id'], None,
+                       self.runtime_node_id, '')]
 
     def get_details(self, index: int, **kwargs):
         form_content_format = self.context.get('form_content_format')

apps/setting/models_provider/impl/base_chat_open_ai.py

@@ -1,6 +1,6 @@
 # coding=utf-8
 import warnings
-from typing import List, Dict, Optional, Any, Iterator, cast, Type
+from typing import List, Dict, Optional, Any, Iterator, cast, Type, Union
 
 import openai
 from langchain_core.callbacks import CallbackManagerForLLMRun
@@ -105,7 +105,8 @@ def _stream(
                     self.usage_metadata = generation_chunk.message.usage_metadata
                 # custom code
                 if 'reasoning_content' in chunk['choices'][0]['delta']:
-                    generation_chunk.message.additional_kwargs["reasoning_content"] = chunk['choices'][0]['delta']['reasoning_content']
+                    generation_chunk.message.additional_kwargs["reasoning_content"] = chunk['choices'][0]['delta'][
+                        'reasoning_content']
 
                 default_chunk_class = generation_chunk.message.__class__
                 logprobs = (generation_chunk.generation_info or {}).get("logprobs")
@@ -116,6 +117,21 @@ def _stream(
                 is_first_chunk = False
                 yield generation_chunk
 
+    def _create_chat_result(self,
+                            response: Union[dict, openai.BaseModel],
+                            generation_info: Optional[Dict] = None):
+        result = super()._create_chat_result(response, generation_info)
+        try:
+            reasoning_content = ''
+            for res in response.choices:
+                _reasoning_content = res.message.model_extra.get('reasoning_content')
+                if _reasoning_content is not None:
+                    reasoning_content += _reasoning_content
+            result.llm_output['reasoning_content'] = reasoning_content
+        except Exception as e:
+            pass
+        return result
+
     def invoke(
             self,
             input: LanguageModelInput,