refactor(agent): remove memory agent, simplify runtime config system

backend/src/core/agentscope/runtime/runner.py

@@ -12,12 +12,12 @@ from agentscope.message import Msg
 from agentscope.model import OpenAIChatModel
 from core.agentscope.prompts.agent_prompt import build_worker_contract_prompt
 from core.agentscope.prompts.system_prompt import build_system_prompt
-from core.agentscope.runtime.pipeline_registry import build_default_pipeline_spec
+from core.agentscope.schemas.agui_input import extract_latest_user_payload
 from core.agentscope.runtime.json_react_agent import JsonReActAgent
 from core.agentscope.runtime.model_tracking import TrackingChatModel
 from core.agentscope.runtime.stage_emitter import PipelineStageEmitter
-from core.agentscope.runtime.tool_selection_registry import TOOL_SELECTION_REGISTRY
-from core.agentscope.tools.toolkit import build_stage_toolkit
+from core.agentscope.tools.tool_config import AgentTool
+from core.agentscope.tools.toolkit import build_toolkit
 from core.agentscope.utils import (
     finalize_json_response,
     patch_agentscope_json_repair_compat,
@@ -31,19 +31,17 @@ from schemas.agent.forwarded_props import (
     ClientTimeContext,
     parse_forwarded_props_client_time,
 )
-from schemas.automation.config import AutomationJobConfig
 from schemas.agent.runtime_models import (
-    AgentOutput,
     RouterAgentOutput,
     WorkerAgentOutputLite,
     resolve_worker_output_model,
 )
 from schemas.agent.system_agent import (
     AgentType,
-    ContextMessagesConfig,
-    ContextBuildStrategy,
     SystemAgentLLMConfig,
 )
+from schemas.automation import RuntimeConfig
+from schemas.memories import MemoryListResponse
 from schemas.user import UserContext
 from services.litellm.service import LiteLLMService
 from sqlalchemy import select
@@ -53,16 +51,6 @@ if TYPE_CHECKING:
     from core.agentscope.runtime.orchestrator import PipelineLike
 
 
-@dataclass(frozen=True)
-class SystemAgentRuntimeConfig:
-    agent_type: AgentType
-    model_code: str
-    api_base_url: str
-    api_key: str
-    llm_config: SystemAgentLLMConfig
-    extra_context: str | None = None
-
-
 @dataclass(frozen=True)
 class StageExecutionResult:
     message: Msg
@@ -82,96 +70,63 @@ class AgentScopeRunner:
         context_messages: list[Msg],
         pipeline: PipelineLike,
         run_input: RunAgentInput,
-        system_agent_mode: str,
-        memory_job_config: AutomationJobConfig | None = None,
+        runtime_config: RuntimeConfig,
+        memories: MemoryListResponse | None = None,
     ) -> dict[str, Any]:
         owner_id = UUID(user_context.id)
         runtime_client_time = self._resolve_runtime_client_time(run_input=run_input)
-        pipeline_spec = build_default_pipeline_spec(mode=system_agent_mode)
-        stage_agent_types = [stage.agent_type for stage in pipeline_spec.stages]
 
         async with AsyncSessionLocal() as session:
-            if stage_agent_types == [AgentType.ROUTER, AgentType.WORKER]:
-                router_config = await self._load_stage_config(
-                    session=session,
-                    agent_type=AgentType.ROUTER,
-                )
-                worker_config = await self._load_stage_config(
-                    session=session,
-                    agent_type=AgentType.WORKER,
-                )
-                worker_toolkit = self._build_stage_toolkit(
-                    session=session,
-                    owner_id=owner_id,
-                    stage_config=worker_config,
-                )
-                router_output = await self._execute_router_step(
-                    pipeline=pipeline,
-                    run_input=run_input,
-                    user_context=user_context,
-                    context_messages=context_messages,
-                    stage_config=router_config,
-                    runtime_client_time=runtime_client_time,
-                )
-                worker_output = await self._execute_worker_step(
-                    pipeline=pipeline,
-                    run_input=run_input,
-                    user_context=user_context,
-                    router_output=router_output,
-                    toolkit=worker_toolkit,
-                    stage_config=worker_config,
-                    runtime_client_time=runtime_client_time,
-                )
-                return {
-                    "router": router_output.model_dump(mode="json", exclude_none=True),
-                    "worker": worker_output.model_dump(mode="json", exclude_none=True),
-                }
-
-            if stage_agent_types[0] == AgentType.MEMORY:
-                if memory_job_config is None:
-                    raise RuntimeError("memory job config is required")
-                stage_config = await self._build_memory_stage_config(
-                    session=session,
-                    memory_job_config=memory_job_config,
-                )
-            else:
-                stage_config = await self._load_stage_config(
-                    session=session,
-                    agent_type=stage_agent_types[0],
-                )
-            stage_toolkit = self._build_stage_toolkit(
+            router_config = await self._load_stage_config(
+                session=session,
+                agent_type=AgentType.ROUTER,
+            )
+            worker_config = await self._load_stage_config(
+                session=session,
+                agent_type=AgentType.WORKER,
+            )
+            worker_toolkit = self._build_toolkit(
                 session=session,
                 owner_id=owner_id,
-                stage_config=stage_config,
+                enabled_tools=runtime_config.enabled_tools,
             )
-            stage_output = await self._execute_single_stage_step(
+
+            router_output = await self._execute_router_step(
                 pipeline=pipeline,
                 run_input=run_input,
                 user_context=user_context,
-                input_messages=context_messages,
-                toolkit=stage_toolkit,
-                stage_config=stage_config,
+                context_messages=context_messages,
+                stage_config=router_config,
                 runtime_client_time=runtime_client_time,
+                memories=memories,
+            )
+            worker_output = await self._execute_worker_step(
+                pipeline=pipeline,
+                run_input=run_input,
+                user_context=user_context,
+                router_output=router_output,
+                toolkit=worker_toolkit,
+                stage_config=worker_config,
+                runtime_client_time=runtime_client_time,
+                memories=memories,
             )
             return {
-                stage_config.agent_type.value: stage_output.model_dump(
-                    mode="json", exclude_none=True
-                ),
+                "router": router_output.model_dump(mode="json", exclude_none=True),
+                "worker": worker_output.model_dump(mode="json", exclude_none=True),
             }
 
-    def _build_stage_toolkit(
+    def _build_toolkit(
         self,
         *,
         session: AsyncSession,
         owner_id: UUID,
-        stage_config: SystemAgentRuntimeConfig,
+        enabled_tools: list[AgentTool],
     ) -> Any:
-        enabled_tool_names = TOOL_SELECTION_REGISTRY.resolve(stage_config=stage_config)
-        return build_stage_toolkit(
-            agent_type=stage_config.agent_type,
+        tool_names = [t.value for t in enabled_tools] if enabled_tools else []
+        return build_toolkit(
             session=session,
             owner_id=owner_id,
-            enabled_tool_names=enabled_tool_names,
+            enabled_tool_names=set(tool_names) if tool_names else None,
         )
 
     async def _load_stage_config(
@@ -179,124 +134,6 @@ class AgentScopeRunner:
         *,
         session: AsyncSession,
         agent_type: AgentType,
-    ) -> SystemAgentRuntimeConfig:
-        return await self._load_system_agent_config(
-            session=session,
-            agent_type=agent_type,
-        )
-
-    async def _execute_router_step(
-        self,
-        *,
-        pipeline: PipelineLike,
-        run_input: RunAgentInput,
-        user_context: UserContext,
-        context_messages: list[Msg],
-        stage_config: SystemAgentRuntimeConfig,
-        runtime_client_time: ClientTimeContext | None,
-    ) -> RouterAgentOutput:
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=AgentType.ROUTER.value,
-            event_type="STEP_STARTED",
-        )
-        router_result = await self._run_router_stage(
-            user_context=user_context,
-            context_messages=context_messages,
-            stage_config=stage_config,
-            runtime_client_time=runtime_client_time,
-        )
-        router_output = RouterAgentOutput.model_validate(router_result.payload)
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=AgentType.ROUTER.value,
-            event_type="STEP_FINISHED",
-        )
-        return router_output
-
-    async def _execute_worker_step(
-        self,
-        *,
-        pipeline: PipelineLike,
-        run_input: RunAgentInput,
-        user_context: UserContext,
-        router_output: RouterAgentOutput,
-        toolkit: Any,
-        stage_config: SystemAgentRuntimeConfig,
-        runtime_client_time: ClientTimeContext | None,
-    ) -> WorkerAgentOutputLite:
-        worker_output_model = resolve_worker_output_model(router_output.ui.ui_mode)
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=AgentType.WORKER.value,
-            event_type="STEP_STARTED",
-        )
-        worker_result = await self._run_worker_stage(
-            user_context=user_context,
-            input_messages=self._build_worker_input_messages(
-                router_output=router_output
-            ),
-            toolkit=toolkit,
-            run_input=run_input,
-            stage_config=stage_config,
-            worker_output_model=worker_output_model,
-            pipeline=pipeline,
-            runtime_client_time=runtime_client_time,
-        )
-        worker_output = worker_output_model.model_validate(worker_result.payload)
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=AgentType.WORKER.value,
-            event_type="STEP_FINISHED",
-        )
-        return worker_output
-
-    async def _execute_single_stage_step(
-        self,
-        *,
-        pipeline: PipelineLike,
-        run_input: RunAgentInput,
-        user_context: UserContext,
-        input_messages: list[Msg],
-        toolkit: Any,
-        stage_config: SystemAgentRuntimeConfig,
-        runtime_client_time: ClientTimeContext | None,
-    ) -> AgentOutput:
-        step_name = stage_config.agent_type.value
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=step_name,
-            event_type="STEP_STARTED",
-        )
-        stage_result = await self._run_worker_stage(
-            user_context=user_context,
-            input_messages=input_messages,
-            toolkit=toolkit,
-            run_input=run_input,
-            stage_config=stage_config,
-            worker_output_model=AgentOutput,
-            pipeline=pipeline,
-            runtime_client_time=runtime_client_time,
-        )
-        stage_output = AgentOutput.model_validate(stage_result.payload)
-        await self._emit_step_event(
-            pipeline=pipeline,
-            run_input=run_input,
-            step_name=step_name,
-            event_type="STEP_FINISHED",
-        )
-        return stage_output
-
-    async def _load_system_agent_config(
-        self,
-        *,
-        session: AsyncSession,
-        agent_type: AgentType,
     ) -> SystemAgentRuntimeConfig:
         stmt = (
             select(SystemAgents, Llm, LlmFactory)
@@ -320,63 +157,80 @@ class AgentScopeRunner:
             extra_context=None,
         )
 
-    async def _build_memory_stage_config(
+    async def _execute_router_step(
         self,
         *,
-        session: AsyncSession,
-        memory_job_config: AutomationJobConfig,
-    ) -> SystemAgentRuntimeConfig:
-        stmt = (
-            select(Llm, LlmFactory)
-            .join(LlmFactory, Llm.factory_id == LlmFactory.id)
-            .where(Llm.model_code == memory_job_config.model_code)
+        pipeline: PipelineLike,
+        run_input: RunAgentInput,
+        user_context: UserContext,
+        context_messages: list[Msg],
+        stage_config: SystemAgentRuntimeConfig,
+        runtime_client_time: ClientTimeContext | None,
+        memories: MemoryListResponse | None,
+    ) -> RouterAgentOutput:
+        await self._emit_step_event(
+            pipeline=pipeline,
+            run_input=run_input,
+            step_name=AgentType.ROUTER.value,
+            event_type="STEP_STARTED",
         )
-        row = (await session.execute(stmt)).one_or_none()
-        if row is None:
-            raise RuntimeError(
-                f"memory model not found: {memory_job_config.model_code}"
-            )
-        llm, factory = row
-        llm_config = SystemAgentLLMConfig(
-            temperature=0.7,
-            max_tokens=None,
-            timeout_seconds=30,
-            context_messages=ContextMessagesConfig(
-                mode=(
-                    ContextBuildStrategy.DAY
-                    if memory_job_config.context.window_mode.value == "day"
-                    else ContextBuildStrategy.NUMBER
-                ),
-                count=memory_job_config.context.window_count,
-            ),
-            enabled_tools=memory_job_config.enabled_tools,
+        router_result = await self._run_router_stage(
+            user_context=user_context,
+            context_messages=context_messages,
+            stage_config=stage_config,
+            runtime_client_time=runtime_client_time,
+            memories=memories,
+            run_input=run_input,
         )
-        return SystemAgentRuntimeConfig(
-            agent_type=AgentType.MEMORY,
-            model_code=llm.model_code,
-            api_base_url=factory.request_url,
-            api_key=self._resolve_provider_api_key(factory_name=factory.name),
-            llm_config=llm_config,
-            extra_context=(
-                f"[Memory Input Template]\n{memory_job_config.input_template.strip()}"
-            ),
+        router_output = RouterAgentOutput.model_validate(router_result.payload)
+        await self._emit_step_event(
+            pipeline=pipeline,
+            run_input=run_input,
+            step_name=AgentType.ROUTER.value,
+            event_type="STEP_FINISHED",
         )
+        return router_output
 
-    @staticmethod
-    def _resolve_provider_api_key(*, factory_name: str) -> str:
-        normalized_factory_name = factory_name.strip().upper()
-        if normalized_factory_name == "VOLCENGINE":
-            normalized_factory_name = "ARK"
-
-        provider_keys = {
-            str(key).strip().upper(): str(value).strip()
-            for key, value in config.llm.provider_keys.items()
-            if str(value).strip()
-        }
-        api_key = provider_keys.get(normalized_factory_name, "")
-        if not api_key:
-            raise RuntimeError(f"provider api key missing for factory: {factory_name}")
-        return api_key
+    async def _execute_worker_step(
+        self,
+        *,
+        pipeline: PipelineLike,
+        run_input: RunAgentInput,
+        user_context: UserContext,
+        router_output: RouterAgentOutput,
+        toolkit: Any,
+        stage_config: SystemAgentRuntimeConfig,
+        runtime_client_time: ClientTimeContext | None,
+        memories: MemoryListResponse | None,
+    ) -> WorkerAgentOutputLite:
+        worker_output_model = resolve_worker_output_model(router_output.ui.ui_mode)
+        await self._emit_step_event(
+            pipeline=pipeline,
+            run_input=run_input,
+            step_name=AgentType.WORKER.value,
+            event_type="STEP_STARTED",
+        )
+        worker_result = await self._run_worker_stage(
+            user_context=user_context,
+            input_messages=self._build_worker_input_messages(
+                router_output=router_output
+            ),
+            toolkit=toolkit,
+            run_input=run_input,
+            stage_config=stage_config,
+            worker_output_model=worker_output_model,
+            pipeline=pipeline,
+            runtime_client_time=runtime_client_time,
+            memories=memories,
+        )
+        worker_output = worker_output_model.model_validate(worker_result.payload)
+        await self._emit_step_event(
+            pipeline=pipeline,
+            run_input=run_input,
+            step_name=AgentType.WORKER.value,
+            event_type="STEP_FINISHED",
+        )
+        return worker_output
 
     async def _run_router_stage(
         self,
@@ -385,7 +239,13 @@ class AgentScopeRunner:
         context_messages: list[Msg],
         stage_config: SystemAgentRuntimeConfig,
         runtime_client_time: ClientTimeContext | None,
+        memories: MemoryListResponse | None,
+        run_input: RunAgentInput,
     ) -> StageExecutionResult:
+        messages_for_router = self._build_router_messages(
+            context_messages=context_messages,
+            run_input=run_input,
+        )
         tracking_model = self._build_model(stage_config=stage_config)
         response, payload = await finalize_json_response(
             model=tracking_model,
@@ -400,10 +260,11 @@ class AgentScopeRunner:
                         now_utc=datetime.now(timezone.utc),
                         runtime_client_time=runtime_client_time,
                         tools=None,
+                        memories=memories,
                     ),
                     "system",
                 ),
-                *context_messages,
+                *messages_for_router,
             ],
             output_model=RouterAgentOutput,
             retries=0,
@@ -423,6 +284,30 @@ class AgentScopeRunner:
             ),
         )
 
+    def _build_router_messages(
+        self,
+        *,
+        context_messages: list[Msg],
+        run_input: RunAgentInput,
+    ) -> list[Msg]:
+        if context_messages:
+            last = context_messages[-1]
+            if last.role == "user":
+                return context_messages
+
+        user_text, user_blocks = extract_latest_user_payload(run_input)
+        if (
+            user_blocks
+            and isinstance(user_blocks[0], dict)
+            and user_blocks[0].get("type") == "text"
+        ):
+            content: Any = user_text
+        else:
+            content = user_blocks
+
+        user_msg = Msg(name="user", role="user", content=content)
+        return [user_msg, *context_messages]
+
     async def _run_worker_stage(
         self,
         *,
@@ -434,6 +319,7 @@ class AgentScopeRunner:
         worker_output_model: type[WorkerAgentOutputLite],
         pipeline: PipelineLike,
         runtime_client_time: ClientTimeContext | None,
+        memories: MemoryListResponse | None,
     ) -> StageExecutionResult:
         tracking_model = self._build_model(stage_config=stage_config)
         emitter = PipelineStageEmitter(
@@ -454,6 +340,7 @@ class AgentScopeRunner:
                 runtime_client_time=runtime_client_time,
                 extra_context=stage_config.extra_context,
                 tools=None,
+                memories=memories,
             ),
             toolkit=toolkit,
             model=tracking_model,
@@ -553,5 +440,31 @@ class AgentScopeRunner:
             getattr(run_input, "forwarded_props", None)
         )
 
+    @staticmethod
+    def _resolve_provider_api_key(*, factory_name: str) -> str:
+        normalized_factory_name = factory_name.strip().upper()
+        if normalized_factory_name == "VOLCENGINE":
+            normalized_factory_name = "ARK"
+
+        provider_keys = {
+            str(key).strip().upper(): str(value).strip()
+            for key, value in config.llm.provider_keys.items()
+            if str(value).strip()
+        }
+        api_key = provider_keys.get(normalized_factory_name, "")
+        if not api_key:
+            raise RuntimeError(f"provider api key missing for factory: {factory_name}")
+        return api_key
+
+
+@dataclass(frozen=True)
+class SystemAgentRuntimeConfig:
+    agent_type: AgentType
+    model_code: str
+    api_base_url: str
+    api_key: str
+    llm_config: SystemAgentLLMConfig
+    extra_context: str | None = None
+
 
 AgentScopeReActRunner = AgentScopeRunner