refactor: 梳理规则体系并统一记忆与部署流程

backend/src/core/agentscope/events/store.py

@@ -9,7 +9,7 @@ from core.logging import get_logger
 from models.agent_chat_message import AgentChatMessageRole
 from models.agent_chat_session import AgentChatSessionStatus
 from schemas.agent.system_agent import AgentType
-from schemas.agent.runtime_models import AgentOutput, ToolAgentOutput
+from schemas.agent.runtime_models import AgentOutput, RouterAgentOutput, ToolAgentOutput
 from schemas.agent.visibility import SystemVisibilityBit, bit_mask
 from schemas.messages.chat_message import AgentChatMessageMetadata
 
@@ -79,6 +79,14 @@ class SqlAlchemyEventStore:
                     session_repo=session_repo,
                     message_repo=message_repo,
                 )
+            elif event_type == "STEP_FINISHED":
+                await self._persist_router_step_output(
+                    event=event,
+                    session_id=session_id,
+                    chat_session=chat_session,
+                    session_repo=session_repo,
+                    message_repo=message_repo,
+                )
             elif event_type == "TOOL_CALL_RESULT":
                 await self._persist_tool_call_result(
                     event=event,
@@ -199,6 +207,95 @@ class SqlAlchemyEventStore:
             cost_delta=cost,
         )
 
+    async def _persist_router_step_output(
+        self,
+        *,
+        event: dict[str, Any],
+        session_id: UUID,
+        chat_session: Any,
+        session_repo: SessionRepository,
+        message_repo: MessageRepository,
+    ) -> None:
+        step_name = self._event_value(event, "stepName")
+        if not isinstance(step_name, str) or step_name.strip().lower() != "router":
+            return
+
+        run_id = self._event_value(event, "runId")
+        run_id_value = run_id if isinstance(run_id, str) and run_id else None
+        if run_id_value is None:
+            return
+
+        persist_payload = event.get("_router_persist")
+        if not isinstance(persist_payload, dict):
+            return
+
+        router_output_raw = persist_payload.get("router_output")
+        response_metadata_raw = persist_payload.get("response_metadata")
+        if not isinstance(router_output_raw, dict):
+            return
+
+        response_metadata = (
+            response_metadata_raw if isinstance(response_metadata_raw, dict) else {}
+        )
+        model_code_raw = response_metadata.get("model")
+        model_code = model_code_raw if isinstance(model_code_raw, str) else None
+        input_tokens = self._to_int(response_metadata.get("inputTokens"))
+        output_tokens = self._to_int(response_metadata.get("outputTokens"))
+        token_delta = input_tokens + output_tokens
+        cost = self._to_decimal(response_metadata.get("cost"))
+        latency_ms = self._to_int_or_none(response_metadata.get("latencyMs"))
+
+        try:
+            router_output = RouterAgentOutput.model_validate(router_output_raw)
+            metadata_model = AgentChatMessageMetadata(
+                run_id=run_id_value,
+                agent_type=AgentType.ROUTER,
+                router_agent_output=router_output,
+            )
+        except Exception:
+            self._logger.warning(
+                "invalid router metadata payload",
+                run_id=run_id_value,
+            )
+            return
+
+        content = ""
+
+        locked_session = await session_repo.lock_session_for_update(
+            session_id=session_id
+        )
+        if locked_session is None:
+            return
+        seq = int(getattr(locked_session, "message_count", 0) or 0) + 1
+        await message_repo.append_message(
+            session_id=session_id,
+            seq=seq,
+            role=AgentChatMessageRole.ASSISTANT,
+            content=content,
+            model_code=model_code,
+            metadata=metadata_model.model_dump(mode="json", exclude_none=True),
+            input_tokens=input_tokens,
+            output_tokens=output_tokens,
+            cost=cost,
+            latency_ms=latency_ms,
+            visibility_mask=0,
+        )
+
+        current_status = getattr(chat_session, "status", AgentChatSessionStatus.RUNNING)
+        status = (
+            current_status
+            if isinstance(current_status, AgentChatSessionStatus)
+            else AgentChatSessionStatus.RUNNING
+        )
+        await self._update_session_state(
+            session_repo=session_repo,
+            chat_session=chat_session,
+            status=status,
+            message_delta=1,
+            token_delta=token_delta,
+            cost_delta=cost,
+        )
+
     async def _persist_tool_call_result(
         self,
         *,