controlmesh 0.40.2__tar.gz → 0.40.3__tar.gz

{controlmesh-0.40.2 → controlmesh-0.40.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: controlmesh
-Version: 0.40.2
+Version: 0.40.3
 Summary: ControlMesh brings official coding CLIs into Telegram, Matrix, and Feishu with persistent workspaces, long-running jobs, and production-friendly bot operations.
 Project-URL: Homepage, https://github.com/muqiao215/ControlMesh
 Project-URL: Repository, https://github.com/muqiao215/ControlMesh

{controlmesh-0.40.2 → controlmesh-0.40.3}/controlmesh/__init__.py

@@ -1,3 +1,3 @@
 """ControlMesh public package and CLI entrypoint surface."""
 
-__version__ = "0.40.2"
+__version__ = "0.40.3"

{controlmesh-0.40.2 → controlmesh-0.40.3}/controlmesh/config.py

@@ -207,6 +207,40 @@ class FeishuGroupConfig(BaseModel):
         default_factory=list,
         validation_alias=AliasChoices("allow_from_users", "allowFromUsers"),
     )
+    agent_roster: list[str] = Field(
+        default_factory=list,
+        validation_alias=AliasChoices("agent_roster", "agentRoster"),
+    )
+    default_agent: str = Field(
+        default="",
+        validation_alias=AliasChoices("default_agent", "defaultAgent"),
+    )
+    allow_interagent_handoff: bool = Field(
+        default=False,
+        validation_alias=AliasChoices("allow_interagent_handoff", "allowInteragentHandoff"),
+    )
+    max_handoff_depth: int = Field(
+        default=1,
+        validation_alias=AliasChoices("max_handoff_depth", "maxHandoffDepth"),
+    )
+
+    @field_validator("agent_roster")
+    @classmethod
+    def _validate_agent_roster(cls, value: list[str]) -> list[str]:
+        return [item.strip() for item in value if item.strip()]
+
+    @field_validator("default_agent")
+    @classmethod
+    def _validate_default_agent(cls, value: str) -> str:
+        return value.strip()
+
+    @field_validator("max_handoff_depth")
+    @classmethod
+    def _validate_max_handoff_depth(cls, value: int) -> int:
+        if value < 0:
+            msg = "Feishu group max_handoff_depth must be >= 0"
+            raise ValueError(msg)
+        return value
 
 
 class FeishuConfig(BaseModel):

{controlmesh-0.40.2 → controlmesh-0.40.3}/controlmesh/messenger/feishu/bot.py

@@ -118,6 +118,24 @@ _TextStreamCallback = Callable[[str], Awaitable[None]]
 _StatusStreamCallback = Callable[[str | None], Awaitable[None]]
 _ToolEventStreamCallback = Callable[[ToolUseEvent | ToolResultEvent], Awaitable[None]]
 _FEISHU_COMMAND_GUIDE_VERSION = 3
+_FEISHU_AGENT_TARGET_PREFIXES = ("agent:", "agent=", "@agent:")
+
+
+@dataclass(frozen=True, slots=True)
+class FeishuAgentRoute:
+    """Resolved Feishu group routing target."""
+
+    agent: str
+    text: str
+    via_default: bool = False
+
+
+@dataclass(frozen=True, slots=True)
+class SimpleTextResult:
+    """Small result adapter for Feishu delivery paths."""
+
+    text: str
+    status: str = "completed"
 
 
 def _stream_callbacks_for_output_mode(
@@ -472,12 +490,20 @@ class FeishuBot:
                     progress.start()
                 if content_key:
                     self._inflight_content_keys.add(content_key)
-                auth_routed, result = await self._run_streaming_turn(
-                    message,
-                    chat_id=chat_id,
-                    topic_id=topic_id,
-                    progress=progress,
-                )
+                route = self._resolve_group_agent_route(message)
+                if route is not None:
+                    result = await self._run_group_agent_route(
+                        message,
+                        route=route,
+                    )
+                    auth_routed = False
+                else:
+                    auth_routed, result = await self._run_streaming_turn(
+                        message,
+                        chat_id=chat_id,
+                        topic_id=topic_id,
+                        progress=progress,
+                    )
         except Exception as exc:
             await progress.finish_failure(str(exc))
             raise
@@ -1033,6 +1059,131 @@ class FeishuBot:
             return True, None
         return False, result
 
+    async def _run_group_agent_route(
+        self,
+        message: FeishuIncomingText,
+        *,
+        route: FeishuAgentRoute,
+    ) -> Any:
+        bus = self._interagent_bus()
+        if bus is None:
+            return SimpleTextResult(
+                text="Agent handoff is unavailable: multi-agent runtime is not active.",
+                status="failed",
+            )
+        prompt = self._build_group_agent_handoff_prompt(message, route=route)
+        response = await bus.send(
+            sender=self._agent_name,
+            recipient=route.agent,
+            message=prompt,
+            new_session=False,
+        )
+        if not response.success:
+            error = response.error or f"Agent `{route.agent}` did not return a result."
+            return SimpleTextResult(text=error, status="failed")
+        visible = f"[{route.agent}]\n{response.text.strip()}" if response.text.strip() else ""
+        return SimpleTextResult(text=visible, status="completed")
+
+    def _interagent_bus(self) -> Any | None:
+        if self._orchestrator is None:
+            return None
+        supervisor = getattr(self._orchestrator, "supervisor", None)
+        return getattr(supervisor, "bus", None)
+
+    def _resolve_group_agent_route(self, message: FeishuIncomingText) -> FeishuAgentRoute | None:
+        if not self._is_group_message(message):
+            return None
+        overrides = self._group_overrides_for_message(message)
+        if overrides is None:
+            return None
+        roster = self._group_agent_roster_for_message(message)
+        if not roster:
+            return None
+
+        explicit = self._extract_explicit_agent_target(message.text, roster)
+        if explicit is not None:
+            agent, routed_text = explicit
+            if agent == self._agent_name:
+                return None
+            return FeishuAgentRoute(agent=agent, text=routed_text)
+
+        default_agent = overrides.default_agent
+        if default_agent and default_agent in roster and default_agent != self._agent_name:
+            return FeishuAgentRoute(agent=default_agent, text=message.text.strip(), via_default=True)
+        return None
+
+    def _group_agent_roster_for_message(self, message: FeishuIncomingText) -> list[str]:
+        overrides = self._group_overrides_for_message(message)
+        if overrides is None:
+            return []
+        return [name for name in overrides.agent_roster if name != self._agent_name]
+
+    def _extract_explicit_agent_target(
+        self,
+        text: str,
+        roster: list[str],
+    ) -> tuple[str, str] | None:
+        stripped = text.strip()
+        if not stripped:
+            return None
+        words = stripped.split(maxsplit=1)
+        first = words[0]
+        rest = words[1].strip() if len(words) > 1 else ""
+        for prefix in _FEISHU_AGENT_TARGET_PREFIXES:
+            if first.lower().startswith(prefix):
+                candidate = first[len(prefix) :].strip()
+                if candidate in roster:
+                    return candidate, rest
+        if first.startswith("@"):
+            candidate = first[1:].strip()
+            if candidate in roster:
+                return candidate, rest
+        return None
+
+    def _build_group_agent_handoff_prompt(
+        self,
+        message: FeishuIncomingText,
+        *,
+        route: FeishuAgentRoute,
+    ) -> str:
+        overrides = self._group_overrides_for_message(message)
+        allow_handoff = bool(overrides and overrides.allow_interagent_handoff)
+        configured_depth = overrides.max_handoff_depth if allow_handoff and overrides else 0
+        handoff_depth_used = 1 if allow_handoff and configured_depth > 0 else 0
+        remaining_depth = max(configured_depth - handoff_depth_used, 0)
+
+        routed_message = FeishuIncomingText(
+            sender_id=message.sender_id,
+            chat_id=message.chat_id,
+            message_id=message.message_id,
+            text=route.text or message.text,
+            thread_id=message.thread_id,
+            create_time_ms=message.create_time_ms,
+            message_type=message.message_type,
+            root_id=message.root_id,
+            parent_id=message.parent_id,
+            quote_summary=message.quote_summary,
+            post_title=message.post_title,
+            chat_type=message.chat_type,
+            mentions_bot=message.mentions_bot,
+            replies_to_bot=message.replies_to_bot,
+        )
+        user_text = build_feishu_agent_input(routed_message)
+        return (
+            "[Feishu controlled group handoff]\n"
+            f"source_agent={self._agent_name}\n"
+            f"target_agent={route.agent}\n"
+            f"chat_id={message.chat_id}\n"
+            f"thread_id={message.thread_id or ''}\n"
+            f"reply_target=original_feishu_group_thread\n"
+            f"handoff_allowed={'true' if allow_handoff else 'false'}\n"
+            f"remaining_handoff_depth={remaining_depth}\n"
+            "Do not start a free bot-to-bot conversation. Answer this delegated request and "
+            "return the final answer here.\n"
+            "[/Feishu controlled group handoff]\n\n"
+            f"{user_text}"
+        )
+
     def _should_use_bundled_native_runtime(self) -> bool:
         if self._config.feishu.runtime_mode != "native" or self._orchestrator is None:
             return False
@@ -2079,9 +2230,6 @@ class FeishuBot:
                 open_id = mention_id.get("open_id")
                 if isinstance(open_id, str) and open_id and open_id == bot_sender_id:
                     return True
-            key = item.get("key")
-            if isinstance(key, str) and key.lower() == "@all":
-                return True
         return False
 
     def _message_replies_to_bot(self, message: dict[str, Any]) -> bool:

{controlmesh-0.40.2 → controlmesh-0.40.3}/docs/README.md

@@ -73,6 +73,7 @@ Runtime behavior notes:
 - [Telegram Setup](telegram-setup.md)
 - [WeChat / Weixin Setup](weixin-setup.md)
 - [QQ Bot Official Pivot](qqbot-official-pivot.md)
+- [v0.40.3 Release Note](release-note-v0.40.3.md)
 - [v0.40.2 Release Note](release-note-v0.40.2.md)
 - [v0.40.1 Release Note](release-note-v0.40.1.md)
 - [v0.40.0 Release Note](release-note-v0.40.0.md)

{controlmesh-0.40.2 → controlmesh-0.40.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "controlmesh"
-version = "0.40.2"
+version = "0.40.3"
 description = "ControlMesh brings official coding CLIs into Telegram, Matrix, and Feishu with persistent workspaces, long-running jobs, and production-friendly bot operations."
 readme = "README.md"
 requires-python = ">=3.11"