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

robosystems_client/models/agent_recommendation_request.py

@@ -0,0 +1,108 @@
+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 ..types import UNSET, Unset
+
+if TYPE_CHECKING:
+  from ..models.agent_recommendation_request_context_type_0 import (
+    AgentRecommendationRequestContextType0,
+  )
+
+
+T = TypeVar("T", bound="AgentRecommendationRequest")
+
+
+@_attrs_define
+class AgentRecommendationRequest:
+  """Request for agent recommendations.
+
+  Attributes:
+      query (str): Query to analyze
+      context (Union['AgentRecommendationRequestContextType0', None, Unset]): Additional context
+  """
+
+  query: str
+  context: Union["AgentRecommendationRequestContextType0", None, Unset] = UNSET
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    from ..models.agent_recommendation_request_context_type_0 import (
+      AgentRecommendationRequestContextType0,
+    )
+
+    query = self.query
+
+    context: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.context, Unset):
+      context = UNSET
+    elif isinstance(self.context, AgentRecommendationRequestContextType0):
+      context = self.context.to_dict()
+    else:
+      context = self.context
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "query": query,
+      }
+    )
+    if context is not UNSET:
+      field_dict["context"] = context
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_recommendation_request_context_type_0 import (
+      AgentRecommendationRequestContextType0,
+    )
+
+    d = dict(src_dict)
+    query = d.pop("query")
+
+    def _parse_context(
+      data: object,
+    ) -> Union["AgentRecommendationRequestContextType0", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        context_type_0 = AgentRecommendationRequestContextType0.from_dict(data)
+
+        return context_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["AgentRecommendationRequestContextType0", None, Unset], data)
+
+    context = _parse_context(d.pop("context", UNSET))
+
+    agent_recommendation_request = cls(
+      query=query,
+      context=context,
+    )
+
+    agent_recommendation_request.additional_properties = d
+    return agent_recommendation_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/agent_recommendation_request_context_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="AgentRecommendationRequestContextType0")
+
+
+@_attrs_define
+class AgentRecommendationRequestContextType0:
+  """ """
+
+  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_recommendation_request_context_type_0 = cls()
+
+    agent_recommendation_request_context_type_0.additional_properties = d
+    return agent_recommendation_request_context_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_recommendation_response.py

@@ -0,0 +1,82 @@
+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_recommendation import AgentRecommendation
+
+
+T = TypeVar("T", bound="AgentRecommendationResponse")
+
+
+@_attrs_define
+class AgentRecommendationResponse:
+  """Response for agent recommendations.
+
+  Attributes:
+      recommendations (list['AgentRecommendation']): List of agent recommendations sorted by confidence
+      query (str): The analyzed query
+  """
+
+  recommendations: list["AgentRecommendation"]
+  query: str
+  additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
+
+  def to_dict(self) -> dict[str, Any]:
+    recommendations = []
+    for recommendations_item_data in self.recommendations:
+      recommendations_item = recommendations_item_data.to_dict()
+      recommendations.append(recommendations_item)
+
+    query = self.query
+
+    field_dict: dict[str, Any] = {}
+    field_dict.update(self.additional_properties)
+    field_dict.update(
+      {
+        "recommendations": recommendations,
+        "query": query,
+      }
+    )
+
+    return field_dict
+
+  @classmethod
+  def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
+    from ..models.agent_recommendation import AgentRecommendation
+
+    d = dict(src_dict)
+    recommendations = []
+    _recommendations = d.pop("recommendations")
+    for recommendations_item_data in _recommendations:
+      recommendations_item = AgentRecommendation.from_dict(recommendations_item_data)
+
+      recommendations.append(recommendations_item)
+
+    query = d.pop("query")
+
+    agent_recommendation_response = cls(
+      recommendations=recommendations,
+      query=query,
+    )
+
+    agent_recommendation_response.additional_properties = d
+    return agent_recommendation_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/agent_request.py

@@ -4,11 +4,13 @@ from typing import TYPE_CHECKING, Any, TypeVar, Union, cast
 from attrs import define as _attrs_define
 from attrs import field as _attrs_field
 
+from ..models.agent_mode import AgentMode
 from ..types import UNSET, Unset
 
 if TYPE_CHECKING:
   from ..models.agent_message import AgentMessage
   from ..models.agent_request_context_type_0 import AgentRequestContextType0
+  from ..models.selection_criteria import SelectionCriteria
 
 
 T = TypeVar("T", bound="AgentRequest")
@@ -16,25 +18,36 @@ T = TypeVar("T", bound="AgentRequest")
 
 @_attrs_define
 class AgentRequest:
-  """Request model for financial agent interactions.
+  """Request model for agent interactions.
 
   Attributes:
-      message (str): Financial analysis query
+      message (str): The query or message to process
       history (Union[Unset, list['AgentMessage']]): Conversation history
-      context (Union['AgentRequestContextType0', None, Unset]): Additional context for analysis (e.g., include_schema,
-          limit_results)
-      force_extended_analysis (Union[Unset, bool]): Force extended analysis mode with comprehensive research (like
-          Claude Desktop's deep research) Default: False.
+      context (Union['AgentRequestContextType0', None, Unset]): Additional context for analysis (e.g., enable_rag,
+          include_schema)
+      mode (Union[AgentMode, None, Unset]): Execution mode Default: AgentMode.STANDARD.
+      agent_type (Union[None, Unset, str]): Specific agent type to use (optional)
+      selection_criteria (Union['SelectionCriteria', None, Unset]): Criteria for agent selection
+      force_extended_analysis (Union[Unset, bool]): Force extended analysis mode with comprehensive research Default:
+          False.
+      enable_rag (Union[Unset, bool]): Enable RAG context enrichment Default: True.
+      stream (Union[Unset, bool]): Enable streaming response Default: False.
   """
 
   message: str
   history: Union[Unset, list["AgentMessage"]] = UNSET
   context: Union["AgentRequestContextType0", None, Unset] = UNSET
+  mode: Union[AgentMode, None, Unset] = AgentMode.STANDARD
+  agent_type: Union[None, Unset, str] = UNSET
+  selection_criteria: Union["SelectionCriteria", None, Unset] = UNSET
   force_extended_analysis: Union[Unset, bool] = False
+  enable_rag: Union[Unset, bool] = True
+  stream: Union[Unset, bool] = False
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 
   def to_dict(self) -> dict[str, Any]:
     from ..models.agent_request_context_type_0 import AgentRequestContextType0
+    from ..models.selection_criteria import SelectionCriteria
 
     message = self.message
 
@@ -53,8 +66,34 @@ class AgentRequest:
     else:
       context = self.context
 
+    mode: Union[None, Unset, str]
+    if isinstance(self.mode, Unset):
+      mode = UNSET
+    elif isinstance(self.mode, AgentMode):
+      mode = self.mode.value
+    else:
+      mode = self.mode
+
+    agent_type: Union[None, Unset, str]
+    if isinstance(self.agent_type, Unset):
+      agent_type = UNSET
+    else:
+      agent_type = self.agent_type
+
+    selection_criteria: Union[None, Unset, dict[str, Any]]
+    if isinstance(self.selection_criteria, Unset):
+      selection_criteria = UNSET
+    elif isinstance(self.selection_criteria, SelectionCriteria):
+      selection_criteria = self.selection_criteria.to_dict()
+    else:
+      selection_criteria = self.selection_criteria
+
     force_extended_analysis = self.force_extended_analysis
 
+    enable_rag = self.enable_rag
+
+    stream = self.stream
+
     field_dict: dict[str, Any] = {}
     field_dict.update(self.additional_properties)
     field_dict.update(
@@ -66,8 +105,18 @@ class AgentRequest:
       field_dict["history"] = history
     if context is not UNSET:
       field_dict["context"] = context
+    if mode is not UNSET:
+      field_dict["mode"] = mode
+    if agent_type is not UNSET:
+      field_dict["agent_type"] = agent_type
+    if selection_criteria is not UNSET:
+      field_dict["selection_criteria"] = selection_criteria
     if force_extended_analysis is not UNSET:
       field_dict["force_extended_analysis"] = force_extended_analysis
+    if enable_rag is not UNSET:
+      field_dict["enable_rag"] = enable_rag
+    if stream is not UNSET:
+      field_dict["stream"] = stream
 
     return field_dict
 
@@ -75,6 +124,7 @@ class AgentRequest:
   def from_dict(cls: type[T], src_dict: Mapping[str, Any]) -> T:
     from ..models.agent_message import AgentMessage
     from ..models.agent_request_context_type_0 import AgentRequestContextType0
+    from ..models.selection_criteria import SelectionCriteria
 
     d = dict(src_dict)
     message = d.pop("message")
@@ -103,13 +153,67 @@ class AgentRequest:
 
     context = _parse_context(d.pop("context", UNSET))
 
+    def _parse_mode(data: object) -> Union[AgentMode, None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, str):
+          raise TypeError()
+        mode_type_0 = AgentMode(data)
+
+        return mode_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union[AgentMode, None, Unset], data)
+
+    mode = _parse_mode(d.pop("mode", UNSET))
+
+    def _parse_agent_type(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)
+
+    agent_type = _parse_agent_type(d.pop("agent_type", UNSET))
+
+    def _parse_selection_criteria(
+      data: object,
+    ) -> Union["SelectionCriteria", None, Unset]:
+      if data is None:
+        return data
+      if isinstance(data, Unset):
+        return data
+      try:
+        if not isinstance(data, dict):
+          raise TypeError()
+        selection_criteria_type_0 = SelectionCriteria.from_dict(data)
+
+        return selection_criteria_type_0
+      except:  # noqa: E722
+        pass
+      return cast(Union["SelectionCriteria", None, Unset], data)
+
+    selection_criteria = _parse_selection_criteria(d.pop("selection_criteria", UNSET))
+
     force_extended_analysis = d.pop("force_extended_analysis", UNSET)
 
+    enable_rag = d.pop("enable_rag", UNSET)
+
+    stream = d.pop("stream", UNSET)
+
     agent_request = cls(
       message=message,
       history=history,
       context=context,
+      mode=mode,
+      agent_type=agent_type,
+      selection_criteria=selection_criteria,
       force_extended_analysis=force_extended_analysis,
+      enable_rag=enable_rag,
+      stream=stream,
     )
 
     agent_request.additional_properties = d

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