OpenAI Agents voice support

agentops/client/api/__init__.py

@@ -9,6 +9,7 @@
 from agentops.client.api.base import BaseApiClient
 from agentops.client.api.types import AuthTokenResponse
 from agentops.client.api.versions.v3 import V3Client
+from agentops.client.api.versions.v4 import V4Client
 
 # Define a type variable for client classes
 T = TypeVar("T", bound=BaseApiClient)
@@ -44,6 +45,16 @@ def v3(self) -> V3Client:
         """
         return self._get_client("v3", V3Client)
 
+    @property
+    def v4(self) -> V4Client:
+        """
+        Get the V4 API client.
+
+        Returns:
+            The V4 API client
+        """
+        return self._get_client("v4", V4Client)
+
     def _get_client(self, version: str, client_class: Type[T]) -> T:
         """
         Get or create a version-specific client.

agentops/client/api/types.py

@@ -5,10 +5,18 @@
 """
 
 from typing import TypedDict
+from pydantic import BaseModel
 
 
 class AuthTokenResponse(TypedDict):
     """Response from the auth/token endpoint"""
 
     token: str
     project_id: str
+
+
+class UploadedObjectResponse(BaseModel):
+    """Response from the v4/objects/upload endpoint"""
+    url: str
+    size: int
+

agentops/client/api/versions/__init__.py

@@ -5,5 +5,6 @@
 """
 
 from agentops.client.api.versions.v3 import V3Client
+from agentops.client.api.versions.v4 import V4Client
 
-__all__ = ["V3Client"]
+__all__ = ["V3Client", "V4Client"]

agentops/client/api/versions/v4.py

@@ -0,0 +1,71 @@
+"""
+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 agentops.client.api.base import BaseApiClient
+from agentops.exceptions import ApiServerException
+from agentops.client.api.types import UploadedObjectResponse
+
+
+class V4Client(BaseApiClient):
+    """Client for the AgentOps V4 API"""
+    auth_token: str
+
+    def set_auth_token(self, token: str):
+        """
+        Set the authentication token for API requests.
+
+        Args:
+            token: The authentication token to set
+        """
+        self.auth_token = token
+
+    def prepare_headers(self, custom_headers: Optional[Dict[str, str]] = None) -> Dict[str, str]:
+        """
+        Prepare headers for API requests.
+
+        Args:
+            custom_headers: Additional headers to include
+        Returns:
+            Headers dictionary with standard headers and any custom headers
+        """
+        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:
+        """
+        Upload an object to the API and return the response.
+
+        Args:
+            body: The object to upload, either as a string or bytes.
+        Returns:
+            UploadedObjectResponse: The response from the API after upload.
+        """
+        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 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)}")
+

agentops/client/client.py

@@ -45,6 +45,9 @@ def init(self, **kwargs):
         # Prefetch JWT token if enabled
         # TODO: Move this validation somewhere else (and integrate with self.config.prefetch_jwt_token once we have a solution to that)
         response = self.api.v3.fetch_auth_token(self.config.api_key)
+
+        # Save the bearer for use with the v4 API
+        self.api.v4.set_auth_token(response["token"])
 
         # Initialize TracingCore with the current configuration and project_id
         tracing_config = self.config.dict()

agentops/helpers/__init__.py

@@ -20,6 +20,8 @@
 from .version import get_agentops_version, check_agentops_update
 from .debug import debug_print_function_params
 from .env import get_env_bool, get_env_int, get_env_list
+from .config import get_config, get_tags_from_config
+from .objects import upload_object
 
 __all__ = [
     "get_ISO_time",
@@ -45,4 +47,7 @@
     "get_env_bool",
     "get_env_int",
     "get_env_list",
+    "get_config",
+    "get_tags_from_config",
+    "upload_object",
 ]

agentops/helpers/config.py

@@ -0,0 +1,31 @@
+"""Helper functions for accessing configuration values.
+
+This module provides utility functions for accessing configuration values from
+the global Config object in a safe way.
+"""
+
+from typing import List, Any
+
+from agentops.config import Config
+
+
+def get_config() -> Config:
+    """Get the global configuration object from the Client singleton.
+
+    Returns:
+        The Config instance from the global Client
+    """
+    from agentops import get_client
+    return get_client().config
+
+
+def get_tags_from_config() -> List[str]:
+    """Get tags from the global configuration.
+
+    Returns:
+        List of tags if they exist in the configuration, or empty list
+    """
+    config = get_config()
+    if config.default_tags:
+        return list(config.default_tags)
+    return []  # Return empty list for empty tags set

agentops/helpers/objects.py

@@ -0,0 +1,14 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from agentops.client.api.types import UploadedObjectResponse
+
+
+def upload_object(body: bytes) -> 'UploadedObjectResponse':
+    """Upload an object to the agentops server."""
+    from agentops import get_client
+
+    client = get_client()
+    return client.api.v4.upload_object(body)
+
+

agentops/instrumentation/__init__.py

@@ -23,7 +23,7 @@ class InstrumentorLoader:
         We use the `provider_import_name` to determine if the library is installed i
     n the environment.
 
-        `modue_name` is the name of the module to import from.
+        `module_name` is the name of the module to import from.
         `class_name` is the name of the class to instantiate from the module.
         `provider_import_name` is the name of the package to check for availability.
     """
@@ -53,7 +53,7 @@ def get_instance(self) -> BaseInstrumentor:
 
 available_instrumentors: list[InstrumentorLoader] = [
     InstrumentorLoader(
-        module_name="opentelemetry.instrumentation.openai",
+        module_name="agentops.instrumentation.openai",
         class_name="OpenAIInstrumentor",
         provider_import_name="openai",
     ),

agentops/instrumentation/common/README.md

@@ -0,0 +1,65 @@
+# AgentOps Instrumentation Common Module
+
+The `agentops.instrumentation.common` module provides shared utilities for OpenTelemetry instrumentation across different LLM service providers.
+
+## Core Components
+
+### Attribute Handler Example
+
+Attribute handlers extract data from method inputs and outputs:
+
+```python
+from typing import Optional, Any, Tuple, Dict
+from agentops.instrumentation.common.attributes import AttributeMap
+from agentops.semconv import SpanAttributes
+
+def my_attribute_handler(args: Optional[Tuple] = None, kwargs: Optional[Dict] = None, return_value: Optional[Any] = None) -> AttributeMap:
+    attributes = {}
+
+    # Extract attributes from kwargs (method inputs)
+    if kwargs:
+        if "model" in kwargs:
+            attributes[SpanAttributes.MODEL_NAME] = kwargs["model"]
+        # ...
+
+    # Extract attributes from return value (method outputs)
+    if return_value:
+        if hasattr(return_value, "model"):
+            attributes[SpanAttributes.LLM_RESPONSE_MODEL] = return_value.model
+        # ...
+
+    return attributes
+```
+
+### `WrapConfig` Class
+
+Config object defining how a method should be wrapped:
+
+```python
+from agentops.instrumentation.common.wrappers import WrapConfig
+from opentelemetry.trace import SpanKind
+
+config = WrapConfig(
+    trace_name="llm.completion",    # Name that will appear in trace spans
+    package="openai.resources",     # Path to the module containing the class
+    class_name="Completions",       # Name of the class containing the method
+    method_name="create",           # Name of the method to wrap
+    handler=my_attribute_handler,   # Function that extracts attributes
+    span_kind=SpanKind.CLIENT       # Type of span to create
+)
+```
+
+### Wrapping/Unwrapping Methods
+
+```python
+from opentelemetry.trace import get_tracer
+from agentops.instrumentation.common.wrappers import wrap, unwrap
+
+# Create a tracer and wrap a method
+tracer = get_tracer("openai", "0.0.0")
+wrap(config, tracer)
+
+# Later, unwrap the method
+unwrap(config)
+```
+

agentops/instrumentation/common/__init__.py

@@ -0,0 +1,6 @@
+from .attributes import AttributeMap, _extract_attributes_from_mapping
+
+__all__ = [
+    "AttributeMap",
+    "_extract_attributes_from_mapping",
+]