agentkernel 0.9.4__tar.gz → 0.9.5__tar.gz

{agentkernel-0.9.4 → agentkernel-0.9.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: agentkernel
-Version: 0.9.4
+Version: 0.9.5
 Summary: Agent Kernel - Unified AI Agents Runtime
 Author: Yaala Labs
 Author-email: Yaala Labs <agentkernel@yaalalabs.com>
@@ -52,6 +52,8 @@ Requires-Dist: langgraph-prebuilt~=1.1.0 ; extra == 'langgraph'
 Requires-Dist: langchain~=1.3.10 ; extra == 'langgraph'
 Requires-Dist: langchain-community~=0.4.1 ; extra == 'langgraph'
 Requires-Dist: litellm~=1.89.2 ; extra == 'langgraph'
+Requires-Dist: livekit-api>=0.4.0 ; extra == 'livekit'
+Requires-Dist: livekit>=0.18.0 ; extra == 'livekit'
 Requires-Dist: logfire>=3.0 ; extra == 'logfire'
 Requires-Dist: fastmcp>=3.2.0,<4.0.0 ; extra == 'mcp'
 Requires-Dist: httpx>=0.27.0 ; extra == 'messenger'
@@ -60,7 +62,7 @@ Requires-Dist: litellm>=1.74.9 ; extra == 'multimodal'
 Requires-Dist: python-multipart>=0.0.12 ; extra == 'multimodal'
 Requires-Dist: nats-py>=2.15.0 ; extra == 'nats'
 Requires-Dist: neo4j>=5.0.0 ; extra == 'neo4j'
-Requires-Dist: openai-agents>=0.7.0 ; extra == 'openai'
+Requires-Dist: openai-agents>=0.20.0 ; extra == 'openai'
 Requires-Dist: openinference-instrumentation-openai-agents>=1.4.0 ; extra == 'openai'
 Requires-Dist: openai-guardrails>=0.2.1 ; extra == 'openai'
 Requires-Dist: traceloop-sdk>=0.61.0 ; extra == 'openllmetry'
@@ -118,6 +120,7 @@ Provides-Extra: kafka
 Provides-Extra: kubernetes
 Provides-Extra: langfuse
 Provides-Extra: langgraph
+Provides-Extra: livekit
 Provides-Extra: logfire
 Provides-Extra: mcp
 Provides-Extra: messenger

{agentkernel-0.9.4 → agentkernel-0.9.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "uv_build"
 
 [project]
 name = "agentkernel"
-version = "0.9.4"
+version = "0.9.5"
 description = "Agent Kernel - Unified AI Agents Runtime"
 readme = "README.md"
 requires-python = ">=3.12,<3.14"
@@ -61,6 +61,10 @@ pydanticai = [
 ]
 cli = [
     
+]
+livekit = [
+    "livekit-api>=0.4.0",
+    "livekit>=0.18.0",
 ]
 aws = [
     "boto3>=1.41.4",
@@ -111,7 +115,7 @@ trino = [
 ]
 
 openai = [
-    "openai-agents>=0.7.0",
+    "openai-agents>=0.20.0",
     "openinference-instrumentation-openai-agents>=1.4.0",
     "openai-guardrails>=0.2.1",
 ]

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/core/__init__.py

@@ -12,6 +12,7 @@ except importlib.metadata.PackageNotFoundError:
     __version__ = "0.1.0"
 
 from .base import Agent, Runner, RunOptionsFactory, Session
+from .realtime import RealtimeRunner
 from .event import (
     MessageEnd,
     MessageStart,
@@ -34,6 +35,7 @@ from .model import (
     AgentRequestFile,
     AgentRequestImage,
     AgentRequestText,
+    AgentRequestVoice,
     AgentReply,
     AgentReplyAny,
     AgentReplyText,

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/core/base.py

@@ -8,7 +8,7 @@ import pickle
 from abc import ABC, abstractmethod
 from collections.abc import AsyncGenerator, Awaitable, Callable, Iterable, Iterator, Mapping
 from enum import Enum
-from typing import TYPE_CHECKING, Any, ClassVar, Self, cast
+from typing import TYPE_CHECKING, Any, ClassVar, Self, Type, cast
 
 from .event import StreamEvent
 from .hooks import PostHook, PreHook
@@ -19,6 +19,9 @@ from .util.picklable import first_unpicklable_entry
 if TYPE_CHECKING:
     from .paused_run import PausedRun
 
+if TYPE_CHECKING:  # pragma: no cover: typing only; avoids a base <-> realtime import cycle
+    from .realtime import RealtimeRunner
+
 _log = logging.getLogger("ak.core.runner")
 
 
@@ -517,14 +520,16 @@ class Agent(ABC):
         """
         return cls.current_agent.get()
 
-    def __init__(self, name: str, runner: Runner):
+    def __init__(self, name: str, runner: Runner, realtime_runner_cls: "Type[RealtimeRunner] | None" = None):
         """
         Initializes an Agent instance.
         :param name: Name of the agent.
         :param runner: Runner associated with the agent.
+        :param realtime_runner_cls: Optional realtime runner class for WebSocket connections.
         """
         self._name: str = name
         self._runner: Runner = runner
+        self._realtime_runner_cls: "Type[RealtimeRunner] | None" = realtime_runner_cls
         self._pre_hooks: list[PreHook] = []
         self._post_hooks: list[PostHook] = []
         self._run_options: dict[str, Any] = {}
@@ -551,6 +556,13 @@ class Agent(ABC):
         """
         return self._runner
 
+    @property
+    def realtime_runner_cls(self) -> "Type[RealtimeRunner] | None":
+        """
+        Returns the realtime runner class associated with the agent, if any.
+        """
+        return self._realtime_runner_cls
+
     @property
     def pre_hooks(self) -> list[PreHook]:
         """

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/core/config.py

@@ -249,6 +249,19 @@ class _GmailConfig(BaseModel):
     )
 
 
+class _LiveKitConfig(BaseModel):
+    """LiveKit realtime voice gateway settings.
+
+    Bound like every other block, from YAML or ``AK_LIVEKIT__<FIELD>`` env vars (e.g.
+    ``AK_LIVEKIT__URL``, ``AK_LIVEKIT__API_KEY``, ``AK_LIVEKIT__API_SECRET``).
+    """
+
+    agent: str = Field(default="", description="Default agent to use for LiveKit interactions")
+    url: str = Field(default="", description="LiveKit server WebSocket URL")
+    api_key: str = Field(default="", description="LiveKit API Key")
+    api_secret: str = Field(default="", description="LiveKit API Secret")
+
+
 class _MultimodalStorageRedisConfig(_RedisConfig):
     ttl: int = Field(default=604800, description="Attachment TTL in seconds")
     prefix: str = Field(default="ak:attachments:", description="Key prefix for attachment keys")
@@ -652,10 +665,36 @@ class _LoggingConfig(BaseModel):
     system: _LogLevelConfig = Field(description="System logging configuration", default_factory=_LogLevelConfig)
 
 
+class _RealtimeConfig(BaseModel):
+    """Realtime-mode playback pacing.
+
+    Outbound model audio is paced so the edge holds ``playback_lead_ms`` of audio ahead of
+    wall-clock. A larger lead absorbs the per-chunk latency and jitter of a store-and-forward
+    broker (SQS adds more than Kafka/NATS), trading a little added latency for smoother playback;
+    a small lead is right for a low-latency transport. Only read when ``execution.mode`` is
+    ``realtime``.
+    """
+
+    playback_lead_ms: int = Field(
+        default=50,
+        ge=0,
+        description="Audio buffered ahead of playback at the edge, in milliseconds (higher = smoother over higher-latency transports)",
+    )
+    input_batch_ms: int = Field(
+        default=100,
+        ge=0,
+        description="Mic audio batched into this many milliseconds per input-queue message; 0 passes every frame through (lowest input latency, many more messages)",
+    )
+
+
 class _ExecutionConfig(BaseModel):
     mode: Optional[ExecutionMode] = Field(
         default=None,
-        description="Execution mode: rest_sync for synchronous REST, rest_async for asynchronous REST, stream for token streaming (WebSocket serverless or containerized direct streaming)",
+        description=(
+            "Execution mode: rest_sync for synchronous REST, rest_async for asynchronous REST, "
+            "stream for token streaming over WebSocket, async for whole-reply WebSocket delivery, "
+            "realtime for persistent realtime sockets (e.g. the LiveKit voice gateway)"
+        ),
     )
     # The default carries the transport type explicitly: `type` is mandatory inside a declared
     # queues block, and a config that declares no block at all still runs single-process on the
@@ -668,6 +707,10 @@ class _ExecutionConfig(BaseModel):
         default=None,
         description="Response storage configuration for async execution mode",
     )
+    realtime: _RealtimeConfig = Field(
+        default_factory=_RealtimeConfig,
+        description="Realtime execution playback pacing (used only when execution.mode is realtime)",
+    )
 
 
 class _SandboxIdentityConfig(BaseModel):
@@ -967,6 +1010,7 @@ class AKConfig(YamlBaseSettingsModified):
         default_factory=_MCPConfig,
     )
     slack: _SlackConfig = Field(description="Slack related configurations", default_factory=_SlackConfig)
+    livekit: _LiveKitConfig = Field(description="LiveKit related configurations", default_factory=_LiveKitConfig)
     whatsapp: _WhatsAppConfig = Field(description="WhatsApp related configurations", default_factory=_WhatsAppConfig)
     messenger: _MessengerConfig = Field(description="Facebook Messenger related configurations", default_factory=_MessengerConfig)
     instagram: _InstagramConfig = Field(description="Instagram Business API related configurations", default_factory=_InstagramConfig)

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/core/event.py

@@ -131,6 +131,20 @@ class ReasoningEnd(StreamEventBase):
     message_id: str
 
 
+class AudioDelta(StreamEventBase):
+    """A fragment of audio returned by the model."""
+
+    type: Literal["audio_delta"] = "audio_delta"
+    message_id: str
+    content: str
+
+
+class Interrupt(StreamEventBase):
+    """The user interrupted the model's in-progress turn (barge-in)."""
+
+    type: Literal["interrupt"] = "interrupt"
+
+
 class PausedInterruption(BaseModel):
     """
     One thing a human must decide before a paused run can continue.
@@ -190,6 +204,8 @@ type StreamEvent = Annotated[
         ReasoningStart,
         ReasoningDelta,
         ReasoningEnd,
+        AudioDelta,
+        Interrupt,
         RunPaused,
     ],
     Field(discriminator="type"),

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/core/model.py

@@ -70,6 +70,23 @@ class AgentRequestAny(BaseModel):
     type: Literal["other"] = "other"
 
 
+class AgentRequestVoice(BaseModel):
+    """
+    AgentRequestVoice encapsulates a voice request to an agent
+
+    audio_data: str  : This should be base64 encoded string or url
+    name: str : name of the voice clip
+    type: Literal["voice"]
+    mime_type: str | None = None : Optional. The IANA standard MIME type of the voice clip
+    """
+
+    prompt: str = ""
+    audio_data: str
+    name: str
+    type: Literal["voice"] = "voice"
+    mime_type: str | None = None
+
+
 class AgentRequestAttachmentRef(BaseModel):
     """
     AgentRequestAttachmentRef references an attachment whose bytes are already
@@ -185,11 +202,15 @@ class AgentResumeRequestAny(_ResumeDecisions):
     type: Literal["resume"] = "resume"
 
 
-type AgentRequest = Union[AgentRequestText, AgentRequestFile, AgentRequestImage, AgentRequestAny, AgentRequestAttachmentRef, AgentResumeRequestAny]
+type AgentRequest = Union[
+    AgentRequestText, AgentRequestFile, AgentRequestImage, AgentRequestVoice, AgentRequestAny, AgentRequestAttachmentRef, AgentResumeRequestAny
+]
 type AgentReply = Union[AgentReplyText, AgentReplyImage, AgentReplyAny]
 
 AgentRequestUnion = Annotated[
-    Union[AgentRequestText, AgentRequestFile, AgentRequestImage, AgentRequestAny, AgentRequestAttachmentRef, AgentResumeRequestAny],
+    Union[
+        AgentRequestText, AgentRequestFile, AgentRequestImage, AgentRequestVoice, AgentRequestAny, AgentRequestAttachmentRef, AgentResumeRequestAny
+    ],
     Field(discriminator="type"),
 ]
 
@@ -273,14 +294,24 @@ class AgentPausedReplyAny(AgentReplyAny):
 
 
 class ExecutionMode(str, Enum):
-    """
-    Execution mode enumeration for Lambda function behavior.
+    """How a request is executed and how its reply is delivered.
+
+    The mode is a process-level configuration value (``execution.mode``), read wherever a
+    component must branch on it; it is never carried on a request.
+
+    - ``REST_SYNC`` / ``REST_ASYNC``: the reply is written to the response store and read back
+      over REST.
+    - ``ASYNC``: WebSocket delivery, whole replies.
+    - ``STREAM``: token streaming (``StreamAgentRunner``), delivered over WebSocket.
+    - ``REALTIME``: a persistent model socket (voice), streamed and delivered through an
+      integration adapter such as the LiveKit gateway.
     """
 
     REST_SYNC = "rest_sync"
     REST_ASYNC = "rest_async"
     STREAM = "stream"
     ASYNC = "async"
+    REALTIME = "realtime"
 
 
 class StreamChunk(BaseModel):

agentkernel-0.9.5/src/agentkernel/core/realtime/__init__.py

@@ -0,0 +1,8 @@
+"""Core building blocks for realtime (persistent-socket) execution.
+
+The framework-agnostic contract every realtime adapter implements, plus the shared PCM16 helpers
+(the edge sample rate and a resampler) the pipeline and the edge both use.
+"""
+
+from .pcm import EDGE_SAMPLE_RATE, PCM16Resampler
+from .runner import RealtimeRunner

agentkernel-0.9.5/src/agentkernel/core/realtime/pcm.py

@@ -0,0 +1,46 @@
+"""PCM16 audio helpers shared by the realtime edge and the framework adapters.
+
+The realtime edge (e.g. the LiveKit gateway) carries PCM16 mono audio at a single rate in both
+directions. A model adapter declares the rates its model wants, and the pipeline converts. Keeping
+the rate and the resampler here gives every layer one source of truth, without naming any vendor.
+"""
+
+import array
+import sys
+
+# PCM16 mono, in and out: the rate the realtime edge carries audio at end to end.
+EDGE_SAMPLE_RATE = 24000
+
+
+class PCM16Resampler:
+    """Converts little-endian mono PCM16 audio between sample rates.
+
+    The pipeline uses it at the one place each direction crosses a rate boundary: edge to model
+    input, and model output to edge, so no adapter resamples.
+    """
+
+    @staticmethod
+    def resample(data: bytes, source_rate: int, target_rate: int) -> bytes:
+        """Linearly resample ``data`` from ``source_rate`` to ``target_rate``."""
+        if not data or source_rate == target_rate:
+            return data
+        samples = array.array("h")
+        samples.frombytes(data[: len(data) - (len(data) % 2)])
+        if not samples:
+            return b""
+        if sys.byteorder == "big":
+            samples.byteswap()
+
+        ratio = source_rate / target_rate
+        out_count = int(len(samples) / ratio)
+        out = array.array("h", bytes(out_count * 2))
+        for i in range(out_count):
+            position = i * ratio
+            left = int(position)
+            right = min(left + 1, len(samples) - 1)
+            fraction = position - left
+            out[i] = int(samples[left] + (samples[right] - samples[left]) * fraction)
+
+        if sys.byteorder == "big":
+            out.byteswap()
+        return out.tobytes()

agentkernel-0.9.5/src/agentkernel/core/realtime/runner.py

@@ -0,0 +1,119 @@
+from __future__ import annotations
+
+from abc import abstractmethod
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, Any, Callable
+
+from ..base import Agent, Runner, Session
+from ..event import StreamEvent
+from ..model import AgentReply, AgentRequest
+from .pcm import EDGE_SAMPLE_RATE
+
+if TYPE_CHECKING:  # typing only; ..tool imports ..base, so this avoids a cycle
+    from ..tool import ToolContext
+
+
+class RealtimeRunner(Runner):
+    """Base class for framework adapters handling realtime streaming via persistent
+    WebSocket/WebRTC connections (e.g. OpenAI Realtime API).
+
+    ``input_sample_rate`` and ``output_sample_rate`` are the PCM16 mono rates the model wants. The
+    pipeline converts between these and :data:`~agentkernel.core.realtime.pcm.EDGE_SAMPLE_RATE`, so
+    an adapter never resamples and no adapter hardcodes the edge's rate.
+
+    The realtime pool creates one instance per session connection, so an instance may keep that
+    connection's socket and state on ``self``. The pool owns everything around the model socket
+    (audio pacing, barge-in decisions, tool execution scopes, queue emission); an adapter only
+    talks to the model and reports what it does through the ``callback`` given to :meth:`connect`,
+    which is why an adapter never imports pipeline types.
+
+    Bring your own adapter by passing its class as ``realtime_runner_cls`` to the framework's
+    ``Module``.
+    """
+
+    input_sample_rate: int = EDGE_SAMPLE_RATE
+    output_sample_rate: int = EDGE_SAMPLE_RATE
+
+    async def run(self, agent: Any, session: Session, requests: list[AgentRequest]) -> AgentReply:
+        """Not supported for realtime runners."""
+        raise NotImplementedError("Realtime runners do not support unary run().")
+
+    async def stream(self, agent: Any, session: Session, requests: list[AgentRequest]) -> AsyncGenerator[StreamEvent, None]:
+        """Not supported for realtime runners."""
+        raise NotImplementedError("Realtime runners do not support unary stream().")
+        yield
+
+    @abstractmethod
+    async def connect(self, session: Session, agent: "Agent", callback: Callable) -> None:
+        """
+        Establishes a persistent socket connection to the framework's Realtime API backend.
+
+        The pool relies on these rules:
+
+        - Report model events through ``callback`` **in the order the model sent them**: the pool
+          paces audio and orders ``done`` / ``interrupt`` behind it on that basis.
+        - ``callback`` is a coroutine function; await every call.
+        - If connecting fails, close anything already opened before raising: the pool drops a
+          connection that failed to connect without calling :meth:`disconnect`.
+        - Report a socket that fails while connected as ``error``, but not a close caused by
+          :meth:`disconnect`.
+
+        :param session: The session to bind this connection to.
+        :param agent: The agent instance.
+        :param callback: The event callback from the pool, awaited as ``callback(event_type, data)``:
+
+            - ``audio_delta``: ``{"delta": <base64 PCM16 at output_sample_rate>, "message_id": str}``
+            - ``transcript_delta``: ``{"delta": <text>, "message_id": str}``
+            - ``tool_call``: ``{"call_id": str, "name": str, "arguments": <JSON string>}``; the pool
+              then calls :meth:`execute_tool` and :meth:`send_tool_result`
+            - ``done``: ``{"status": ...}``, the end of a model turn
+            - ``error``: ``{"message": str}``, the socket failed; the pool tells the user and
+              replaces the connection
+            - ``interrupt``: ``{}``, the user spoke while the model was responding
+            - ``speech_started``: ``{}``, the user spoke outside a response; the pool treats it as a
+              barge-in only while it still holds audio the user has not heard
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def append_audio(self, base64_audio: str) -> None:
+        """Appends audio to the model's input buffer, at :attr:`input_sample_rate`."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def send_text(self, text: str) -> None:
+        """Sends a text message and requests a response."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def send_tool_result(self, call_id: str, result: str) -> None:
+        """Sends a tool execution result back to the model."""
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def execute_tool(self, name: str, arguments: str, context: "ToolContext", call_id: str) -> str:
+        """Executes the named tool with JSON ``arguments`` and returns its string result.
+
+        Owned by the adapter because both the tool object and the context it needs are
+        framework-native: the OpenAI SDK expects its own ``ToolContext`` built around the run
+        context, and ADK injects a ``ToolContext`` (session state, actions) into tools that
+        declare one. The adapter activates ``context`` the way its framework expects; the
+        caller only constructs it.
+
+        :param name: Tool name, matching the model's function call.
+        :param arguments: Raw JSON argument string the model emitted.
+        :param context: The Agent Kernel tool context for this call.
+        :param call_id: The model's function-call id (frameworks correlate the response by it).
+        :return: The tool result as a string.
+        """
+        raise NotImplementedError()
+
+    @abstractmethod
+    async def disconnect(self) -> None:
+        """
+        Closes the active persistent socket connection.
+
+        Must be safe to call more than once, and after a :meth:`connect` that failed or never ran:
+        the pool calls it on idle eviction, on a failed socket, and at shutdown.
+        """
+        raise NotImplementedError()

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/deployment/aws/containerized/akagentrunner.py

@@ -6,6 +6,9 @@ import logging
 from ....core.chat_service import ChatService
 from ....core.config import AKConfig, ExecutionMode
 from ....core.model import BaseRunRequest, StreamChunk
+from ....pipeline.realtime_pool import RealtimeConnectionPool
+from ....pipeline.thread_runner import ThreadRunner
+from ....pipeline.transport.base import QueueTransportFactory
 from ..core.sqs_handler import SQSHandler
 from .core import ECSSQSConsumer
 
@@ -163,10 +166,13 @@ class ECSAgentRunner(ECSSQSConsumer):
 
     @classmethod
     def run(cls) -> None:
-        """Dispatch to ECSStreamAgentRunner when execution.mode is STREAM."""
+        """Dispatch to ECSStreamAgentRunner or ECSRealtimeAgentRunner based on execution.mode."""
         # cls check avoids redirect loops when a subclass (e.g. ECSStreamAgentRunner) calls this via inheritance.
-        if cls is ECSAgentRunner and cls._config.execution.mode == ExecutionMode.STREAM:
-            return ECSStreamAgentRunner.run()
+        if cls is ECSAgentRunner:
+            if cls._config.execution.mode == ExecutionMode.STREAM:
+                return ECSStreamAgentRunner.run()
+            elif cls._config.execution.mode == ExecutionMode.REALTIME:
+                return ECSRealtimeAgentRunner.run()
         return super().run()
 
 
@@ -277,3 +283,50 @@ class ECSStreamAgentRunner(ECSAgentRunner):
             )
         except Exception:
             cls._log.exception("Failed to send permanent-failure stream chunk to output queue")
+
+
+class ECSRealtimeAgentRunner(ECSAgentRunner):
+    """
+    ECS Agent Runner for REALTIME execution mode — polls the Input Queue and forwards
+    audio/text chunks to the RealtimeConnectionPool.
+
+    The ECS equivalent of pipeline.agent_runner.RealtimeAgentRunner.
+    """
+
+    _log = logging.getLogger("ak.ecs.realtimeagentrunner")
+
+    @classmethod
+    def _get_extra_tasks(cls) -> list[ThreadRunner.Task]:
+        pool = RealtimeConnectionPool.initialize()
+        return [pool.get_task()]
+
+    @classmethod
+    def on_permanent_failure(cls, record: dict) -> None:
+        """Tell the room its input failed, as a marked error chunk its edge can deliver. Catches own exceptions."""
+        cls._log.error(f"Permanent failure for message {record.get('MessageId')}")
+        try:
+            record_attributes = cls._get_record_attributes(raw_queue_message=record)
+            attributes = {**SQSHandler.get_message_custom_attributes(record), "request_id": record_attributes["request_id"]}
+            if record_attributes.get("user_id"):
+                attributes["user_id"] = record_attributes["user_id"]
+            dedup_id = record_attributes.get("message_deduplication_id")
+            RealtimeConnectionPool.send_permanent_failure(
+                QueueTransportFactory.create(),
+                attributes,
+                record_attributes["message_group_id"],
+                f"{dedup_id}-error" if dedup_id else None,
+                f"Failed to process message after {cls._config.execution.queues.input.max_receive_count} retries",
+            )
+        except Exception:
+            cls._log.exception("Failed to send permanent-failure error chunk to output queue")
+
+    @classmethod
+    def process_message(cls, record: dict) -> None:
+        receive_count = record.get("Attributes", {}).get("ApproximateReceiveCount", "1")
+        body = BaseRunRequest.model_validate(json.loads(record["Body"]))
+        record_attributes = cls._get_record_attributes(raw_queue_message=record, body=body)
+        request_id = record_attributes["request_id"]
+        RealtimeConnectionPool.initialize().dispatch(
+            body, request_id, record_attributes.get("user_id"), SQSHandler.get_message_custom_attributes(record), cls._get_chat_service()
+        )
+        cls._log.debug(f"[REALTIME CHUNK] request_id={request_id} (receive_count={receive_count})")

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/deployment/aws/containerized/core/sqs_consumer.py

@@ -13,6 +13,7 @@ import boto3
 from .....core.config import AKConfig
 from .....pipeline.consumer import ConsumerLoop
 from .....pipeline.envelope import QueueMessage
+from .....pipeline.thread_runner import ThreadRunner
 from .....pipeline.transport.base import TransportConsumer
 from ...core.raw_queue_consumer import RawQueueConsumer
 
@@ -155,6 +156,11 @@ class ECSSQSConsumer(RawQueueConsumer):
         else:
             cls.process_message(record)
 
+    @classmethod
+    def _get_extra_tasks(cls) -> List[ThreadRunner.Task]:
+        """Additional background tasks to run alongside the queue consumers."""
+        return []
+
     @classmethod
     def _build_consumer_loop(cls) -> ConsumerLoop:
         """Bind a ConsumerLoop to this class's SQS surface; built per call so subclass overrides apply."""
@@ -167,6 +173,7 @@ class ECSSQSConsumer(RawQueueConsumer):
             consumer_factory=lambda: _ECSRecordConsumer(cls),
             thread_name_prefix="sqs-consumer",
             logger=cls._log,
+            extra_tasks=cls._get_extra_tasks(),
         )
 
     @classmethod

{agentkernel-0.9.4 → agentkernel-0.9.5}/src/agentkernel/framework/adk/__init__.py

@@ -13,4 +13,4 @@ try:
 except importlib.metadata.PackageNotFoundError:
     __version__ = "0.1.0"
 
-from .adk import GoogleADKModule, GoogleADKToolBuilder
+from .adk import GoogleADKModule, GoogleADKRealtimeRunner, GoogleADKToolBuilder