mseep-agentops 0.4.18__py3-none-any.whl → 0.4.22__py3-none-any.whl

agentops/client/api/base.py

@@ -15,16 +15,15 @@ from agentops.helpers.version import get_agentops_version
 class TokenFetcher(Protocol):
     """Protocol for token fetching functions"""
 
-    def __call__(self, api_key: str) -> str:
-        ...
+    def __call__(self, api_key: str) -> str: ...
 
 
 class BaseApiClient:
     """
-    Base class for API communication with connection pooling.
+    Base class for API communication with async HTTP methods.
 
     This class provides the core HTTP functionality without authentication.
-    It should be used for APIs that don't require authentication.
+    All HTTP methods are asynchronous.
     """
 
     def __init__(self, endpoint: str):
@@ -72,16 +71,16 @@ class BaseApiClient:
         """
         return f"{self.endpoint}{path}"
 
-    def request(
+    async def async_request(
         self,
         method: str,
         path: str,
         data: Optional[Dict[str, Any]] = None,
         headers: Optional[Dict[str, str]] = None,
         timeout: int = 30,
-    ) -> requests.Response:
+    ) -> Optional[Dict[str, Any]]:
         """
-        Make a generic HTTP request
+        Make a generic async HTTP request
 
         Args:
             method: HTTP method (e.g., 'get', 'post', 'put', 'delete')
@@ -91,7 +90,7 @@ class BaseApiClient:
             timeout: Request timeout in seconds
 
         Returns:
-            Response from the API
+            JSON response as dictionary, or None if request failed
 
         Raises:
             Exception: If the request fails
@@ -99,17 +98,16 @@ class BaseApiClient:
         url = self._get_full_url(path)
 
         try:
-            response = self.http_client.request(method=method, url=url, data=data, headers=headers, timeout=timeout)
-
-            self.last_response = response
-            return response
-        except requests.RequestException as e:
-            self.last_response = None
+            response_data = await self.http_client.async_request(
+                method=method, url=url, data=data, headers=headers, timeout=timeout
+            )
+            return response_data
+        except Exception as e:
             raise Exception(f"{method.upper()} request failed: {str(e)}") from e
 
-    def post(self, path: str, data: Dict[str, Any], headers: Dict[str, str]) -> requests.Response:
+    async def post(self, path: str, data: Dict[str, Any], headers: Dict[str, str]) -> Optional[Dict[str, Any]]:
         """
-        Make POST request
+        Make async POST request
 
         Args:
             path: API endpoint path
@@ -117,26 +115,26 @@ class BaseApiClient:
             headers: Request headers
 
         Returns:
-            Response from the API
+            JSON response as dictionary, or None if request failed
         """
-        return self.request("post", path, data=data, headers=headers)
+        return await self.async_request("post", path, data=data, headers=headers)
 
-    def get(self, path: str, headers: Dict[str, str]) -> requests.Response:
+    async def get(self, path: str, headers: Dict[str, str]) -> Optional[Dict[str, Any]]:
         """
-        Make GET request
+        Make async GET request
 
         Args:
             path: API endpoint path
             headers: Request headers
 
         Returns:
-            Response from the API
+            JSON response as dictionary, or None if request failed
         """
-        return self.request("get", path, headers=headers)
+        return await self.async_request("get", path, headers=headers)
 
-    def put(self, path: str, data: Dict[str, Any], headers: Dict[str, str]) -> requests.Response:
+    async def put(self, path: str, data: Dict[str, Any], headers: Dict[str, str]) -> Optional[Dict[str, Any]]:
         """
-        Make PUT request
+        Make async PUT request
 
         Args:
             path: API endpoint path
@@ -144,19 +142,19 @@ class BaseApiClient:
             headers: Request headers
 
         Returns:
-            Response from the API
+            JSON response as dictionary, or None if request failed
         """
-        return self.request("put", path, data=data, headers=headers)
+        return await self.async_request("put", path, data=data, headers=headers)
 
-    def delete(self, path: str, headers: Dict[str, str]) -> requests.Response:
+    async def delete(self, path: str, headers: Dict[str, str]) -> Optional[Dict[str, Any]]:
         """
-        Make DELETE request
+        Make async DELETE request
 
         Args:
             path: API endpoint path
             headers: Request headers
 
         Returns:
-            Response from the API
+            JSON response as dictionary, or None if request failed
         """
-        return self.request("delete", path, headers=headers)
+        return await self.async_request("delete", path, headers=headers)

agentops/client/api/versions/v3.py

@@ -6,7 +6,7 @@ This module provides the client for the V3 version of the AgentOps API.
 
 from agentops.client.api.base import BaseApiClient
 from agentops.client.api.types import AuthTokenResponse
-from agentops.exceptions import ApiServerException
+from agentops.client.http.http_client import HttpClient
 from agentops.logging import logger
 from termcolor import colored
 
@@ -24,32 +24,36 @@ class V3Client(BaseApiClient):
         # Set up with V3-specific auth endpoint
         super().__init__(endpoint)
 
-    def fetch_auth_token(self, api_key: str) -> AuthTokenResponse:
-        path = "/v3/auth/token"
-        data = {"api_key": api_key}
-        headers = self.prepare_headers()
-
-        r = self.post(path, data, headers)
+    async def fetch_auth_token(self, api_key: str) -> AuthTokenResponse:
+        """
+        Asynchronously fetch authentication token.
 
-        if r.status_code != 200:
-            error_msg = f"Authentication failed: {r.status_code}"
-            try:
-                error_data = r.json()
-                if "error" in error_data:
-                    error_msg = f"{error_data['error']}"
-            except Exception:
-                pass
-            logger.error(f"{error_msg} - Perhaps an invalid API key?")
-            raise ApiServerException(error_msg)
+        Args:
+            api_key: The API key to authenticate with
 
+        Returns:
+            AuthTokenResponse containing token and project information, or None if failed
+        """
         try:
-            jr = r.json()
-            token = jr.get("token")
+            path = "/v3/auth/token"
+            data = {"api_key": api_key}
+            headers = self.prepare_headers()
+
+            # Build full URL
+            url = self._get_full_url(path)
+
+            # Make async request
+            response_data = await HttpClient.async_request(
+                method="POST", url=url, data=data, headers=headers, timeout=30
+            )
+
+            token = response_data.get("token")
             if not token:
-                raise ApiServerException("No token in authentication response")
+                logger.warning("Authentication failed: Perhaps an invalid API key?")
+                return None
 
             # Check project premium status
-            if jr.get("project_prem_status") != "pro":
+            if response_data.get("project_prem_status") != "pro":
                 logger.info(
                     colored(
                         "\x1b[34mYou're on the agentops free plan 🤔\x1b[0m",
@@ -57,9 +61,9 @@ class V3Client(BaseApiClient):
                     )
                 )
 
-            return jr
-        except Exception as e:
-            logger.error(f"Failed to process authentication response: {str(e)}")
-            raise ApiServerException(f"Failed to process authentication response: {str(e)}")
+            return response_data
+
+        except Exception:
+            return None
 
     # Add V3-specific API methods here

agentops/client/api/versions/v4.py

@@ -4,18 +4,22 @@ V4 API client for the AgentOps API.
 This module provides the client for the V4 version of the AgentOps API.
 """
 
-from typing import Optional, Union, Dict
+from typing import Optional, Union, Dict, Any
 
+import requests
 from agentops.client.api.base import BaseApiClient
+from agentops.client.http.http_client import HttpClient
 from agentops.exceptions import ApiServerException
-from agentops.client.api.types import UploadedObjectResponse
 from agentops.helpers.version import get_agentops_version
 
 
 class V4Client(BaseApiClient):
     """Client for the AgentOps V4 API"""
 
-    auth_token: str
+    def __init__(self, endpoint: str):
+        """Initialize the V4 API client."""
+        super().__init__(endpoint)
+        self.auth_token: Optional[str] = None
 
     def set_auth_token(self, token: str):
         """
@@ -36,69 +40,106 @@ class V4Client(BaseApiClient):
             Headers dictionary with standard headers and any custom headers
         """
         headers = {
-            "Authorization": f"Bearer {self.auth_token}",
             "User-Agent": f"agentops-python/{get_agentops_version() or 'unknown'}",
         }
+
+        # Only add Authorization header if we have a token
+        if self.auth_token:
+            headers["Authorization"] = f"Bearer {self.auth_token}"
+
         if custom_headers:
             headers.update(custom_headers)
         return headers
 
-    def upload_object(self, body: Union[str, bytes]) -> UploadedObjectResponse:
+    def post(self, path: str, body: Union[str, bytes], headers: Optional[Dict[str, str]] = None) -> requests.Response:
         """
-        Upload an object to the API and return the response.
+        Make a POST request to the V4 API.
 
         Args:
-            body: The object to upload, either as a string or bytes.
+            path: The API path to POST to
+            body: The request body (string or bytes)
+            headers: Optional headers to include
+
         Returns:
-            UploadedObjectResponse: The response from the API after upload.
+            The response object
         """
-        if isinstance(body, bytes):
-            body = body.decode("utf-8")
+        url = self._get_full_url(path)
+        request_headers = headers or self.prepare_headers()
 
-        response = self.post("/v4/objects/upload/", body, self.prepare_headers())
+        return HttpClient.get_session().post(url, json={"body": body}, headers=request_headers, timeout=30)
 
-        if response.status_code != 200:
-            error_msg = f"Upload failed: {response.status_code}"
-            try:
-                error_data = response.json()
-                if "error" in error_data:
-                    error_msg = error_data["error"]
-            except Exception:
-                pass
-            raise ApiServerException(error_msg)
+    def upload_object(self, body: Union[str, bytes]) -> Dict[str, Any]:
+        """
+        Upload an object to the V4 API.
+
+        Args:
+            body: The object body to upload
+
+        Returns:
+            Dictionary containing upload response data
 
+        Raises:
+            ApiServerException: If the upload fails
+        """
         try:
-            response_data = response.json()
-            return UploadedObjectResponse(**response_data)
-        except Exception as e:
-            raise ApiServerException(f"Failed to process upload response: {str(e)}")
+            # Convert bytes to string for consistency with test expectations
+            if isinstance(body, bytes):
+                body = body.decode("utf-8")
+
+            response = self.post("/v4/objects/upload/", body, self.prepare_headers())
+
+            if response.status_code != 200:
+                error_msg = f"Upload failed: {response.status_code}"
+                try:
+                    error_data = response.json()
+                    if "error" in error_data:
+                        error_msg = error_data["error"]
+                except:
+                    pass
+                raise ApiServerException(error_msg)
+
+            try:
+                return response.json()
+            except Exception as e:
+                raise ApiServerException(f"Failed to process upload response: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise ApiServerException(f"Failed to upload object: {e}")
 
-    def upload_logfile(self, body: Union[str, bytes], trace_id: int) -> UploadedObjectResponse:
+    def upload_logfile(self, body: Union[str, bytes], trace_id: str) -> Dict[str, Any]:
         """
-        Upload an log file to the API and return the response.
+        Upload a logfile to the V4 API.
 
         Args:
-            body: The log file to upload, either as a string or bytes.
+            body: The logfile content to upload
+            trace_id: The trace ID associated with the logfile
+
         Returns:
-            UploadedObjectResponse: The response from the API after upload.
-        """
-        if isinstance(body, bytes):
-            body = body.decode("utf-8")
+            Dictionary containing upload response data
 
-        response = self.post("/v4/logs/upload/", body, {**self.prepare_headers(), "Trace-Id": str(trace_id)})
+        Raises:
+            ApiServerException: If the upload fails
+        """
+        try:
+            # Convert bytes to string for consistency with test expectations
+            if isinstance(body, bytes):
+                body = body.decode("utf-8")
+
+            headers = {**self.prepare_headers(), "Trace-Id": str(trace_id)}
+            response = self.post("/v4/logs/upload/", body, headers)
+
+            if response.status_code != 200:
+                error_msg = f"Upload failed: {response.status_code}"
+                try:
+                    error_data = response.json()
+                    if "error" in error_data:
+                        error_msg = error_data["error"]
+                except:
+                    pass
+                raise ApiServerException(error_msg)
 
-        if response.status_code != 200:
-            error_msg = f"Upload failed: {response.status_code}"
             try:
-                error_data = response.json()
-                if "error" in error_data:
-                    error_msg = error_data["error"]
-            except Exception:
-                pass
-            raise ApiServerException(error_msg)
-
-        try:
-            response_data = response.json()
-            return UploadedObjectResponse(**response_data)
-        except Exception as e:
-            raise ApiServerException(f"Failed to process upload response: {str(e)}")
+                return response.json()
+            except Exception as e:
+                raise ApiServerException(f"Failed to process upload response: {str(e)}")
+        except requests.exceptions.RequestException as e:
+            raise ApiServerException(f"Failed to upload logfile: {e}")

agentops/client/client.py

@@ -1,9 +1,10 @@
 import atexit
+import asyncio
+import threading
 from typing import Optional, Any
 
 from agentops.client.api import ApiClient
 from agentops.config import Config
-from agentops.exceptions import NoApiKeyException
 from agentops.instrumentation import instrument_all
 from agentops.logging import logger
 from agentops.logging.config import configure_logging, intercept_opentelemetry_logging
@@ -40,13 +41,17 @@ class Client:
     config: Config
     _initialized: bool
     _init_trace_context: Optional[TraceContext] = None  # Stores the context of the auto-started trace
-    _legacy_session_for_init_trace: Optional[
-        Session
-    ] = None  # Stores the legacy Session wrapper for the auto-started trace
+    _legacy_session_for_init_trace: Optional[Session] = (
+        None  # Stores the legacy Session wrapper for the auto-started trace
+    )
 
     __instance = None  # Class variable for singleton pattern
 
     api: ApiClient
+    _auth_token: Optional[str] = None
+    _project_id: Optional[str] = None
+    _auth_lock = threading.Lock()
+    _auth_task: Optional[asyncio.Task] = None
 
     def __new__(cls, *args: Any, **kwargs: Any) -> "Client":
         if cls.__instance is None:
@@ -54,6 +59,10 @@ class Client:
             # Initialize instance variables that should only be set once per instance
             cls.__instance._init_trace_context = None
             cls.__instance._legacy_session_for_init_trace = None
+            cls.__instance._auth_token = None
+            cls.__instance._project_id = None
+            cls.__instance._auth_lock = threading.Lock()
+            cls.__instance._auth_task = None
         return cls.__instance
 
     def __init__(self):
@@ -68,6 +77,73 @@ class Client:
             # self._init_trace_context = None # Already done in __new__
             # self._legacy_session_for_init_trace = None # Already done in __new__
 
+    def get_current_jwt(self) -> Optional[str]:
+        """Get the current JWT token."""
+        with self._auth_lock:
+            return self._auth_token
+
+    def _set_auth_data(self, token: str, project_id: str):
+        """Set authentication data thread-safely."""
+        with self._auth_lock:
+            self._auth_token = token
+            self._project_id = project_id
+
+        # Update the HTTP client's project ID
+        from agentops.client.http.http_client import HttpClient
+
+        HttpClient.set_project_id(project_id)
+
+    async def _fetch_auth_async(self, api_key: str) -> Optional[dict]:
+        """Asynchronously fetch authentication token."""
+        try:
+            response = await self.api.v3.fetch_auth_token(api_key)
+            if response:
+                self._set_auth_data(response["token"], response["project_id"])
+
+                # Update V4 client with token
+                self.api.v4.set_auth_token(response["token"])
+
+                # Update tracer config with real project ID
+                tracing_config = {"project_id": response["project_id"]}
+                tracer.update_config(tracing_config)
+
+                logger.debug("Successfully fetched authentication token asynchronously")
+                return response
+            else:
+                logger.debug("Authentication failed - will continue without authentication")
+                return None
+        except Exception:
+            return None
+
+    def _start_auth_task(self, api_key: str):
+        """Start the async authentication task."""
+        if self._auth_task and not self._auth_task.done():
+            return  # Task already running
+
+        try:
+            loop = asyncio.get_event_loop()
+            if loop.is_running():
+                # Use existing event loop
+                self._auth_task = loop.create_task(self._fetch_auth_async(api_key))
+            else:
+                # Create new event loop in background thread
+                def run_async_auth():
+                    asyncio.run(self._fetch_auth_async(api_key))
+
+                import threading
+
+                auth_thread = threading.Thread(target=run_async_auth, daemon=True)
+                auth_thread.start()
+        except RuntimeError:
+            # Create new event loop in background thread
+            def run_async_auth():
+                asyncio.run(self._fetch_auth_async(api_key))
+
+            import threading
+
+            auth_thread = threading.Thread(target=run_async_auth, daemon=True)
+            auth_thread.start()
+
     def init(self, **kwargs: Any) -> None:  # Return type updated to None
         # Recreate the Config object to parse environment variables at the time of initialization
         # This allows re-init with new env vars if needed, though true singletons usually init once.
@@ -94,35 +170,36 @@ class Client:
             return None  # If not auto-starting, and already initialized, return None
 
         if not self.config.api_key:
-            raise NoApiKeyException
+            logger.warning(
+                "No API key provided. AgentOps will initialize but authentication will fail. "
+                "Set AGENTOPS_API_KEY environment variable or pass api_key parameter."
+            )
+            # Continue without API key - spans will be created but exports will fail gracefully
 
         configure_logging(self.config)
         intercept_opentelemetry_logging()
 
         self.api = ApiClient(self.config.endpoint)
 
-        try:
-            response = self.api.v3.fetch_auth_token(self.config.api_key)
-            if response is None:
-                # If auth fails, we cannot proceed with tracer initialization that depends on project_id
-                logger.error("Failed to fetch auth token. AgentOps SDK will not be initialized.")
-                return None  # Explicitly return None if auth fails
-        except Exception as e:
-            # Re-raise authentication exceptions so they can be caught by tests and calling code
-            logger.error(f"Authentication failed: {e}")
-            raise
-
-        self.api.v4.set_auth_token(response["token"])
-
+        # Initialize tracer with JWT provider for dynamic updates
         tracing_config = self.config.dict()
-        tracing_config["project_id"] = response["project_id"]
+        tracing_config["project_id"] = "temporary"  # Will be updated when auth completes
 
-        tracer.initialize_from_config(tracing_config, jwt=response["token"])
+        # Create JWT provider function for dynamic updates
+        def jwt_provider():
+            return self.get_current_jwt()
+
+        # Initialize tracer with JWT provider
+        tracer.initialize_from_config(tracing_config, jwt_provider=jwt_provider)
 
         if self.config.instrument_llm_calls:
             instrument_all()
 
-        # self._initialized = True # Set initialized to True here - MOVED to after trace start attempt
+        # Start authentication task only if we have an API key
+        if self.config.api_key:
+            self._start_auth_task(self.config.api_key)
+        else:
+            logger.debug("No API key available - skipping authentication task")
 
         global _atexit_registered
         if not _atexit_registered:
@@ -201,11 +278,3 @@ class Client:
     # Deprecate and remove the old global _active_session from this module.
     # Consumers should use agentops.start_trace() or rely on the auto-init trace.
     # For a transition, the auto-init trace's legacy wrapper is set to legacy module's globals.
-
-
-# Ensure the global _active_session (if needed for some very old compatibility) points to the client's legacy session for init trace.
-# This specific global _active_session in client.py is problematic and should be phased out.
-# For now, _client_legacy_session_for_init_trace is the primary global for the auto-init trace's legacy Session.
-
-# Remove the old global _active_session defined at the top of this file if it's no longer the primary mechanism.
-# The new globals _client_init_trace_context and _client_legacy_session_for_init_trace handle the auto-init trace.

agentops/client/http/README.md

@@ -0,0 +1,87 @@
+# AgentOps HTTP Client Architecture
+
+This directory contains the HTTP client architecture for the AgentOps SDK. The architecture follows a clean separation of concerns design principle.
+
+## Components
+
+### HttpClient
+
+The `HttpClient` class provides low-level HTTP functionality:
+- Connection pooling
+- Retry logic
+- Basic HTTP methods (GET, POST, PUT, DELETE)
+
+### AuthManager
+
+The `AuthManager` class handles authentication concerns:
+- Token acquisition and storage
+- Token refresh logic
+- Authentication header preparation
+- Thread-safe token operations
+
+### HTTP Adapters
+
+#### BaseHTTPAdapter
+- Enhanced connection pooling and retry logic
+- Used by the `HttpClient` for basic HTTP operations
+
+#### AuthenticatedHttpAdapter
+- Extends `BaseHTTPAdapter` with authentication capabilities
+- Automatically adds authentication headers to requests
+- Handles token refresh when authentication fails
+- Can be mounted to any requests.Session
+
+## Design Principles
+
+1. **Separation of Concerns**
+   - HTTP concerns are isolated from authentication concerns
+   - Each component has a single responsibility
+
+2. **Composition over Inheritance**
+   - Components use composition rather than inheritance
+   - `ApiClient` composes `HttpClient` and `AuthManager`
+
+3. **Clear Interfaces**
+   - Each component has a well-defined interface
+   - Implementation details are hidden
+
+4. **Dependency Flow**
+   - Dependencies flow in one direction
+   - Lower-level components (HTTP, Auth) don't depend on higher-level components
+
+## Usage
+
+### Basic API Client Usage
+
+The HTTP client architecture is used by the `ApiClient` class, which provides a high-level interface for making API calls. Specific API versions (like `V3Client`) extend the `ApiClient` to provide version-specific functionality.
+
+```python
+# Example usage
+from agentops.client.v3_client import V3Client
+
+client = V3Client(endpoint="https://api.agentops.ai")
+response = client.authenticated_request(
+    method="get",
+    path="/v3/some/endpoint",
+    api_key="your-api-key"
+)
+```
+
+### Using with External Libraries
+
+The architecture also supports integration with external libraries that need authenticated HTTP sessions:
+
+```python
+# Example with OpenTelemetry exporter
+from agentops.client.v3_client import V3Client
+from agentops.client.exporters import AuthenticatedOTLPExporter
+
+client = V3Client(endpoint="https://api.agentops.ai")
+session = client.create_authenticated_session(api_key="your-api-key")
+
+exporter = AuthenticatedOTLPExporter(
+    endpoint="https://api.agentops.ai/v3/traces",
+    api_client=client,
+    api_key="your-api-key"
+)
+```