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

hivetrace/errors/validation.py

@@ -14,7 +14,7 @@ class ValidationError(HiveTraceError):
 class InvalidParameterError(ValidationError):
     """Exception for invalid parameter."""
 
-    def __init__(self, parameter: str, message: str = None):
+    def __init__(self, parameter: str, message: str | None = None):
         message = message or f"Invalid parameter: {parameter}"
         super().__init__(message)
         self.parameter = parameter

hivetrace/handlers/response_builder.py

@@ -1,7 +1,6 @@
-from datetime import datetime
 from typing import Any, Dict, Optional
 
-from ..models.responses import HivetraceResponse, ProcessResponse, SuccessResponse
+from ..models.responses import HivetraceResponse, ProcessResponse
 
 
 class ResponseBuilder:
@@ -9,81 +8,29 @@ class ResponseBuilder:
     Response builder for creating structured responses.
     """
 
-    @staticmethod
-    def build_success_response(
-        data: Dict[str, Any] = None, request_id: Optional[str] = None
-    ) -> SuccessResponse:
-        """Builds a successful response."""
-        return SuccessResponse(
-            success=True,
-            timestamp=datetime.utcnow().isoformat(),
-            request_id=request_id,
-            **(data or {}),
-        )
-
     @staticmethod
     def build_process_response(
-        message_id: Optional[str] = None,
-        trace_id: Optional[str] = None,
-        request_id: Optional[str] = None,
-        additional_data: Dict[str, Any] = None,
+        data: Optional[Dict[str, Any]] = None,
     ) -> ProcessResponse:
-        """Builds a response to process a message."""
-        return ProcessResponse(
-            success=True,
-            timestamp=datetime.utcnow().isoformat(),
-            message_id=message_id,
-            trace_id=trace_id,
-            request_id=request_id,
-            **(additional_data or {}),
-        )
+        """Builds a process response directly from API payload."""
+        return ProcessResponse(**(data or {}))
 
     @staticmethod
     def build_response_from_api(
-        api_response: Dict[str, Any], request_id: Optional[str] = None
+        api_response: Dict[str, Any],
+        request_id: Optional[str] = None,
+        *,
+        endpoint: Optional[str] = None,
     ) -> HivetraceResponse:
         """
-        Builds a response from API data.
+        Builds a typed response from API data when appropriate.
 
-        Automatically determines the response type and creates the corresponding model.
+        We keep the SDK "transparent" by only parsing into `ProcessResponse` for
+        `/process_*` endpoints. For other endpoints we return the raw dict, since
+        their payload shapes can vary.
         """
-        excluded_keys = {
-            "message_id",
-            "trace_id",
-            "request_id",
-            "success",
-            "timestamp",
-            "blocked",
-        }
 
-        if (
-            api_response.get("success")
-            or "message_id" in api_response
-            or "trace_id" in api_response
-        ):
-            return ResponseBuilder.build_process_response(
-                message_id=api_response.get("message_id"),
-                trace_id=api_response.get("trace_id"),
-                request_id=api_response.get("request_id", request_id),
-                additional_data={
-                    k: v
-                    for k, v in api_response.items()
-                    if k not in excluded_keys
-                },
-            )
+        if endpoint and endpoint.startswith("/process_"):
+            return ResponseBuilder.build_process_response(api_response)
 
         return api_response
-
-    @staticmethod
-    def add_request_id(
-        response: HivetraceResponse, request_id: str
-    ) -> HivetraceResponse:
-        """Adds request_id to an existing response."""
-        if isinstance(response, dict):
-            response["request_id"] = request_id
-            return response
-        elif hasattr(response, "request_id"):
-            response.request_id = request_id
-            return response
-        else:
-            return response

hivetrace/models/requests.py

@@ -1,15 +1,23 @@
 from typing import Any, Dict, Optional, Union
 from uuid import UUID
 
-from pydantic import BaseModel, Field, validator
+from pydantic import BaseModel, ConfigDict, Field, field_validator
 
 
 class BaseRequest(BaseModel):
     """Base request model."""
 
-    class Config:
-        extra = "forbid"
-        use_enum_values = True
+    model_config = ConfigDict(extra="forbid", use_enum_values=True)
+
+    @field_validator("application_id", check_fields=False)
+    @classmethod
+    def validate_application_id(cls, v: str) -> str:
+        """Validation of UUID."""
+        try:
+            UUID(v)
+            return v
+        except ValueError:
+            raise ValueError("application_id must be a valid UUID")
 
 
 class MessageRequest(BaseRequest):
@@ -21,17 +29,9 @@ class MessageRequest(BaseRequest):
         None, description="Additional parameters"
     )
 
-    @validator("application_id")
-    def validate_application_id(cls, v):
-        """Validation of UUID."""
-        try:
-            UUID(v)
-            return v
-        except ValueError:
-            raise ValueError("application_id must be a valid UUID")
-
-    @validator("message")
-    def validate_message(cls, v):
+    @field_validator("message")
+    @classmethod
+    def validate_message(cls, v: str) -> str:
         """Validation of message."""
         if not v.strip():
             raise ValueError("Message cannot be empty")
@@ -64,24 +64,17 @@ class FunctionCallRequest(BaseRequest):
         None, description="Additional parameters"
     )
 
-    @validator("application_id")
-    def validate_application_id(cls, v):
-        """Validation of UUID."""
-        try:
-            UUID(v)
-            return v
-        except ValueError:
-            raise ValueError("application_id must be a valid UUID")
-
-    @validator("func_name")
-    def validate_func_name(cls, v):
+    @field_validator("func_name")
+    @classmethod
+    def validate_func_name(cls, v: str) -> str:
         """Validation of function name."""
         if not v.strip():
             raise ValueError("Function name cannot be empty")
         return v.strip()
 
-    @validator("tool_call_id")
-    def validate_tool_call_id(cls, v):
+    @field_validator("tool_call_id")
+    @classmethod
+    def validate_tool_call_id(cls, v: str) -> str:
         """Validation of tool call ID."""
         if not v.strip():
             raise ValueError("Tool call ID cannot be empty")

hivetrace/models/responses.py

@@ -1,44 +1,49 @@
 from typing import Any, Dict, List, Literal, Optional, Union
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, ConfigDict, Field
 
 
 class BaseResponse(BaseModel):
     """Base response model."""
 
-    class Config:
-        extra = "allow"
-        use_enum_values = True
+    model_config = ConfigDict(extra="allow", use_enum_values=True)
 
 
 class SuccessResponse(BaseResponse):
     """Success response from HiveTrace API."""
 
-    success: bool = Field(True, description="Success flag")
-    timestamp: Optional[str] = Field(None, description="Timestamp")
-    request_id: Optional[str] = Field(None, description="Request ID for tracking")
-
-
-class ProcessResponse(SuccessResponse):
-    """Response to process a message."""
-
-    message_id: Optional[str] = Field(None, description="ID of processed message")
-    trace_id: Optional[str] = Field(None, description="Trace ID")
-    blocked: Optional[bool] = Field(
-        None,
-        description="Role restriction flag. True if message/response is blocked by policy.",
+    success: bool = Field(default=True, description="Success flag")
+    timestamp: Optional[str] = Field(default=None, description="Timestamp")
+    request_id: Optional[str] = Field(default=None, description="Request ID for tracking")
+
+
+class ProcessResponse(BaseResponse):
+    """
+    Response model for `/process_request/` and `/process_response/`.
+    Matches the API payload shape (no SDK-added fields).
+    """
+
+    request_id: Optional[str] = Field(default=None, description="Request ID for tracking")
+    schema_version: Optional[str] = Field(default=None, description="Schema version")
+    status: Optional[str] = Field(default=None, description="Status string")
+    errors: List[Any] = Field(default_factory=list, description="Errors list")
+    tokens: Optional[Dict[str, Any]] = Field(default=None, description="Token usage info")
+    guardrails: Optional[Dict[str, Any]] = Field(default=None, description="Guardrails result")
+    custom_policy: Optional[Dict[str, Any]] = Field(
+        default=None, description="Custom policy result"
     )
+    dataclean: Optional[Dict[str, Any]] = Field(default=None, description="Data cleaning result")
 
 
 class ErrorResponse(BaseResponse):
     """Base response model with error."""
 
-    success: bool = Field(False, description="Success flag")
+    success: bool = Field(default=False, description="Success flag")
     error: str = Field(..., description="Error message")
     error_type: str = Field(..., description="Error type")
     details: str = Field(..., description="Error details")
-    status_code: Optional[int] = Field(None, description="HTTP status code")
-    request_id: Optional[str] = Field(None, description="Request ID for tracking")
+    status_code: Optional[int] = Field(default=None, description="HTTP status code")
+    request_id: Optional[str] = Field(default=None, description="Request ID for tracking")
 
 
 class ConnectionErrorResponse(ErrorResponse):
@@ -81,7 +86,7 @@ class ValidationErrorResponse(ErrorResponse):
 
     error_type: Literal["validation_error"] = "validation_error"
     field_errors: Optional[List[Dict[str, Any]]] = Field(
-        None, description="Field validation errors"
+        default=None, description="Field validation errors"
     )
 
 

hivetrace/utils/error_helpers.py

@@ -10,8 +10,19 @@ from ..models.responses import HivetraceResponse
 def is_error_response(response: HivetraceResponse) -> bool:
     """Checks if the response is an error."""
     if isinstance(response, dict):
-        return "error" in response
-    return hasattr(response, "error") and hasattr(response, "error_type")
+        if response.get("error") or response.get("error_type"):
+            return True
+        status = response.get("status")
+        if isinstance(status, str) and "success" not in status.lower():
+            return True
+        return False
+
+    if getattr(response, "error", None) or getattr(response, "error_type", None):
+        return True
+    status = getattr(response, "status", None)
+    if isinstance(status, str) and "success" not in status.lower():
+        return True
+    return False
 
 
 def get_error_type(response: HivetraceResponse) -> Optional[str]:
@@ -74,5 +85,16 @@ def get_status_code(response: HivetraceResponse) -> Optional[int]:
 def is_success_response(response: HivetraceResponse) -> bool:
     """Checks if the response is a success."""
     if isinstance(response, dict):
+        status = response.get("status")
+        if isinstance(status, str):
+            return "success" in status.lower() and "error" not in response
         return response.get("success", True) and "error" not in response
-    return hasattr(response, "success") and getattr(response, "success", True)
+
+    if hasattr(response, "success"):
+        return bool(getattr(response, "success", True))
+
+    status = getattr(response, "status", None)
+    if isinstance(status, str):
+        return "success" in status.lower()
+
+    return False