solana-agent 31.1.7__py3-none-any.whl → 31.2.1__py3-none-any.whl

solana_agent/services/realtime.py

@@ -0,0 +1,506 @@
+from __future__ import annotations
+
+import asyncio
+import logging
+from typing import Any, AsyncGenerator, Dict, Optional
+
+from solana_agent.interfaces.providers.realtime import (
+    BaseRealtimeSession,
+    RealtimeSessionOptions,
+)
+from solana_agent.interfaces.providers.audio import AudioTranscoder
+
+logger = logging.getLogger(__name__)
+
+
+class RealtimeService:
+    """High-level service to manage a realtime audio session.
+
+    Responsibilities:
+    - Connect/close a realtime session (WebSocket-based)
+    - Update voice and VAD at runtime via session.update
+    - Append/commit/clear input audio buffers
+    - Expose separate async generators for audio and input/output transcripts
+    - Allow out-of-band response.create (e.g., text-to-speech without new audio)
+    """
+
+    def __init__(
+        self,
+        session: BaseRealtimeSession,
+        options: Optional[RealtimeSessionOptions] = None,
+        transcoder: Optional[AudioTranscoder] = None,
+        accept_compressed_input: bool = False,
+        client_input_mime: str = "audio/mp4",
+        encode_output: bool = False,
+        client_output_mime: str = "audio/aac",
+    ) -> None:
+        self._session = session
+        self._options = options or RealtimeSessionOptions()
+        self._connected = False
+        self._lock = asyncio.Lock()
+        self._transcoder = transcoder
+        # Client-side transport controls (do not affect OpenAI session formats)
+        self._accept_compressed_input = accept_compressed_input
+        self._client_input_mime = client_input_mime
+        self._encode_output = encode_output
+        self._client_output_mime = client_output_mime
+
+    async def start(self) -> None:  # pragma: no cover
+        async with self._lock:
+            if self._connected:
+                return
+            logger.info("RealtimeService: starting session")
+            await self._session.connect()
+            self._connected = True
+
+    async def stop(self) -> None:  # pragma: no cover
+        async with self._lock:
+            if not self._connected:
+                return
+            logger.info("RealtimeService: stopping session")
+            await self._session.close()
+            self._connected = False
+
+    # --- Configuration ---
+    async def configure(
+        self,
+        *,
+        voice: Optional[str] = None,
+        vad_enabled: Optional[bool] = None,
+        instructions: Optional[str] = None,
+        input_rate_hz: Optional[int] = None,
+        output_rate_hz: Optional[int] = None,
+        input_mime: Optional[str] = None,
+        output_mime: Optional[str] = None,
+        tools: Optional[list[dict[str, Any]]] = None,
+        tool_choice: Optional[str] = None,
+    ) -> None:  # pragma: no cover
+        """Update session settings (voice, VAD, formats, tools)."""
+        patch: Dict[str, Any] = {}
+
+        audio_patch: Dict[str, Any] = {}
+        if input_mime or input_rate_hz is not None or vad_enabled is not None:
+            turn_detection = None
+            if vad_enabled is not None:
+                if vad_enabled:
+                    turn_detection = {
+                        "type": "semantic_vad",
+                        "create_response": True,
+                    }
+                else:
+                    turn_detection = None
+            audio_patch["input"] = {
+                "format": "pcm16",  # session is fixed to PCM16 server-side
+                "turn_detection": turn_detection,
+            }
+
+        if output_mime or output_rate_hz is not None or voice is not None:
+            audio_patch["output"] = {
+                "format": "pcm16",  # session is fixed to PCM16 server-side
+                "voice": voice or self._options.voice,
+                "speed": 1.0,
+            }
+
+        if audio_patch:
+            patch["audio"] = audio_patch
+
+        if instructions is not None:
+            patch["instructions"] = instructions
+        if tools is not None:
+            patch["tools"] = tools
+        if tool_choice is not None:
+            patch["tool_choice"] = tool_choice
+
+        if patch:
+            logger.debug("RealtimeService.configure patch: %s", patch)
+            await self._session.update_session(patch)
+
+        # Update local options snapshot
+        if voice is not None:
+            self._options.voice = voice
+        if vad_enabled is not None:
+            self._options.vad_enabled = vad_enabled
+        if instructions is not None:
+            self._options.instructions = instructions
+        if input_rate_hz is not None:
+            self._options.input_rate_hz = input_rate_hz
+        if output_rate_hz is not None:
+            self._options.output_rate_hz = output_rate_hz
+        if input_mime is not None:
+            self._options.input_mime = input_mime
+        if output_mime is not None:
+            self._options.output_mime = output_mime
+        if tools is not None:
+            self._options.tools = tools
+        if tool_choice is not None:
+            self._options.tool_choice = tool_choice
+
+    # --- Audio input ---
+    async def append_audio(self, chunk_bytes: bytes) -> None:  # pragma: no cover
+        """Accepts PCM16 by default; if accept_compressed_input is True, transcodes client audio to PCM16.
+
+        This keeps the server session configured for PCM while allowing mobile clients to send MP4/AAC.
+        """
+        logger.debug(
+            "RealtimeService.append_audio: len=%d, accept_compressed_input=%s, client_input_mime=%s",
+            len(chunk_bytes),
+            self._accept_compressed_input,
+            self._client_input_mime,
+        )
+        if self._accept_compressed_input:
+            if not self._transcoder:
+                raise ValueError(
+                    "Compressed input enabled but no transcoder configured"
+                )
+            pcm16 = await self._transcoder.to_pcm16(
+                chunk_bytes, self._client_input_mime, self._options.input_rate_hz
+            )
+            await self._session.append_audio(pcm16)
+            logger.debug("RealtimeService.append_audio: sent PCM16 len=%d", len(pcm16))
+            return
+        # Default: pass-through PCM16
+        await self._session.append_audio(chunk_bytes)
+        logger.debug(
+            "RealtimeService.append_audio: sent passthrough len=%d", len(chunk_bytes)
+        )
+
+    async def commit_input(self) -> None:  # pragma: no cover
+        logger.debug("RealtimeService.commit_input")
+        await self._session.commit_input()
+
+    async def clear_input(self) -> None:  # pragma: no cover
+        logger.debug("RealtimeService.clear_input")
+        await self._session.clear_input()
+
+    # --- Out-of-band response (e.g., TTS without new audio) ---
+    async def create_response(  # pragma: no cover
+        self, response_patch: Optional[Dict[str, Any]] = None
+    ) -> None:
+        await self._session.create_response(response_patch)
+
+    # --- Streams ---
+    def iter_events(self) -> AsyncGenerator[Dict[str, Any], None]:  # pragma: no cover
+        return self._session.iter_events()
+
+    def iter_output_audio(self) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        return self._session.iter_output_audio()
+
+    async def iter_output_audio_encoded(
+        self,
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        """Stream PCM16 audio, tolerating long tool executions by waiting while calls are pending.
+
+        - If no audio arrives immediately, we keep waiting as long as a function/tool call is pending.
+        - Bridge across multiple audio segments (e.g., pre-call and post-call responses).
+        - Only end the stream when no audio is available and no pending tool call remains.
+        """
+
+        def _has_pending_tool() -> bool:
+            try:
+                return bool(
+                    getattr(self._session, "has_pending_tool_call", lambda: False)()
+                )
+            except Exception:
+                return False
+
+        async def _produce_pcm():
+            max_wait_pending_sec = 600.0  # allow up to 10 minutes while tools run
+            waited_while_pending = 0.0
+            base_idle_timeout = 12.0
+            idle_slice = 1.0
+
+            while True:
+                gen = self._session.iter_output_audio()
+                try:
+                    # Inner loop for one segment until generator ends
+                    while True:
+                        try:
+                            chunk = await asyncio.wait_for(
+                                gen.__anext__(), timeout=idle_slice
+                            )
+                        except asyncio.TimeoutError:
+                            if _has_pending_tool():
+                                waited_while_pending += idle_slice
+                                if waited_while_pending <= max_wait_pending_sec:
+                                    continue
+                                else:
+                                    logger.warning(
+                                        "RealtimeService: exceeded max pending-tool wait; ending stream"
+                                    )
+                                    return
+                            else:
+                                # No pending tool: accumulate idle time; stop after base timeout
+                                waited_while_pending += idle_slice
+                                if waited_while_pending >= base_idle_timeout:
+                                    logger.warning(
+                                        "RealtimeService: idle with no pending tool; ending stream"
+                                    )
+                                    return
+                                continue
+                        # Got a chunk; reset idle counter and yield
+                        waited_while_pending = 0.0
+                        if not chunk:
+                            continue
+                        yield chunk
+                except StopAsyncIteration:
+                    # Segment ended; if a tool is pending, continue to next segment
+                    if _has_pending_tool():
+                        await asyncio.sleep(0.25)
+                        continue
+                    # Otherwise, no more audio segments expected
+                    return
+
+        if self._encode_output and self._transcoder:
+            async for out in self._transcoder.stream_from_pcm16(
+                _produce_pcm(), self._client_output_mime, self._options.output_rate_hz
+            ):
+                yield out
+        else:
+            async for chunk in _produce_pcm():
+                yield chunk
+
+    def iter_input_transcript(self) -> AsyncGenerator[str, None]:  # pragma: no cover
+        return self._session.iter_input_transcript()
+
+    def iter_output_transcript(self) -> AsyncGenerator[str, None]:  # pragma: no cover
+        return self._session.iter_output_transcript()
+
+
+class TwinRealtimeService:
+    """Orchestrates two realtime sessions in parallel:
+
+    - conversation: full duplex (audio out + assistant transcript, tools, etc.)
+    - transcription: transcription-only session per GA (input transcript deltas)
+
+    Audio input is fanned out to both sessions. Output audio is sourced from the
+    conversation session only. Input transcript is sourced from the transcription
+    session only. This aligns with the GA guidance to use a dedicated
+    transcription session for reliable realtime STT, while the conversation
+    session handles assistant speech.
+    """
+
+    def __init__(
+        self,
+        conversation: BaseRealtimeSession,
+        transcription: BaseRealtimeSession,
+        *,
+        conv_options: Optional[RealtimeSessionOptions] = None,
+        trans_options: Optional[RealtimeSessionOptions] = None,
+        transcoder: Optional[AudioTranscoder] = None,
+        accept_compressed_input: bool = False,
+        client_input_mime: str = "audio/mp4",
+        encode_output: bool = False,
+        client_output_mime: str = "audio/aac",
+    ) -> None:
+        self._conv = conversation
+        self._trans = transcription
+        self._conv_opts = conv_options or RealtimeSessionOptions()
+        self._trans_opts = trans_options or RealtimeSessionOptions()
+        self._transcoder = transcoder
+        self._accept_compressed_input = accept_compressed_input
+        self._client_input_mime = client_input_mime
+        self._encode_output = encode_output
+        self._client_output_mime = client_output_mime
+        self._connected = False
+        self._lock = asyncio.Lock()
+
+    async def start(self) -> None:  # pragma: no cover
+        async with self._lock:
+            if self._connected:
+                return
+            logger.info("TwinRealtimeService: starting conversation + transcription")
+            await asyncio.gather(self._conv.connect(), self._trans.connect())
+            self._connected = True
+
+    async def stop(self) -> None:  # pragma: no cover
+        async with self._lock:
+            if not self._connected:
+                return
+            logger.info("TwinRealtimeService: stopping both sessions")
+            try:
+                await asyncio.gather(self._conv.close(), self._trans.close())
+            finally:
+                self._connected = False
+
+    async def reconnect(self) -> None:  # pragma: no cover
+        async with self._lock:
+            try:
+                await asyncio.gather(self._conv.close(), self._trans.close())
+            except Exception:
+                pass
+            self._connected = False
+            await self.start()
+
+    async def configure(
+        self,
+        *,
+        voice: Optional[str] = None,
+        vad_enabled: Optional[bool] = None,
+        instructions: Optional[str] = None,
+        input_rate_hz: Optional[int] = None,
+        output_rate_hz: Optional[int] = None,
+        input_mime: Optional[str] = None,
+        output_mime: Optional[str] = None,
+        tools: Optional[list[dict[str, Any]]] = None,
+        tool_choice: Optional[str] = None,
+    ) -> None:  # pragma: no cover
+        # Only the conversation session needs voice/tools; transcription session
+        # already has its own VAD model configured at connect-time.
+        patch: Dict[str, Any] = {}
+        audio_patch: Dict[str, Any] = {}
+        if (
+            vad_enabled is not None
+            or input_rate_hz is not None
+            or input_mime is not None
+        ):
+            turn_detection = None
+            if vad_enabled is not None:
+                if vad_enabled:
+                    turn_detection = {"type": "semantic_vad", "create_response": True}
+                else:
+                    turn_detection = None
+            audio_patch["input"] = {"format": "pcm16", "turn_detection": turn_detection}
+        if output_rate_hz is not None or output_mime is not None or voice is not None:
+            audio_patch["output"] = {
+                "format": "pcm16",
+                "voice": voice or self._conv_opts.voice,
+                "speed": 1.0,
+            }
+        if audio_patch:
+            patch["audio"] = audio_patch
+        if instructions is not None:
+            patch["instructions"] = instructions
+        if tools is not None:
+            patch["tools"] = tools
+        if tool_choice is not None:
+            patch["tool_choice"] = tool_choice
+
+        if patch:
+            logger.debug("TwinRealtimeService.configure patch (conv): %s", patch)
+            await self._conv.update_session(patch)
+
+        # Update local snapshots
+        if voice is not None:
+            self._conv_opts.voice = voice
+        if vad_enabled is not None:
+            self._conv_opts.vad_enabled = vad_enabled
+            self._trans_opts.vad_enabled = vad_enabled
+        if instructions is not None:
+            self._conv_opts.instructions = instructions
+        if input_rate_hz is not None:
+            self._conv_opts.input_rate_hz = input_rate_hz
+            self._trans_opts.input_rate_hz = input_rate_hz
+        if output_rate_hz is not None:
+            self._conv_opts.output_rate_hz = output_rate_hz
+        if input_mime is not None:
+            self._conv_opts.input_mime = input_mime
+            self._trans_opts.input_mime = input_mime
+        if output_mime is not None:
+            self._conv_opts.output_mime = output_mime
+        if tools is not None:
+            self._conv_opts.tools = tools
+        if tool_choice is not None:
+            self._conv_opts.tool_choice = tool_choice
+
+    async def append_audio(self, chunk_bytes: bytes) -> None:  # pragma: no cover
+        # Transcode once if needed, then fan out to both
+        if self._accept_compressed_input:
+            if not self._transcoder:
+                raise ValueError(
+                    "Compressed input enabled but no transcoder configured"
+                )
+            pcm16 = await self._transcoder.to_pcm16(
+                chunk_bytes, self._client_input_mime, self._conv_opts.input_rate_hz
+            )
+            await asyncio.gather(
+                self._conv.append_audio(pcm16), self._trans.append_audio(pcm16)
+            )
+            return
+        await asyncio.gather(
+            self._conv.append_audio(chunk_bytes),
+            self._trans.append_audio(chunk_bytes),
+        )
+
+    async def commit_input(self) -> None:  # pragma: no cover
+        await asyncio.gather(self._conv.commit_input(), self._trans.commit_input())
+
+    async def commit_conversation(self) -> None:  # pragma: no cover
+        await self._conv.commit_input()
+
+    async def commit_transcription(self) -> None:  # pragma: no cover
+        await self._trans.commit_input()
+
+    async def clear_input(self) -> None:  # pragma: no cover
+        await asyncio.gather(self._conv.clear_input(), self._trans.clear_input())
+
+    async def create_response(
+        self, response_patch: Optional[Dict[str, Any]] = None
+    ) -> None:  # pragma: no cover
+        # Only conversation session creates assistant responses
+        await self._conv.create_response(response_patch)
+
+    # --- Streams ---
+    def iter_events(self) -> AsyncGenerator[Dict[str, Any], None]:  # pragma: no cover
+        # Prefer conversation events; caller can listen to transcription via iter_input_transcript
+        return self._conv.iter_events()
+
+    def iter_output_audio(self) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        return self._conv.iter_output_audio()
+
+    async def iter_output_audio_encoded(
+        self,
+    ) -> AsyncGenerator[bytes, None]:  # pragma: no cover
+        # Reuse the same encoding pipeline as RealtimeService but source from conversation
+        pcm_gen = self._conv.iter_output_audio()
+
+        try:
+            first_chunk = await asyncio.wait_for(pcm_gen.__anext__(), timeout=12.0)
+        except StopAsyncIteration:
+            logger.warning("TwinRealtimeService: no PCM produced (ended immediately)")
+            return
+        except asyncio.TimeoutError:
+            logger.warning("TwinRealtimeService: no PCM within timeout; closing conv")
+            try:
+                # Close both sessions to ensure clean restart on next turn
+                await asyncio.gather(self._conv.close(), self._trans.close())
+                self._connected = False
+            except Exception:
+                pass
+            return
+
+        async def _pcm_iter():
+            if first_chunk:
+                yield first_chunk
+            async for c in pcm_gen:
+                if not c:
+                    continue
+                yield c
+
+        if self._encode_output and self._transcoder:
+            async for out in self._transcoder.stream_from_pcm16(
+                _pcm_iter(), self._client_output_mime, self._conv_opts.output_rate_hz
+            ):
+                yield out
+        else:
+            async for chunk in _pcm_iter():
+                yield chunk
+
+    def iter_input_transcript(self) -> AsyncGenerator[str, None]:  # pragma: no cover
+        return self._trans.iter_input_transcript()
+
+    def iter_output_transcript(self) -> AsyncGenerator[str, None]:  # pragma: no cover
+        return self._conv.iter_output_transcript()
+
+    def iter_transcription_events(
+        self,
+    ) -> AsyncGenerator[Dict[str, Any], None]:  # pragma: no cover
+        # Expose transcription session events for completion detection
+        return self._trans.iter_events()
+
+    def is_connected(self) -> bool:  # pragma: no cover
+        return self._connected
+
+    def set_tool_executor(self, executor) -> None:  # pragma: no cover
+        # Forward to conversation session (tools only apply there)
+        if hasattr(self._conv, "set_tool_executor"):
+            self._conv.set_tool_executor(executor)

{solana_agent-31.1.7.dist-info → solana_agent-31.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: solana-agent
-Version: 31.1.7
+Version: 31.2.1
 Summary: AI Agents for Solana
 License: MIT
 Keywords: solana,solana ai,solana agent,ai,ai agent,ai agents
@@ -14,11 +14,11 @@ Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
-Requires-Dist: instructor (==1.11.2)
-Requires-Dist: llama-index-core (==0.13.5)
-Requires-Dist: llama-index-embeddings-openai (==0.5.0)
-Requires-Dist: logfire (==4.3.6)
-Requires-Dist: openai (==1.106.1)
+Requires-Dist: instructor (==1.11.3)
+Requires-Dist: llama-index-core (==0.14.0)
+Requires-Dist: llama-index-embeddings-openai (==0.5.1)
+Requires-Dist: logfire (==4.5.0)
+Requires-Dist: openai (==1.107.0)
 Requires-Dist: pillow (==11.3.0)
 Requires-Dist: pinecone[asyncio] (==7.3.0)
 Requires-Dist: pydantic (>=2)
@@ -26,7 +26,8 @@ Requires-Dist: pymongo (==4.14.1)
 Requires-Dist: pypdf (==6.0.0)
 Requires-Dist: rich (>=13,<14.0)
 Requires-Dist: scrubadub (==2.0.1)
-Requires-Dist: typer (==0.17.3)
+Requires-Dist: typer (==0.17.4)
+Requires-Dist: websockets (>=13,<16)
 Requires-Dist: zep-cloud (==3.4.3)
 Project-URL: Documentation, https://docs.solana-agent.com
 Project-URL: Homepage, https://solana-agent.com
@@ -52,7 +53,7 @@ Build your AI agents in three lines of code!
 ## Why?
 * Three lines of code setup
 * Simple Agent Definition
-* Fast & Streaming Responses
+* Streaming or Realtime Responses
 * Solana Integration
 * Multi-Agent Swarm
 * Multi-Modal (Images & Audio & Text)
@@ -131,6 +132,7 @@ Smart workflows are as easy as combining your tools and prompts.
 **OpenAI**
 * [gpt-4.1](https://platform.openai.com/docs/models/gpt-4.1) (agent & router)
 * [text-embedding-3-large](https://platform.openai.com/docs/models/text-embedding-3-large) (embedding)
+* [gpt-realtime](https://platform.openai.com/docs/models/gpt-realtime) (realtime audio agent)
 * [tts-1](https://platform.openai.com/docs/models/tts-1) (audio TTS)
 * [gpt-4o-mini-transcribe](https://platform.openai.com/docs/models/gpt-4o-mini-transcribe) (audio transcription)
 
@@ -307,6 +309,36 @@ async for response in solana_agent.process("user123", audio_content, audio_input
     print(response, end="")
 ```
 
+### Realtime Audio Streaming
+
+If input and/or output is encoded (compressed) like mp4/aac then you must have `ffmpeg` installed.
+
+Due to the overhead of the router (API call) - realtime only supports a single agent setup.
+
+Realtime uses MongoDB for memory so Zep is not needed.
+
+```python
+from solana_agent import SolanaAgent
+
+solana_agent = SolanaAgent(config=config)
+
+# Example: mobile sends MP4/AAC; server encodes output to AAC
+audio_content = await audio_file.read()  # bytes
+async for audio_chunk in solana_agent.process(
+    "user123",                    # required
+    audio_content,                # required
+    realtime=True,                # optional (default False)
+    output_format="audio",        # required
+    vad=True,                     # enable VAD (optional)
+    rt_encode_input=True,         # accept compressed input (optional)
+    rt_encode_output=True,        # encode output for client (optional)
+    rt_voice="marin"              # the voice to use for interactions (optional)
+    audio_input_format="mp4",     # client transport (optional)
+    audio_output_format="aac"     # client transport (optional)
+):
+    handle_audio(audio_chunk)
+```
+
 ### Image/Text Streaming
 
 ```python

{solana_agent-31.1.7.dist-info → solana_agent-31.2.1.dist-info}/RECORD

@@ -1,28 +1,32 @@
 solana_agent/__init__.py,sha256=iu0PnSAEZ6qzzHFVu7WVCQVbeCZmiZ6axUDDgWRn1j4,1070
 solana_agent/adapters/__init__.py,sha256=tiEEuuy0NF3ngc_tGEcRTt71zVI58v3dYY9RvMrF2Cg,204
+solana_agent/adapters/ffmpeg_transcoder.py,sha256=X8k4oz7CWcmhwvzXriatbE15wvQoU1jGdRdk7zp5mSA,9332
 solana_agent/adapters/mongodb_adapter.py,sha256=Hq3S8VzfLmnPjV40z8yJXGqUamOJcX5GbOMd-1nNWO4,3175
-solana_agent/adapters/openai_adapter.py,sha256=QaLOl48DhwtRk6AwRzEcFa_g29iOZW_KU3sCKckgsLE,26502
+solana_agent/adapters/openai_adapter.py,sha256=U3x6fMRmdvfvNt7M9-RKzV835WtPxNGrV1VRBMiRHV8,26714
+solana_agent/adapters/openai_realtime_ws.py,sha256=XTgwWXF4aD38UJSH7PCLIAqt9EuUUwsHRoM1Q6Fq66A,74352
 solana_agent/adapters/pinecone_adapter.py,sha256=XlfOpoKHwzpaU4KZnovO2TnEYbsw-3B53ZKQDtBeDgU,23847
 solana_agent/cli.py,sha256=FGvTIQmKLp6XsQdyKtuhIIfbBtMmcCCXfigNrj4bzMc,4704
 solana_agent/client/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/client/solana_agent.py,sha256=Ivi18kQaHu8Jp395SNe-dr751AEjmNxkt2dGfVXzVew,9374
+solana_agent/client/solana_agent.py,sha256=hLtiR3xD1eFww7XRdg4dTvxlJnTCepilYmEfABn9L7E,10344
 solana_agent/domains/__init__.py,sha256=HiC94wVPRy-QDJSSRywCRrhrFfTBeHjfi5z-QfZv46U,168
 solana_agent/domains/agent.py,sha256=8pAi1-kIgzFNANt3dyQjw-1zbThcNdpEllbAGWi79uI,2841
 solana_agent/domains/routing.py,sha256=1yR4IswGcmREGgbOOI6TKCfuM7gYGOhQjLkBqnZ-rNo,582
 solana_agent/factories/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-solana_agent/factories/agent_factory.py,sha256=FgwRpATEc_pFZV2My-yoql_nT1SBIqjU8KEPBleWE6M,14128
+solana_agent/factories/agent_factory.py,sha256=d9VuD5E9khqVXU_Qu67zKU2yVvXHK2EmercDmSZ4stk,14226
 solana_agent/guardrails/pii.py,sha256=FCz1IC3mmkr41QFFf5NaC0fwJrVkwFsxgyOCS2POO5I,4428
 solana_agent/interfaces/__init__.py,sha256=IQs1WIM1FeKP1-kY2FEfyhol_dB-I-VAe2rD6jrVF6k,355
-solana_agent/interfaces/client/client.py,sha256=9hg35-hp_CI-WVGOXehBE1ZCKYahLmbeAvtQOYmML4o,3245
+solana_agent/interfaces/client/client.py,sha256=VWMoxCflhxjwgmaCqDlU5Z9xSWgq0lrHa7ANagfsGVg,3660
 solana_agent/interfaces/guardrails/guardrails.py,sha256=gZCQ1FrirW-mX6s7FoYrbRs6golsp-x269kk4kQiZzc,572
 solana_agent/interfaces/plugins/plugins.py,sha256=Rz52cWBLdotwf4kV-2mC79tRYlN29zHSu1z9-y1HVPk,3329
+solana_agent/interfaces/providers/audio.py,sha256=CescIuGBEUQZ4XRyxb_1VYrO9x3Q80ilp-sxpYpxAyQ,1213
 solana_agent/interfaces/providers/data_storage.py,sha256=Y92Cq8BtC55VlsYLD7bo3ofqQabNnlg7Q4H1Q6CDsLU,1713
-solana_agent/interfaces/providers/llm.py,sha256=pvhatUVeaw7OE0iX_6O4LXnd-vtNCsoD-GYRn9uN4pc,3559
+solana_agent/interfaces/providers/llm.py,sha256=nerYO7QcbdSY44_YFqf_f4lftL0HbwC_G_er6oW80tw,3484
 solana_agent/interfaces/providers/memory.py,sha256=28X1LeS-bEac4yoIXdRPyuRU91oW9Kdt2NZtDmwSTxM,1360
+solana_agent/interfaces/providers/realtime.py,sha256=P0xKgMOWa0Zrp46g_Z9dzbWhjGdzRgnDeman-bc1xyQ,3089
 solana_agent/interfaces/providers/vector_storage.py,sha256=XPYzvoWrlDVFCS9ItBmoqCFWXXWNYY-d9I7_pvP7YYk,1561
-solana_agent/interfaces/services/agent.py,sha256=A-Hmgelr3g_qaNB0PEPMFHxB5nSCBK0WJ5hauJtIcmI,2257
+solana_agent/interfaces/services/agent.py,sha256=Hz3ldNb0NDMp8Rm9E3GM0L3kMAO3XLJ6U2HAh6gdPeU,2176
 solana_agent/interfaces/services/knowledge_base.py,sha256=Mu8lCGFXPmI_IW5LRGti7octLoWZIg4k5PmGwPfe7LQ,1479
-solana_agent/interfaces/services/query.py,sha256=uu_qV-DcMEAjj-XQkIc29-inXgERohui4FXrbJj7tBo,1838
+solana_agent/interfaces/services/query.py,sha256=jk-k6UeBFfWyZdPUr9imYLmlikTAuHegP0oWg2_ioew,2014
 solana_agent/interfaces/services/routing.py,sha256=Qbn3-DQGVSQKaegHDekSFmn_XCklA0H2f0XUx9-o3wA,367
 solana_agent/plugins/__init__.py,sha256=coZdgJKq1ExOaj6qB810i3rEhbjdVlrkN76ozt_Ojgo,193
 solana_agent/plugins/manager.py,sha256=mO_dKSVJ8GToD3wZflMcpKDEBXRoaaMRtY267HENCI0,5542
@@ -30,14 +34,15 @@ solana_agent/plugins/registry.py,sha256=VAG0BWdUUIsEE-VpATtHi8qat7ziPuh7pKuzGXau
 solana_agent/plugins/tools/__init__.py,sha256=VDjJxvUjefIy10VztQ9WDKgIegvDbIXBQWsHLhxdZ3o,125
 solana_agent/plugins/tools/auto_tool.py,sha256=uihijtlc9CCqCIaRcwPuuN7o1SHIpWL2GV3vr33GG3E,1576
 solana_agent/repositories/__init__.py,sha256=fP83w83CGzXLnSdq-C5wbw9EhWTYtqE2lQTgp46-X_4,163
-solana_agent/repositories/memory.py,sha256=YYbpUZi9iQ9-RfnlZSiFn5OhtEUyfqXV5n55Kgibf3M,10109
+solana_agent/repositories/memory.py,sha256=cipt9eC5YApi8ozFXAV5xq7QxQJExJmVdgGjkBjHwF0,17279
 solana_agent/services/__init__.py,sha256=iko0c2MlF8b_SA_nuBGFllr2E3g_JowOrOzGcnU9tkA,162
-solana_agent/services/agent.py,sha256=m6nqBFHB7IxUOwK0c2nlH6rt1hsRq4csxbT_oJaLBAA,23438
+solana_agent/services/agent.py,sha256=LWjsdmCeygwmjFoazOCVhrb0hdZHQDEQo_DFWZe57Lk,23133
 solana_agent/services/knowledge_base.py,sha256=ZvOPrSmcNDgUzz4bJIQ4LeRl9vMZiK9hOfs71IpB7Bk,32735
-solana_agent/services/query.py,sha256=X8SpNskx_UkLCPsk_GUFxa3rtmYPLowi7QStxKOzI_c,43829
+solana_agent/services/query.py,sha256=3nNGTNNQm-kYN60mIALIbc8ocWN5hQx8zT-pueKl0kA,67602
+solana_agent/services/realtime.py,sha256=kd9THmffBgquUr4Oho0q8QAa7kPwH6OIR74j7YAoc6s,20592
 solana_agent/services/routing.py,sha256=hsHe8HSGO_xFc0A17WIOGTidLTfLSfApQw3l2HHqkLo,7614
-solana_agent-31.1.7.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
-solana_agent-31.1.7.dist-info/METADATA,sha256=Q7bcSMIFKuwOoWvsej9dNBj9v4XVk5wbaTAZPicqX_I,29932
-solana_agent-31.1.7.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
-solana_agent-31.1.7.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
-solana_agent-31.1.7.dist-info/RECORD,,
+solana_agent-31.2.1.dist-info/LICENSE,sha256=BnSRc-NSFuyF2s496l_4EyrwAP6YimvxWcjPiJ0J7g4,1057
+solana_agent-31.2.1.dist-info/METADATA,sha256=1GipkxJJmxfMzgAdqtpCpoBKXfsKQBbAPG2Zn0Qx4I4,31240
+solana_agent-31.2.1.dist-info/WHEEL,sha256=b4K_helf-jlQoXBBETfwnf4B04YC67LOev0jo4fX5m8,88
+solana_agent-31.2.1.dist-info/entry_points.txt,sha256=-AuT_mfqk8dlZ0pHuAjx1ouAWpTRjpqvEUa6YV3lmc0,53
+solana_agent-31.2.1.dist-info/RECORD,,