dv-pipecat-ai 0.0.85.dev823__py3-none-any.whl → 0.0.85.dev825__py3-none-any.whl

{dv_pipecat_ai-0.0.85.dev823.dist-info → dv_pipecat_ai-0.0.85.dev825.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev823
+Version: 0.0.85.dev825
 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.dev823.dist-info → dv_pipecat_ai-0.0.85.dev825.dist-info}/RECORD

@@ -1,4 +1,4 @@
-dv_pipecat_ai-0.0.85.dev823.dist-info/licenses/LICENSE,sha256=DWY2QGf2eMCFhuu2ChairtT6CB7BEFffNVhXWc4Od08,1301
+dv_pipecat_ai-0.0.85.dev825.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
@@ -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
@@ -352,7 +352,7 @@ pipecat/tests/utils.py,sha256=DEHDQV8uhCuKIqoHUPGVdUoCiKqTCG9zv5GqLXWWwvY,7870
 pipecat/transcriptions/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 pipecat/transcriptions/language.py,sha256=-mWI1MiZbasuoqZTOBH69dAmoM7-UJzWq9rSCcrnmh4,8228
 pipecat/transports/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-pipecat/transports/base_input.py,sha256=BDex3CfCefwXyjK0M_FBXYEjqXYKUKR5ODtxcRp66uI,20086
+pipecat/transports/base_input.py,sha256=WGtoXXlF3GIjYgjtYnAgi8nZozd5abNlGNjwRnz8FRs,20138
 pipecat/transports/base_output.py,sha256=mNlIOo7tETlbYPbDyOtA2H-TkBGFKmjuCMDzQUtiwmk,35423
 pipecat/transports/base_transport.py,sha256=JlNiH0DysTfr6azwHauJqY_Z9HJC702O29Q0qrsLrg4,7530
 pipecat/transports/daily/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -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.dev823.dist-info/METADATA,sha256=QzFZChlDc4joKwMeDE3JSyM7EQzpJLPuIyfsNhrVgzE,32924
-dv_pipecat_ai-0.0.85.dev823.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-dv_pipecat_ai-0.0.85.dev823.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
-dv_pipecat_ai-0.0.85.dev823.dist-info/RECORD,,
+dv_pipecat_ai-0.0.85.dev825.dist-info/METADATA,sha256=9do57Wuqp0n9sMyV0YkeHfibkx3w57ANLCiGI7Pbzsk,32924
+dv_pipecat_ai-0.0.85.dev825.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+dv_pipecat_ai-0.0.85.dev825.dist-info/top_level.txt,sha256=kQzG20CxGf-nSsHmtXHx3hY2-8zHA3jYg8jk0TajqXc,8
+dv_pipecat_ai-0.0.85.dev825.dist-info/RECORD,,

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

pipecat/transports/base_input.py

@@ -297,6 +297,17 @@ class BaseInputTransport(FrameProcessor):
         elif isinstance(frame, EmulateUserStoppedSpeakingFrame):
             self.logger.debug("Emulating user stopped speaking")
             await self._handle_user_interruption(VADState.QUIET, emulated=True)
+        elif isinstance(frame, VADParamsUpdateFrame):
+            if self.vad_analyzer:
+                self.vad_analyzer.set_params(frame.params)
+                speech_frame = SpeechControlParamsFrame(
+                    vad_params=frame.params,
+                    turn_params=self._params.turn_analyzer.params
+                    if self._params.turn_analyzer
+                    else None,
+                )
+                await self.push_frame(speech_frame)
+            await self.push_frame(frame, direction)
         # All other system frames
         elif isinstance(frame, SystemFrame):
             await self.push_frame(frame, direction)
@@ -309,16 +320,6 @@ class BaseInputTransport(FrameProcessor):
         elif isinstance(frame, StopFrame):
             await self.push_frame(frame, direction)
             await self.pause(frame)
-        elif isinstance(frame, VADParamsUpdateFrame):
-            if self.vad_analyzer:
-                self.vad_analyzer.set_params(frame.params)
-                speech_frame = SpeechControlParamsFrame(
-                    vad_params=frame.params,
-                    turn_params=self._params.turn_analyzer.params
-                    if self._params.turn_analyzer
-                    else None,
-                )
-                await self.push_frame(speech_frame)
         elif isinstance(frame, FilterUpdateSettingsFrame) and self._params.audio_in_filter:
             await self._params.audio_in_filter.process_frame(frame)
         # Other frames