chore: checkpoint current backend/runtime changes

backend/src/core/agent/infrastructure/queue/tasks.py

@@ -1,15 +1,15 @@
 from __future__ import annotations
 
-from typing import Any, Protocol, cast
+from typing import Any, Protocol
 from uuid import UUID
 
 from core.agent.application.resume_service import ResumeService
 from core.agent.application.run_service import RunService
 from core.agent.infrastructure.events.redis_stream import RedisStreamEventStore
-from core.celery.app import celery_app
 from core.config.settings import config
 from core.logging import get_logger
-from services.base.redis import redis_service
+from core.taskiq.app import bulk_broker, critical_broker, default_broker
+from services.base.redis import get_or_init_redis_client
 
 logger = get_logger("core.agent.infrastructure.queue.tasks")
 
@@ -29,13 +29,12 @@ class ResumeServiceLike(Protocol):
 
 
 async def _build_redis_publisher() -> PublishEvent:
-    settings = cast(Any, config)
-    client = redis_service.get_client()
+    client = await get_or_init_redis_client()
     event_store = RedisStreamEventStore(
         client=client,
-        stream_prefix=settings.agent_runtime.redis_stream_prefix,
-        read_count=settings.agent_runtime.redis_stream_read_count,
-        block_ms=settings.agent_runtime.redis_stream_block_ms,
+        stream_prefix=config.agent_runtime.redis_stream_prefix,
+        read_count=config.agent_runtime.redis_stream_read_count,
+        block_ms=config.agent_runtime.redis_stream_block_ms,
     )
 
     async def _publish(event_type: str, payload: dict[str, object]) -> None:
@@ -70,22 +69,27 @@ async def run_agent_task(
         raise ValueError("session_id is required")
     UUID(session_id)
 
+    tool_call_id = ""
+    user_input = ""
+    if command_type == "resume":
+        tool_call_id = str(command.get("tool_call_id", ""))
+        if not tool_call_id:
+            raise ValueError("tool_call_id is required")
+    else:
+        user_input = str(command.get("user_input", ""))
+        if not user_input:
+            raise ValueError("user_input is required")
+
     start_event = "RUN_RESUMED" if command_type == "resume" else "RUN_STARTED"
     await publisher(start_event, {"session_id": session_id})
 
     try:
         if command_type == "resume":
-            tool_call_id = str(command.get("tool_call_id", ""))
-            if not tool_call_id:
-                raise ValueError("tool_call_id is required")
             result = await service_resume.resume(
                 session_id=session_id,
                 tool_call_id=tool_call_id,
             )
         else:
-            user_input = str(command.get("user_input", ""))
-            if not user_input:
-                raise ValueError("user_input is required")
             result = await service_run.run(
                 session_id=session_id,
                 user_input=user_input,
@@ -125,6 +129,16 @@ async def run_agent_task(
         raise
 
 
-@celery_app.task(name="tasks.agent.run_command")
+@default_broker.task(task_name="tasks.agent.run_command")
 async def run_command_task(command: dict[str, Any]) -> dict[str, object]:
     return await run_agent_task(command)
+
+
+@critical_broker.task(task_name="tasks.agent.run_command.critical")
+async def run_command_task_critical(command: dict[str, Any]) -> dict[str, object]:
+    return await run_agent_task(command)
+
+
+@bulk_broker.task(task_name="tasks.agent.run_command.bulk")
+async def run_command_task_bulk(command: dict[str, Any]) -> dict[str, object]:
+    return await run_agent_task(command)