service-forge 0.1.11__py3-none-any.whl → 0.1.24__py3-none-any.whl

service_forge/storage/feedback_storage.py

@@ -0,0 +1,245 @@
+from typing import Optional, Any
+from datetime import datetime
+from uuid import uuid4
+from loguru import logger
+from sqlalchemy import select, and_
+from sqlalchemy.exc import SQLAlchemyError
+
+from ..db.models.feedback import FeedbackBase
+from ..db.database import DatabaseManager
+
+
+class FeedbackStorage:
+    """反馈存储管理器 - 使用 PostgreSQL 数据库存储"""
+
+    def __init__(self, database_manager: DatabaseManager = None):
+        self.database_manager = database_manager
+        self._db = None
+        # 内存存储后备(用于数据库未配置时)
+        self._storage: dict[str, dict[str, Any]] = {}
+        self._task_index: dict[str, list[str]] = {}
+        self._workflow_index: dict[str, list[str]] = {}
+
+    @property
+    def db(self):
+        """延迟获取数据库连接"""
+        if self._db is None and self.database_manager is not None:
+            self._db = self.database_manager.get_default_postgres_database()
+        return self._db
+
+    async def create_feedback(
+        self,
+        task_id: str,
+        workflow_name: str,
+        rating: Optional[int] = None,
+        comment: Optional[str] = None,
+        metadata: Optional[dict[str, Any]] = None,
+    ) -> dict[str, Any]:
+        """创建新的反馈记录"""
+        if self.db is None:
+            logger.warning("数据库未初始化,使用内存存储(数据将在重启后丢失)")
+            return self._create_feedback_in_memory(task_id, workflow_name, rating, comment, metadata)
+
+        try:
+            feedback_id = uuid4()
+            created_at = datetime.now()
+
+            feedback = FeedbackBase(
+                feedback_id=feedback_id,
+                task_id=task_id,
+                workflow_name=workflow_name,
+                rating=rating,
+                comment=comment,
+                extra_metadata=metadata or {},
+                created_at=created_at,
+            )
+
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                session.add(feedback)
+                await session.commit()
+                await session.refresh(feedback)
+
+                logger.info(f"创建反馈: feedback_id={feedback_id}, task_id={task_id}, workflow={workflow_name}")
+                return feedback.to_dict()
+
+        except SQLAlchemyError as e:
+            logger.error(f"数据库创建反馈失败: {e}")
+            raise
+        except Exception as e:
+            logger.error(f"创建反馈失败: {e}")
+            raise
+
+    async def get_feedback(self, feedback_id: str) -> Optional[dict[str, Any]]:
+        """根据反馈ID获取反馈"""
+        if self.db is None:
+            return self._get_feedback_from_memory(feedback_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).where(FeedbackBase.feedback_id == feedback_id)
+                )
+                feedback = result.scalar_one_or_none()
+                return feedback.to_dict() if feedback else None
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询反馈失败: {e}")
+            return None
+
+    async def get_feedbacks_by_task(self, task_id: str) -> list[dict[str, Any]]:
+        """根据任务ID获取所有反馈"""
+        if self.db is None:
+            return self._get_feedbacks_by_task_from_memory(task_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase)
+                    .where(FeedbackBase.task_id == task_id)
+                    .order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询任务反馈失败: {e}")
+            return []
+
+    async def get_feedbacks_by_workflow(self, workflow_name: str) -> list[dict[str, Any]]:
+        """根据工作流名称获取所有反馈"""
+        if self.db is None:
+            return self._get_feedbacks_by_workflow_from_memory(workflow_name)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase)
+                    .where(FeedbackBase.workflow_name == workflow_name)
+                    .order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询工作流反馈失败: {e}")
+            return []
+
+    async def get_all_feedbacks(self) -> list[dict[str, Any]]:
+        """获取所有反馈"""
+        if self.db is None:
+            return self._get_all_feedbacks_from_memory()
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).order_by(FeedbackBase.created_at.desc())
+                )
+                feedbacks = result.scalars().all()
+                return [f.to_dict() for f in feedbacks]
+
+        except SQLAlchemyError as e:
+            logger.error(f"查询所有反馈失败: {e}")
+            return []
+
+    async def delete_feedback(self, feedback_id: str) -> bool:
+        """删除反馈"""
+        if self.db is None:
+            return self._delete_feedback_from_memory(feedback_id)
+
+        try:
+            session_factory = await self.db.get_session_factory()
+            async with session_factory() as session:
+                result = await session.execute(
+                    select(FeedbackBase).where(FeedbackBase.feedback_id == feedback_id)
+                )
+                feedback = result.scalar_one_or_none()
+
+                if not feedback:
+                    return False
+
+                await session.delete(feedback)
+                await session.commit()
+
+                logger.info(f"删除反馈: feedback_id={feedback_id}")
+                return True
+
+        except SQLAlchemyError as e:
+            logger.error(f"删除反馈失败: {e}")
+            return False
+
+    # ========== 内存存储后备方法(用于数据库未配置时) ==========
+
+    def _create_feedback_in_memory(
+        self,
+        task_id: str,
+        workflow_name: str,
+        rating: Optional[int],
+        comment: Optional[str],
+        metadata: Optional[dict[str, Any]],
+    ) -> dict[str, Any]:
+        """内存存储版本"""
+        feedback_id = str(uuid4())
+        created_at = datetime.now()
+
+        feedback_data = {
+            "feedback_id": feedback_id,
+            "task_id": task_id,
+            "workflow_name": workflow_name,
+            "rating": rating,
+            "comment": comment,
+            "metadata": metadata or {},
+            "created_at": created_at,
+        }
+
+        self._storage[feedback_id] = feedback_data
+
+        if task_id not in self._task_index:
+            self._task_index[task_id] = []
+        self._task_index[task_id].append(feedback_id)
+
+        if workflow_name not in self._workflow_index:
+            self._workflow_index[workflow_name] = []
+        self._workflow_index[workflow_name].append(feedback_id)
+
+        logger.info(f"[内存存储]创建反馈: feedback_id={feedback_id}")
+        return feedback_data
+
+    def _get_feedback_from_memory(self, feedback_id: str) -> Optional[dict[str, Any]]:
+        return self._storage.get(feedback_id)
+
+    def _get_feedbacks_by_task_from_memory(self, task_id: str) -> list[dict[str, Any]]:
+        feedback_ids = self._task_index.get(task_id, [])
+        return [self._storage[fid] for fid in feedback_ids if fid in self._storage]
+
+    def _get_feedbacks_by_workflow_from_memory(self, workflow_name: str) -> list[dict[str, Any]]:
+        feedback_ids = self._workflow_index.get(workflow_name, [])
+        return [self._storage[fid] for fid in feedback_ids if fid in self._storage]
+
+    def _get_all_feedbacks_from_memory(self) -> list[dict[str, Any]]:
+        return list(self._storage.values())
+
+    def _delete_feedback_from_memory(self, feedback_id: str) -> bool:
+        if feedback_id not in self._storage:
+            return False
+
+        feedback = self._storage[feedback_id]
+        task_id = feedback["task_id"]
+        workflow_name = feedback["workflow_name"]
+
+        if task_id in self._task_index:
+            self._task_index[task_id].remove(feedback_id)
+        if workflow_name in self._workflow_index:
+            self._workflow_index[workflow_name].remove(feedback_id)
+
+        del self._storage[feedback_id]
+        logger.info(f"[内存存储]删除反馈: feedback_id={feedback_id}")
+        return True
+
+
+# 全局单例实例
+feedback_storage = FeedbackStorage()

service_forge/utils/default_type_converter.py

@@ -2,8 +2,8 @@ from ..utils.type_converter import TypeConverter
 from ..workflow.workflow import Workflow
 from ..api.http_api import fastapi_app
 from ..api.kafka_api import KafkaApp, kafka_app
-from fastapi import FastAPI
 from ..workflow.workflow_type import WorkflowType, workflow_type_register
+from fastapi import FastAPI
 
 type_converter = TypeConverter()
 type_converter.register(str, Workflow, lambda s, node: node.sub_workflows.get_workflow(s))

service_forge/utils/type_converter.py

@@ -1,6 +1,8 @@
 from typing import Any, Callable, Type, Dict, Tuple, Set, List
 from collections import deque
 import inspect
+import traceback
+from pydantic import BaseModel
 from typing_extensions import get_origin, get_args
 
 def is_type(value, dst_type):
@@ -57,6 +59,9 @@ class TypeConverter:
         except Exception:
             pass
 
+        if issubclass(dst_type, BaseModel) and isinstance(value, dict):
+            return dst_type(**value)
+
         path = self._find_path(src_type, dst_type)
         if not path:
             raise TypeError(f"No conversion path found from {src_type.__name__} to {dst_type.__name__}.")

service_forge/utils/workflow_clone.py

@@ -57,8 +57,8 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         }
 
     workflow = Workflow(
-        name=self.name,
-        description=self.description,
+        id=self.id,
+        config=self.config,
         nodes=[node_map[node] for node in self.nodes],
         input_ports=[port_map[port] for port in self.input_ports],
         output_ports=[port_map[port] for port in self.output_ports],
@@ -69,6 +69,7 @@ def workflow_clone(self: Workflow, task_id: uuid.UUID, trigger_node: Trigger) ->
         callbacks=self.callbacks,
         task_id=task_id,
         real_trigger_node=trigger_node,
+        global_context=self.global_context,
     )
 
     for node in workflow.nodes:

service_forge/workflow/node.py

@@ -10,6 +10,7 @@ from .context import Context
 from ..utils.register import Register
 from ..db.database import DatabaseManager, PostgresDatabase, MongoDatabase, RedisDatabase
 from ..utils.workflow_clone import node_clone
+from .workflow_callback import CallbackEvent
 
 if TYPE_CHECKING:
     from .workflow import Workflow
@@ -62,6 +63,10 @@ class Node(ABC):
     def database_manager(self) -> DatabaseManager:
         return self.workflow.database_manager
 
+    @property
+    def global_context(self) -> Context:
+        return self.workflow.global_context
+
     def backup(self) -> None:
         # do NOT use deepcopy here
         # self.bak_context = deepcopy(self.context)
@@ -181,4 +186,7 @@ class Node(ABC):
     def _clone(self, context: Context) -> Node:
         return node_clone(self, context)
 
+    async def stream_output(self, data: Any) -> None:
+         await self.workflow.call_callbacks(CallbackEvent.ON_NODE_STREAM_OUTPUT, node=self, output=data)
+
 node_register = Register[Node]()

service_forge/workflow/nodes/llm/query_llm_node.py

@@ -36,6 +36,6 @@ class QueryLLMNode(Node):
                 prompt = f.read()
 
         print(f"prompt: {prompt} temperature: {temperature}")
-        response = chat_stream(prompt, system_prompt, Model.DEEPSEEK_V3_250324, temperature)
+        response = chat_stream(prompt, system_prompt, Model.GEMINI, temperature)
         for chunk in response:
             yield chunk

service_forge/workflow/trigger.py

@@ -19,6 +19,10 @@ class Trigger(Node, ABC):
     async def _run(self) -> AsyncIterator[bool]:
         ...
 
+    @abstractmethod
+    async def _stop(self) -> AsyncIterator[bool]:
+        ...
+
     def trigger(self, task_id: uuid.UUID) -> bool:
         self.prepare_output_edges(self.get_output_port_by_name('trigger'), True)
         return task_id

service_forge/workflow/triggers/a2a_api_trigger.py

@@ -253,3 +253,5 @@ class A2AAPITrigger(Trigger):
                 logger.error(f"Error in A2AAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/fast_api_trigger.py

@@ -33,6 +33,9 @@ class FastAPITrigger(Trigger):
         super().__init__(name)
         self.events = {}
         self.is_setup_route = False
+        self.app = None
+        self.route_path = None
+        self.route_method = None
 
     @staticmethod
     def serialize_result(result: Any):
@@ -141,6 +144,11 @@ class FastAPITrigger(Trigger):
         async def handler(request: Request):
             return await self.handle_request(request, data_type, extractor, is_stream)
 
+        # Save route information for cleanup
+        self.app = app
+        self.route_path = path
+        self.route_method = method.upper()
+
         if method == "GET":
             app.get(path)(handler)
         elif method == "POST":
@@ -167,3 +175,27 @@ class FastAPITrigger(Trigger):
                 logger.error(f"Error in FastAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        if self.is_setup_route:
+            # Remove the route from the app
+            if self.app and self.route_path and self.route_method:
+                # Find and remove matching route
+                routes_to_remove = []
+                for route in self.app.routes:
+                    if hasattr(route, "path") and hasattr(route, "methods"):
+                        if route.path == self.route_path and self.route_method in route.methods:
+                            routes_to_remove.append(route)
+                
+                # Remove found routes
+                for route in routes_to_remove:
+                    try:
+                        self.app.routes.remove(route)
+                        logger.info(f"Removed route {self.route_method} {self.route_path} from FastAPI app")
+                    except ValueError:
+                        logger.warning(f"Route {self.route_method} {self.route_path} not found in app.routes")
+            
+            # Reset route information
+            self.app = None
+            self.route_path = None
+            self.route_method = None
+            self.is_setup_route = False

service_forge/workflow/triggers/kafka_api_trigger.py

@@ -42,3 +42,6 @@ class KafkaAPITrigger(Trigger):
             trigger = await self.trigger_queue.get()
             self.prepare_output_edges(self.get_output_port_by_name('data'), trigger['data'])
             yield self.trigger(trigger['id'])
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/once_trigger.py

@@ -17,4 +17,7 @@ class OnceTrigger(Trigger):
         super().__init__(name)
 
     async def _run(self) -> AsyncIterator[bool]:
-        yield self.trigger(uuid.uuid4())
+        yield self.trigger(uuid.uuid4())
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/period_trigger.py

@@ -23,4 +23,7 @@ class PeriodTrigger(Trigger):
     async def _run(self, times: int, period: float) -> AsyncIterator[bool]:
         for _ in range(times):
             await asyncio.sleep(period)
-            yield uuid.uuid4()
+            yield uuid.uuid4()
+
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/triggers/websocket_api_trigger.py

@@ -120,12 +120,16 @@ class WebSocketAPITrigger(Trigger):
         self.result_queues[task_id] = asyncio.Queue()
         self.stream_queues[task_id] = asyncio.Queue()
 
-        try:
-            converted_data = data_type(**message_data)
-        except Exception as e:
-            error_msg = {"error": f"Failed to convert data: {str(e)}"}
-            await websocket.send_text(json.dumps(error_msg))
-            return
+        if data_type is Any:
+            converted_data = message_data
+        else:
+            try:
+                # TODO: message_data is Message, need to convert to dict
+                converted_data = data_type(**message_data)
+            except Exception as e:
+                error_msg = {"error": f"Failed to convert data: {str(e)}"}
+                await websocket.send_text(json.dumps(error_msg))
+                return
 
         # Always start background task to handle stream output
         asyncio.create_task(self.handle_stream_output(websocket, task_id))
@@ -143,16 +147,14 @@ class WebSocketAPITrigger(Trigger):
             
             try:
                 while True:
-                    # Receive message from client
-                    data = await websocket.receive_text()
+                    data = await websocket.receive()
                     try:
-                        message = json.loads(data)
-                        
+                        # message = json.loads(data)
                         # Handle the message and trigger workflow
                         await self.handle_websocket_message(
                             websocket,
                             data_type,
-                            message
+                            data
                         )
                     except json.JSONDecodeError:
                         error_msg = {"error": "Invalid JSON format"}
@@ -182,3 +184,5 @@ class WebSocketAPITrigger(Trigger):
                 logger.error(f"Error in WebSocketAPITrigger._run: {e}")
                 continue
 
+    async def _stop(self) -> AsyncIterator[bool]:
+        pass

service_forge/workflow/workflow.py

@@ -12,12 +12,14 @@ from .edge import Edge
 from ..db.database import DatabaseManager
 from ..utils.workflow_clone import workflow_clone
 from .workflow_callback import WorkflowCallback, BuiltinWorkflowCallback, CallbackEvent
+from .workflow_config import WorkflowConfig
+from .context import Context
 
 class Workflow:
     def __init__(
         self,
-        name: str,
-        description: str,
+        id: uuid.UUID,
+        config: WorkflowConfig,
         nodes: list[Node],
         input_ports: list[Port],
         output_ports: list[Port],
@@ -30,9 +32,12 @@ class Workflow:
         # for run
         task_id: uuid.UUID = None,
         real_trigger_node: Trigger = None,
+
+        # global variables
+        global_context: Context = None,
     ) -> None:
-        self.name = name
-        self.description = description
+        self.id = id
+        self.config = config
         self.nodes = nodes
         self.ready_nodes: list[Node] = []
         self.input_ports = input_ports
@@ -47,7 +52,20 @@ class Workflow:
         self.callbacks = callbacks
         self.task_id = task_id
         self.real_trigger_node = real_trigger_node
+        self.global_context = global_context
         self._validate()
+    
+    @property
+    def name(self) -> str:
+        return self.config.name
+    
+    @property
+    def version(self) -> str:
+        return self.config.version
+    
+    @property
+    def description(self) -> str:
+        return self.config.description
 
     def register_callback(self, callback: WorkflowCallback) -> None:
         self.callbacks.append(callback)
@@ -61,6 +79,8 @@ class Workflow:
                 await callback.on_workflow_start(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_WORKFLOW_END:
                 await callback.on_workflow_end(*args, **kwargs)
+            elif callback_type == CallbackEvent.ON_WORKFLOW_ERROR:
+                await callback.on_workflow_error(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_NODE_START:
                 await callback.on_node_start(*args, **kwargs)
             elif callback_type == CallbackEvent.ON_NODE_END:
@@ -104,7 +124,7 @@ class Workflow:
             raise ValueError("Multiple trigger nodes found in workflow.")
         return trigger_nodes[0]
 
-    async def _run_node_with_callbacks(self, node: Node) -> None:
+    async def _run_node_with_callbacks(self, node: Node) -> bool:
         await self.call_callbacks(CallbackEvent.ON_NODE_START, node=node)
         
         try:
@@ -113,8 +133,13 @@ class Workflow:
                 await self.handle_node_stream_output(node, result)
             elif asyncio.iscoroutine(result):
                 await result
+        except Exception as e:
+            await self.call_callbacks(CallbackEvent.ON_WORKFLOW_ERROR, workflow=self, node=node, error=e)
+            logger.error(f"Error when running node {node.name}: {str(e)}, task_id: {self.task_id}")
+            return False
         finally:
             await self.call_callbacks(CallbackEvent.ON_NODE_END, node=node)
+        return True
 
     async def run_after_trigger(self) -> Any:
         logger.info(f"Running workflow: {self.name}")
@@ -125,30 +150,41 @@ class Workflow:
         for edge in self.get_trigger_node().output_edges:
             edge.end_port.trigger()
 
-        try:
-            for input_port in self.input_ports:
-                if input_port.value is not None:
-                    input_port.port.node.fill_input(input_port.port, input_port.value)
-
-            for node in self.nodes:
-                for key in node.AUTO_FILL_INPUT_PORTS:
-                    if key[0] not in [edge.end_port.name for edge in node.input_edges]:
-                        node.fill_input_by_name(key[0], key[1])
-
-            while self.ready_nodes:
-                nodes = self.ready_nodes.copy()
-                self.ready_nodes = []
-
-                tasks = []
-                for node in nodes:
-                    tasks.append(asyncio.create_task(self._run_node_with_callbacks(node)))
-
-                await asyncio.gather(*tasks)
-
-        except Exception as e:
-            error_msg = f"Error in run_after_trigger: {str(e)}"
-            logger.error(error_msg)
-            raise e
+        for input_port in self.input_ports:
+            if input_port.value is not None:
+                input_port.port.node.fill_input(input_port.port, input_port.value)
+
+        for node in self.nodes:
+            for key in node.AUTO_FILL_INPUT_PORTS:
+                if key[0] not in [edge.end_port.name for edge in node.input_edges]:
+                    node.fill_input_by_name(key[0], key[1])
+
+        while self.ready_nodes:
+            nodes = self.ready_nodes.copy()
+            self.ready_nodes = []
+
+            tasks = []
+            for node in nodes:
+                tasks.append(asyncio.create_task(self._run_node_with_callbacks(node)))
+
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            
+            for i, result in enumerate(results):
+                if isinstance(result, Exception):
+                    for task in tasks:
+                        if not task.done():
+                            task.cancel()
+                    await asyncio.gather(*tasks, return_exceptions=True)
+                    return
+                    # raise result
+                elif result is False:
+                    logger.error(f"Node execution failed, stopping workflow: {nodes[i].name}")
+                    for task in tasks:
+                        if not task.done():
+                            task.cancel()
+                    await asyncio.gather(*tasks, return_exceptions=True)
+                    return
+                    # raise RuntimeError(f"Workflow stopped due to node execution failure: {nodes[i].name}")
 
         if len(self.output_ports) > 0:
             if len(self.output_ports) == 1:
@@ -173,8 +209,11 @@ class Workflow:
                 # TODO: clear new_workflow
 
             except Exception as e:
-                error_msg = f"Error running workflow: {str(e)}, {traceback.format_exc()}"
-                logger.error(error_msg)
+                await self.call_callbacks(CallbackEvent.ON_WORKFLOW_ERROR, workflow=self, node=None, error=e)
+                # error_msg = f"Error running workflow: {str(e)}, {traceback.format_exc()}"
+                # logger.error(error_msg)
+                # await self.call_callbacks(CallbackEvent.ON_WORKFLOW_END, workflow=self, node=None, error=e)
+                return
 
     async def run(self):
         tasks = []
@@ -186,6 +225,10 @@ class Workflow:
         if tasks:
             await asyncio.gather(*tasks)
 
+    async def stop(self):
+        trigger = self.get_trigger_node()
+        await trigger._stop()
+
     def trigger(self, trigger_name: str, **kwargs) -> uuid.UUID:
         trigger = self.get_trigger_node()
         task_id = uuid.uuid4()

service_forge/workflow/workflow_callback.py

@@ -31,7 +31,7 @@ class WorkflowCallback:
         pass
 
     @abstractmethod
-    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+    async def on_workflow_error(self, workflow: Workflow, node: Node, error: Any) -> None:
         pass
 
     @abstractmethod
@@ -90,7 +90,7 @@ class BuiltinWorkflowCallback(WorkflowCallback):
             logger.error(f"发送 workflow_end 消息到 websocket 失败: {e}")
 
     @override
-    async def on_workflow_error(self, workflow: Workflow, error: Any) -> None:
+    async def on_workflow_error(self, workflow: Workflow, node: Node | None, error: Any) -> None:
         workflow_result = WorkflowResult(result=error, is_end=False, is_error=True)
         
         if workflow.task_id in workflow.real_trigger_node.result_queues:
@@ -103,6 +103,7 @@ class BuiltinWorkflowCallback(WorkflowCallback):
             message = {
                 "type": "workflow_error",
                 "task_id": str(workflow.task_id),
+                "node": node.name if node else None,
                 "error": self._serialize_result(error),
                 "is_end": False,
                 "is_error": True