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

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

@@ -12,31 +12,28 @@ from core.agentscope.events import (
     RedisStreamBus,
     SqlAlchemyEventStore,
 )
-from core.agentscope.services.context_service import AgentContextService
 from core.agentscope.runtime.orchestrator import AgentScopeRuntimeOrchestrator
-from core.agentscope.runtime.pipeline_registry import build_default_pipeline_spec
 from core.agentscope.schemas.agui_input import parse_run_input
+from core.agentscope.services.context_service import AgentContextService
 from core.auth.models import CurrentUser
 from core.config.settings import config
 from core.db.session import AsyncSessionLocal
 from core.logging import get_logger
 from core.taskiq.app import worker_agent_broker, worker_automation_broker
-from schemas.agent.visibility import SystemVisibilityBit, bit_mask
-from schemas.automation.config import AutomationJobConfig
+from schemas.automation import MemoryContextConfig, RuntimeConfig
+from schemas.memories import MemoryListResponse
 from schemas.messages.chat_message import (
     AgentChatMessageMetadata,
     extract_user_message_attachments,
 )
-from schemas.agent.forwarded_props import parse_forwarded_props_agent_type
 from schemas.user import UserContext
 from services.base.redis import get_or_init_redis_client
 from services.base.supabase import supabase_service
 from v1.agent.repository import AgentRepository
-from v1.memory.repository import MemoryRepository
-from v1.memory.service import MemoryService
+from v1.memories.repository import MemoriesRepository
+from v1.memories.service import MemoriesService
 from v1.users.dependencies import get_user_service
 
-
 logger = get_logger("core.agentscope.runtime.tasks")
 _MAX_CONTEXT_ATTACHMENTS = 3
 
@@ -86,29 +83,14 @@ async def _build_recent_context_messages(
     *,
     session: Any,
     thread_id: str,
-    context_mode: str,
-    memory_job_config: AutomationJobConfig | None = None,
+    context_config: "MemoryContextConfig",
 ) -> list[Msg]:
     context_service = AgentContextService(repository=AgentRepository(session))
-    if memory_job_config is not None:
-        visibility_mask = bit_mask(bit=int(SystemVisibilityBit.UI_HISTORY))
-        if memory_job_config.context.window_mode.value == "day":
-            result = await context_service.load_by_day_window(
-                thread_id=thread_id,
-                day_count=memory_job_config.context.window_count,
-                visibility_mask=visibility_mask,
-            )
-        else:
-            result = await context_service.load_by_user_message_window(
-                thread_id=thread_id,
-                user_message_limit=memory_job_config.context.window_count,
-                visibility_mask=visibility_mask,
-            )
-    else:
-        result = await context_service.load_context_messages(
-            thread_id=thread_id,
-            system_agent_mode=context_mode,
-        )
+    result = await context_service.load_context_messages(
+        thread_id=thread_id,
+        context_config=context_config,
+    )
+
     if not result:
         return []
 
@@ -193,6 +175,7 @@ async def run_agentscope_task(command: dict[str, Any]) -> dict[str, object]:
     command_type = str(command.get("command", "run")).strip().lower()
     raw_owner_id = command.get("owner_id")
     run_input_raw = command.get("run_input")
+    runtime_config_raw = command.get("runtime_config")
 
     if not isinstance(raw_owner_id, str) or not raw_owner_id.strip():
         raise ValueError("owner_id is required")
@@ -200,15 +183,7 @@ async def run_agentscope_task(command: dict[str, Any]) -> dict[str, object]:
         raise ValueError("run_input is required")
 
     run_input = parse_run_input(run_input_raw)
-    system_agent_mode = parse_forwarded_props_agent_type(
-        getattr(run_input, "forwarded_props", None)
-    )
-    raw_automation_job_id = command.get("automation_job_id")
-    if system_agent_mode == "memory" and (
-        not isinstance(raw_automation_job_id, str) or not raw_automation_job_id
-    ):
-        raise ValueError("automation_job_id is required for memory mode")
-    pipeline_spec = build_default_pipeline_spec(mode=system_agent_mode)
+    runtime_config = RuntimeConfig.model_validate(runtime_config_raw or {})
     thread_id = run_input.thread_id
     run_id = run_input.run_id
     owner_id = UUID(raw_owner_id)
@@ -220,15 +195,10 @@ async def run_agentscope_task(command: dict[str, Any]) -> dict[str, object]:
 
     async with AsyncSessionLocal() as session:
         user_context = await _build_user_context(owner_id=owner_id, session=session)
-        memory_job_config: AutomationJobConfig | None = None
-        if system_agent_mode == "memory":
-            assert isinstance(raw_automation_job_id, str)
-            job_uuid = UUID(raw_automation_job_id)
-            memory_service = MemoryService(MemoryRepository(session))
-            memory_job_config = await memory_service.get_memory_job_config(
-                job_id=job_uuid,
-                owner_id=owner_id,
-            )
+        memories_service = MemoriesService(MemoriesRepository(session))
+        memories: MemoryListResponse = await memories_service.get_all_memories(
+            owner_id=owner_id
+        )
 
         redis_client = await get_or_init_redis_client()
         bus = RedisStreamBus(
@@ -251,16 +221,15 @@ async def run_agentscope_task(command: dict[str, Any]) -> dict[str, object]:
         context_messages = await _build_recent_context_messages(
             session=session,
             thread_id=thread_id,
-            context_mode=pipeline_spec.stages[0].agent_type.value,
-            memory_job_config=memory_job_config,
+            context_config=runtime_config.context,
         )
 
         await runtime.run(
             run_input=run_input,
             context_messages=context_messages,
             user_context=user_context,
-            system_agent_mode=system_agent_mode,
-            memory_job_config=memory_job_config,
+            runtime_config=runtime_config,
+            memories=memories,
         )
     logger.info(
         "agentscope runtime task completed",