hivetrace 1.3.16__py3-none-any.whl → 1.4.0__py3-none-any.whl

hivetrace/adapters/base_adapter.py

@@ -2,7 +2,7 @@
 Base adapter class for HiveTrace integrations.
 """
 
-from typing import Any, Dict, Optional
+from typing import Any, Coroutine, Dict, Optional, cast
 
 
 class BaseAdapter:
@@ -115,7 +115,13 @@ class BaseAdapter:
                     maybe_coro = actual_log_method()
 
                 if inspect.isawaitable(maybe_coro):
-                    asyncio.create_task(maybe_coro)
+                    if inspect.iscoroutine(maybe_coro):
+                        asyncio.create_task(cast(Coroutine[Any, Any, Any], maybe_coro))
+                    else:
+                        async def _await_and_drop() -> None:
+                            await maybe_coro
+
+                        asyncio.create_task(_await_and_drop())
                 else:
                     # If the method is unexpectedly sync in async mode, call directly
                     # to avoid dropping the log.

hivetrace/adapters/crewai/adapter.py

@@ -28,15 +28,15 @@ class CrewAIAdapter(BaseAdapter):
     ):
         super().__init__(hivetrace, application_id, user_id, session_id)
         self.agent_id_mapping = agent_id_mapping or {}
-        self.agents_info = {}
-        self._runtime_user_id = None
-        self._runtime_session_id = None
-        self._runtime_agents_conversation_id = None
-        self._current_parent_agent_id = None
-        self._last_active_agent_id = None
+        self.agents_info: Dict[str, Dict[str, Any]] = {}
+        self._runtime_user_id: Optional[str] = None
+        self._runtime_session_id: Optional[str] = None
+        self._runtime_agents_conversation_id: Optional[str] = None
+        self._current_parent_agent_id: Optional[str] = None
+        self._last_active_agent_id: Optional[str] = None
         self._conversation_started = False
         self._first_agent_logged = False
-        self._recent_messages = []
+        self._recent_messages: list[int] = []
         self._max_recent_messages = 5
 
     def _reset_conversation_state(self):

hivetrace/adapters/crewai/decorators.py

@@ -35,6 +35,9 @@ def trace(
             "Use @trace(hivetrace=your_instance) instead of @trace"
         )
 
+    if application_id is None:
+        raise ValueError("application_id is required")
+
     adapter = CrewAIAdapter(
         hivetrace=hivetrace,
         application_id=application_id,

hivetrace/adapters/crewai/monitored_agent.py

@@ -2,7 +2,7 @@
 Monitored Agent implementation for CrewAI.
 """
 
-from typing import Any, Callable
+from typing import Any, Callable, Optional
 
 from crewai import Agent, Task
 
@@ -37,7 +37,7 @@ class MonitoredAgent(Agent):
         self._adapter_instance = adapter_instance
         self.callback_func = callback_func
         self.agent_id = agent_id
-        self._last_thought = None
+        self._last_thought: Optional[str] = None
 
     def execute_task(self, task: Task) -> str:
         """

hivetrace/adapters/crewai/tool_wrapper.py

@@ -1,7 +1,7 @@
 """Tool wrapping utilities for CrewAI adapter."""
 
 import functools
-from typing import Any, Callable
+from typing import Any, Callable, cast
 
 from hivetrace.utils.uuid_generator import generate_uuid
 
@@ -58,12 +58,13 @@ def wrap_tool(tool: Any, agent_role: str, adapter_instance) -> Any:
     if not (hasattr(tool, "_run") and callable(tool._run)):
         return tool
 
-    if getattr(tool._run, "_is_hivetrace_wrapped", False):
+    run_callable = cast(Any, tool._run)
+    if getattr(run_callable, "_is_hivetrace_wrapped", False):
         return tool
 
     tool_name = getattr(tool, "name", "unknown_tool")
     wrapped = wrap_tool_function(tool._run, tool_name, agent_role, adapter_instance)
-    wrapped._is_hivetrace_wrapped = True
+    setattr(cast(Any, wrapped), "_is_hivetrace_wrapped", True)
     tool._run = wrapped
 
     return tool

hivetrace/adapters/openai_agents/adapter.py

@@ -11,21 +11,33 @@ class OpenaiAgentsAdapter(BaseAdapter):
     def log_traces(self, trace_calls: dict[str, Call | None], conversation_uuid: str):
         _trace_calls = self._join_handoff_spans(trace_calls)
         _trace_calls = self._join_agent_calling_tool_spans(_trace_calls)
-        source_agent = _trace_calls[list(_trace_calls.keys())[0]]
+        source_agent: AgentCall | None = None
+        for call in _trace_calls.values():
+            if isinstance(call, AgentCall):
+                source_agent = call
+                break
+        if source_agent is None:
+            return
+
         self._log_start_message(source_agent, conversation_uuid)
 
         for trace_call in _trace_calls.values():
             if trace_call is None or trace_call.span_parent_id is None:
                 continue
 
-            parent_agent: AgentCall = _trace_calls[trace_call.span_parent_id]
-            if trace_call.type == "agent":
+            parent = _trace_calls.get(trace_call.span_parent_id)
+            if not isinstance(parent, AgentCall):
+                continue
+
+            if isinstance(trace_call, AgentCall):
+                if trace_call.output is None:
+                    continue
                 additional_params = {
                     "agent_conversation_id": conversation_uuid,
                     "is_final_answer": False,
                     "agents": {
                         trace_call.agent_uuid: {
-                            "agent_parent_id": parent_agent.agent_uuid,
+                            "agent_parent_id": parent.agent_uuid,
                             "name": trace_call.name,
                             "description": trace_call.instructions,
                         },
@@ -37,6 +49,8 @@ class OpenaiAgentsAdapter(BaseAdapter):
                 )
 
             elif trace_call.type == "tool":
+                if trace_call.output is None:
+                    continue
                 self._prepare_and_log(
                     log_method_name_stem="function_call",
                     is_async=False,
@@ -49,9 +63,9 @@ class OpenaiAgentsAdapter(BaseAdapter):
                         "additional_parameters": {
                             "agent_conversation_id": conversation_uuid,
                             "agents": {
-                                parent_agent.agent_uuid: {
-                                    "name": parent_agent.name,
-                                    "description": parent_agent.instructions,
+                                parent.agent_uuid: {
+                                    "name": parent.name,
+                                    "description": parent.instructions,
                                 },
                             },
                         },
@@ -63,15 +77,19 @@ class OpenaiAgentsAdapter(BaseAdapter):
         self, trace_calls: dict[str, Call | None]
     ) -> dict[str, Call | None]:
         for span_id, span in trace_calls.items():
+            if span is None:
+                continue
             if span.type == "agent" and span.span_parent_id is not None:
                 parent = trace_calls[span.span_parent_id]
+                if parent is None:
+                    continue
                 if parent.type == "tool":
                     trace_calls[span.span_parent_id] = None
-                    trace_calls[span_id].span_parent_id = parent.span_parent_id
-                    trace_calls[span_id].input = (
+                    span.span_parent_id = parent.span_parent_id
+                    span.input = (
                         parent.input if span.input is None else span.input
                     )
-                    trace_calls[span_id].output = (
+                    span.output = (
                         parent.output if span.output is None else span.output
                     )
         return trace_calls
@@ -80,18 +98,22 @@ class OpenaiAgentsAdapter(BaseAdapter):
         self, trace_calls: dict[str, Call | None]
     ) -> dict[str, Call | None]:
         for span in reversed(trace_calls.values()):
+            if span is None:
+                continue
             if span.type == "handoff" and span.span_parent_id is not None:
                 parent = trace_calls[span.span_parent_id]
                 child = next(
                     (
                         call
                         for call in trace_calls.values()
-                        if call.name == span.to_agent
+                        if call is not None and call.name == span.to_agent
                     ),
                     None,
                 )
                 if parent is None:
                     continue
+                if child is None:
+                    continue
                 child.span_parent_id = span.span_parent_id
                 if parent.output is None:
                     parent.output = child.output
@@ -100,6 +122,8 @@ class OpenaiAgentsAdapter(BaseAdapter):
         return trace_calls
 
     def _log_start_message(self, trace_call: AgentCall, conversation_uuid: str):
+        if trace_call.input is None:
+            return
         self.input(
             message=trace_call.input,
             additional_params={
@@ -114,6 +138,8 @@ class OpenaiAgentsAdapter(BaseAdapter):
         )
 
     def _log_final_message(self, trace_call: AgentCall, conversation_uuid: str):
+        if trace_call.output is None:
+            return
         self.output(
             message=trace_call.output,
             additional_params={

hivetrace/adapters/openai_agents/tracing.py

@@ -121,8 +121,10 @@ class HivetraceOpenAIAgentProcessor(TracingProcessor):
             isinstance(span.span_data, FunctionSpanData)
             and span.span_data.type == "function"
         ):
-            self._trace_calls[span.span_id].input = span.span_data.input
-            self._trace_calls[span.span_id].output = span.span_data.output
+            call = self._trace_calls.get(span.span_id)
+            if call is not None:
+                call.input = span.span_data.input
+                call.output = span.span_data.output
 
         # Save input and output for agent
         elif (
@@ -133,15 +135,16 @@ class HivetraceOpenAIAgentProcessor(TracingProcessor):
             if not response or not response.output:
                 return
             if isinstance(response.output[0], ResponseOutputMessage):
-                self._trace_calls[span.parent_id].input = span.span_data.input[0][
-                    "content"
-                ]
-                self._trace_calls[span.parent_id].output = (
-                    response.output[0].content[0].text
-                )
-                self._trace_calls[span.parent_id].instructions = response.instructions
+                parent_call = self._trace_calls.get(span.parent_id)
+                if parent_call is None:
+                    return
+                parent_call.input = span.span_data.input[0]["content"]
+                parent_call.output = response.output[0].content[0].text
+                parent_call.instructions = response.instructions
             elif isinstance(response.output[0], ResponseFunctionToolCall):
-                self._trace_calls[span.parent_id].instructions = response.instructions
+                parent_call = self._trace_calls.get(span.parent_id)
+                if parent_call is not None:
+                    parent_call.instructions = response.instructions
 
     def shutdown(self):
         self._trace_calls = {}

hivetrace/client/async_client.py

@@ -30,17 +30,17 @@ class AsyncHivetraceSDK(BaseHivetraceSDK):
     async def __aexit__(self, exc_type, exc_val, exc_tb):
         await self.close()
 
-    async def _send_request(
-        self, endpoint: str, payload: Dict[str, Any]
+    async def _post_and_parse(
+        self, request_args: Dict[str, Any], endpoint: str
     ) -> HivetraceResponse:
-        request_args = self._build_request_args(endpoint, payload)
+        """
+        Sends a POST request and parses the response.
+        """
         try:
             response = await self.session.post(**request_args)
             response.raise_for_status()
-
             api_data = response.json()
-            return ResponseBuilder.build_response_from_api(api_data)
-
+            return ResponseBuilder.build_response_from_api(api_data, endpoint=endpoint)
         except httpx.HTTPStatusError as e:
             return ErrorHandler.handle_http_error(e)
         except httpx.ConnectError as e:
@@ -54,40 +54,17 @@ class AsyncHivetraceSDK(BaseHivetraceSDK):
         except Exception as e:
             return ErrorHandler.handle_unexpected_error(e)
 
+    async def _send_request(
+        self, endpoint: str, payload: Dict[str, Any]
+    ) -> HivetraceResponse:
+        request_args = self._build_request_args(endpoint, payload)
+        return await self._post_and_parse(request_args, endpoint)
+
     async def _send_files(
         self, endpoint: str, files: List[Tuple[str, bytes, str]]
     ) -> HivetraceResponse:
         request_args = self._build_files_request_args(endpoint, files)
-        try:
-            response = await self.session.post(**request_args)
-            response.raise_for_status()
-            api_data = response.json()
-            return ResponseBuilder.build_response_from_api(api_data)
-        except httpx.HTTPStatusError as e:
-            return ErrorHandler.handle_http_error(e)
-        except httpx.ConnectError as e:
-            return ErrorHandler.handle_connection_error(e)
-        except httpx.TimeoutException as e:
-            return ErrorHandler.handle_timeout_error(e)
-        except httpx.RequestError as e:
-            return ErrorHandler.handle_request_error(e)
-        except ValueError as e:
-            return ErrorHandler.handle_json_decode_error(e)
-        except Exception as e:
-            return ErrorHandler.handle_unexpected_error(e)
-
-    async def _get_blocking_status(self, endpoint: str) -> Optional[bool]:
-        url = f"{self.hivetrace_url}/{endpoint.lstrip('/')}"
-        headers = {"Authorization": f"Bearer {self.hivetrace_access_token}"}
-        try:
-            response = await self.session.get(
-                url, headers=headers, timeout=self._DEFAULT_TIMEOUT
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data.get("blocked")
-        except Exception:
-            return None
+        return await self._post_and_parse(request_args, endpoint)
 
     async def input(
         self,
@@ -100,22 +77,15 @@ class AsyncHivetraceSDK(BaseHivetraceSDK):
             application_id, message, additional_parameters
         )
         process_response = await self._send_request("/process_request/", payload)
-        
+
         analysis_id = self._extract_analysis_id(process_response)
         if analysis_id:
             if files:
                 files_response = await self._send_files(
                     f"/user_prompt_analysis/{analysis_id}/attach_files", files
                 )
-                if hasattr(files_response, "success") and not files_response.success:
-                    return files_response
-                elif isinstance(files_response, dict) and not files_response.get("success", True):
+                if self._is_failure_response(files_response):
                     return files_response
-                    
-            blocked = await self._get_blocking_status(
-                f"/user_prompt_analysis/{analysis_id}/check_blocking"
-            )
-            self._set_blocked(process_response, blocked)
         return process_response
 
     async def output(
@@ -129,22 +99,15 @@ class AsyncHivetraceSDK(BaseHivetraceSDK):
             application_id, message, additional_parameters
         )
         process_response = await self._send_request("/process_response/", payload)
-        
+
         analysis_id = self._extract_analysis_id(process_response)
         if analysis_id:
             if files:
                 files_response = await self._send_files(
                     f"/llm_response_analysis/{analysis_id}/attach_files", files
                 )
-                if hasattr(files_response, "success") and not files_response.success:
+                if self._is_failure_response(files_response):
                     return files_response
-                elif isinstance(files_response, dict) and not files_response.get("success", True):
-                    return files_response
-                    
-            blocked = await self._get_blocking_status(
-                f"/llm_response_analysis/{analysis_id}/check_blocking"
-            )
-            self._set_blocked(process_response, blocked)
         return process_response
 
     async def function_call(

hivetrace/client/base.py

@@ -1,13 +1,11 @@
 import os
-import uuid
 from abc import ABC, abstractmethod
-from typing import Any, Dict, List, Optional, Tuple, Union
+from typing import Any, Awaitable, Dict, List, Optional, Tuple, Union
 
 import httpx
 from pydantic import ValidationError
 
 from ..errors import InvalidParameterError, MissingConfigError
-from ..handlers import ErrorHandler
 from ..models import (
     FunctionCallRequest,
     HivetraceResponse,
@@ -54,34 +52,6 @@ class BaseHivetraceSDK(ABC):
 
         return value
 
-    @staticmethod
-    def _validate_application_id(application_id: str) -> str:
-        try:
-            return str(uuid.UUID(application_id))
-        except ValueError as e:
-            raise InvalidParameterError(
-                parameter="application_id", message="Invalid application_id format"
-            ) from e
-
-    @staticmethod
-    def _validate_message(message: str) -> None:
-        if not isinstance(message, str) or not message.strip():
-            raise InvalidParameterError(
-                parameter="message", message="Message must be non-empty"
-            )
-
-    @staticmethod
-    def _validate_additional_parameters(
-        additional_parameters: Optional[Dict[str, Any]],
-    ) -> None:
-        if additional_parameters is not None and not isinstance(
-            additional_parameters, dict
-        ):
-            raise InvalidParameterError(
-                parameter="additional_parameters",
-                message="Additional parameters must be a dict or None",
-            )
-
     def _build_request_args(
         self, endpoint: str, payload: Dict[str, Any]
     ) -> Dict[str, Any]:
@@ -137,21 +107,29 @@ class BaseHivetraceSDK(ABC):
         return None
 
     @staticmethod
-    def _set_blocked(response: Any, blocked: Optional[bool]) -> Any:
-        """Sets 'blocked' flag on response when possible."""
+    def _is_failure_response(response: Any) -> bool:
         try:
             if isinstance(response, dict):
-                response["blocked"] = blocked
-                return response
-            if hasattr(response, "blocked"):
-                setattr(response, "blocked", blocked)
-                return response
+                if response.get("success") is False:
+                    return True
+                status = response.get("status")
+                if isinstance(status, str) and "success" not in status.lower():
+                    return True
+                if response.get("error") or response.get("error_type"):
+                    return True
+                return False
+
+            if hasattr(response, "success") and getattr(response, "success") is False:
+                return True
+            status = getattr(response, "status", None)
+            if isinstance(status, str) and "success" not in status.lower():
+                return True
+            if getattr(response, "error", None) or getattr(response, "error_type", None):
+                return True
         except Exception:
-            return response
-        return response
+            return False
 
-    def _handle_http_error(self, error: httpx.HTTPStatusError) -> HivetraceResponse:
-        return ErrorHandler.handle_http_error(error)
+        return False
 
     def _build_message_payload(
         self,
@@ -166,7 +144,7 @@ class BaseHivetraceSDK(ABC):
                 message=message,
                 additional_parameters=additional_parameters,
             )
-            return request_model.dict()
+            return request_model.model_dump()
         except ValidationError as e:
             raise InvalidParameterError(
                 parameter="request_data", message=f"Validation failed: {e}"
@@ -191,7 +169,7 @@ class BaseHivetraceSDK(ABC):
                 func_result=func_result,
                 additional_parameters=additional_parameters,
             )
-            return request_model.dict()
+            return request_model.model_dump()
         except ValidationError as e:
             raise InvalidParameterError(
                 parameter="request_data", message=f"Validation failed: {e}"
@@ -203,7 +181,8 @@ class BaseHivetraceSDK(ABC):
         application_id: str,
         message: str,
         additional_parameters: Optional[Dict[str, Any]] = None,
-    ) -> HivetraceResponse:
+        files: Optional[List[Tuple[str, bytes, str]]] = None,
+    ) -> Union[HivetraceResponse, Awaitable[HivetraceResponse]]:
         """Sends user request to HiveTrace."""
         pass
 
@@ -213,7 +192,8 @@ class BaseHivetraceSDK(ABC):
         application_id: str,
         message: str,
         additional_parameters: Optional[Dict[str, Any]] = None,
-    ) -> HivetraceResponse:
+        files: Optional[List[Tuple[str, bytes, str]]] = None,
+    ) -> Union[HivetraceResponse, Awaitable[HivetraceResponse]]:
         """Sends LLM response to HiveTrace."""
         pass
 
@@ -226,11 +206,11 @@ class BaseHivetraceSDK(ABC):
         func_args: str,
         func_result: Optional[Union[Dict, str]] = None,
         additional_parameters: Optional[Dict[str, Any]] = None,
-    ) -> HivetraceResponse:
+    ) -> Union[HivetraceResponse, Awaitable[HivetraceResponse]]:
         """Sends function call to HiveTrace."""
         pass
 
     @abstractmethod
-    def close(self) -> None:
+    def close(self) -> Union[None, Awaitable[None]]:
         """Closes HTTP session and frees resources."""
         pass

hivetrace/client/sync_client.py

@@ -43,17 +43,15 @@ class SyncHivetraceSDK(BaseHivetraceSDK):
         except Exception:
             pass
 
-    def _send_request(
-        self, endpoint: str, payload: Dict[str, Any]
-    ) -> HivetraceResponse:
-        request_args = self._build_request_args(endpoint, payload)
+    def _post_and_parse(self, request_args: Dict[str, Any], endpoint: str) -> HivetraceResponse:
+        """
+        Sends a POST request and parses the response.
+        """
         try:
             response = self.session.post(**request_args)
             response.raise_for_status()
-
             api_data = response.json()
-            return ResponseBuilder.build_response_from_api(api_data)
-
+            return ResponseBuilder.build_response_from_api(api_data, endpoint=endpoint)
         except httpx.HTTPStatusError as e:
             return ErrorHandler.handle_http_error(e)
         except httpx.ConnectError as e:
@@ -67,42 +65,17 @@ class SyncHivetraceSDK(BaseHivetraceSDK):
         except Exception as e:
             return ErrorHandler.handle_unexpected_error(e)
 
+    def _send_request(
+        self, endpoint: str, payload: Dict[str, Any]
+    ) -> HivetraceResponse:
+        request_args = self._build_request_args(endpoint, payload)
+        return self._post_and_parse(request_args, endpoint)
+
     def _send_files(
         self, endpoint: str, files: List[Tuple[str, bytes, str]]
     ) -> HivetraceResponse:
         request_args = self._build_files_request_args(endpoint, files)
-        try:
-            response = self.session.post(**request_args)
-            response.raise_for_status()
-
-            api_data = response.json()
-            return ResponseBuilder.build_response_from_api(api_data)
-
-        except httpx.HTTPStatusError as e:
-            return ErrorHandler.handle_http_error(e)
-        except httpx.ConnectError as e:
-            return ErrorHandler.handle_connection_error(e)
-        except httpx.TimeoutException as e:
-            return ErrorHandler.handle_timeout_error(e)
-        except httpx.RequestError as e:
-            return ErrorHandler.handle_request_error(e)
-        except ValueError as e:
-            return ErrorHandler.handle_json_decode_error(e)
-        except Exception as e:
-            return ErrorHandler.handle_unexpected_error(e)
-
-    def _get_blocking_status(self, endpoint: str) -> Optional[bool]:
-        url = f"{self.hivetrace_url}/{endpoint.lstrip('/')}"
-        headers = {"Authorization": f"Bearer {self.hivetrace_access_token}"}
-        try:
-            response = self.session.get(
-                url, headers=headers, timeout=self._DEFAULT_TIMEOUT
-            )
-            response.raise_for_status()
-            data = response.json()
-            return data.get("blocked")
-        except Exception:
-            return None
+        return self._post_and_parse(request_args, endpoint)
 
     def input(
         self,
@@ -115,22 +88,15 @@ class SyncHivetraceSDK(BaseHivetraceSDK):
             application_id, message, additional_parameters
         )
         process_response = self._send_request("/process_request/", payload)
-        
+
         analysis_id = self._extract_analysis_id(process_response)
         if analysis_id:
             if files:
                 files_response = self._send_files(
                     f"/user_prompt_analysis/{analysis_id}/attach_files", files
                 )
-                if hasattr(files_response, "success") and not files_response.success:
-                    return files_response
-                elif isinstance(files_response, dict) and not files_response.get("success", True):
+                if self._is_failure_response(files_response):
                     return files_response
-                    
-            blocked = self._get_blocking_status(
-                f"/user_prompt_analysis/{analysis_id}/check_blocking"
-            )
-            self._set_blocked(process_response, blocked)
         return process_response
 
     def output(
@@ -144,22 +110,15 @@ class SyncHivetraceSDK(BaseHivetraceSDK):
             application_id, message, additional_parameters
         )
         process_response = self._send_request("/process_response/", payload)
-        
+
         analysis_id = self._extract_analysis_id(process_response)
         if analysis_id:
             if files:
                 files_response = self._send_files(
                     f"/llm_response_analysis/{analysis_id}/attach_files", files
                 )
-                if hasattr(files_response, "success") and not files_response.success:
-                    return files_response
-                elif isinstance(files_response, dict) and not files_response.get("success", True):
+                if self._is_failure_response(files_response):
                     return files_response
-                    
-            blocked = self._get_blocking_status(
-                f"/llm_response_analysis/{analysis_id}/check_blocking"
-            )
-            self._set_blocked(process_response, blocked)
         return process_response
 
     def function_call(

hivetrace/errors/api.py

@@ -8,7 +8,7 @@ from .base import HiveTraceError
 class APIError(HiveTraceError):
     """Базовое исключение для API ошибок."""
 
-    def __init__(self, message: str, status_code: int = None):
+    def __init__(self, message: str, status_code: int | None = None):
         super().__init__(message)
         self.status_code = status_code
 
@@ -16,7 +16,7 @@ class APIError(HiveTraceError):
 class HTTPError(APIError):
     """Исключение для HTTP ошибок."""
 
-    def __init__(self, status_code: int, message: str = None):
+    def __init__(self, status_code: int, message: str | None = None):
         message = message or f"HTTP error {status_code}"
         super().__init__(message, status_code)