feat: add label to block input/outputs

Author: lss233

data/dispatch_rules/rules.yaml

@@ -69,39 +69,6 @@
     category: system
     permission: user
   prefix: /help
-- rule_id: system_status
-  name: 系统状态
-  description: 显示系统状态
-  type: prefix
-  priority: 10
-  workflow_id: system:status
-  enabled: true
-  metadata:
-    category: system
-    permission: user
-  prefix: /status
-- rule_id: system_admin
-  name: 管理员命令
-  description: 管理员命令，需要管理员权限
-  type: regex
-  priority: 20
-  workflow_id: system:admin
-  enabled: true
-  metadata:
-    category: system
-    permission: admin
-  pattern: ^/(ban|unban|kick|mute) \S+
-- rule_id: system_settings
-  name: 系统设置
-  description: 修改系统设置
-  type: prefix
-  priority: 10
-  workflow_id: system:settings
-  enabled: true
-  metadata:
-    category: system
-    permission: admin
-  prefix: /settings
 - rule_id: system_clear_memory
   name: 清空记忆
   description: 清空当前对话的记忆
@@ -121,3 +88,13 @@
   workflow_id: chat:normal
   enabled: true
   metadata: {}
+- rule_id: asd
+  name: dsa
+  description: asd
+  type: keyword
+  priority: 5
+  workflow_id: game:gacha
+  enabled: true
+  metadata: {}
+  keywords:
+  - asdsd

framework/web/api/block/models.py

@@ -7,6 +7,7 @@ class BlockType(BaseModel):
     """Block类型信息"""
     type_name: str
     name: str
+    label: str
     description: str
     inputs: List[BlockInput]
     outputs: List[BlockOutput]

framework/web/api/block/routes.py

@@ -17,15 +17,17 @@ async def list_block_types():
     types = []
     for block_type in registry.get_all_types():
         inputs, outputs, configs = registry.extract_block_info(block_type)
-        
+        type_name = registry.get_block_type_name(block_type)
         types.append(BlockType(
-            type_name=registry.get_block_type_name(block_type),
+            type_name=type_name,
             name=block_type.name,
+            label=registry.get_localized_name(type_name),
             description=getattr(block_type, 'description', ''),
             inputs=inputs.values(),
             outputs=outputs.values(),
             configs=configs.values()
         ))
+        print(block_type.name, type_name, registry.get_localized_name(block_type.name))
 
     return BlockTypeList(types=types).model_dump()
 
@@ -44,6 +46,7 @@ async def get_block_type(type_name: str):
     for name, info in block_type.get_inputs().items():
         inputs.append(BlockInput(
             name=name,
+            label=registry.get_localized_name(name),
             description=info.get('description', ''),
             type=info.get('type', 'any'),
             required=info.get('required', True),
@@ -71,6 +74,7 @@ async def get_block_type(type_name: str):
     return BlockTypeResponse(type=BlockType(
         type_name=registry.get_block_type_name(block_type),
         name=block_type.name,
+        label=registry.get_localized_name(block_type.name),
         description=block_type.description,
         inputs=inputs,
         outputs=outputs,

framework/workflow/core/block/base.py

@@ -31,7 +31,7 @@ def execute(self, **kwargs) -> Dict[str, Any]:
 class ConditionBlock(Block):
     """条件判断块"""
     name: str = "condition"
-    outputs: Dict[str, Output] = {"condition_result": Output("condition_result", bool, "Condition result")}
+    outputs: Dict[str, Output] = {"condition_result": Output("condition_result", "条件结果", bool, "条件结果")}
 
     def __init__(self, condition_func: Callable[[Dict[str, Any]], bool], inputs: Dict[str, 'Input']):
         super().__init__()
@@ -46,8 +46,8 @@ class LoopBlock(Block):
     """循环控制块"""
     name: str = "loop"
     outputs: Dict[str, Output] = {
-        "should_continue": Output("should_continue", bool, "Continue loop?"),
-        "iteration": Output("iteration", dict, "Current iteration data")
+        "should_continue": Output("should_continue", "是否继续", bool, "是否继续"),
+        "iteration": Output("iteration", "当前迭代数据", dict, "当前迭代数据")
     }
 
     def __init__(self, 
@@ -74,7 +74,7 @@ def execute(self, **kwargs) -> Dict[str, Any]:
 class LoopEndBlock(Block):
     """循环结束块，收集循环结果"""
     name: str = "loop_end"
-    outputs: Dict[str, Output] = {"loop_results": Output("loop_results", list, "Collected loop results")}
+    outputs: Dict[str, Output] = {"loop_results": Output("loop_results", "收集的循环结果", list, "收集的循环结果")}
 
     def __init__(self, inputs: Dict[str, 'Input']):
         super().__init__()

framework/workflow/core/block/input_output.py

@@ -2,9 +2,10 @@
 
 
 class Input:
-    def __init__(self, name: str, data_type: type, description: str,
-                 nullable: bool = False, default: Optional[Any] = None):
+    def __init__(self, name: str, label: str, data_type: type, description: str,
+                nullable: bool = False, default: Optional[Any] = None):
         self.name = name
+        self.label = label
         self.data_type = data_type
         self.description = description
         self.nullable = nullable
@@ -17,8 +18,9 @@ def validate(self, value: Any) -> bool:
 
 
 class Output:
-    def __init__(self, name: str, data_type: type, description: str):
+    def __init__(self, name: str, label: str, data_type: type, description: str):
         self.name = name
+        self.label = label
         self.data_type = data_type
         self.description = description
 

framework/workflow/core/block/registry.py

@@ -9,25 +9,33 @@ class BlockRegistry:
 
     def __init__(self):
         self._blocks = {}
+        self._localized_names = {}
 
-    def register(self, block_id: str, group_id: str, block_class: Type[Block]):
+    def register(self, block_id: str, group_id: str, block_class: Type[Block], localized_name: Optional[str] = None):
         """注册一个 block
         
         Args:
             block_id: block 的唯一标识
             group_id: 组标识（internal 为框架内置）
             block_class: block 类
+            localized_name: 本地化名称
         """
         full_name = f"{group_id}:{block_id}"
         if full_name in self._blocks:
             raise ValueError(f"Block {full_name} already registered")
         self._blocks[full_name] = block_class
         block_class.id = block_id
+        if localized_name:
+            self._localized_names[full_name] = localized_name
 
     def get(self, full_name: str) -> Optional[Type[Block]]:
         """获取已注册的 block 类"""
         return self._blocks.get(full_name)
 
+    def get_localized_name(self, block_id: str) -> Optional[str]:
+        """获取本地化名称"""
+        return self._localized_names.get(block_id, block_id)
+    
     def clear(self):
         """清空注册表"""
         self._blocks.clear() 
@@ -67,6 +75,7 @@ def extract_block_info(self, block_type: Type[Block]) -> Tuple[Dict[str, BlockIn
         for name, input_info in getattr(block_type, 'inputs', {}).items():
             inputs[name] = BlockInput(
                 name=name,
+                label=input_info.label,
                 description=input_info.description,
                 type=input_info.data_type.__name__ if hasattr(input_info.data_type, '__name__') else str(input_info.data_type),
                 required=True,  # 假设所有输入都是必需的
@@ -77,6 +86,7 @@ def extract_block_info(self, block_type: Type[Block]) -> Tuple[Dict[str, BlockIn
         for name, output_info in getattr(block_type, 'outputs', {}).items():
             outputs[name] = BlockOutput(
                 name=name,
+                label=output_info.label,
                 description=output_info.description,
                 type=output_info.data_type.__name__ if hasattr(output_info.data_type, '__name__') else str(output_info.data_type)
             )

framework/workflow/core/block/schema.py

@@ -6,6 +6,7 @@
 class BlockInput(BaseModel):
     """Block输入定义"""
     name: str
+    label: str
     description: str
     type: str
     required: bool = True
@@ -14,6 +15,7 @@ class BlockInput(BaseModel):
 class BlockOutput(BaseModel):
     """Block输出定义"""
     name: str
+    label: str
     description: str
     type: str
 

framework/workflow/core/workflow/builder.py

@@ -297,20 +297,24 @@ def end_loop(self) -> 'WorkflowBuilder':
         return self
 
     def _connect_blocks(self, source_block: Block, target_block: Block):
-        """连接两个块，自动处理输入输出匹配"""
-        for output_name, output in source_block.outputs.items():
-            for input_name, input in target_block.inputs.items():
+        """连接两个块，自动处理输入输出匹配，只连接一次"""
+        is_connected = False
+        for input_name, input in target_block.inputs.items():
+            for output_name, output in source_block.outputs.items():
                 # 检查数据类型是否匹配
                 if output.data_type == input.data_type:
                     # 创建新的连线
                     wire = Wire(source_block, output_name, target_block, input_name)
-                    # 检查是否已存在相同的连线
-                    if not any(w.source_block == wire.source_block and 
-                             w.target_block == wire.target_block and
-                             w.source_output == wire.source_output and
-                             w.target_input == wire.target_input 
-                             for w in self.wires):
+                    # 跳过已被连接的 input
+                    if not any(w.target_block == wire.target_block and
+                            w.target_input == wire.target_input 
+                            for w in self.wires):
+                        is_connected = True
                         self.wires.append(wire)
+                        break
+            # 如果连接成功，则跳出循环
+            if is_connected:
+                break
 
     def _find_parallel_nodes(self, start_node: Node) -> List[Node]:
         """查找所有并行节点"""

framework/workflow/implementations/blocks/game/dice.py

@@ -13,10 +13,10 @@ class DiceRoll(Block):
     """骰子掷点 block"""
     name = "dice_roll"
     inputs = {
-        "message": Input("message", IMMessage, "Input message containing dice command")
+        "message": Input("message", "输入消息", IMMessage, "输入消息包含骰子命令")
     }
     outputs = {
-        "response": Output("response", IMMessage, "Response message with dice roll result")
+        "response": Output("response", "响应消息", IMMessage, "响应消息包含骰子掷点结果")
     }
 
     def execute(self, message: IMMessage) -> Dict[str, Any]:

framework/workflow/implementations/blocks/game/gacha.py

@@ -10,10 +10,10 @@ class GachaSimulator(Block):
     """抽卡模拟器 block"""
     name = "gacha_simulator"
     inputs = {
-        "message": Input("message", IMMessage, "Input message containing gacha command")
+        "message": Input("message", "输入消息", IMMessage, "输入消息包含抽卡命令")
     }
     outputs = {
-        "response": Output("response", IMMessage, "Response message with gacha results")
+        "response": Output("response", "响应消息", IMMessage, "响应消息包含抽卡结果")
     }
 
     def __init__(self, rates: Dict[str, float] = None):