lucidicai 2.1.1__tar.gz → 2.1.3__tar.gz

{lucidicai-2.1.1 → lucidicai-2.1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: lucidicai
-Version: 2.1.1
+Version: 2.1.3
 Summary: Lucidic AI Python SDK
 Author: Andy Liang
 Author-email: andy@lucidic.ai

{lucidicai-2.1.1 → lucidicai-2.1.3}/lucidicai/__init__.py

@@ -100,6 +100,7 @@ def _end_session(
 ):
     """End the current session."""
     from .sdk.init import get_resources, get_session_id, get_event_queue
+    from .sdk.shutdown_manager import get_shutdown_manager
 
     # Use provided session_id or fall back to context
     if not session_id:
@@ -125,6 +126,9 @@ def _end_session(
     # Clear session context
     clear_active_session()
 
+    # unregister from shutdown manager
+    get_shutdown_manager().unregister_session(session_id)
+
 
 def _get_session():
     """Get the current session object."""
@@ -293,7 +297,7 @@ get_error_history = error_boundary.get_error_history
 clear_error_history = error_boundary.clear_error_history
 
 # Version
-__version__ = "2.1.1"
+__version__ = "2.1.3"
 
 # Apply error boundary wrapping to all SDK functions
 from .sdk.error_boundary import wrap_sdk_function

lucidicai-2.1.3/lucidicai/api/client.py

@@ -0,0 +1,357 @@
+"""Pure HTTP client for Lucidic API communication.
+
+This module contains only the HTTP client logic using httpx,
+supporting both synchronous and asynchronous operations.
+"""
+import asyncio
+from datetime import datetime, timezone
+from typing import Any, Dict, Optional
+
+import httpx
+
+from ..core.config import SDKConfig, get_config
+from ..core.errors import APIKeyVerificationError
+from ..utils.logger import debug, info, warning, error, mask_sensitive, truncate_data
+
+
+class HttpClient:
+    """HTTP client for API communication with sync and async support."""
+    
+    def __init__(self, config: Optional[SDKConfig] = None):
+        """Initialize the HTTP client.
+        
+        Args:
+            config: SDK configuration (uses global if not provided)
+        """
+        self.config = config or get_config()
+        self.base_url = self.config.network.base_url
+        
+        # Build default headers
+        self._headers = self._build_headers()
+        
+        # Transport configuration for connection pooling and retries
+        self._transport_kwargs = {
+            "retries": self.config.network.max_retries,
+        }
+        
+        # Connection limits for pooling
+        self._limits = httpx.Limits(
+            max_connections=self.config.network.connection_pool_maxsize,
+            max_keepalive_connections=self.config.network.connection_pool_size,
+        )
+        
+        # Lazy-initialized clients
+        self._sync_client: Optional[httpx.Client] = None
+        self._async_client: Optional[httpx.AsyncClient] = None
+    
+    def _build_headers(self) -> Dict[str, str]:
+        """Build default headers for requests."""
+        headers = {
+            "User-Agent": "lucidic-sdk/2.0",
+            "Content-Type": "application/json"
+        }
+        
+        if self.config.api_key:
+            headers["Authorization"] = f"Api-Key {self.config.api_key}"
+        
+        if self.config.agent_id:
+            headers["x-agent-id"] = self.config.agent_id
+        
+        return headers
+    
+    @property
+    def sync_client(self) -> httpx.Client:
+        """Get or create the synchronous HTTP client."""
+        if self._sync_client is None or self._sync_client.is_closed:
+            transport = httpx.HTTPTransport(**self._transport_kwargs)
+            self._sync_client = httpx.Client(
+                base_url=self.base_url,
+                headers=self._headers,
+                timeout=httpx.Timeout(self.config.network.timeout),
+                limits=self._limits,
+                transport=transport,
+            )
+        return self._sync_client
+    
+    @property
+    def async_client(self) -> httpx.AsyncClient:
+        """Get or create the asynchronous HTTP client."""
+        if self._async_client is None or self._async_client.is_closed:
+            transport = httpx.AsyncHTTPTransport(**self._transport_kwargs)
+            self._async_client = httpx.AsyncClient(
+                base_url=self.base_url,
+                headers=self._headers,
+                timeout=httpx.Timeout(self.config.network.timeout),
+                limits=self._limits,
+                transport=transport,
+            )
+        return self._async_client
+    
+    def _add_timestamp(self, data: Optional[Dict[str, Any]]) -> Dict[str, Any]:
+        """Add current_time to request data."""
+        if data is None:
+            data = {}
+        data["current_time"] = datetime.now(timezone.utc).isoformat()
+        return data
+    
+    def _handle_response(self, response: httpx.Response) -> Dict[str, Any]:
+        """Handle HTTP response and parse JSON.
+        
+        Args:
+            response: httpx Response object
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            APIKeyVerificationError: On 401 Unauthorized responses
+            httpx.HTTPStatusError: On other HTTP errors
+        """
+        # Log and raise for HTTP errors
+        if not response.is_success:
+            try:
+                error_data = response.json()
+                error_msg = error_data.get('detail', response.text)
+            except Exception:
+                error_msg = response.text
+            
+            error(f"[HTTP] Error {response.status_code}: {error_msg}")
+            
+            # Raise specific error for authentication/authorization failures
+            if response.status_code in (401, 403):
+                raise APIKeyVerificationError(f"Authentication failed: {error_msg}")
+        
+        response.raise_for_status()
+        
+        # Parse JSON response
+        try:
+            data = response.json()
+        except ValueError:
+            # For empty responses (like verifyapikey), return success
+            if response.status_code == 200 and not response.text:
+                data = {"success": True}
+            else:
+                # Return text if not JSON
+                data = {"response": response.text}
+        
+        debug(f"[HTTP] Response ({response.status_code}): {truncate_data(data)}")
+        
+        return data
+    
+    # ==================== Synchronous Methods ====================
+    
+    def get(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous GET request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return self.request("GET", endpoint, params=params)
+    
+    def post(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous POST request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return self.request("POST", endpoint, json=data)
+    
+    def put(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous PUT request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return self.request("PUT", endpoint, json=data)
+    
+    def delete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make a synchronous DELETE request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return self.request("DELETE", endpoint, params=params)
+    
+    def request(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make a synchronous HTTP request.
+        
+        Args:
+            method: HTTP method
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            json: Request body (for POST/PUT)
+            **kwargs: Additional arguments for httpx
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            httpx.HTTPError: On HTTP errors
+        """
+        url = f"/{endpoint}"
+        
+        # Log request details
+        debug(f"[HTTP] {method} {self.base_url}{url}")
+        if params:
+            debug(f"[HTTP] Query params: {mask_sensitive(params)}")
+        if json:
+            debug(f"[HTTP] Request body: {truncate_data(mask_sensitive(json))}")
+        
+        response = self.sync_client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            **kwargs
+        )
+        
+        return self._handle_response(response)
+    
+    # ==================== Asynchronous Methods ====================
+    
+    async def aget(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous GET request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return await self.arequest("GET", endpoint, params=params)
+    
+    async def apost(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous POST request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return await self.arequest("POST", endpoint, json=data)
+    
+    async def aput(self, endpoint: str, data: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous PUT request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            data: Request body data
+            
+        Returns:
+            Response data as dictionary
+        """
+        data = self._add_timestamp(data)
+        return await self.arequest("PUT", endpoint, json=data)
+    
+    async def adelete(self, endpoint: str, params: Optional[Dict[str, Any]] = None) -> Dict[str, Any]:
+        """Make an asynchronous DELETE request.
+        
+        Args:
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            
+        Returns:
+            Response data as dictionary
+        """
+        return await self.arequest("DELETE", endpoint, params=params)
+    
+    async def arequest(
+        self,
+        method: str,
+        endpoint: str,
+        params: Optional[Dict[str, Any]] = None,
+        json: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> Dict[str, Any]:
+        """Make an asynchronous HTTP request.
+        
+        Args:
+            method: HTTP method
+            endpoint: API endpoint (without base URL)
+            params: Query parameters
+            json: Request body (for POST/PUT)
+            **kwargs: Additional arguments for httpx
+            
+        Returns:
+            Response data as dictionary
+            
+        Raises:
+            httpx.HTTPError: On HTTP errors
+        """
+        url = f"/{endpoint}"
+        
+        # Log request details
+        debug(f"[HTTP] {method} {self.base_url}{url}")
+        if params:
+            debug(f"[HTTP] Query params: {mask_sensitive(params)}")
+        if json:
+            debug(f"[HTTP] Request body: {truncate_data(mask_sensitive(json))}")
+        
+        response = await self.async_client.request(
+            method=method,
+            url=url,
+            params=params,
+            json=json,
+            **kwargs
+        )
+        
+        return self._handle_response(response)
+    
+    # ==================== Lifecycle Methods ====================
+    
+    def close(self) -> None:
+        """Close the synchronous HTTP client."""
+        if self._sync_client is not None and not self._sync_client.is_closed:
+            self._sync_client.close()
+            self._sync_client = None
+    
+    async def aclose(self) -> None:
+        """Close the asynchronous HTTP client."""
+        if self._async_client is not None and not self._async_client.is_closed:
+            await self._async_client.aclose()
+            self._async_client = None
+    
+    def __enter__(self) -> "HttpClient":
+        """Context manager entry for sync client."""
+        return self
+    
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit for sync client."""
+        self.close()
+    
+    async def __aenter__(self) -> "HttpClient":
+        """Async context manager entry."""
+        return self
+    
+    async def __aexit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Async context manager exit."""
+        await self.aclose()

{lucidicai-2.1.1 → lucidicai-2.1.3}/lucidicai/sdk/context.py

@@ -151,6 +151,27 @@ def session(**init_params) -> Iterator[None]:
             clear_thread_session()
         current_session_id.reset(token)
         try:
+            # Force flush OpenTelemetry spans before ending session
+            from .init import get_tracer_provider
+            from ..utils.logger import debug, info
+            import time
+
+            tracer_provider = get_tracer_provider()
+            if tracer_provider:
+                debug(f"[Session] Force flushing OpenTelemetry spans for session {session_id}")
+                try:
+                    # Force flush with 5 second timeout to ensure all spans are exported
+                    flush_result = tracer_provider.force_flush(timeout_millis=5000)
+                    debug(f"[Session] Tracer provider force_flush returned: {flush_result}")
+
+                    # Give a small additional delay to ensure the exporter processes everything
+                    # This is necessary because force_flush on the provider flushes the processors,
+                    # but the exporter might still be processing the spans
+                    time.sleep(0.5)
+                    debug(f"[Session] Successfully flushed spans for session {session_id}")
+                except Exception as e:
+                    debug(f"[Session] Error flushing spans: {e}")
+
             # Pass session_id explicitly to avoid context issues
             lai.end_session(session_id=session_id)
         except Exception:
@@ -184,6 +205,27 @@ async def session_async(**init_params) -> AsyncIterator[None]:
         clear_task_session()
         current_session_id.reset(token)
         try:
+            # Force flush OpenTelemetry spans before ending session
+            from .init import get_tracer_provider
+            from ..utils.logger import debug, info
+            import asyncio
+
+            tracer_provider = get_tracer_provider()
+            if tracer_provider:
+                debug(f"[Session] Force flushing OpenTelemetry spans for async session {session_id}")
+                try:
+                    # Force flush with 5 second timeout to ensure all spans are exported
+                    flush_result = tracer_provider.force_flush(timeout_millis=5000)
+                    debug(f"[Session] Tracer provider force_flush returned: {flush_result}")
+
+                    # Give a small additional delay to ensure the exporter processes everything
+                    # This is necessary because force_flush on the provider flushes the processors,
+                    # but the exporter might still be processing the spans
+                    await asyncio.sleep(0.5)
+                    debug(f"[Session] Successfully flushed spans for async session {session_id}")
+                except Exception as e:
+                    debug(f"[Session] Error flushing spans: {e}")
+
             # Pass session_id explicitly to avoid context issues in async
             lai.end_session(session_id=session_id)
         except Exception: