dv-pipecat-ai 0.0.85.dev818__tar.gz → 0.0.85.dev819__tar.gz

{dv_pipecat_ai-0.0.85.dev818 → dv_pipecat_ai-0.0.85.dev819}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev818
+Version: 0.0.85.dev819
 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.dev818 → dv_pipecat_ai-0.0.85.dev819}/src/dv_pipecat_ai.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dv-pipecat-ai
-Version: 0.0.85.dev818
+Version: 0.0.85.dev819
 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.dev818 → dv_pipecat_ai-0.0.85.dev819}/src/dv_pipecat_ai.egg-info/SOURCES.txt

@@ -477,6 +477,7 @@ src/pipecat/utils/__init__.py
 src/pipecat/utils/base_object.py
 src/pipecat/utils/logger_config.py
 src/pipecat/utils/network.py
+src/pipecat/utils/redis.py
 src/pipecat/utils/string.py
 src/pipecat/utils/time.py
 src/pipecat/utils/utils.py

{dv_pipecat_ai-0.0.85.dev818 → dv_pipecat_ai-0.0.85.dev819}/src/pipecat/services/salesforce/llm.py

@@ -8,10 +8,9 @@
 
 import asyncio
 import json
-import os
 import time
-from typing import Any, Dict, List, Optional, AsyncGenerator
 from dataclasses import dataclass
+from typing import AsyncGenerator, Dict, Optional
 
 import httpx
 from loguru import logger
@@ -40,6 +39,7 @@ from pipecat.processors.aggregators.llm_response import (
     LLMUserAggregatorParams,
 )
 from env_config import api_config
+from pipecat.utils.redis import create_async_redis_client
 
 
 @dataclass
@@ -56,8 +56,8 @@ class SalesforceAgentLLMService(LLMService):
     """Salesforce Agent API LLM service implementation.
 
     This service integrates with Salesforce Agent API to provide conversational
-    AI capabilities using Salesforce's Agentforce platform. It follows the same
-    pattern as Vistaar LLM service for proper frame processing.
+
+    AI capabilities using Salesforce's Agentforce platform.
     """
 
     def __init__(
@@ -65,38 +65,48 @@ class SalesforceAgentLLMService(LLMService):
         *,
         model: str = "salesforce-agent",
         session_timeout_secs: float = 3600.0,
+        agent_id: str = api_config.SALESFORCE_AGENT_ID,
+        org_domain: str = api_config.SALESFORCE_ORG_DOMAIN,
+        client_id: str = api_config.SALESFORCE_CLIENT_ID,
+        client_secret: str = api_config.SALESFORCE_CLIENT_SECRET,
+        api_host: str = api_config.SALESFORCE_API_HOST,
+        redis_url: Optional[str] = None,
         **kwargs,
     ):
         """Initialize Salesforce Agent LLM service.
 
         Reads configuration from environment variables:
         - SALESFORCE_AGENT_ID: The Salesforce agent ID to interact with
-        - SALESFORCE_API_KEY: OAuth access token (optional, will use client credentials if not provided)
         - SALESFORCE_ORG_DOMAIN: Salesforce org domain (e.g., https://myorg.my.salesforce.com)
         - SALESFORCE_CLIENT_ID: Connected app client ID for OAuth
         - SALESFORCE_CLIENT_SECRET: Connected app client secret for OAuth
-        - SALESFORCE_API_HOST: Salesforce API host (default: https://api.salesforce.com)
+        - SALESFORCE_API_HOST: Salesforce API host base URL (e.g., https://api.salesforce.com)
 
         Args:
             model: The model name (defaults to "salesforce-agent").
             session_timeout_secs: Session timeout in seconds (default: 1 hour).
+            agent_id: Salesforce agent ID. Defaults to SALESFORCE_AGENT_ID.
+            org_domain: Salesforce org domain. Defaults to SALESFORCE_ORG_DOMAIN.
+            client_id: Salesforce connected app client ID. Defaults to SALESFORCE_CLIENT_ID.
+            client_secret: Salesforce connected app client secret. Defaults to SALESFORCE_CLIENT_SECRET.
+            api_host: Salesforce API host base URL. Defaults to SALESFORCE_API_HOST.
+            redis_url: Optional Redis URL override for token caching.
             **kwargs: Additional arguments passed to parent LLMService.
         """
         # Initialize parent LLM service
         super().__init__(**kwargs)
-            
-        self._agent_id = api_config.SALESFORCE_AGENT_ID
-        self._api_key = api_config.SALESFORCE_API_KEY
-        self._org_domain = api_config.SALESFORCE_ORG_DOMAIN
-        self._client_id = api_config.SALESFORCE_CLIENT_ID
-        self._client_secret = api_config.SALESFORCE_CLIENT_SECRET
-        self._api_host = api_config.SALESFORCE_API_HOST
+        self._agent_id = agent_id
+        self._org_domain = org_domain 
+        self._client_id = client_id
+        self._client_secret = client_secret
+        self._api_host = api_host
 
 
         # Validate required environment variables
         required_vars = {
             "SALESFORCE_AGENT_ID": self._agent_id,
             "SALESFORCE_ORG_DOMAIN": self._org_domain,
+            "SALESFORCE_API_HOST": self._api_host,
             "SALESFORCE_CLIENT_ID": self._client_id,
             "SALESFORCE_CLIENT_SECRET": self._client_secret,
         }
@@ -109,31 +119,140 @@ class SalesforceAgentLLMService(LLMService):
 
         self._session_timeout_secs = session_timeout_secs
 
+        if redis_url is not None:
+            self._redis_url = redis_url
+        else:
+            self._redis_url = getattr(api_config, "REDIS_URL", None)
+        self._redis_client = None
+        self._redis_client_init_attempted = False
+        self._token_cache_key = f"salesforce_agent_access_token:{self._agent_id}"
+        self._token_cache_leeway_secs = 300
+        self._sequence_counter = 0
+        self._warmup_task: Optional[asyncio.Task] = None
+
         # Session management
         self._sessions: Dict[str, SalesforceSessionInfo] = {}
         self._current_session_id: Optional[str] = None
 
         # HTTP client for API calls
-        self._http_client = httpx.AsyncClient(timeout=30.0)
+        self._http_client = httpx.AsyncClient(
+            timeout=30.0,
+            limits=httpx.Limits(
+                max_keepalive_connections=10,
+                max_connections=100,
+                keepalive_expiry=None,
+            ),
+        )
+
+        self._schedule_session_warmup()
         
 
     async def __aenter__(self):
         """Async context manager entry."""
+        await self.ensure_session_ready()
         return self
 
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         """Async context manager exit."""
+        if self._warmup_task:
+            try:
+                await asyncio.shield(self._warmup_task)
+            except Exception as exc:  # pragma: no cover - warmup best effort
+                logger.debug(f"Salesforce warmup task failed during exit: {exc}")
+            finally:
+                self._warmup_task = None
+
         await self._cleanup_sessions()
         await self._http_client.aclose()
 
+        if self._redis_client:
+            close_coro = getattr(self._redis_client, "close", None)
+            if callable(close_coro):
+                try:
+                    await close_coro()
+                except Exception as exc:  # pragma: no cover - best effort cleanup
+                    logger.debug(f"Failed to close Redis client cleanly: {exc}")
+        self._redis_client = None
+        self._redis_client_init_attempted = False
+
     def can_generate_metrics(self) -> bool:
         """Check if this service can generate processing metrics."""
         return True
 
+    def _schedule_session_warmup(self):
+        """Kick off background warm-up if an event loop is running."""
+        try:
+            loop = asyncio.get_running_loop()
+        except RuntimeError:
+            return
+
+        if loop.is_closed():
+            return
+
+        async def _warmup():
+            try:
+                await self.ensure_session_ready()
+            except Exception as exc:  # pragma: no cover - warmup best effort
+                logger.warning(f"Salesforce warmup failed: {exc}")
+                raise
+
+        task = loop.create_task(_warmup())
+
+        def _on_done(warmup_task: asyncio.Task):
+            if warmup_task.cancelled():
+                logger.debug("Salesforce warmup task cancelled")
+            elif warmup_task.exception():
+                logger.warning(f"Salesforce warmup task error: {warmup_task.exception()}")
+            self._warmup_task = None
+
+        task.add_done_callback(_on_done)
+        self._warmup_task = task
+
+    def _get_redis_client(self):
+        """Return a Redis client for token caching if configured."""
+        if self._redis_client is None and not self._redis_client_init_attempted:
+            self._redis_client_init_attempted = True
+            self._redis_client = create_async_redis_client(
+                self._redis_url, decode_responses=True, encoding="utf-8", logger=logger
+            )
+
+        return self._redis_client
+
+    async def _get_cached_access_token(self) -> Optional[str]:
+        """Return cached access token from Redis."""
+        redis_client = self._get_redis_client()
+        if not redis_client:
+            return None
+
+        try:
+            return await redis_client.get(self._token_cache_key)
+        except Exception as exc:  # pragma: no cover - cache failures shouldn't break flow
+            logger.warning(f"Failed to read Salesforce token from Redis: {exc}")
+            return None
+
+    async def _set_cached_access_token(self, token: str, expires_in: Optional[int]):
+        """Persist access token in Redis with TTL matching Salesforce expiry."""
+        redis_client = self._get_redis_client()
+        if not redis_client:
+            return
+
+        ttl_seconds = 3600
+        if expires_in is not None:
+            try:
+                ttl_seconds = max(int(expires_in) - self._token_cache_leeway_secs, 30)
+            except (TypeError, ValueError):
+                logger.debug("Unable to parse Salesforce token expiry; falling back to default TTL")
+
+        try:
+            await redis_client.set(self._token_cache_key, token, ex=ttl_seconds)
+        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."""
-        if self._api_key and not self._api_key.startswith("Bearer"):
-            return self._api_key
+        cached_token = await self._get_cached_access_token()
+        if cached_token:
+            return cached_token
 
         token_url = f"{self._org_domain}/services/oauth2/token"
         data = {
@@ -146,7 +265,9 @@ class SalesforceAgentLLMService(LLMService):
             response = await self._http_client.post(token_url, data=data)
             response.raise_for_status()
             token_data = response.json()
-            return token_data["access_token"]
+            access_token = token_data["access_token"]
+            await self._set_cached_access_token(access_token, token_data.get("expires_in"))
+            return access_token
         except Exception as e:
             logger.error(f"Failed to get access token: {e}")
             raise
@@ -207,13 +328,17 @@ class SalesforceAgentLLMService(LLMService):
                 return self._current_session_id
             else:
                 # Session expired, remove it
-                del self._sessions[self._current_session_id]
+                self._sessions.pop(self._current_session_id, None)
                 self._current_session_id = None
 
         # Create new session
         self._current_session_id = await self._create_session()
         return self._current_session_id
 
+    async def ensure_session_ready(self) -> str:
+        """Ensure a Salesforce session is ready for use."""
+        return await self._get_or_create_session()
+
     async def _cleanup_sessions(self):
         """Clean up expired sessions."""
         current_time = time.time()
@@ -236,7 +361,7 @@ class SalesforceAgentLLMService(LLMService):
             except Exception as e:
                 logger.warning(f"Failed to end session {session_id}: {e}")
             finally:
-                del self._sessions[session_id]
+                self._sessions.pop(session_id, None)
                 if self._current_session_id == session_id:
                     self._current_session_id = None
 
@@ -272,7 +397,8 @@ class SalesforceAgentLLMService(LLMService):
 
     def _generate_sequence_id(self) -> int:
         """Generate a sequence ID for the message."""
-        return int(time.time() * 1000) % 2147483647  # Keep within int32 range
+        self._sequence_counter += 1
+        return self._sequence_counter
 
     async def _stream_salesforce_response(self, session_id: str, user_message: str) -> AsyncGenerator[str, None]:
         """Stream response from Salesforce Agent API."""
@@ -337,8 +463,6 @@ class SalesforceAgentLLMService(LLMService):
 
     async def _process_context(self, context: OpenAILLMContext):
         """Process the LLM context and generate streaming response.
-        
-        Following Vistaar pattern for simple, direct processing.
 
         Args:
             context: The OpenAI LLM context containing messages to process.
@@ -387,8 +511,6 @@ class SalesforceAgentLLMService(LLMService):
 
     async def process_frame(self, frame: Frame, direction: FrameDirection):
         """Process frames for LLM completion requests.
-        
-        Following the exact Vistaar pattern - call super() for non-context frames only.
 
         Args:
             frame: The frame to process.
@@ -431,7 +553,7 @@ class SalesforceAgentLLMService(LLMService):
         """Create context aggregators for Salesforce LLM.
 
         Since Salesforce uses OpenAI-compatible message format, we reuse OpenAI's
-        context aggregators directly, similar to how Vistaar works.
+        context aggregators directly
 
         Args:
             context: The LLM context to create aggregators for.
@@ -462,4 +584,4 @@ class SalesforceAgentLLMService(LLMService):
         try:
             asyncio.create_task(self._http_client.aclose())
         except:
-            pass
+            pass

dv_pipecat_ai-0.0.85.dev819/src/pipecat/utils/redis.py

@@ -0,0 +1,58 @@
+"""Async Redis helper utilities."""
+
+from __future__ import annotations
+
+from typing import Any, Optional, TYPE_CHECKING
+
+from urllib.parse import urlparse
+
+try:
+    import redis.asyncio as redis
+except ImportError:  # pragma: no cover - Redis is optional
+    redis = None
+
+
+if TYPE_CHECKING:  # pragma: no cover - typing aid
+    from redis.asyncio import Redis
+
+
+def create_async_redis_client(
+    url: Optional[str],
+    *,
+    decode_responses: bool = True,
+    encoding: str = "utf-8",
+    logger: Optional[Any] = None,
+    **kwargs,
+) -> Optional["Redis"]:
+    """Return a configured async Redis client or None if unavailable.
+
+    Args:
+        url: Redis connection URL.
+        decode_responses: Whether to decode responses to str.
+        encoding: Character encoding to use with decoded responses.
+        logger: Optional logger supporting .warning() for diagnostics.
+        **kwargs: Additional keyword arguments forwarded to Redis.from_url.
+    """
+    if redis is None:
+        return None
+
+    if not url or url in {"redis_url", "REDIS_URL"}:
+        return None
+
+    parsed = urlparse(url)
+    connection_kwargs = {
+        "decode_responses": decode_responses,
+        "encoding": encoding,
+    }
+    connection_kwargs.update(kwargs)
+
+    if parsed.scheme == "rediss":
+        connection_kwargs.setdefault("ssl_cert_reqs", "none")
+        connection_kwargs.setdefault("ssl_check_hostname", False)
+
+    try:
+        return redis.Redis.from_url(url, **connection_kwargs)
+    except Exception as exc:  # pragma: no cover - best effort logging
+        if logger is not None:
+            logger.warning(f"Failed to create Redis client: {exc}")
+        return None