from RemoteA2aAgent to Supervisor

[ktk94]

After installing the RemoteA2aAgent as a subagent on the Supervisor, sending a request to the RemoteA2aAgent during the test, the agent has even checked the operation.
RemoteA2aAgent then responds, but 400 BadRequest errors are continuously occurring on the Supervisor side.
How can I solve this issue

Executor function of RemoteA2aAgent.

import json
class ReviewAgentExecutor(A2aAgentExecutor)
    def __init__(self) -> None:
        self.agent = None
        self.runner = None
        self._current_session = None
        self._session_mapping = Dict[str,str] = {}
    def _init_agent(self) -> None:
        if self.agent is None:
            self.agent = sequential_agent
            self.runner = Runner(
                app_name = "ReviewAgent",
                agent = sequential_agent,
                artifact_service=GcsArtifactService(bucket_name=""),
                session_service = VertexAiSessionService(project = "",location = '',agent_engine_id=''),
                memory_service = VertexAiMemoryBankService(project = "",location = '')
            )
    async def execute(self, context: RequestContext,event_queue:EventQueue) -> None:
        if self.agent is None:
            self._init_agent()
        updater = TaskUpdater(event_queue,context.task_id,context.context_id)
        
        if not context.current_task:
            await updater.submit()
        await updater.start_work()
         
        try:
            session = await self._get_or_create_session(context)
            self._current_session = session
            category = context.metadata.get("category")
            part_nm = context.metadata.get('part_nm')
            designer = context.metadata.get("designer")
            chat_id = context.metadata.get("chatId")
            date = context.metadata.get('date')

            
            base_instruction = f"""
            작업 환경 정보
            Chat ID : {chat_id}
            Part NM : {part_nm}
            Designer : {designer}
            Date : {date}
            """
            if category =="L0 신규 개발":
                source_gcs_path = context.metadata.get('source_gcs_path')
                argumented_query = f"{base_instruction}[작업유형] : 신규 개발, 원천 경로 {source_gcs_path}"
            if category == "L0 변경 개발":
                chg_req_path = context.metadata.get('chg_req_path')
                argumented_query = f"{base_instruction}[작업유형] : 변경 개발, 변경 요청서 경로 {chg_req_path}"

            user_query = context.get_user_input()
            final_prompt = f"{argumented_query}\n {user_query}"
            content = types.Content(role = 'user',parts = [types.Part(text=final_prompt)])

            async for event in self.runner.run_async(
                session_id = session.id,
                user_id = context.metadata.get('chat_id'),
                new_message  = content,
            ):

                if event.content and event.content.parts:
                    for part in event.content.parts:
                        fn_resp  = getattr(part,'function_response',None)
                        if fn_resp == 'function_response':
                            fn_name= fn_resp.name
                            fn_result = fn_resp.response
                            if fn_name =="tool_run_rag_tool":
                                session.state["ReviewToolResult"] = fn_result
                            if fn_name =="tool_run_change_tool":
                                session.state["ReviewToolResult"] = fn_result

            
            refreshed_session = await self.runner.session_service.get_session(
                app_name = self.runner.app_name,
                user_id = context.metadata.get('chat_id'),
                session_id = session.id)
            state = refreshed_session.state
            review_data = state.get('review_result')
            verify_data = state.get('verification_result')
            await event_queue.enqueue_event(
                TaskStatusUpdateEvent(
                    task_id = context.task_id,
                    status = TaskTatus(
                        state = TaskState.working,
                        timmestamp = datetime.now(),
                        message = Message(
                            message_id = str(uuid.uuid4()),
                            role = Role.agent,
                            parts = [
                                Part(root=TextPart(
                                kind = 'text',
                                metadata==None,
                                text = json.dumps(review_data,ensure_ascii=False))),
                                Part(root=TextPart(
                                kind = 'text',
                                metadata==None,
                                text = json.dumps(verify_data,ensure_ascii=False))),
                                Part(root=TextPart(
                                kind = 'text',
                                metadata==None,
                                text = json.dumps(session.id,ensure_ascii=False),
                            ))]
                        )
                    ),
                    contetxt_id = context.context_id,
                    final = True
                )
            )
        except Exception as e:
            await updater.update_status(
                TaskState.failed, message = new_agent_text_message(f"Error: {e!s}")
            )
            raise
    async def _get_or_create_session(self,context:str):
        """Get existing session or create new one"""
        incoming_session_id = None 
        if context.metadata:
            incoming_session_id = context.metadata.get('vertex_session_id')
        session = None
        if incoming_session_id:
            try:
                session = await self.runner.session_service.get_session(
                    app_name = self.runner.app_name,
                    user_id = context.metadata.get('chat_id'),
                    session_id = incoming_session_id
                )
            except Exception:
                session = None
        if not session:
            session = await self.runner.session_service.create_session(
                app_name = self.runner.app_name,
                user_id = context.metadata.get('chat_id'),
            )
        return session
    
    def _extract_answer(self,event) -> str:
        if not hasattr(event,'content') or event.content is None:
            return "No content in event"
        if not hasattr(event.content,'parts') or event.content.parts is None:
            return "No parts in content"
        
        parts = event.content.parts
        text_parts = [part.text for part in parts if hasattr(part,'text') and part.text]
        return " ".join(text_parts) if text_parts else "No Answer Found"
    async def cancel(self,context:RequestContext,event_queue: EventQueue)-> NoReturn :
        raise ServerError(error = UnsupportedOperationError())
    

plz helpme