add message error record

api/core/app/task_pipeline/based_generate_task_pipeline.py

@@ -14,10 +14,12 @@ from core.app.entities.task_entities import (
     PingStreamResponse,
     TaskState,
 )
+from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
 from core.model_runtime.errors.invoke import InvokeAuthorizationError, InvokeError
 from core.moderation.output_moderation import ModerationRule, OutputModeration
+from extensions.ext_database import db
 from models.account import Account
-from models.model import EndUser
+from models.model import EndUser, Message
 
 logger = logging.getLogger(__name__)
 
@@ -48,21 +50,60 @@ class BasedGenerateTaskPipeline:
         self._output_moderation_handler = self._init_output_moderation()
         self._stream = stream
 
-    def _handle_error(self, event: QueueErrorEvent) -> Exception:
+    def _handle_error(self, event: QueueErrorEvent, message: Optional[Message] = None) -> Exception:
         """
         Handle error event.
         :param event: event
+        :param message: message
         :return:
         """
         logger.debug("error: %s", event.error)
         e = event.error
 
         if isinstance(e, InvokeAuthorizationError):
-            return InvokeAuthorizationError('Incorrect API key provided')
+            err = InvokeAuthorizationError('Incorrect API key provided')
         elif isinstance(e, InvokeError) or isinstance(e, ValueError):
-            return e
+            err = e
         else:
-            return Exception(e.description if getattr(e, 'description', None) is not None else str(e))
+            err = Exception(e.description if getattr(e, 'description', None) is not None else str(e))
+
+        if message:
+            message = db.session.query(Message).filter(Message.id == message.id).first()
+            err_desc = self._error_to_desc(err)
+            message.status = 'error'
+            message.error = err_desc
+
+            db.session.commit()
+
+        return err
+
+    def _error_to_desc(cls, e: Exception) -> str:
+        """
+        Error to desc.
+        :param e: exception
+        :return:
+        """
+        error_responses = {
+            ValueError: None,
+            ProviderTokenNotInitError: None,
+            QuotaExceededError: "Your quota for Dify Hosted Model Provider has been exhausted. "
+                                "Please go to Settings -> Model Provider to complete your own provider credentials.",
+            ModelCurrentlyNotSupportError: None,
+            InvokeError: None
+        }
+
+        # Determine the response based on the type of exception
+        data = None
+        for k, v in error_responses.items():
+            if isinstance(e, k):
+                data = v
+
+        if data:
+            message = getattr(e, 'description', str(e)) if data is None else data
+        else:
+            message = 'Internal Server Error, please contact support.'
+
+        return message
 
     def _error_to_stream_response(self, e: Exception) -> ErrorStreamResponse:
         """

api/core/app/task_pipeline/easy_ui_based_generate_task_pipeline.py

@@ -1,3 +1,4 @@
+import json
 import logging
 import time
 from collections.abc import Generator
@@ -195,7 +196,7 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline, MessageCycleMan
             event = message.event
 
             if isinstance(event, QueueErrorEvent):
-                err = self._handle_error(event)
+                err = self._handle_error(event, self._message)
                 yield self._error_to_stream_response(err)
                 break
             elif isinstance(event, QueueStopEvent | QueueMessageEndEvent):
@@ -281,6 +282,8 @@ class EasyUIBasedGenerateTaskPipeline(BasedGenerateTaskPipeline, MessageCycleMan
         self._message.provider_response_latency = time.perf_counter() - self._start_at
         self._message.total_price = usage.total_price
         self._message.currency = usage.currency
+        self._message.message_metadata = json.dumps(jsonable_encoder(self._task_state.metadata)) \
+            if self._task_state.metadata else None
 
         db.session.commit()
 

api/core/app/task_pipeline/workflow_cycle_manage.py

@@ -458,11 +458,24 @@ class WorkflowCycleManage:
 
     def _handle_workflow_finished(self, event: QueueStopEvent | QueueWorkflowSucceededEvent | QueueWorkflowFailedEvent) \
             -> Optional[WorkflowRun]:
-        workflow_run = db.session.query(WorkflowRun).filter(WorkflowRun.id == self._task_state.workflow_run_id).first()
-        if not workflow_run:
-            return None
-
         if isinstance(event, QueueStopEvent):
+            latest_node_execution_info = self._task_state.latest_node_execution_info
+            if latest_node_execution_info:
+                workflow_node_execution = db.session.query(WorkflowNodeExecution).filter(
+                    WorkflowNodeExecution.id == latest_node_execution_info.workflow_node_execution_id).first()
+                if (workflow_node_execution
+                        and workflow_node_execution.status == WorkflowNodeExecutionStatus.RUNNING.value):
+                    self._workflow_node_execution_failed(
+                        workflow_node_execution=workflow_node_execution,
+                        start_at=latest_node_execution_info.start_at,
+                        error='Workflow stopped.'
+                    )
+
+            workflow_run = db.session.query(WorkflowRun).filter(
+                WorkflowRun.id == self._task_state.workflow_run_id).first()
+            if not workflow_run:
+                return None
+
             workflow_run = self._workflow_run_failed(
                 workflow_run=workflow_run,
                 start_at=self._task_state.start_at,