dv-pipecat-ai 0.0.85.dev834__py3-none-any.whl → 0.0.85.dev840__py3-none-any.whl

{dv_pipecat_ai-0.0.85.dev834.dist-info → dv_pipecat_ai-0.0.85.dev840.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev834
+Version: 0.0.85.dev840
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat
@@ -26,6 +26,7 @@ Requires-Dist: numpy<3,>=1.26.4
 Requires-Dist: Pillow<12,>=11.1.0
 Requires-Dist: protobuf~=5.29.3
 Requires-Dist: pydantic<3,>=2.10.6
+Requires-Dist: PyJWT<3,>=2.8.0
 Requires-Dist: pyloudnorm~=0.1.1
 Requires-Dist: resampy~=0.4.3
 Requires-Dist: soxr~=0.5.0

{dv_pipecat_ai-0.0.85.dev834.dist-info → dv_pipecat_ai-0.0.85.dev840.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dv_pipecat_ai-0.0.85.dev834.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
+dv_pipecat_ai-0.0.85.dev840.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
 pipecat/__init__.py,sha256=j0Xm6adxHhd7D06dIyyPV_GlBYLlBnTAERVvD_jAARQ,861
 pipecat/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/adapters/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -153,7 +153,7 @@ pipecat/runner/livekit.py,sha256=in-2Io3FUZV-VcZZ-gQCx9L1WnKp5sHqmm7tDYlFNl4,458
 pipecat/runner/run.py,sha256=McalzMoFYEJJRXyoD5PBAyUhHCdsEeeZJk8lBvplRck,30054
 pipecat/runner/types.py,sha256=zHjbAiU17fG0ypLXCEzPu7bpDOutAg-4gE7TESvK8n0,1761
 pipecat/runner/utils.py,sha256=Ve9rjRvbt1o8e9by0nIrCJzUDGcuJUeYYhkqycmgHXc,18682
-pipecat/serializers/__init__.py,sha256=xcmbbR7YYU5C4HPbo2WVgPij-Bl_qlrLcnunCdpcZkg,804
+pipecat/serializers/__init__.py,sha256=z0V5GflCoPt4k2Yqm4ivuzKDh9VsYYAgK2UXZTw10aU,863
 pipecat/serializers/asterisk.py,sha256=QLJMXkU3DZ0sgFw3Vq2Zf8PHKkQQguL_v-l2Io4lZ_M,6729
 pipecat/serializers/base_serializer.py,sha256=OyBUZccs2ZT9mfkBbq2tGsUJMvci6o-j90Cl1sicPaI,2030
 pipecat/serializers/convox.py,sha256=fj9NkFTB74B9k8qWEuICQNGUQtEV0DusaHohkOqNLa8,11145
@@ -164,6 +164,7 @@ pipecat/serializers/plivo.py,sha256=ie6VUhZDTJ7KlAuJyHNeIeMtJ3ScDq_2js1SZtz7jLI,
 pipecat/serializers/protobuf.py,sha256=L0jSqvgTdkfxsu6JWjYK8QSTVji9nhzmgRsEEbGU7xY,5223
 pipecat/serializers/telnyx.py,sha256=eFkC7dExDFildYLR8DPvgfHbgXlCwdSPd1vc11yxyok,10847
 pipecat/serializers/twilio.py,sha256=0emSzXVw8DU_N5RPruMekbBKku9Q429-0z1PMuYejSk,10823
+pipecat/serializers/vi.py,sha256=Q7kMXvKM493RIuOUc99LKZWgVmvd8_owAzIK_oEktfw,11150
 pipecat/services/__init__.py,sha256=8e3Ta-8_BOPozhDB3l0GJkNXs5PWhib6yqZQUof2Kvw,1209
 pipecat/services/ai_service.py,sha256=yE386fm2Id-yD4fCNfkmEMtg0lTA7PB17n2x_A_jwTg,5896
 pipecat/services/ai_services.py,sha256=_RrDWfM8adV17atzY9RxK0nXRVM5kbUkKrvN90GAWYM,795
@@ -338,7 +339,7 @@ pipecat/services/together/llm.py,sha256=VSayO-U6g9Ld0xK9CXRQPUsd5gWJKtiA8qDAyXgs
 pipecat/services/ultravox/__init__.py,sha256=EoHCSXI2o0DFQslELgkhAGZtxDj63gZi-9ZEhXljaKE,259
 pipecat/services/ultravox/stt.py,sha256=uCQm_-LbycXdXRV6IE1a6Mymis6tyww7V8PnPzAQtx8,16586
 pipecat/services/vistaar/__init__.py,sha256=UFfSWFN5rbzl6NN-E_OH_MFaSYodZWNlenAU0wk-rAI,110
-pipecat/services/vistaar/llm.py,sha256=GNVKaelbpNH7NW7iOpBj2rJjmhMVUsPqfnBI-YgIjjw,19326
+pipecat/services/vistaar/llm.py,sha256=PrJIPPBh6PSKMtGRd2nYu1aIzk2covbwLEuUbZvDAVM,23114
 pipecat/services/whisper/__init__.py,sha256=smADmw0Fv98k7cGRuHTEcljKTO2WdZqLpJd0qsTCwH8,281
 pipecat/services/whisper/base_stt.py,sha256=VhslESPnYIeVbmnQTzmlZPV35TH49duxYTvJe0epNnE,7850
 pipecat/services/whisper/stt.py,sha256=9Qd56vWMzg3LtHikQnfgyMtl4odE6BCHDbpAn3HSWjw,17480
@@ -415,7 +416,7 @@ pipecat/utils/tracing/service_decorators.py,sha256=fwzxFpi8DJl6BJbK74G0UEB4ccMJg
 pipecat/utils/tracing/setup.py,sha256=7TEgPNpq6M8lww8OQvf0P9FzYc5A30xICGklVA-fua0,2892
 pipecat/utils/tracing/turn_context_provider.py,sha256=ikon3plFOx0XbMrH6DdeHttNpb-U0gzMZIm3bWLc9eI,2485
 pipecat/utils/tracing/turn_trace_observer.py,sha256=dma16SBJpYSOE58YDWy89QzHyQFc_9gQZszKeWixuwc,9725
-dv_pipecat_ai-0.0.85.dev834.dist-info/METADATA,sha256=XxgFHDSl86nlTft4vFFQJ1hPi8bNDPJznW83XbbOhKk,32924
-dv_pipecat_ai-0.0.85.dev834.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_pipecat_ai-0.0.85.dev834.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
-dv_pipecat_ai-0.0.85.dev834.dist-info/RECORD,,
+dv_pipecat_ai-0.0.85.dev840.dist-info/METADATA,sha256=ALfdKasSbWLkqVlc0XSkl9lo6qzO7Wpior0WxVFzWZk,32955
+dv_pipecat_ai-0.0.85.dev840.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dv_pipecat_ai-0.0.85.dev840.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
+dv_pipecat_ai-0.0.85.dev840.dist-info/RECORD,,

pipecat/serializers/__init__.py

@@ -5,6 +5,7 @@ from .exotel import ExotelFrameSerializer
 from .plivo import PlivoFrameSerializer
 from .telnyx import TelnyxFrameSerializer
 from .twilio import TwilioFrameSerializer
+from .vi import VIFrameSerializer
 
 __all__ = [
     "FrameSerializer",
@@ -15,6 +16,7 @@ __all__ = [
     "PlivoFrameSerializer",
     "TelnyxFrameSerializer",
     "TwilioFrameSerializer",
+    "VIFrameSerializer",
 ]
 
 # Optional imports

pipecat/serializers/vi.py

@@ -0,0 +1,324 @@
+#
+# Copyright (c) 2024–2025, Daily
+#
+# SPDX-License-Identifier: BSD 2-Clause License
+#
+
+"""Vodafone Idea (VI) WebSocket frame serializer for audio streaming and call management."""
+
+import base64
+import json
+from datetime import datetime, timezone
+from typing import Optional
+
+from loguru import logger
+from pydantic import BaseModel
+
+from pipecat.audio.utils import create_default_resampler
+from pipecat.frames.frames import (
+    AudioRawFrame,
+    CancelFrame,
+    EndFrame,
+    Frame,
+    InputAudioRawFrame,
+    InputDTMFFrame,
+    KeypadEntry,
+    StartFrame,
+    StartInterruptionFrame,
+    TransportMessageFrame,
+    TransportMessageUrgentFrame,
+)
+from pipecat.serializers.base_serializer import FrameSerializer, FrameSerializerType
+
+
+class VIFrameSerializer(FrameSerializer):
+    """Serializer for Vodafone Idea (VI) WebSocket protocol.
+
+    This serializer handles converting between Pipecat frames and VI's WebSocket
+    protocol for bidirectional audio streaming. It supports audio conversion, DTMF events,
+    and real-time communication with VI telephony systems.
+
+    VI WebSocket protocol requirements:
+    - PCM audio format at 8kHz sample rate
+    - 16-bit Linear PCM encoding
+    - Base64 encoded audio payloads
+    - JSON message format for control and media events
+    - Bitrate: 128 Kbps
+
+    Events (VI → Endpoint):
+    - connected: WebSocket connection established
+    - start: Stream session started with call/stream IDs
+    - media: Audio data in Base64-encoded PCM
+    - dtmf: Keypad digit pressed
+    - stop: Stream ended
+    - mark: Audio playback checkpoint confirmation
+
+    Events (Endpoint → VI):
+    - media: Send audio back to VI
+    - mark: Request acknowledgment for audio playback
+    - clear: Clear queued audio (interruption)
+    - exit: Terminate session gracefully
+    """
+
+    class InputParams(BaseModel):
+        """Configuration parameters for VIFrameSerializer.
+
+        Attributes:
+            vi_sample_rate: Sample rate used by VI, defaults to 8000 Hz (telephony standard).
+            sample_rate: Optional override for pipeline input sample rate.
+            auto_hang_up: Whether to automatically terminate call on EndFrame.
+        """
+
+        vi_sample_rate: int = 8000
+        sample_rate: Optional[int] = None
+        auto_hang_up: bool = False
+
+    def __init__(
+        self,
+        stream_id: str,
+        call_id: Optional[str] = None,
+        params: Optional[InputParams] = None,
+    ):
+        """Initialize the VIFrameSerializer.
+
+        Args:
+            stream_id: The VI stream identifier.
+            call_id: The associated VI call identifier.
+            params: Configuration parameters.
+        """
+        self._stream_id = stream_id
+        self._call_id = call_id
+        self._params = params or VIFrameSerializer.InputParams()
+
+        self._vi_sample_rate = self._params.vi_sample_rate
+        self._sample_rate = 0  # Pipeline input rate
+        self._call_ended = False
+
+        self._resampler = create_default_resampler()
+
+    @property
+    def type(self) -> FrameSerializerType:
+        """Gets the serializer type.
+
+        Returns:
+            The serializer type as TEXT for JSON WebSocket messages.
+        """
+        return FrameSerializerType.TEXT
+
+    async def setup(self, frame: StartFrame):
+        """Sets up the serializer with pipeline configuration.
+
+        Args:
+            frame: The StartFrame containing pipeline configuration.
+        """
+        self._sample_rate = self._params.sample_rate or frame.audio_in_sample_rate
+
+    async def serialize(self, frame: Frame) -> str | bytes | None:
+        """Serializes a Pipecat frame to VI WebSocket format.
+
+        Handles conversion of various frame types to VI WebSocket messages.
+        For EndFrames, initiates call termination if auto_hang_up is enabled.
+
+        Args:
+            frame: The Pipecat frame to serialize.
+
+        Returns:
+            Serialized data as JSON string, or None if the frame isn't handled.
+        """
+        if (
+            self._params.auto_hang_up
+            and not self._call_ended
+            and isinstance(frame, (EndFrame, CancelFrame))
+        ):
+            self._call_ended = True
+            # Return the exit event to terminate the VI session
+            return await self._send_exit_event()
+
+        elif isinstance(frame, StartInterruptionFrame):
+            # Clear/interrupt command for VI - clears queued audio
+            message = {
+                "event": "clear",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+            }
+            logger.debug(f"VI: Sending clear event for stream_id: {self._stream_id}")
+            return json.dumps(message)
+
+        elif isinstance(frame, AudioRawFrame):
+            if self._call_ended:
+                logger.debug("VI SERIALIZE: Skipping audio - call has ended")
+                return None
+
+            # Convert PCM audio to VI format
+            data = frame.audio
+
+            # Resample to VI sample rate (8kHz)
+            serialized_data = await self._resampler.resample(
+                data, frame.sample_rate, self._vi_sample_rate
+            )
+
+            # Encode as base64 for transmission
+            payload = base64.b64encode(serialized_data).decode("ascii")
+
+            # VI expects media event format with Base64-encoded PCM audio
+            timestamp = datetime.now(timezone.utc).isoformat().replace("+00:00", "Z")
+
+            message = {
+                "event": "media",
+                "stream_id": self._stream_id,
+                "media": {
+                    "timestamp": timestamp,
+                    "chunk": len(serialized_data),  # Chunk size in bytes
+                    "payload": payload,
+                },
+            }
+
+            return json.dumps(message)
+
+        elif isinstance(frame, (TransportMessageFrame, TransportMessageUrgentFrame)):
+            # Pass through transport messages (for mark events, etc.)
+            return json.dumps(frame.message)
+
+        return None
+
+    async def _send_exit_event(self):
+        """Send an exit event to VI to terminate the session gracefully.
+
+        This method is called when auto_hang_up is enabled and an EndFrame or
+        CancelFrame is received. The exit event allows IVR logic to continue
+        after the WebSocket session ends.
+        """
+        try:
+            exit_event = {
+                "event": "exit",
+                "stream_id": self._stream_id,
+                "call_id": self._call_id,
+                "timestamp": datetime.now(timezone.utc).isoformat().replace("+00:00", "Z"),
+            }
+
+            logger.info(
+                f"VI auto_hang_up: Sending exit event for stream_id: {self._stream_id}, call_id: {self._call_id}"
+            )
+            return json.dumps(exit_event)
+        except Exception as e:
+            logger.error(f"VI auto_hang_up: Failed to create exit event: {e}")
+            return None
+
+    async def deserialize(self, data: str | bytes) -> Frame | None:
+        """Deserializes VI WebSocket data to Pipecat frames.
+
+        Handles conversion of VI media events to appropriate Pipecat frames.
+
+        Args:
+            data: The raw WebSocket data from VI.
+
+        Returns:
+            A Pipecat frame corresponding to the VI event, or None if unhandled.
+        """
+        try:
+            message = json.loads(data)
+        except json.JSONDecodeError:
+            logger.error(f"Invalid JSON received from VI: {data}")
+            return None
+
+        # Log all incoming events for debugging and monitoring
+        event = message.get("event")
+        logger.debug(
+            f"VI INCOMING EVENT: {event} - stream_id: {self._stream_id}, call_id: {self._call_id}"
+        )
+
+        if event == "media":
+            # Handle incoming audio data from VI
+            media = message.get("media", {})
+            payload_base64 = media.get("payload")
+
+            if not payload_base64:
+                logger.warning("VI DESERIALIZE: No payload in VI media message")
+                return None
+
+            try:
+                payload = base64.b64decode(payload_base64)
+                chunk_size = len(payload)
+
+                # Log chunk info (optional)
+                logger.debug(
+                    f"VI DESERIALIZE: Received audio from VI - {chunk_size} bytes at {self._vi_sample_rate}Hz"
+                )
+
+            except Exception as e:
+                logger.error(f"VI DESERIALIZE: Error decoding VI audio payload: {e}")
+                return None
+
+            # Convert from VI sample rate (8kHz) to pipeline sample rate
+            deserialized_data = await self._resampler.resample(
+                payload,
+                self._vi_sample_rate,
+                self._sample_rate,
+            )
+
+            audio_frame = InputAudioRawFrame(
+                audio=deserialized_data,
+                num_channels=1,  # VI uses mono audio
+                sample_rate=self._sample_rate,
+            )
+            return audio_frame
+
+        elif event == "dtmf":
+            # Handle DTMF events
+            dtmf_data = message.get("dtmf", {})
+            digit = dtmf_data.get("digit")
+
+            if digit:
+                try:
+                    logger.info(f"VI: Received DTMF digit: {digit}")
+                    return InputDTMFFrame(KeypadEntry(digit))
+                except ValueError:
+                    logger.warning(f"Invalid DTMF digit from VI: {digit}")
+                    return None
+
+        elif event == "connected":
+            # Handle connection event
+            logger.info(f"VI connection established: {message}")
+            return None
+
+        elif event == "start":
+            # Handle stream start event
+            logger.info(f"VI stream started: {message}")
+            return None
+
+        elif event == "stop":
+            # Handle stream stop event
+            logger.info(f"VI stream stopped: {message}")
+            # Don't end the call here, wait for explicit exit or call end
+            return None
+
+        elif event == "mark":
+            # Handle mark event - checkpoint confirming audio playback completion
+            mark_data = message.get("mark", {})
+            mark_name = mark_data.get("name", "unknown")
+            logger.info(f"VI mark event received: {mark_name}")
+            # Mark events are informational, no frame to return
+            return None
+
+        elif event == "error":
+            # Handle error events
+            error_msg = message.get("error", "Unknown error")
+            logger.error(f"VI error: {error_msg}")
+            return None
+
+        elif event == "exit":
+            # Handle exit event from VI
+            logger.info("VI exit event received - terminating session")
+            self._call_ended = True
+            return CancelFrame()
+
+        elif event == "call_end" or event == "callEnd":
+            # Handle call end event (if VI sends this)
+            logger.info("VI call end event received")
+            self._call_ended = True
+            return CancelFrame()
+
+        else:
+            logger.debug(f"VI UNHANDLED EVENT: {event}")
+
+        return None

pipecat/services/vistaar/llm.py

@@ -10,9 +10,17 @@ from typing import Any, AsyncGenerator, Dict, List, Optional
 from urllib.parse import urlencode
 
 import httpx
+import jwt
 from loguru import logger
 from pydantic import BaseModel, Field
 
+try:
+    import redis.asyncio as redis
+    REDIS_AVAILABLE = True
+except ImportError:
+    REDIS_AVAILABLE = False
+    redis = None
+
 from pipecat.frames.frames import (
     CancelFrame,
     EndFrame,
@@ -55,7 +63,9 @@ class VistaarLLMService(LLMService):
         Parameters:
             source_lang: Source language code (e.g., 'mr' for Marathi, 'hi' for Hindi).
             target_lang: Target language code for responses.
-            session_id: Session ID for maintaining conversation context.
+            session_id: Session ID for maintaining conversation context (also used for JWT caching).
+            pre_query_response_phrases: List of phrases to say while waiting for response.
+            phone_number: Phone number for JWT subject claim.
             extra: Additional model-specific parameters
         """
 
@@ -63,6 +73,7 @@ class VistaarLLMService(LLMService):
         target_lang: Optional[str] = Field(default="mr")
         session_id: Optional[str] = Field(default=None)
         pre_query_response_phrases: Optional[List[str]] = Field(default_factory=list)
+        phone_number: Optional[str] = Field(default="UNKNOWN")
         extra: Optional[Dict[str, Any]] = Field(default_factory=dict)
 
     def __init__(
@@ -72,6 +83,9 @@ class VistaarLLMService(LLMService):
         params: Optional[InputParams] = None,
         timeout: float = 30.0,
         interim_timeout: float = 5.0,
+        redis_client: Optional[Any] = None,  # redis.Redis type
+        jwt_private_key: Optional[str] = None,
+        jwt_token_expiry: int = 3600,
         **kwargs,
     ):
         """Initialize Vistaar LLM service.
@@ -81,6 +95,9 @@ class VistaarLLMService(LLMService):
             params: Input parameters for model configuration and behavior.
             timeout: Request timeout in seconds. Defaults to 30.0 seconds.
             interim_timeout: Time in seconds before sending interim message. Defaults to 5.0 seconds.
+            redis_client: Optional Redis client for JWT token caching.
+            jwt_private_key: Optional RSA private key in PEM format for JWT signing.
+            jwt_token_expiry: JWT token expiry time in seconds. Defaults to 3600 (1 hour).
             **kwargs: Additional arguments passed to the parent LLMService.
         """
         super().__init__(**kwargs)
@@ -95,6 +112,16 @@ class VistaarLLMService(LLMService):
         self._extra = params.extra if isinstance(params.extra, dict) else {}
         self._timeout = timeout
         self._interim_timeout = interim_timeout
+        self._phone_number = params.phone_number
+
+        # JWT authentication setup
+        self._redis_client = redis_client
+        self._jwt_private_key = jwt_private_key
+        self._jwt_token_expiry = jwt_token_expiry
+        self._jwt_issuer = "voice-provider"
+
+        if self._jwt_private_key and not self._redis_client:
+            logger.warning("JWT private key provided but no Redis client for caching. JWT auth will regenerate tokens on each request.")
 
         # Create an async HTTP client
         self._client = httpx.AsyncClient(timeout=httpx.Timeout(self._timeout), verify=False)
@@ -112,6 +139,53 @@ class VistaarLLMService(LLMService):
             f"Vistaar LLM initialized - Base URL: {self._base_url}, Session ID: {self._session_id}, Source Lang: {self._source_lang}, Target Lang: {self._target_lang}, Timeout: {self._timeout}s"
         )
 
+    async def _get_jwt_token(self) -> Optional[str]:
+        """Generate or retrieve a cached JWT token.
+
+        Returns:
+            JWT token string or None if JWT auth is not configured.
+        """
+        if not self._jwt_private_key:
+            return None
+
+        # Try to get from Redis cache if available
+        if self._redis_client and self._session_id:
+            redis_key = f"vistaar_jwt:{self._session_id}"
+            try:
+                cached_token = await self._redis_client.get(redis_key)
+                if cached_token:
+                    logger.debug(f"Retrieved JWT token from Redis cache for session_id: {self._session_id}")
+                    return cached_token.decode('utf-8') if isinstance(cached_token, bytes) else cached_token
+            except Exception as e:
+                logger.warning(f"Redis cache retrieval failed: {e}. Generating new token.")
+
+        # Generate new token
+        current_time = int(time.time())
+        payload = {
+            "sub": self._phone_number,  # Subject identifier (phone number)
+            "iss": self._jwt_issuer,    # Issuer
+            "iat": current_time,         # Issued at timestamp
+            "exp": current_time + self._jwt_token_expiry  # Expiration timestamp
+        }
+
+        token = jwt.encode(payload, self._jwt_private_key, algorithm="RS256")
+        logger.info(f"Generated new JWT token for {self._phone_number}, expires in {self._jwt_token_expiry}s")
+
+        # Cache in Redis if available
+        if self._redis_client and self._session_id:
+            redis_key = f"vistaar_jwt:{self._session_id}"
+            try:
+                await self._redis_client.setex(
+                    redis_key,
+                    self._jwt_token_expiry,
+                    token
+                )
+                logger.debug(f"Cached JWT token in Redis for session_id: {self._session_id} with {self._jwt_token_expiry}s TTL")
+            except Exception as e:
+                logger.warning(f"Redis cache storage failed: {e}. Continuing without cache.")
+
+        return token
+
     async def _extract_messages_to_query(self, context: OpenAILLMContext) -> str:
         """Extract only the last user message from context.
 
@@ -259,9 +333,20 @@ class VistaarLLMService(LLMService):
         self._interim_in_progress = False
         self._interim_completion_event.clear()  # Reset the event for new request
 
+        # Prepare headers with JWT authentication if configured
+        headers = {}
+        try:
+            jwt_token = await self._get_jwt_token()
+            if jwt_token:
+                headers["Authorization"] = f"Bearer {jwt_token}"
+                logger.debug(f"Added JWT authentication header for session_id: {self._session_id}")
+        except Exception as e:
+            logger.error(f"Failed to generate JWT token: {e}")
+            raise
+
         try:
             # Use httpx to handle SSE streaming
-            async with self._client.stream("GET", url) as response:
+            async with self._client.stream("GET", url, headers=headers) as response:
                 self._current_response = response  # Store for potential cancellation
                 response.raise_for_status()