dv-pipecat-ai 0.0.85.dev822__py3-none-any.whl → 0.0.85.dev824__py3-none-any.whl

{dv_pipecat_ai-0.0.85.dev822.dist-info → dv_pipecat_ai-0.0.85.dev824.dist-info}/METADATA

@@ -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.dist-info → dv_pipecat_ai-0.0.85.dev824.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dv_pipecat_ai-0.0.85.dev822.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
+dv_pipecat_ai-0.0.85.dev824.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
@@ -108,7 +108,7 @@ pipecat/processors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 pipecat/processors/async_generator.py,sha256=qPOZxk5eOad_NrF_Z06vWZ6deXIxb9AKZKYO2e5pkJs,2385
 pipecat/processors/consumer_processor.py,sha256=DrWCKnfblknZJ0bLmR_unIeJ1axQw4IPUn2IB3KLGGA,3228
 pipecat/processors/dtmf_aggregator.py,sha256=mo_IXUlsnVl-_Xn8sbTGnRF4Lkts0h6E3uauGbeFyWs,10204
-pipecat/processors/frame_processor.py,sha256=Qf-EJCWlw2itvJTsFykKBfjcsXRQUDgSqJDF8gb60V0,33806
+pipecat/processors/frame_processor.py,sha256=uBu6Waa0_diMXdQXMZ5V5a_KwaaPzcieyuv5gO9u-ME,33841
 pipecat/processors/idle_frame_processor.py,sha256=z8AuhGap61lA5K35P6XCaOpn4kkmK_9NZNppbpQxheU,3124
 pipecat/processors/logger.py,sha256=8xa4KKekXQIETlQR7zoGnwUpLNo8CeDVm7YjyXePN-w,2385
 pipecat/processors/producer_processor.py,sha256=iIIOHZd77APvUGP7JqFbznAHUnCULcq_qYiSEjwXHcc,3265
@@ -318,7 +318,7 @@ pipecat/services/riva/__init__.py,sha256=rObSsj504O_TMXhPBg_ymqKslZBhovlR-A0aaRZ
 pipecat/services/riva/stt.py,sha256=bAss4dimx8eideaSPmPHM15_rSV3tfXNf13o5n1mfv4,25146
 pipecat/services/riva/tts.py,sha256=idbqx3I2NlWCXtrIFsjEaYapxA3BLIA14ai3aMBh-2w,8158
 pipecat/services/salesforce/__init__.py,sha256=OFvYbcvCadYhcKdBAVLj3ZUXVXQ1HyVyhgxIFf6_Thg,173
-pipecat/services/salesforce/llm.py,sha256=_DQ5JG5QYJG5Y8_LZLsPu5NeGzDBL8oy3_fFqNhz3-E,23009
+pipecat/services/salesforce/llm.py,sha256=xBy5PSftIwD0v3eXxC5QCSlb8R8HiU1KQTX4R9qEmkA,28108
 pipecat/services/sambanova/__init__.py,sha256=oTXExLic-qTcsfsiWmssf3Elclf3IIWoN41_2IpoF18,128
 pipecat/services/sambanova/llm.py,sha256=5XVfPLEk__W8ykFqLdV95ZUhlGGkAaJwmbciLdZYtTc,8976
 pipecat/services/sambanova/stt.py,sha256=ZZgEZ7WQjLFHbCko-3LNTtVajjtfUvbtVLtFcaNadVQ,2536
@@ -415,7 +415,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.dev822.dist-info/METADATA,sha256=32ww2Lem8OVrVN8fSto1BPjfW5dXjPi4fS9Me8Zz-YE,32924
-dv_pipecat_ai-0.0.85.dev822.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_pipecat_ai-0.0.85.dev822.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
-dv_pipecat_ai-0.0.85.dev822.dist-info/RECORD,,
+dv_pipecat_ai-0.0.85.dev824.dist-info/METADATA,sha256=uKWtJ_kdcJbjQXBfvv2_jUlyrmLwFG7YVWXKZYTZFo8,32924
+dv_pipecat_ai-0.0.85.dev824.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dv_pipecat_ai-0.0.85.dev824.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
+dv_pipecat_ai-0.0.85.dev824.dist-info/RECORD,,

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)
 

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