robosystems-client 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

robosystems_client/models/agent_response.py

@@ -1,13 +1,20 @@
+import datetime
 from collections.abc import Mapping
 from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
+from dateutil.parser import isoparse
 
+from ..models.agent_mode import AgentMode
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
+  from ..models.agent_response_error_details_type_0 import (
+    AgentResponseErrorDetailsType0,
+  )
   from ..models.agent_response_metadata_type_0 import AgentResponseMetadataType0
+  from ..models.agent_response_tokens_used_type_0 import AgentResponseTokensUsedType0
 
 
 T = TypeVar("T", bound="AgentResponse")
@@ -15,26 +22,47 @@ T = TypeVar("T", bound="AgentResponse")
 
 @_attrs_define
 class AgentResponse:
-  """Response model for financial agent interactions.
+  """Response model for agent interactions.
 
   Attributes:
-      response (str): Financial analysis response
-      metadata (Union['AgentResponseMetadataType0', None, Unset]): Analysis metadata (e.g., analysis_type, graph_id)
-      operation_id (Union[None, Unset, str]): SSE operation ID for monitoring extended analysis via
-          /v1/operations/{operation_id}/stream
-      is_partial (Union[Unset, bool]): Whether this is a partial response with more analysis coming Default: False.
+      content (str): The agent's response content
+      agent_used (str): The agent type that handled the request
+      mode_used (AgentMode): Agent execution modes.
+      metadata (Union['AgentResponseMetadataType0', None, Unset]): Response metadata including routing info
+      tokens_used (Union['AgentResponseTokensUsedType0', None, Unset]): Token usage statistics
+      confidence_score (Union[None, Unset, float]): Confidence score of the response
+      operation_id (Union[None, Unset, str]): Operation ID for SSE monitoring
+      is_partial (Union[Unset, bool]): Whether this is a partial response Default: False.
+      error_details (Union['AgentResponseErrorDetailsType0', None, Unset]): Error details if any
+      execution_time (Union[None, Unset, float]): Execution time in seconds
+      timestamp (Union[Unset, datetime.datetime]): Response timestamp
   """
 
-  response: str
+  content: str
+  agent_used: str
+  mode_used: AgentMode
   metadata: Union["AgentResponseMetadataType0", None, Unset] = UNSET
+  tokens_used: Union["AgentResponseTokensUsedType0", None, Unset] = UNSET
+  confidence_score: Union[None, Unset, float] = UNSET
   operation_id: Union[None, Unset, str] = UNSET
   is_partial: Union[Unset, bool] = False
+  error_details: Union["AgentResponseErrorDetailsType0", None, Unset] = UNSET
+  execution_time: Union[None, Unset, float] = UNSET
+  timestamp: Union[Unset, datetime.datetime] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
+    from ..models.agent_response_error_details_type_0 import (
+      AgentResponseErrorDetailsType0,
+    )
     from ..models.agent_response_metadata_type_0 import AgentResponseMetadataType0
+    from ..models.agent_response_tokens_used_type_0 import AgentResponseTokensUsedType0
+
+    content = self.content
 
-    response = self.response
+    agent_used = self.agent_used
+
+    mode_used = self.mode_used.value
 
     metadata: Union[None, Unset, dict[str, Any]]
     if isinstance(self.metadata, Unset):
@@ -44,6 +72,20 @@ class AgentResponse:
     else:
       metadata = self.metadata
 
+    tokens_used: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.tokens_used, Unset):
+      tokens_used = UNSET
+    elif isinstance(self.tokens_used, AgentResponseTokensUsedType0):
+      tokens_used = self.tokens_used.to_dict()
+    else:
+      tokens_used = self.tokens_used
+
+    confidence_score: Union[None, Unset, float]
+    if isinstance(self.confidence_score, Unset):
+      confidence_score = UNSET
+    else:
+      confidence_score = self.confidence_score
+
     operation_id: Union[None, Unset, str]
     if isinstance(self.operation_id, Unset):
       operation_id = UNSET
@@ -52,28 +94,66 @@ class AgentResponse:
 
     is_partial = self.is_partial
 
+    error_details: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.error_details, Unset):
+      error_details = UNSET
+    elif isinstance(self.error_details, AgentResponseErrorDetailsType0):
+      error_details = self.error_details.to_dict()
+    else:
+      error_details = self.error_details
+
+    execution_time: Union[None, Unset, float]
+    if isinstance(self.execution_time, Unset):
+      execution_time = UNSET
+    else:
+      execution_time = self.execution_time
+
+    timestamp: Union[Unset, str] = UNSET
+    if not isinstance(self.timestamp, Unset):
+      timestamp = self.timestamp.isoformat()
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
       {
-        "response": response,
+        "content": content,
+        "agent_used": agent_used,
+        "mode_used": mode_used,
       }
     )
     if metadata is not UNSET:
       field_dict["metadata"] = metadata
+    if tokens_used is not UNSET:
+      field_dict["tokens_used"] = tokens_used
+    if confidence_score is not UNSET:
+      field_dict["confidence_score"] = confidence_score
     if operation_id is not UNSET:
       field_dict["operation_id"] = operation_id
     if is_partial is not UNSET:
       field_dict["is_partial"] = is_partial
+    if error_details is not UNSET:
+      field_dict["error_details"] = error_details
+    if execution_time is not UNSET:
+      field_dict["execution_time"] = execution_time
+    if timestamp is not UNSET:
+      field_dict["timestamp"] = timestamp
 
     return field_dict
 
   @classmethod
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_response_error_details_type_0 import (
+      AgentResponseErrorDetailsType0,
+    )
     from ..models.agent_response_metadata_type_0 import AgentResponseMetadataType0
+    from ..models.agent_response_tokens_used_type_0 import AgentResponseTokensUsedType0
 
     d = dict(src_dict)
-    response = d.pop("response")
+    content = d.pop("content")
+
+    agent_used = d.pop("agent_used")
+
+    mode_used = AgentMode(d.pop("mode_used"))
 
     def _parse_metadata(
       data: object,
@@ -94,6 +174,34 @@ class AgentResponse:
 
     metadata = _parse_metadata(d.pop("metadata", UNSET))
 
+    def _parse_tokens_used(
+      data: object,
+    ) -> Union["AgentResponseTokensUsedType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        tokens_used_type_0 = AgentResponseTokensUsedType0.from_dict(data)
+
+        return tokens_used_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AgentResponseTokensUsedType0", None, Unset], data)
+
+    tokens_used = _parse_tokens_used(d.pop("tokens_used", UNSET))
+
+    def _parse_confidence_score(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    confidence_score = _parse_confidence_score(d.pop("confidence_score", UNSET))
+
     def _parse_operation_id(data: object) -> Union[None, Unset, str]:
       if data is None:
         return data
@@ -105,11 +213,53 @@ class AgentResponse:
 
     is_partial = d.pop("is_partial", UNSET)
 
+    def _parse_error_details(
+      data: object,
+    ) -> Union["AgentResponseErrorDetailsType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        error_details_type_0 = AgentResponseErrorDetailsType0.from_dict(data)
+
+        return error_details_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AgentResponseErrorDetailsType0", None, Unset], data)
+
+    error_details = _parse_error_details(d.pop("error_details", UNSET))
+
+    def _parse_execution_time(data: object) -> Union[None, Unset, float]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, float], data)
+
+    execution_time = _parse_execution_time(d.pop("execution_time", UNSET))
+
+    _timestamp = d.pop("timestamp", UNSET)
+    timestamp: Union[Unset, datetime.datetime]
+    if isinstance(_timestamp, Unset):
+      timestamp = UNSET
+    else:
+      timestamp = isoparse(_timestamp)
+
     agent_response = cls(
-      response=response,
+      content=content,
+      agent_used=agent_used,
+      mode_used=mode_used,
       metadata=metadata,
+      tokens_used=tokens_used,
+      confidence_score=confidence_score,
       operation_id=operation_id,
       is_partial=is_partial,
+      error_details=error_details,
+      execution_time=execution_time,
+      timestamp=timestamp,
     )
 
     agent_response.additional_properties = d

robosystems_client/models/agent_response_error_details_type_0.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AgentResponseErrorDetailsType0")
+
+
+@_attrs_define
+class AgentResponseErrorDetailsType0:
+  """ """
+
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    agent_response_error_details_type_0 = cls()
+
+    agent_response_error_details_type_0.additional_properties = d
+    return agent_response_error_details_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/agent_response_tokens_used_type_0.py

@@ -0,0 +1,44 @@
+from collections.abc import Mapping
+from typing import Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+T = TypeVar("T", bound="AgentResponseTokensUsedType0")
+
+
+@_attrs_define
+class AgentResponseTokensUsedType0:
+  """ """
+
+  additional_properties: dict[str, int] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    d = dict(src_dict)
+    agent_response_tokens_used_type_0 = cls()
+
+    agent_response_tokens_used_type_0.additional_properties = d
+    return agent_response_tokens_used_type_0
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> int:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: int) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/auth_response.py

@@ -1,9 +1,11 @@
 from collections.abc import Mapping
-from typing import TYPE_CHECKING, Any, TypeVar
+from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..types import UNSET, Unset
+
 if TYPE_CHECKING:
   from ..models.auth_response_user import AuthResponseUser
 
@@ -18,12 +20,12 @@ class AuthResponse:
   Attributes:
       user (AuthResponseUser): User information
       message (str): Success message
-      token (str): JWT authentication token
+      token (Union[None, Unset, str]): JWT authentication token (optional for cookie-based auth)
   """
 
   user: "AuthResponseUser"
   message: str
-  token: str
+  token: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -31,7 +33,11 @@ class AuthResponse:
 
     message = self.message
 
-    token = self.token
+    token: Union[None, Unset, str]
+    if isinstance(self.token, Unset):
+      token = UNSET
+    else:
+      token = self.token
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -39,9 +45,10 @@ class AuthResponse:
       {
         "user": user,
         "message": message,
-        "token": token,
       }
     )
+    if token is not UNSET:
+      field_dict["token"] = token
 
     return field_dict
 
@@ -54,7 +61,14 @@ class AuthResponse:
 
     message = d.pop("message")
 
-    token = d.pop("token")
+    def _parse_token(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    token = _parse_token(d.pop("token", UNSET))
 
     auth_response = cls(
       user=user,

robosystems_client/models/batch_agent_request.py

@@ -0,0 +1,85 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar, Union
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+from ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.agent_request import AgentRequest
+
+
+T = TypeVar("T", bound="BatchAgentRequest")
+
+
+@_attrs_define
+class BatchAgentRequest:
+  """Request for batch processing multiple queries.
+
+  Attributes:
+      queries (list['AgentRequest']): List of queries to process
+      parallel (Union[Unset, bool]): Process queries in parallel Default: False.
+  """
+
+  queries: list["AgentRequest"]
+  parallel: Union[Unset, bool] = False
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    queries = []
+    for queries_item_data in self.queries:
+      queries_item = queries_item_data.to_dict()
+      queries.append(queries_item)
+
+    parallel = self.parallel
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "queries": queries,
+      }
+    )
+    if parallel is not UNSET:
+      field_dict["parallel"] = parallel
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_request import AgentRequest
+
+    d = dict(src_dict)
+    queries = []
+    _queries = d.pop("queries")
+    for queries_item_data in _queries:
+      queries_item = AgentRequest.from_dict(queries_item_data)
+
+      queries.append(queries_item)
+
+    parallel = d.pop("parallel", UNSET)
+
+    batch_agent_request = cls(
+      queries=queries,
+      parallel=parallel,
+    )
+
+    batch_agent_request.additional_properties = d
+    return batch_agent_request
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/batch_agent_response.py

@@ -0,0 +1,90 @@
+from collections.abc import Mapping
+from typing import TYPE_CHECKING, Any, TypeVar
+
+from attrs import define as _attrs_define
+from attrs import field as _attrs_field
+
+if TYPE_CHECKING:
+  from ..models.agent_response import AgentResponse
+
+
+T = TypeVar("T", bound="BatchAgentResponse")
+
+
+@_attrs_define
+class BatchAgentResponse:
+  """Response for batch processing.
+
+  Attributes:
+      results (list['AgentResponse']): List of agent responses
+      total_execution_time (float): Total execution time
+      parallel_processed (bool): Whether queries were processed in parallel
+  """
+
+  results: list["AgentResponse"]
+  total_execution_time: float
+  parallel_processed: bool
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    results = []
+    for results_item_data in self.results:
+      results_item = results_item_data.to_dict()
+      results.append(results_item)
+
+    total_execution_time = self.total_execution_time
+
+    parallel_processed = self.parallel_processed
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "results": results,
+        "total_execution_time": total_execution_time,
+        "parallel_processed": parallel_processed,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_response import AgentResponse
+
+    d = dict(src_dict)
+    results = []
+    _results = d.pop("results")
+    for results_item_data in _results:
+      results_item = AgentResponse.from_dict(results_item_data)
+
+      results.append(results_item)
+
+    total_execution_time = d.pop("total_execution_time")
+
+    parallel_processed = d.pop("parallel_processed")
+
+    batch_agent_response = cls(
+      results=results,
+      total_execution_time=total_execution_time,
+      parallel_processed=parallel_processed,
+    )
+
+    batch_agent_response.additional_properties = d
+    return batch_agent_response
+
+  @property
+  def additional_keys(self) -> list[str]:
+    return list(self.additional_properties.keys())
+
+  def __getitem__(self, key: str) -> Any:
+    return self.additional_properties[key]
+
+  def __setitem__(self, key: str, value: Any) -> None:
+    self.additional_properties[key] = value
+
+  def __delitem__(self, key: str) -> None:
+    del self.additional_properties[key]
+
+  def __contains__(self, key: str) -> bool:
+    return key in self.additional_properties

robosystems_client/models/credit_summary.py

@@ -1,5 +1,5 @@
 from collections.abc import Mapping
-from typing import Any, TypeVar, Union
+from typing import Any, TypeVar, Union, cast
 
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
@@ -21,8 +21,8 @@ class CreditSummary:
       rollover_credits (float): Credits rolled over from previous month
       allows_rollover (bool): Whether rollover is allowed
       is_active (bool): Whether credit pool is active
-      last_allocation_date (Union[Unset, str]): Last allocation date (ISO format)
-      next_allocation_date (Union[Unset, str]): Next allocation date (ISO format)
+      last_allocation_date (Union[None, Unset, str]): Last allocation date (ISO format)
+      next_allocation_date (Union[None, Unset, str]): Next allocation date (ISO format)
   """
 
   current_balance: float
@@ -32,8 +32,8 @@ class CreditSummary:
   rollover_credits: float
   allows_rollover: bool
   is_active: bool
-  last_allocation_date: Union[Unset, str] = UNSET
-  next_allocation_date: Union[Unset, str] = UNSET
+  last_allocation_date: Union[None, Unset, str] = UNSET
+  next_allocation_date: Union[None, Unset, str] = UNSET
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
@@ -51,9 +51,17 @@ class CreditSummary:
 
     is_active = self.is_active
 
-    last_allocation_date = self.last_allocation_date
+    last_allocation_date: Union[None, Unset, str]
+    if isinstance(self.last_allocation_date, Unset):
+      last_allocation_date = UNSET
+    else:
+      last_allocation_date = self.last_allocation_date
 
-    next_allocation_date = self.next_allocation_date
+    next_allocation_date: Union[None, Unset, str]
+    if isinstance(self.next_allocation_date, Unset):
+      next_allocation_date = UNSET
+    else:
+      next_allocation_date = self.next_allocation_date
 
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
@@ -92,9 +100,27 @@ class CreditSummary:
 
     is_active = d.pop("is_active")
 
-    last_allocation_date = d.pop("last_allocation_date", UNSET)
+    def _parse_last_allocation_date(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
 
-    next_allocation_date = d.pop("next_allocation_date", UNSET)
+    last_allocation_date = _parse_last_allocation_date(
+      d.pop("last_allocation_date", UNSET)
+    )
+
+    def _parse_next_allocation_date(data: object) -> Union[None, Unset, str]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      return cast(Union[None, Unset, str], data)
+
+    next_allocation_date = _parse_next_allocation_date(
+      d.pop("next_allocation_date", UNSET)
+    )
 
     credit_summary = cls(
       current_balance=current_balance,