aiqa-client 0.4.7__tar.gz → 0.5.2__tar.gz

{aiqa_client-0.4.7/aiqa_client.egg-info → aiqa_client-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.4.7
+Version: 0.5.2
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/aiqa/__init__.py

@@ -6,7 +6,7 @@ The client initializes automatically when WithTracing is first used.
 
 Set environment variables:
     AIQA_SERVER_URL: URL of the AIQA server
-    AIQA_API_KEY: API key for authentication
+    AIQA_API_KEY: API key for authentication (required)
     AIQA_COMPONENT_TAG: Optional component identifier
     AIQA_STARTUP_DELAY_SECONDS: Optional delay before first flush (default: 10s)
 

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/aiqa/client.py

@@ -2,10 +2,12 @@
 import os
 import logging
 from functools import lru_cache
-from typing import Optional, TYPE_CHECKING, Any
+from typing import Optional, TYPE_CHECKING, Any, Dict
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.sdk.trace.export import BatchSpanProcessor
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+import requests
 
 from .constants import AIQA_TRACER_NAME, LOG_TAG
 
@@ -30,7 +32,7 @@ except ImportError:
         # Set to None so we can check later
         TraceIdRatioBased = None
 
-from .http_utils import get_server_url, get_api_key
+from .http_utils import get_server_url, get_api_key, build_headers, format_http_error
 
 class AIQAClient:
     """
@@ -100,14 +102,14 @@ class AIQAClient:
             self.enabled = False
             if self._provider:
                 self._provider.shutdown()
-            if self._exporter:
-                self._exporter.shutdown()
+            # OTLP exporter doesn't have a separate shutdown method - it's handled by the provider
         except Exception as e:
             logger.error(f"Error shutting down tracing: {e}")
             # Still disable even if shutdown had errors
             self.enabled = False
 
 
+
 # Global singleton instance
 client: AIQAClient = AIQAClient()
 
@@ -176,11 +178,10 @@ def _init_tracing() -> None:
         server_url = get_server_url()
         api_key = get_api_key()
         
-        if not server_url or not api_key:
+        if not api_key:
             client.enabled = False
-            missing_vars = [var for var, val in [("AIQA_SERVER_URL", server_url), ("AIQA_API_KEY", api_key)] if not val]
             logger.warning(
-                f"AIQA tracing is disabled: missing required environment variables: {', '.join(missing_vars)}"
+                f"AIQA tracing is disabled: missing required environment variables: AIQA_API_KEY"
             )
             client._initialized = True
             return
@@ -227,20 +228,39 @@ def _init_tracing() -> None:
 
 def _attach_aiqa_processor(provider: TracerProvider) -> None:
     """Attach AIQA span processor to the provider. Idempotent - safe to call multiple times."""
-    from .aiqa_exporter import AIQASpanExporter
-    
     try:
         # Check if already attached
         for p in provider._active_span_processor._span_processors:
-            if isinstance(getattr(p, "exporter", None), AIQASpanExporter):
+            if isinstance(getattr(p, "exporter", None), OTLPSpanExporter):
                 logger.debug(f"AIQA span processor already attached, skipping")
                 return
 
-        exporter = AIQASpanExporter(
-            server_url=os.getenv("AIQA_SERVER_URL"),
-            api_key=os.getenv("AIQA_API_KEY"),
-            # max_buffer_spans will be read from AIQA_MAX_BUFFER_SPANS env var by the exporter
+        server_url = get_server_url()
+        api_key = get_api_key()
+        
+        # Build headers for authentication
+        # OTLP exporter sets its own Content-Type, so we only need Authorization
+        auth_headers = {}
+        if api_key:
+            auth_headers["Authorization"] = f"ApiKey {api_key}"
+        elif os.getenv("AIQA_API_KEY"):
+            auth_headers["Authorization"] = f"ApiKey {os.getenv('AIQA_API_KEY')}"
+        
+        # OTLP HTTP exporter requires the full endpoint URL including /v1/traces
+        # Ensure server_url doesn't have trailing slash or /v1/traces, then append /v1/traces
+        base_url = server_url.rstrip('/')
+        if base_url.endswith('/v1/traces'):
+            endpoint = base_url
+        else:
+            endpoint = f"{base_url}/v1/traces"
+        
+        # Create OTLP exporter with authentication headers only
+        # The exporter will set Content-Type and other headers automatically
+        exporter = OTLPSpanExporter(
+            endpoint=endpoint,
+            headers=auth_headers if auth_headers else None,
         )
+        
         provider.add_span_processor(BatchSpanProcessor(exporter))
         global client
         client.exporter = exporter
@@ -266,4 +286,66 @@ def get_aiqa_tracer() -> trace.Tracer:
     except Exception as e:
         # Log issue but still return a tracer
         logger.info(f"Issue getting AIQA tracer with version: {e}, using fallback")
-        return trace.get_tracer(AIQA_TRACER_NAME)
+        return trace.get_tracer(AIQA_TRACER_NAME)
+
+
+def get_organisation(
+    organisation_id: str,
+    server_url: Optional[str] = None,
+    api_key: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Get organisation information based on API key via an API call.
+    
+    Args:
+        organisation_id: ID of the organisation to retrieve
+        server_url: Optional server URL (defaults to AIQA_SERVER_URL env var)
+        api_key: Optional API key (defaults to AIQA_API_KEY env var)
+    
+    Returns:
+        Organisation object as a dictionary
+    """
+    url = get_server_url(server_url)
+    key = get_api_key(api_key)
+    headers = build_headers(key)
+    
+    response = requests.get(
+        f"{url}/organisation/{organisation_id}",
+        headers=headers,
+    )
+    
+    if not response.ok:
+        raise Exception(format_http_error(response, "get organisation"))
+    
+    return response.json()
+
+
+def get_api_key_info(
+    api_key_id: str,
+    server_url: Optional[str] = None,
+    api_key: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Get API key information via an API call.
+    
+    Args:
+        api_key_id: ID of the API key to retrieve
+        server_url: Optional server URL (defaults to AIQA_SERVER_URL env var)
+        api_key: Optional API key (defaults to AIQA_API_KEY env var)
+    
+    Returns:
+        ApiKey object as a dictionary
+    """
+    url = get_server_url(server_url)
+    key = get_api_key(api_key)
+    headers = build_headers(key)
+    
+    response = requests.get(
+        f"{url}/api-key/{api_key_id}",
+        headers=headers,
+    )
+    
+    if not response.ok:
+        raise Exception(format_http_error(response, "get api key info"))
+    
+    return response.json()

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/aiqa/constants.py

@@ -3,6 +3,6 @@ Constants used across the AIQA client package.
 """
 
 AIQA_TRACER_NAME = "aiqa-tracer"
-VERSION = "0.4.7" # automatically updated by set-version-json.sh
+VERSION = "0.5.2" # automatically updated by set-version-json.sh
 
 LOG_TAG = "AIQA" # Used in all logging output to identify AIQA messages

aiqa_client-0.5.2/aiqa/http_utils.py

@@ -0,0 +1,143 @@
+"""
+Shared HTTP utilities for AIQA client.
+Provides common functions for building headers, handling errors, and accessing environment variables.
+Supports AIQA-specific env vars (AIQA_SERVER_URL, AIQA_API_KEY) with fallback to OTLP standard vars.
+"""
+
+import os
+from typing import Dict, Optional
+
+
+def build_headers(api_key: Optional[str] = None) -> Dict[str, str]:
+    """
+    Build HTTP headers for AIQA API requests.
+    
+    Checks AIQA_API_KEY first, then falls back to OTEL_EXPORTER_OTLP_HEADERS if not set.
+    
+    Args:
+        api_key: Optional API key. If not provided, will try to get from AIQA_API_KEY env var,
+                 then from OTEL_EXPORTER_OTLP_HEADERS.
+    
+    Returns:
+        Dictionary with Content-Type, Accept-Encoding, and optionally Authorization header.
+    """
+    headers = {
+        "Content-Type": "application/json",
+        "Accept-Encoding": "gzip, deflate, br",  # Request compression (aiohttp handles decompression automatically)
+    }
+    
+    # Check parameter first
+    if api_key:
+        headers["Authorization"] = f"ApiKey {api_key}"
+        return headers
+    
+    # Check AIQA_API_KEY env var
+    aiqa_api_key = os.getenv("AIQA_API_KEY")
+    if aiqa_api_key:
+        headers["Authorization"] = f"ApiKey {aiqa_api_key}"
+        return headers
+    
+    # Fallback to OTLP headers (format: "key1=value1,key2=value2")
+    otlp_headers = os.getenv("OTEL_EXPORTER_OTLP_HEADERS")
+    if otlp_headers:
+        # Parse comma-separated key=value pairs
+        for header_pair in otlp_headers.split(","):
+            header_pair = header_pair.strip()
+            if "=" in header_pair:
+                key, value = header_pair.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+                if key.lower() == "authorization":
+                    headers["Authorization"] = value
+                else:
+                    headers[key] = value
+    
+    return headers
+
+
+def get_server_url(server_url: Optional[str] = None) -> str:
+    """
+    Get server URL from parameter or environment variable, with trailing slash removed.
+    
+    Checks AIQA_SERVER_URL first, then falls back to OTEL_EXPORTER_OTLP_ENDPOINT if not set.
+    
+    Args:
+        server_url: Optional server URL. If not provided, will get from AIQA_SERVER_URL env var,
+                    then from OTEL_EXPORTER_OTLP_ENDPOINT.
+    
+    Returns:
+        Server URL with trailing slash removed. Defaults to https://server-aiqa.winterwell.com if not set.
+    """
+    # Check parameter first
+    if server_url:
+        return server_url.rstrip("/")
+    
+    # Check AIQA_SERVER_URL env var
+    url = os.getenv("AIQA_SERVER_URL")
+    if url:
+        return url.rstrip("/")
+    
+    # Fallback to OTLP endpoint
+    url = os.getenv("OTEL_EXPORTER_OTLP_ENDPOINT")
+    if url:
+        return url.rstrip("/")
+    
+    # Default fallback
+    return "https://server-aiqa.winterwell.com"
+
+
+def get_api_key(api_key: Optional[str] = None) -> str:
+    """
+    Get API key from parameter or environment variable.
+    
+    Checks AIQA_API_KEY first, then falls back to OTEL_EXPORTER_OTLP_HEADERS if not set.
+    
+    Args:
+        api_key: Optional API key. If not provided, will get from AIQA_API_KEY env var,
+                 then from OTEL_EXPORTER_OTLP_HEADERS (looking for Authorization header).
+    
+    Returns:
+        API key or empty string if not set.
+    """
+    # Check parameter first
+    if api_key:
+        return api_key
+    
+    # Check AIQA_API_KEY env var
+    aiqa_api_key = os.getenv("AIQA_API_KEY")
+    if aiqa_api_key:
+        return aiqa_api_key
+    
+    # Fallback to OTLP headers (look for Authorization header)
+    otlp_headers = os.getenv("OTEL_EXPORTER_OTLP_HEADERS")
+    if otlp_headers:
+        for header_pair in otlp_headers.split(","):
+            header_pair = header_pair.strip()
+            if "=" in header_pair:
+                key, value = header_pair.split("=", 1)
+                key = key.strip()
+                value = value.strip()
+                if key.lower() == "authorization":
+                    # Extract API key from "ApiKey <key>" or just return the value
+                    if value.startswith("ApiKey "):
+                        return value[7:]
+                    return value
+    
+    return ""
+
+
+def format_http_error(response, operation: str) -> str:
+    """
+    Format an HTTP error message from a response object.
+    
+    Args:
+        response: Response object with status_code, reason, and text attributes
+        operation: Description of the operation that failed (e.g., "fetch dataset")
+    
+    Returns:
+        Formatted error message string.
+    """
+    error_text = response.text if hasattr(response, "text") else "Unknown error"
+    status_code = getattr(response, "status_code", getattr(response, "status", "unknown"))
+    reason = getattr(response, "reason", "")
+    return f"Failed to {operation}: {status_code} {reason} - {error_text}"

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/aiqa/tracing.py

@@ -8,13 +8,13 @@ import logging
 import inspect
 import os
 import copy
+import requests
 from typing import Any, Callable, Optional, List
 from functools import wraps
 from opentelemetry import trace
 from opentelemetry.sdk.trace import TracerProvider
 from opentelemetry.trace import Status, StatusCode, SpanContext, TraceFlags
 from opentelemetry.propagate import inject, extract
-from .aiqa_exporter import AIQASpanExporter
 from .client import get_aiqa_client, get_component_tag, set_component_tag as _set_component_tag, get_aiqa_tracer
 from .constants import AIQA_TRACER_NAME, LOG_TAG
 from .object_serialiser import serialize_for_span
@@ -31,13 +31,11 @@ async def flush_tracing() -> None:
     if you want to flush immediately, e.g. before exiting a process.
     A common use is if you are tracing unit tests or experiment runs.
 
-    This flushes both the BatchSpanProcessor and the exporter buffer.
+    This flushes the BatchSpanProcessor (OTLP exporter doesn't have a separate flush method).
     """
     client = get_aiqa_client()
     if client.provider:
         client.provider.force_flush()  # Synchronous method
-    if client.exporter:    
-        await client.exporter.flush()
 
 
 # Export provider and exporter accessors for advanced usage
@@ -117,12 +115,10 @@ class TracingOptions:
         self.filter_output = filter_output
 
 
-def _prepare_input(args: tuple, kwargs: dict) -> Any:
+def _prepare_input(args: tuple, kwargs: dict, sig: Optional[inspect.Signature] = None) -> Any:
     """Prepare input for span attributes. 
-    Aims to produce nice span attributes for the input, since {args, kwargs} is not a natural way to read function input. 
-    So can "unwrap" the args, kwargs.
-    
-    For single-arg-dicts or kwargs-only, returns a shallow copy of the input data.
+    Converts args and kwargs into a unified dict structure using function signature when available.
+    Falls back to legacy behavior for functions without inspectable signatures.
     
     Note: This function does NOT serialize values - it just structures the data.
     Serialization happens later via serialize_for_span() to avoid double-encoding
@@ -130,6 +126,22 @@ def _prepare_input(args: tuple, kwargs: dict) -> Any:
     """
     if not args and not kwargs:
         return None
+    
+    # Try to bind args to parameter names using function signature
+    if sig is not None:
+        try:
+            bound = sig.bind(*args, **kwargs)
+            bound.apply_defaults()
+            # Return dict of all arguments (positional args are now named)
+            result = bound.arguments.copy()
+            # Shallow copy to protect against mutating the input
+            return result
+        except (TypeError, ValueError):
+            # Binding failed (e.g., wrong number of args, *args/**kwargs issues)
+            # Fall through to legacy behavior
+            pass
+    
+    # in case binding fails
     if not kwargs:
         if len(args) == 1:
             arg0 = args[0]
@@ -150,15 +162,17 @@ def _prepare_and_filter_input(
     kwargs: dict,
     filter_input: Optional[Callable[[Any], Any]],
     ignore_input: Optional[List[str]],
+    sig: Optional[inspect.Signature] = None,
 ) -> Any:
     """
     Prepare and filter input for span attributes - applies the user's filter_input and ignore_input.
-    For single-arg-dicts or kwargs-only, returns a shallow copy of the input data.
+    Converts all args to a dict using function signature when available.
     """
     # Handle "self" in ignore_input by skipping the first argument
     filtered_args = args
     filtered_kwargs = kwargs.copy() if kwargs else {}
     filtered_ignore_input = ignore_input
+    filtered_sig = sig
     if ignore_input and "self" in ignore_input:
         # Remove "self" from ignore_input list (we'll handle it specially)
         filtered_ignore_input = [key for key in ignore_input if key != "self"]
@@ -168,8 +182,14 @@ def _prepare_and_filter_input(
         # Also remove "self" from kwargs if present
         if "self" in filtered_kwargs:
             del filtered_kwargs["self"]
-    # turn args, kwargs into one "nice" object
-    input_data = _prepare_input(filtered_args, filtered_kwargs)
+        # Adjust signature to remove "self" parameter if present
+        # This is needed because we removed self from args, so signature binding will fail otherwise
+        if filtered_sig is not None:
+            params = list(filtered_sig.parameters.values())
+            if params and params[0].name == "self":
+                filtered_sig = filtered_sig.replace(parameters=params[1:])
+    # turn args, kwargs into one "nice" object (now always a dict when signature is available)
+    input_data = _prepare_input(filtered_args, filtered_kwargs, filtered_sig)
     if filter_input and input_data is not None:
         input_data = filter_input(input_data)
     if filtered_ignore_input and len(filtered_ignore_input) > 0:
@@ -447,6 +467,15 @@ def WithTracing(
         is_generator = inspect.isgeneratorfunction(fn)
         is_async_generator = inspect.isasyncgenfunction(fn) if hasattr(inspect, 'isasyncgenfunction') else False
         
+        # Get function signature once at decoration time for efficient arg name resolution
+        fn_sig: Optional[inspect.Signature] = None
+        try:
+            fn_sig = inspect.signature(fn)
+        except (ValueError, TypeError):
+            # Some callables (e.g., builtins, C extensions) don't have inspectable signatures
+            # Will fall back to legacy behavior
+            pass
+        
         # Don't get tracer here - get it lazily when function is called
         # This ensures initialization only happens when tracing is actually used
         
@@ -595,7 +624,7 @@ def WithTracing(
         if is_async_generator:
             @wraps(fn)
             async def async_gen_traced_fn(*args, **kwargs):
-                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input, fn_sig)
                 return await _execute_generator_async(
                     lambda: fn(*args, **kwargs),
                     input_data
@@ -607,7 +636,7 @@ def WithTracing(
         elif is_generator:
             @wraps(fn)
             def gen_traced_fn(*args, **kwargs):
-                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input, fn_sig)
                 return _execute_generator_sync(
                     lambda: fn(*args, **kwargs),
                     input_data
@@ -619,7 +648,7 @@ def WithTracing(
         elif is_async:
             @wraps(fn)
             async def async_traced_fn(*args, **kwargs):
-                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input, fn_sig)
                 return await _execute_with_span_async(
                     lambda: fn(*args, **kwargs),
                     input_data
@@ -631,7 +660,7 @@ def WithTracing(
         else:
             @wraps(fn)
             def sync_traced_fn(*args, **kwargs):
-                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input)
+                input_data = _prepare_and_filter_input(args, kwargs, filter_input, ignore_input, fn_sig)
                 return _execute_with_span_sync(
                     lambda: fn(*args, **kwargs),
                     input_data
@@ -678,6 +707,7 @@ def get_active_span() -> Optional[trace.Span]:
 
 def set_conversation_id(conversation_id: str) -> bool:
     """
+    Naturally a conversation might span several traces. 
     Set the gen_ai.conversation.id attribute on the active span.
     This allows you to group multiple traces together that are part of the same conversation.
     See https://opentelemetry.io/docs/specs/semconv/gen-ai/gen-ai-events/ for more details.
@@ -1027,14 +1057,12 @@ def get_span(span_id: str, organisation_id: Optional[str] = None, exclude: Optio
             print(f"Found span: {span['name']}")
             my_function(**span['input'])
     """
-    import os
-    import requests
-    
     server_url = get_server_url()
     api_key = get_api_key()
     org_id = organisation_id or os.getenv("AIQA_ORGANISATION_ID", "")
     
-    if not server_url:
+    # Check if server_url is the default (meaning AIQA_SERVER_URL was not set)
+    if not os.getenv("AIQA_SERVER_URL"):
         raise ValueError("AIQA_SERVER_URL is not set. Cannot retrieve span.")    
     if not org_id:
         raise ValueError("Organisation ID is required. Provide it as parameter or set AIQA_ORGANISATION_ID environment variable.")

{aiqa_client-0.4.7 → aiqa_client-0.5.2/aiqa_client.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aiqa-client
-Version: 0.4.7
+Version: 0.5.2
 Summary: OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server
 Author-email: AIQA <info@aiqa.dev>
 License: MIT

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/aiqa_client.egg-info/SOURCES.txt

@@ -3,7 +3,6 @@ MANIFEST.in
 README.md
 pyproject.toml
 aiqa/__init__.py
-aiqa/aiqa_exporter.py
 aiqa/client.py
 aiqa/constants.py
 aiqa/experiment_runner.py
@@ -17,6 +16,8 @@ aiqa_client.egg-info/SOURCES.txt
 aiqa_client.egg-info/dependency_links.txt
 aiqa_client.egg-info/requires.txt
 aiqa_client.egg-info/top_level.txt
+tests/test_api_key.py
+tests/test_integration.py
 tests/test_object_serialiser.py
 tests/test_startup_reliability.py
 tests/test_tracing.py

{aiqa_client-0.4.7 → aiqa_client-0.5.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "aiqa-client"
-version = "0.4.7"
+version = "0.5.2"
 description = "OpenTelemetry-based Python client for tracing functions and sending traces to the AIQA server"
 readme = "README.md"
 requires-python = ">=3.8"

aiqa_client-0.5.2/tests/test_api_key.py

@@ -0,0 +1,96 @@
+"""
+Integration test for get_api_key_info functionality.
+
+This test verifies that get_api_key_info works correctly with environment variables
+loaded from .env files.
+
+Prerequisites:
+- AIQA server must be running and accessible
+- Set AIQA_SERVER_URL and AIQA_API_KEY environment variables in .env
+- Server must have PostgreSQL configured
+- The API key must be valid and associated with an organisation
+"""
+
+import os
+import pytest
+import requests
+from typing import Optional
+from aiqa.client import get_api_key_info
+from aiqa.http_utils import get_server_url, get_api_key, build_headers
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+def get_api_key_id_from_list() -> Optional[str]:
+    """
+    Helper function to get an API key ID by listing API keys.
+    
+    Returns:
+        First API key ID found
+    """
+    
+    server_url = get_server_url()
+    api_key = get_api_key()
+    
+    url = f"{server_url}/api-key"
+    params = {}
+    headers = build_headers(api_key)
+    
+    response = requests.get(url, params=params, headers=headers, timeout=5)
+    if response.status_code == 200:
+        api_keys = response.json()
+        if api_keys and len(api_keys) > 0:
+            return api_keys[0].get("id")
+    return None
+
+
+@pytest.fixture(scope="function")
+def check_server_available():
+    """Fixture that skips tests if server is not available."""
+    server_url = os.getenv("AIQA_SERVER_URL")
+    api_key = os.getenv("AIQA_API_KEY")
+    
+    if not server_url or not api_key:
+        pytest.skip("AIQA_SERVER_URL and AIQA_API_KEY environment variables must be set")
+    
+    # Try to connect to server
+    try:
+        url = f"{server_url.rstrip('/')}/span"
+        headers = build_headers(api_key)
+        response = requests.get(
+            url,
+            params={"q": "name:nonexistent", "limit": "1"},
+            headers=headers,
+            timeout=5
+        )
+        # 200 means server is up (even if no results)
+        # 401/403 means server is up but auth failed
+        # Other errors might mean server is down
+        if response.status_code not in [200, 401, 403]:
+            pytest.skip(f"Server appears to be down (status {response.status_code})")
+    except requests.exceptions.RequestException as e:
+        pytest.skip(f"Cannot connect to server: {e}")
+
+
+def test_get_api_key_info(check_server_available):
+    """Test that get_api_key_info works correctly with environment variables from .env."""
+    # Get an API key ID to test with
+    api_key_id = get_api_key_id_from_list()
+    
+    if not api_key_id:
+        pytest.skip("AIQA_ORGANISATION_ID must be set to test get_api_key_info, or no API keys found")
+    
+    # Test get_api_key_info - it should load server_url and api_key from .env
+    api_key_info = get_api_key_info(api_key_id)
+    
+    # Verify the response structure
+    assert api_key_info is not None, "API key info should not be None"
+    assert "id" in api_key_info, "API key info should have 'id' field"
+    assert api_key_info["id"] == api_key_id, f"API key ID should match: expected {api_key_id}, got {api_key_info['id']}"
+    
+    # Verify other expected fields
+    assert "organisation" in api_key_info, "API key info should have 'organisation' field"
+    assert "role" in api_key_info, "API key info should have 'role' field"
+    assert api_key_info["role"] in ["trace", "developer", "admin"], "API key role should be valid"
+