后端没修完版

src/langbot/pkg/platform/botmgr.py

@@ -2,7 +2,6 @@ from __future__ import annotations
 
 import asyncio
 import json
-import re
 import traceback
 import sqlalchemy
 
@@ -54,29 +53,24 @@ class RuntimeBot:
         self.task_context = taskmgr.TaskContext()
         self.logger = logger
 
-    @staticmethod
-    def _match_operator(actual: str, operator: str, expected: str) -> bool:
-        """Evaluate a single operator condition."""
-        if operator == 'eq':
-            return actual == expected
-        elif operator == 'neq':
-            return actual != expected
-        elif operator == 'contains':
-            return expected in actual
-        elif operator == 'not_contains':
-            return expected not in actual
-        elif operator == 'starts_with':
-            return actual.startswith(expected)
-        elif operator == 'regex':
-            try:
-                return bool(re.search(expected, actual))
-            except re.error:
-                return False
-        return False
-
     PIPELINE_DISCARD = '__discard__'
     PIPELINE_DISCARD_DISPLAY_NAME = 'Discarded'
 
+    def get_binding_info(self) -> tuple[str, str | None]:
+        """Get the binding type and UUID for this bot.
+        
+        Returns:
+            tuple: (binding_type, binding_uuid) where binding_type is 'pipeline' or 'workflow'
+        """
+        binding_type = getattr(self.bot_entity, 'binding_type', 'pipeline') or 'pipeline'
+        binding_uuid = getattr(self.bot_entity, 'binding_uuid', None)
+        
+        # Fallback to use_pipeline_uuid for backward compatibility
+        if not binding_uuid and binding_type == 'pipeline':
+            binding_uuid = self.bot_entity.use_pipeline_uuid
+            
+        return binding_type, binding_uuid
+
     def resolve_pipeline_uuid(
         self,
         launcher_type: str,
@@ -84,56 +78,26 @@ class RuntimeBot:
         message_text: str,
         message_element_types: list[str] | None = None,
     ) -> tuple[str | None, bool]:
-        """Resolve pipeline UUID based on routing rules.
+        """Resolve pipeline UUID for message processing.
 
-        Rules are evaluated in order; first match wins.
-        Falls back to use_pipeline_uuid if no rule matches.
-
-        Rule types:
-          - launcher_type: session type ("person" / "group")
-          - launcher_id: session / group id
-          - message_content: message text content
-          - message_has_element: message contains element of given type
-            (Image, Voice, File, Forward, Face, At, AtAll, Quote)
-            Operators: eq (has), neq (doesn't have)
-
-        Operators: eq, neq, contains, not_contains, starts_with, regex
-
-        When pipeline_uuid is ``__discard__``, the message should be
-        silently dropped by the caller.
+        NOTE: Routing rules have been removed. Bot now directly binds to a
+        Pipeline or Workflow. This method is kept for backward compatibility
+        but only returns the direct binding.
 
         Returns:
-            tuple: (pipeline_uuid, routed_by_rule) - routed_by_rule is True
-            when a routing rule matched, False when falling back to default.
+            tuple: (pipeline_uuid, routed_by_rule) - routed_by_rule is always False
+            as routing rules are no longer used.
         """
-        rules = self.bot_entity.pipeline_routing_rules or []
-        element_type_set = set(message_element_types or [])
-
-        for rule in rules:
-            rule_type = rule.get('type')
-            operator = rule.get('operator', 'eq')
-            rule_value = rule.get('value', '')
-            target_uuid = rule.get('pipeline_uuid')
-            if not rule_type or not target_uuid:
-                continue
-
-            if rule_type == 'launcher_type':
-                if self._match_operator(launcher_type, operator, rule_value):
-                    return target_uuid, True
-            elif rule_type == 'launcher_id':
-                if self._match_operator(str(launcher_id), operator, str(rule_value)):
-                    return target_uuid, True
-            elif rule_type == 'message_content':
-                if self._match_operator(message_text, operator, rule_value):
-                    return target_uuid, True
-            elif rule_type == 'message_has_element':
-                has_element = rule_value in element_type_set
-                if operator == 'eq' and has_element:
-                    return target_uuid, True
-                elif operator == 'neq' and not has_element:
-                    return target_uuid, True
-
-        return self.bot_entity.use_pipeline_uuid, False
+        binding_type, binding_uuid = self.get_binding_info()
+        
+        # If bound to workflow, return None for pipeline_uuid
+        # The caller should check binding_type and handle accordingly
+        if binding_type == 'workflow':
+            # For workflow binding, we still need to return something
+            # The actual workflow handling should be done by the caller
+            return None, False
+            
+        return binding_uuid, False
 
     async def _record_discarded_message(
         self,

src/langbot/pkg/platform/sources/websocket_adapter.py

@@ -369,6 +369,7 @@ class WebSocketAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter)
         """
         pipeline_uuid = connection.pipeline_uuid
         session_type = connection.session_type
+        is_workflow = bool(connection.metadata.get('is_workflow'))
 
         # 获取stream参数，默认为True
         self.stream_enabled = message_data.get('stream', True)
@@ -410,6 +411,61 @@ class WebSocketAdapter(abstract_platform_adapter.AbstractMessagePlatformAdapter)
             session_type=session_type,
         )
 
+        if is_workflow:
+            # 设置 pipeline_uuid，以便工作流节点发送消息时能正确广播
+            self.ap.platform_mgr.websocket_proxy_bot.bot_entity.use_pipeline_uuid = pipeline_uuid
+
+            message_content = str(message_chain)
+            message_context = {
+                'message_id': str(message_id),
+                'message_content': message_content,
+                'sender_id': f'websocket_{connection.connection_id}',
+                'sender_name': 'User',
+                'platform': 'websocket',
+                'conversation_id': connection.connection_id,
+                'is_group': session_type == 'group',
+                'group_id': 'websocketgroup' if session_type == 'group' else None,
+                'mentions': [],
+                'reply_to': None,
+                'raw_message': {
+                    'message': message_chain_obj,
+                    'connection_id': connection.connection_id,
+                    'session_type': session_type,
+                },
+            }
+
+            trigger_data = {
+                'message': message_content,
+                'message_chain': message_chain_obj,
+                'session_type': session_type,
+                'connection_id': connection.connection_id,
+                'message_context': message_context,
+            }
+
+            try:
+                from ...api.http.service.workflow import WorkflowExecutionFailedError
+
+                execution_id = await self.ap.workflow_service.execute_workflow(
+                    pipeline_uuid,
+                    trigger_type='message',
+                    trigger_data=trigger_data,
+                    session_id=f'{session_type}_{connection.connection_id}',
+                    user_id=message_context['sender_id'],
+                    bot_id=self.ap.platform_mgr.websocket_proxy_bot.bot_entity.uuid,
+                )
+                await connection.send_queue.put(
+                    {
+                        'type': 'broadcast',
+                        'message': f'Workflow execution started: {execution_id}',
+                    }
+                )
+            except WorkflowExecutionFailedError as e:
+                await connection.send_queue.put({'type': 'error', 'message': e.message})
+            except Exception as e:
+                logger.error(f'Workflow websocket execution error: {e}', exc_info=True)
+                await connection.send_queue.put({'type': 'error', 'message': str(e)})
+            return
+
         # 添加消息源
         message_chain.insert(0, platform_message.Source(id=message_id, time=datetime.now().timestamp()))