Redis-backed session service and orchestration plugin (state tracking, abort, crash recovery)

Is your feature request related to a specific problem?

ADK currently has no Redis-backed session service and lacks runtime orchestration primitives for production agent deployments. Specifically:

1. No Redis session backend, existing options are InMemory (lost on restart), SQLite (single-node), Database (heavy), and VertexAI (vendor-locked). Redis is the standard for distributed, low-latency session state but is missing. (#2524)
2. No external abort/kill mechanism — there is no way to stop a running agent mid-execution from outside. Users have been requesting this since #1621 and again in #4796. In production, when an agent goes off-rails, you need an immediate kill switch, not a graceful timeout.
3. No crash recovery, if a process dies mid-task, the task state is lost. There's no mechanism to detect orphaned tasks on restart and recover or fail them cleanly.
4. No task lifecycle state tracking, no built-in way to track whether a task is running, completed, failed, timed out, or aborted.

Describe the Solution You'd Like

A RedisSessionService implementing BaseSessionService and a RedisOrchestrationPlugin extending BasePlugin that provides:

• Redis session service: create_session, get_session, list_sessions, delete_session, append_event backed by Redis with configurable TTL
• Task state machine: running → completed / failed / timed_out / aborted, tracked in Redis with Pub/Sub notifications
• External abort: publish to a Redis channel to kill a running agent mid-execution. Not a polite stop — an immediate process-level kill
• Crash recovery: on startup, scan for tasks stuck in "running" state and mark them failed with a recovery message

Plugin hooks mapping:

• before_run_callback → register task as RUNNING
• after_run_callback → mark COMPLETED/FAILED
• before_agent_callback → check abort signal
• on_model_error_callback → handle crash recovery

Impact on your work

I run multi-agent systems in managing infrastructure via Telegram, Discord, Slack, and web interfaces. Without these primitives, every production ADK deployment needs to build them from scratch. I've already built and battle-tested this with different frame works with 100 concurrent agents across 10,000 rounds. See my github

The agent safety model (dual-gate firewall with deterministic denylist + independent LLM judge) is documented in a separate IETF Internet-Draft: https://datatracker.ietf.org/doc/draft-baysal-asimov-safety-architecture/

Willingness to contribute

Yes. I have a working implementation ready to port to the adk-python. This addresses #2524, #4796, and #1621.

---

Describe Alternatives You've Considered

• SQLite/Database session service — exists but doesn't provide the low-latency Pub/Sub needed for real-time abort signals
• InMemory session service — lost on restart, not suitable for production
• Building it outside ADK — works but fragments the ecosystem. This belongs in the framework.

Proposed API / Implementation

Session service

from google.adk.sessions import RedisSessionService

session_service = RedisSessionService(
redis_url="redis://localhost:6379",
key_prefix="adk:",
session_ttl=3600,
)

Orchestration plugin

from google.adk.plugins import RedisOrchestrationPlugin

plugin = RedisOrchestrationPlugin(
redis_url="redis://localhost:6379",
enable_state_tracking=True,
enable_abort=True,
enable_crash_recovery=True,
)

App with both

from google.adk.apps import App

app = App(
name="my_app",
agent=my_agent,
plugins=[plugin],
)

Runner

runner = Runner(
app=app,
session_service=session_service,
)

External abort from anywhere

import redis
r = redis.from_url("redis://localhost:6379")
r.publish("adk:abort:task-123", '{"action": "abort"}')

Additional Context

• Addresses three open issues: #2524 (Redis memory/session), #4796 (stop run_async externally), #1621 (terminate conversation)
• Battle-tested at scale: 100 concurrent agents, 10,000 rounds, with HMAC-signed results
• Zero new dependencies beyond redis-py (optional install)