dv-pipecat-ai 0.0.85.dev822__tar.gz → 0.0.85.dev824__tar.gz

{dv_pipecat_ai-0.0.85.dev822 → dv_pipecat_ai-0.0.85.dev824}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev822
+Version: 0.0.85.dev824
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.85.dev822 → dv_pipecat_ai-0.0.85.dev824}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev822
+Version: 0.0.85.dev824
 Summary: An open source framework for voice (and multimodal) assistants
 License-Expression: BSD-2-Clause
 Project-URL: Source, https://github.com/pipecat-ai/pipecat

{dv_pipecat_ai-0.0.85.dev822 → dv_pipecat_ai-0.0.85.dev824}/src/pipecat/processors/frame_processor.py

@@ -591,7 +591,7 @@ class FrameProcessor(BaseObject):
 
     async def pause_processing_system_frames(self):
         """Pause processing of queued system frames."""
-        logger.trace(f"{self}: pausing system frame processing")
+        self.logger.trace(f"{self}: pausing system frame processing")
         self.__should_block_system_frames = True
         if self.__input_event:
             self.__input_event.clear()
@@ -812,7 +812,7 @@ class FrameProcessor(BaseObject):
             True if the processor has been started.
         """
         if not self.__started:
-            logger.error(f"{self} Trying to process {frame} but StartFrame not received yet")
+            self.logger.error(f"{self} Trying to process {frame} but StartFrame not received yet")
         return self.__started
 
     def __create_input_task(self):
@@ -876,7 +876,7 @@ class FrameProcessor(BaseObject):
 
             await self._call_event_handler("on_after_process_frame", frame)
         except Exception as e:
-            logger.exception(f"{self}: error processing frame: {e}")
+            self.logger.exception(f"{self}: error processing frame: {e}")
             await self.push_error(ErrorFrame(str(e)))
 
     async def __input_frame_task_handler(self):
@@ -890,11 +890,11 @@ class FrameProcessor(BaseObject):
             (frame, direction, callback) = await self.__input_queue.get()
 
             if self.__should_block_system_frames and self.__input_event:
-                logger.trace(f"{self}: system frame processing paused")
+                self.logger.trace(f"{self}: system frame processing paused")
                 await self.__input_event.wait()
                 self.__input_event.clear()
                 self.__should_block_system_frames = False
-                logger.trace(f"{self}: system frame processing resumed")
+                self.logger.trace(f"{self}: system frame processing resumed")
 
             if isinstance(frame, SystemFrame):
                 await self.__process_frame(frame, direction, callback)
@@ -913,11 +913,11 @@ class FrameProcessor(BaseObject):
             (frame, direction, callback) = await self.__process_queue.get()
 
             if self.__should_block_frames and self.__process_event:
-                logger.trace(f"{self}: frame processing paused")
+                self.logger.trace(f"{self}: frame processing paused")
                 await self.__process_event.wait()
                 self.__process_event.clear()
                 self.__should_block_frames = False
-                logger.trace(f"{self}: frame processing resumed")
+                self.logger.trace(f"{self}: frame processing resumed")
 
             await self.__process_frame(frame, direction, callback)
 

{dv_pipecat_ai-0.0.85.dev822 → dv_pipecat_ai-0.0.85.dev824}/src/pipecat/services/salesforce/llm.py

@@ -236,23 +236,49 @@ class SalesforceAgentLLMService(LLMService):
         if not redis_client:
             return
 
-        ttl_seconds = 3600
+        ttl_seconds = 3600  # Default fallback
+        
+        # Try to get expiration from expires_in parameter first
         if expires_in is not None:
             try:
                 ttl_seconds = max(int(expires_in) - self._token_cache_leeway_secs, 30)
+                logger.debug(f"Using expires_in parameter: {expires_in}s, TTL: {ttl_seconds}s")
             except (TypeError, ValueError):
-                logger.debug("Unable to parse Salesforce token expiry; falling back to default TTL")
+                logger.debug("Unable to parse expires_in parameter")
+                expires_in = None
+        
+        # If no expires_in available, use default TTL
+        if expires_in is None:
+            logger.debug("No expiration info found, using default TTL")
 
         try:
             await redis_client.set(self._token_cache_key, token, ex=ttl_seconds)
+            logger.debug(f"Cached Salesforce token with TTL: {ttl_seconds}s")
         except Exception as exc:  # pragma: no cover - cache failures shouldn't break flow
             logger.warning(f"Failed to store Salesforce token in Redis: {exc}")
 
-    async def _get_access_token(self) -> str:
-        """Get OAuth access token using client credentials."""
-        cached_token = await self._get_cached_access_token()
-        if cached_token:
-            return cached_token
+    async def _clear_cached_access_token(self):
+        """Clear cached access token from Redis."""
+        redis_client = self._get_redis_client()
+        if not redis_client:
+            return
+
+        try:
+            await redis_client.delete(self._token_cache_key)
+            logger.debug("Cleared cached Salesforce access token")
+        except Exception as exc:  # pragma: no cover - cache failures shouldn't break flow
+            logger.warning(f"Failed to clear Salesforce token from Redis: {exc}")
+
+    async def _get_access_token(self, *, force_refresh: bool = False) -> str:
+        """Get OAuth access token using client credentials.
+        
+        Args:
+            force_refresh: If True, skip cache and fetch fresh token from Salesforce.
+        """
+        if not force_refresh:
+            cached_token = await self._get_cached_access_token()
+            if cached_token:
+                return cached_token
 
         token_url = f"{self._org_domain}/services/oauth2/token"
         data = {
@@ -267,21 +293,58 @@ class SalesforceAgentLLMService(LLMService):
             token_data = response.json()
             access_token = token_data["access_token"]
             await self._set_cached_access_token(access_token, token_data.get("expires_in"))
+            logger.debug("Retrieved fresh Salesforce access token")
             return access_token
         except Exception as e:
             logger.error(f"Failed to get access token: {e}")
             raise
 
+    async def _make_authenticated_request(self, method: str, url: str, **kwargs):
+        """Make an authenticated HTTP request with automatic token refresh on auth errors.
+        
+        Args:
+            method: HTTP method (GET, POST, DELETE, etc.)
+            url: Request URL
+            **kwargs: Additional arguments passed to httpx request
+            
+        Returns:
+            httpx.Response: The HTTP response
+            
+        Raises:
+            Exception: If request fails after token refresh attempt
+        """
+        # First attempt with current token
+        access_token = await self._get_access_token()
+        headers = kwargs.get("headers", {})
+        headers["Authorization"] = f"Bearer {access_token}"
+        kwargs["headers"] = headers
+        
+        try:
+            response = await self._http_client.request(method, url, **kwargs)
+            response.raise_for_status()
+            return response
+        except httpx.HTTPStatusError as e:
+            # If authentication error, clear cache and retry with fresh token
+            if e.response.status_code in (401, 403):
+                logger.warning(f"Salesforce authentication error ({e.response.status_code}), refreshing token")
+                await self._clear_cached_access_token()
+                
+                # Retry with fresh token
+                fresh_token = await self._get_access_token(force_refresh=True)
+                headers["Authorization"] = f"Bearer {fresh_token}"
+                kwargs["headers"] = headers
+                
+                response = await self._http_client.request(method, url, **kwargs)
+                response.raise_for_status()
+                return response
+            else:
+                # Re-raise non-auth errors
+                raise
+
     async def _create_session(self) -> str:
         """Create a new Salesforce Agent session."""
-        access_token = await self._get_access_token()
         session_url = f"{self._api_host}/einstein/ai-agent/v1/agents/{self._agent_id}/sessions"
 
-        headers = {
-            "Authorization": f"Bearer {access_token}",
-            "Content-Type": "application/json",
-        }
-
         external_session_key = f"pipecat-{int(time.time())}-{id(self)}"
 
         payload = {
@@ -295,8 +358,11 @@ class SalesforceAgentLLMService(LLMService):
         }
 
         try:
-            response = await self._http_client.post(session_url, headers=headers, json=payload)
-            response.raise_for_status()
+            response = await self._make_authenticated_request(
+                "POST", session_url, 
+                headers={"Content-Type": "application/json"}, 
+                json=payload
+            )
             session_data = response.json()
             session_id = session_data["sessionId"]
 
@@ -351,13 +417,11 @@ class SalesforceAgentLLMService(LLMService):
         for session_id in expired_sessions:
             try:
                 # End the session via API
-                access_token = await self._get_access_token()
                 url = f"{self._api_host}/einstein/ai-agent/v1/sessions/{session_id}"
-                headers = {
-                    "Authorization": f"Bearer {access_token}",
-                    "x-session-end-reason": "UserRequest",
-                }
-                await self._http_client.delete(url, headers=headers)
+                await self._make_authenticated_request(
+                    "DELETE", url,
+                    headers={"x-session-end-reason": "UserRequest"}
+                )
             except Exception as e:
                 logger.warning(f"Failed to end session {session_id}: {e}")
             finally:
@@ -402,14 +466,7 @@ class SalesforceAgentLLMService(LLMService):
 
     async def _stream_salesforce_response(self, session_id: str, user_message: str) -> AsyncGenerator[str, None]:
         """Stream response from Salesforce Agent API."""
-        access_token = await self._get_access_token()
         url = f"{self._api_host}/einstein/ai-agent/v1/sessions/{session_id}/messages/stream"
-        
-        headers = {
-            "Authorization": f"Bearer {access_token}",
-            "Content-Type": "application/json",
-            "Accept": "text/event-stream",
-        }
 
         message_data = {
             "message": {
@@ -426,6 +483,14 @@ class SalesforceAgentLLMService(LLMService):
             ]
         }
 
+        # First attempt with current token
+        access_token = await self._get_access_token()
+        headers = {
+            "Authorization": f"Bearer {access_token}",
+            "Content-Type": "application/json",
+            "Accept": "text/event-stream",
+        }
+
         try:
             logger.info(f"🌐 Salesforce API request: {user_message[:50]}...")
             async with self._http_client.stream("POST", url, headers=headers, json=message_data) as response:
@@ -457,6 +522,49 @@ class SalesforceAgentLLMService(LLMService):
                             logger.warning(f"JSON decode error: {e}, line: {line}")
                             continue
 
+        except httpx.HTTPStatusError as e:
+            # If authentication error, retry with fresh token
+            if e.response.status_code in (401, 403):
+                logger.warning(f"Salesforce streaming authentication error ({e.response.status_code}), refreshing token")
+                await self._clear_cached_access_token()
+                
+                # Retry with fresh token
+                fresh_token = await self._get_access_token(force_refresh=True)
+                headers["Authorization"] = f"Bearer {fresh_token}"
+                
+                logger.info(f"🔄 Retrying Salesforce stream with fresh token: {user_message[:50]}...")
+                async with self._http_client.stream("POST", url, headers=headers, json=message_data) as response:
+                    response.raise_for_status()
+                    
+                    async for line in response.aiter_lines():
+                        if not line:
+                            continue
+
+                        # Parse SSE format
+                        if line.startswith("data: "):
+                            try:
+                                data = json.loads(line[6:])
+                                message = data.get("message", {})
+                                message_type = message.get("type")
+
+                                if message_type == "TextChunk":
+                                    content = message.get("text", "") or message.get("message", "")
+                                    if content:
+                                        yield content
+                                elif message_type == "EndOfTurn":
+                                    logger.info("🏁 Salesforce response complete")
+                                    break
+                                elif message_type == "Inform":
+                                    # Skip INFORM events to avoid duplication
+                                    continue
+
+                            except json.JSONDecodeError as e:
+                                logger.warning(f"JSON decode error: {e}, line: {line}")
+                                continue
+            else:
+                # Re-raise non-auth errors
+                logger.error(f"Failed to stream from Salesforce Agent API: {e}")
+                raise
         except Exception as e:
             logger.error(f"Failed to stream from Salesforce Agent API: {e}")
             raise