hivetrace 1.3.4__py3-none-any.whl → 1.3.5__py3-none-any.whl

hivetrace/__init__.py

@@ -1,20 +1,110 @@
-from .hivetrace import (
-    HivetraceSDK,
+"""
+HiveTrace SDK - Python client for monitoring LLM applications.
+"""
+
+# Main clients
+from .client import AsyncHivetraceSDK, BaseHivetraceSDK, SyncHivetraceSDK
+
+# Exceptions (only exception classes)
+from .errors import (
+    APIError,
+    ConfigurationError,
+    ConnectionError,
+    HiveTraceError,
+    HTTPError,
+    InvalidFormatError,
     InvalidParameterError,
+    JSONDecodeError,
     MissingConfigError,
+    MissingParameterError,
+    NetworkError,
+    RateLimitError,
+    RequestError,
+    TimeoutError,
     UnauthorizedError,
+    ValidationError,
+)
+
+# Handlers
+from .handlers import ErrorHandler, ResponseBuilder
+
+# Data models (Pydantic)
+from .models import (
+    FunctionCallRequest,
+    HivetraceResponse,
+    InputRequest,
+    OutputRequest,
+    ProcessResponse,
+    SuccessResponse,
+)
+
+# Utils
+from .utils import (
+    generate_uuid,
+    get_error_details,
+    get_error_type,
+    get_status_code,
+    is_connection_error,
+    is_error_response,
+    is_http_error,
+    is_json_decode_error,
+    is_request_error,
+    is_success_response,
+    is_timeout_error,
+    is_validation_error,
 )
 
 __all__ = [
-    "HivetraceSDK",
-    "InvalidParameterError",
+    # Main classes
+    "AsyncHivetraceSDK",
+    "SyncHivetraceSDK",
+    "BaseHivetraceSDK",
+    # Exceptions
+    "HiveTraceError",
+    "ConfigurationError",
     "MissingConfigError",
     "UnauthorizedError",
+    "ValidationError",
+    "InvalidParameterError",
+    "MissingParameterError",
+    "InvalidFormatError",
+    "NetworkError",
+    "ConnectionError",
+    "TimeoutError",
+    "RequestError",
+    "APIError",
+    "HTTPError",
+    "JSONDecodeError",
+    "RateLimitError",
+    # Models
+    "HivetraceResponse",
+    "SuccessResponse",
+    "ProcessResponse",
+    "InputRequest",
+    "OutputRequest",
+    "FunctionCallRequest",
+    # Handlers
+    "ErrorHandler",
+    "ResponseBuilder",
+    # Utils
+    "generate_uuid",
+    "is_error_response",
+    "is_success_response",
+    "get_error_type",
+    "get_error_details",
+    "get_status_code",
+    "is_connection_error",
+    "is_timeout_error",
+    "is_http_error",
+    "is_json_decode_error",
+    "is_request_error",
+    "is_validation_error",
 ]
 
+# Optional adapters
 try:
-    from hivetrace.crewai_adapter import CrewAIAdapter as _CrewAIAdapter
-    from hivetrace.crewai_adapter import trace as _crewai_trace
+    from hivetrace.adapters.crewai import CrewAIAdapter as _CrewAIAdapter
+    from hivetrace.adapters.crewai import trace as _crewai_trace
 
     CrewAIAdapter = _CrewAIAdapter
     crewai_trace = _crewai_trace
@@ -25,12 +115,31 @@ except ImportError:
     pass
 
 try:
-    from hivetrace.adapters.langchain import LangChainAdapter as _LangChainAdapter
-    from hivetrace.adapters.langchain import trace as _langchain_trace
+    from hivetrace.adapters.langchain import (
+        LangChainAdapter as _LangChainAdapter,
+    )
+    from hivetrace.adapters.langchain import (
+        run_with_tracing as _run_with_tracing,
+    )
+    from hivetrace.adapters.langchain import (
+        run_with_tracing_async as _run_with_tracing_async,
+    )
+    from hivetrace.adapters.langchain import (
+        trace as _langchain_trace,
+    )
 
     LangChainAdapter = _LangChainAdapter
     langchain_trace = _langchain_trace
+    run_with_tracing = _run_with_tracing
+    run_with_tracing_async = _run_with_tracing_async
 
-    __all__.extend(["LangChainAdapter", "langchain_trace"])
+    __all__.extend(
+        [
+            "LangChainAdapter",
+            "langchain_trace",
+            "run_with_tracing",
+            "run_with_tracing_async",
+        ]
+    )
 except ImportError:
     pass

hivetrace/adapters/base_adapter.py

@@ -54,8 +54,14 @@ class BaseAdapter:
         - additional_params_from_caller: Additional parameters to include in the log
         """
         final_additional_params = additional_params_from_caller or {}
-        final_additional_params.setdefault("user_id", self.user_id)
-        final_additional_params.setdefault("session_id", self.session_id)
+        if hasattr(self, "user_id") and self.user_id is not None and self.user_id != "":
+            final_additional_params.setdefault("user_id", self.user_id)
+        if (
+            hasattr(self, "session_id")
+            and self.session_id is not None
+            and self.session_id != ""
+        ):
+            final_additional_params.setdefault("session_id", self.session_id)
 
         log_kwargs = {
             "application_id": self.application_id,
@@ -71,19 +77,49 @@ class BaseAdapter:
             if tool_call_details is None:
                 print("Warning: tool_call_details is None for function_call")
                 return
-            log_kwargs.update(tool_call_details)
+            merged_tool_details = dict(tool_call_details)
+            ap = dict(merged_tool_details.get("additional_parameters", {}) or {})
+            if (
+                hasattr(self, "user_id")
+                and self.user_id is not None
+                and self.user_id != ""
+            ):
+                ap.setdefault("user_id", self.user_id)
+            if (
+                hasattr(self, "session_id")
+                and self.session_id is not None
+                and self.session_id != ""
+            ):
+                ap.setdefault("session_id", self.session_id)
+            if ap:
+                merged_tool_details["additional_parameters"] = ap
+            log_kwargs.update(merged_tool_details)
         else:
             print(f"Error: Unsupported log_method_name_stem: {log_method_name_stem}")
             return
 
-        method_to_call_name = f"{log_method_name_stem}{'_async' if is_async else ''}"
+        # Both SyncHivetraceSDK and AsyncHivetraceSDK expose the same method names
+        # (input/output/function_call). In async mode they are coroutines.
+        method_to_call_name = log_method_name_stem
 
         try:
             actual_log_method = getattr(self.trace, method_to_call_name)
             if is_async:
                 import asyncio
-
-                asyncio.create_task(actual_log_method(**log_kwargs))
+                import inspect
+
+                try:
+                    maybe_coro = actual_log_method(**log_kwargs)
+                except TypeError:
+                    # Fallback: call without kwargs if signature mismatch (defensive)
+                    maybe_coro = actual_log_method()
+
+                if inspect.isawaitable(maybe_coro):
+                    asyncio.create_task(maybe_coro)
+                else:
+                    # If the method is unexpectedly sync in async mode, call directly
+                    # to avoid dropping the log.
+                    pass
             else:
                 actual_log_method(**log_kwargs)
         except AttributeError: