Merge remote-tracking branch 'upstream/v2' into PR/fix-6

Author: wangliang181230

apps/application/chat_pipeline/step/chat_step/impl/base_chat_step.py

@@ -150,7 +150,8 @@ def event_content(response,
             all_text = 'Exception:' + str(e)
         write_context(step, manage, 0, 0, all_text)
         post_response_handler.handler(chat_id, chat_record_id, paragraph_list, problem_text,
-                                      all_text, manage, step, padding_problem_text, reasoning_content='')
+                                      all_text, manage, step, padding_problem_text,
+                                      reasoning_content=reasoning_content if reasoning_content_enable else '')
         if not manage.debug:
             add_access_num(chat_user_id, chat_user_type, manage.context.get('application_id'))
         yield manage.get_base_to_response().to_stream_chunk_response(chat_id, str(chat_record_id), 'ai-chat-node',
@@ -214,8 +215,13 @@ def execute(self, message_list: List[BaseMessage],
 
     def get_details(self, manage, **kwargs):
         # 提取长期记忆
-        extract_long_term_memory.delay(
-            manage.context.get('workspace_id'), manage.context.get('application_id'), manage.context.get('chat_user_id')
+        extract_long_term_memory.apply_async(
+            args=(
+                manage.context.get('workspace_id'),
+                manage.context.get('application_id'),
+                manage.context.get('chat_user_id'),
+            ),
+            countdown=1,
         )
         return {
             'status': self.status,
@@ -387,6 +393,7 @@ def get_stream_result(self, message_list: List[BaseMessage],
                 if isinstance(msg, SystemMessage):
                     if isinstance(msg.content, str):
                         user_system_prompt = msg.content.replace('{memory}', memory)
+                        msg.content = user_system_prompt
                     elif isinstance(msg.content, list):
                         user_system_prompt = ''.join(
                             item.get('text', '') if isinstance(item, dict) else str(item)

apps/application/flow/compare/__init__.py

@@ -6,31 +6,78 @@
     @date：2024/6/7 14:43
     @desc:
 """
+from typing import List
 
-from .contain_compare import *
+from .contain_compare import ContainCompare
 from .end_with import EndWithCompare
-from .equal_compare import *
-from .ge_compare import *
-from .gt_compare import *
-from .is_not_null_compare import *
+from .equal_compare import EqualCompare
+from .ge_compare import GECompare
+from .gt_compare import GTCompare
+from .is_not_null_compare import IsNotNullCompare
 from .is_not_true import IsNotTrueCompare
-from .is_null_compare import *
+from .is_null_compare import IsNullCompare
 from .is_true import IsTrueCompare
-from .le_compare import *
-from .len_equal_compare import *
-from .len_ge_compare import *
-from .len_gt_compare import *
-from .len_le_compare import *
-from .len_lt_compare import *
-from .lt_compare import *
-from .not_contain_compare import *
-from .not_equal_compare import *
+from .le_compare import LECompare
+from .len_equal_compare import LenEqualCompare
+from .len_ge_compare import LenGECompare
+from .len_gt_compare import LenGTCompare
+from .len_le_compare import LenLECompare
+from .len_lt_compare import LenLTCompare
+from .lt_compare import LTCompare
+from .not_contain_compare import NotContainCompare
+from .not_equal_compare import NotEqualCompare
 from .regex_compare import RegexCompare
 from .start_with import StartWithCompare
 from .wildcard_compare import WildcardCompare
 
-compare_handle_list = [GECompare(), GTCompare(), ContainCompare(), EqualCompare(), LTCompare(), LECompare(),
-                       LenLECompare(), LenGECompare(), LenEqualCompare(), LenGTCompare(), LenLTCompare(),
-                       IsNullCompare(),
-                       IsNotNullCompare(), NotContainCompare(), NotEqualCompare(), IsTrueCompare(), IsNotTrueCompare(), StartWithCompare(),
-                       EndWithCompare(), RegexCompare(), WildcardCompare()]
+_compare_handler_dict = {
+    'is_null': IsNullCompare(),
+    'is_not_null': IsNotNullCompare(),
+    'contain': ContainCompare(),
+    'not_contain': NotContainCompare(),
+    'eq': EqualCompare(),
+    'not_eq': NotEqualCompare(),
+    'ge': GECompare(),
+    'gt': GTCompare(),
+    'le': LECompare(),
+    'lt': LTCompare(),
+    'len_eq': LenEqualCompare(),
+    'len_ge': LenGECompare(),
+    'len_gt': LenGTCompare(),
+    'len_le': LenLECompare(),
+    'len_lt': LenLTCompare(),
+    'is_true': IsTrueCompare(),
+    'is_not_true': IsNotTrueCompare(),
+    'start_with': StartWithCompare(),
+    'end_with': EndWithCompare(),
+    'regex': RegexCompare(),
+    'wildcard': WildcardCompare(),
+}
+
+
+def _compare(source_value, compare, target_value):
+    compare_handler = _compare_handler_dict.get(compare)
+    if compare_handler is None:
+        raise RuntimeError(f"Unknown compare handler '{compare}'")
+    return compare_handler.compare(source_value, compare, target_value)
+
+
+def _assertion(workflow_manage, field_list: List[str], compare: str, value):
+    try:
+        value = workflow_manage.generate_prompt(value)
+    except Exception:
+        pass
+    field_value = None
+    try:
+        field_value = workflow_manage.get_reference_field(field_list[0], field_list[1:])
+    except  Exception:
+        pass
+    return _compare(field_value, compare, value)
+
+
+def do_assertion(workflow_manage, condition, condition_list):
+    b = False if condition == 'and' else True
+    for row in condition_list:
+        if _assertion(workflow_manage, row.get('field'), row.get('compare'), row.get('value')) is b:
+            return b
+    return not b

apps/application/flow/compare/compare.py

@@ -7,13 +7,8 @@
     @desc:
 """
 from abc import abstractmethod
-from typing import List
-
 
 class Compare:
-    @abstractmethod
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        pass
 
     @abstractmethod
     def compare(self, source_value, compare, target_value):

apps/application/flow/compare/contain_compare.py

@@ -6,17 +6,11 @@
     @date：2024/6/11 10:02
     @desc:
 """
-from typing import List
-
-from application.flow.compare.compare import Compare
+from .compare import Compare
 
 
 class ContainCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'contain':
-            return True
-
     def compare(self, source_value, compare, target_value):
         target_value = str(target_value)
 

apps/application/flow/compare/end_with.py

@@ -6,17 +6,11 @@
     @date：2025/10/20 10:37
     @desc:
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class EndWithCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'end_with':
-            return True
-
     def compare(self, source_value, compare, target_value):
         source_value = str(source_value)
         return source_value.endswith(str(target_value))

apps/application/flow/compare/equal_compare.py

@@ -6,16 +6,10 @@
     @date：2024/6/7 14:44
     @desc:
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class EqualCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'eq':
-            return True
-
     def compare(self, source_value, compare, target_value):
         return str(source_value) == str(target_value)

apps/application/flow/compare/ge_compare.py

@@ -6,23 +6,17 @@
     @date：2024/6/11 9:52
     @desc: 大于比较器
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class GECompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'ge':
-            return True
-
     def compare(self, source_value, compare, target_value):
         try:
             return float(source_value) >= float(target_value)
-        except Exception as e:
+        except Exception:
             try:
                 return str(source_value) >= str(target_value)
-            except Exception as _:
+            except Exception:
                 pass
             return False

apps/application/flow/compare/gt_compare.py

@@ -6,23 +6,17 @@
     @date：2024/6/11 9:52
     @desc: 大于比较器
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class GTCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'gt':
-            return True
-
     def compare(self, source_value, compare, target_value):
         try:
             return float(source_value) > float(target_value)
-        except Exception as e:
+        except Exception:
             try:
                 return str(source_value) > str(target_value)
-            except Exception as _:
+            except Exception:
                 pass
             return False

apps/application/flow/compare/is_not_null_compare.py

@@ -6,17 +6,11 @@
     @date：2024/6/28 10:45
     @desc:
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class IsNotNullCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'is_not_null':
-            return True
-
     def compare(self, source_value, compare, target_value):
         try:
             return source_value is not None and len(source_value) > 0

apps/application/flow/compare/is_not_true.py

@@ -6,19 +6,13 @@
     @date：2025/4/7 13:44
     @desc:
 """
-from typing import List
-
-from application.flow.compare import Compare
+from .compare import Compare
 
 
 class IsNotTrueCompare(Compare):
 
-    def support(self, node_id, fields: List[str], source_value, compare, target_value):
-        if compare == 'is_not_true':
-            return True
-
     def compare(self, source_value, compare, target_value):
         try:
             return source_value is False
-        except Exception as e:
+        except Exception:
             return False