robosystems-client 0.2.12__py3-none-any.whl → 0.2.13__py3-none-any.whl

robosystems_client/api/agent/auto_select_agent.py

@@ -9,19 +9,35 @@ from ...models.agent_request import AgentRequest
 from ...models.agent_response import AgentResponse
 from ...models.error_response import ErrorResponse
 from ...models.http_validation_error import HTTPValidationError
-from ...types import Response
+from ...models.response_mode import ResponseMode
+from ...types import UNSET, Response, Unset
 
 
 def _get_kwargs(
   graph_id: str,
   *,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> dict[str, Any]:
   headers: dict[str, Any] = {}
 
+  params: dict[str, Any] = {}
+
+  json_mode: Union[None, Unset, str]
+  if isinstance(mode, Unset):
+    json_mode = UNSET
+  elif isinstance(mode, ResponseMode):
+    json_mode = mode.value
+  else:
+    json_mode = mode
+  params["mode"] = json_mode
+
+  params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
   _kwargs: dict[str, Any] = {
     "method": "post",
     "url": f"/v1/graphs/{graph_id}/agent",
+    "params": params,
   }
 
   _kwargs["json"] = body.to_dict()
@@ -40,6 +56,10 @@ def _parse_response(
 
     return response_200
 
+  if response.status_code == 202:
+    response_202 = cast(Any, None)
+    return response_202
+
   if response.status_code == 400:
     response_400 = cast(Any, None)
     return response_400
@@ -84,10 +104,11 @@ def sync_detailed(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   r"""Auto-select agent for query
 
-   Automatically select the best agent for your query.
+   Automatically select the best agent for your query with intelligent execution strategy.
 
   **Agent Selection Process:**
 
@@ -96,7 +117,8 @@ def sync_detailed(
   2. Enriching context with RAG if enabled
   3. Evaluating all available agents against selection criteria
   4. Selecting the best match based on confidence scores
-  5. Executing the query with the selected agent
+  5. Choosing execution strategy (sync/SSE/async) based on expected time
+  6. Executing the query with the selected agent
 
   **Available Agent Types:**
   - `financial`: Financial analysis, SEC filings, company metrics
@@ -109,6 +131,14 @@ def sync_detailed(
   - `extended`: Comprehensive analysis (~15-60s), deep research
   - `streaming`: Real-time response streaming
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   **Confidence Score Interpretation:**
   - `0.9-1.0`: High confidence, agent is ideal match
   - `0.7-0.9`: Good confidence, agent is suitable
@@ -132,6 +162,8 @@ def sync_detailed(
 
   Args:
       graph_id (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -145,6 +177,7 @@ def sync_detailed(
   kwargs = _get_kwargs(
     graph_id=graph_id,
     body=body,
+    mode=mode,
   )
 
   response = client.get_httpx_client().request(
@@ -159,10 +192,11 @@ def sync(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   r"""Auto-select agent for query
 
-   Automatically select the best agent for your query.
+   Automatically select the best agent for your query with intelligent execution strategy.
 
   **Agent Selection Process:**
 
@@ -171,7 +205,8 @@ def sync(
   2. Enriching context with RAG if enabled
   3. Evaluating all available agents against selection criteria
   4. Selecting the best match based on confidence scores
-  5. Executing the query with the selected agent
+  5. Choosing execution strategy (sync/SSE/async) based on expected time
+  6. Executing the query with the selected agent
 
   **Available Agent Types:**
   - `financial`: Financial analysis, SEC filings, company metrics
@@ -184,6 +219,14 @@ def sync(
   - `extended`: Comprehensive analysis (~15-60s), deep research
   - `streaming`: Real-time response streaming
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   **Confidence Score Interpretation:**
   - `0.9-1.0`: High confidence, agent is ideal match
   - `0.7-0.9`: Good confidence, agent is suitable
@@ -207,6 +250,8 @@ def sync(
 
   Args:
       graph_id (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -221,6 +266,7 @@ def sync(
     graph_id=graph_id,
     client=client,
     body=body,
+    mode=mode,
   ).parsed
 
 
@@ -229,10 +275,11 @@ async def asyncio_detailed(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   r"""Auto-select agent for query
 
-   Automatically select the best agent for your query.
+   Automatically select the best agent for your query with intelligent execution strategy.
 
   **Agent Selection Process:**
 
@@ -241,7 +288,8 @@ async def asyncio_detailed(
   2. Enriching context with RAG if enabled
   3. Evaluating all available agents against selection criteria
   4. Selecting the best match based on confidence scores
-  5. Executing the query with the selected agent
+  5. Choosing execution strategy (sync/SSE/async) based on expected time
+  6. Executing the query with the selected agent
 
   **Available Agent Types:**
   - `financial`: Financial analysis, SEC filings, company metrics
@@ -254,6 +302,14 @@ async def asyncio_detailed(
   - `extended`: Comprehensive analysis (~15-60s), deep research
   - `streaming`: Real-time response streaming
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   **Confidence Score Interpretation:**
   - `0.9-1.0`: High confidence, agent is ideal match
   - `0.7-0.9`: Good confidence, agent is suitable
@@ -277,6 +333,8 @@ async def asyncio_detailed(
 
   Args:
       graph_id (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -290,6 +348,7 @@ async def asyncio_detailed(
   kwargs = _get_kwargs(
     graph_id=graph_id,
     body=body,
+    mode=mode,
   )
 
   response = await client.get_async_httpx_client().request(**kwargs)
@@ -302,10 +361,11 @@ async def asyncio(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   r"""Auto-select agent for query
 
-   Automatically select the best agent for your query.
+   Automatically select the best agent for your query with intelligent execution strategy.
 
   **Agent Selection Process:**
 
@@ -314,7 +374,8 @@ async def asyncio(
   2. Enriching context with RAG if enabled
   3. Evaluating all available agents against selection criteria
   4. Selecting the best match based on confidence scores
-  5. Executing the query with the selected agent
+  5. Choosing execution strategy (sync/SSE/async) based on expected time
+  6. Executing the query with the selected agent
 
   **Available Agent Types:**
   - `financial`: Financial analysis, SEC filings, company metrics
@@ -327,6 +388,14 @@ async def asyncio(
   - `extended`: Comprehensive analysis (~15-60s), deep research
   - `streaming`: Real-time response streaming
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   **Confidence Score Interpretation:**
   - `0.9-1.0`: High confidence, agent is ideal match
   - `0.7-0.9`: Good confidence, agent is suitable
@@ -350,6 +419,8 @@ async def asyncio(
 
   Args:
       graph_id (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -365,5 +436,6 @@ async def asyncio(
       graph_id=graph_id,
       client=client,
       body=body,
+      mode=mode,
     )
   ).parsed

robosystems_client/api/agent/execute_specific_agent.py

@@ -9,7 +9,8 @@ from ...models.agent_request import AgentRequest
 from ...models.agent_response import AgentResponse
 from ...models.error_response import ErrorResponse
 from ...models.http_validation_error import HTTPValidationError
-from ...types import Response
+from ...models.response_mode import ResponseMode
+from ...types import UNSET, Response, Unset
 
 
 def _get_kwargs(
@@ -17,12 +18,27 @@ def _get_kwargs(
   agent_type: str,
   *,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> dict[str, Any]:
   headers: dict[str, Any] = {}
 
+  params: dict[str, Any] = {}
+
+  json_mode: Union[None, Unset, str]
+  if isinstance(mode, Unset):
+    json_mode = UNSET
+  elif isinstance(mode, ResponseMode):
+    json_mode = mode.value
+  else:
+    json_mode = mode
+  params["mode"] = json_mode
+
+  params = {k: v for k, v in params.items() if v is not UNSET and v is not None}
+
   _kwargs: dict[str, Any] = {
     "method": "post",
     "url": f"/v1/graphs/{graph_id}/agent/{agent_type}",
+    "params": params,
   }
 
   _kwargs["json"] = body.to_dict()
@@ -41,6 +57,10 @@ def _parse_response(
 
     return response_200
 
+  if response.status_code == 202:
+    response_202 = cast(Any, None)
+    return response_202
+
   if response.status_code == 400:
     response_400 = cast(Any, None)
     return response_400
@@ -90,21 +110,32 @@ def sync_detailed(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   """Execute specific agent
 
-   Execute a specific agent type directly.
+   Execute a specific agent type directly with intelligent execution strategy.
 
   Available agents:
   - **financial**: Financial analysis, SEC filings, accounting data
   - **research**: Deep research and comprehensive analysis
   - **rag**: Fast retrieval without AI (no credits required)
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   Use this endpoint when you know which agent you want to use.
 
   Args:
       graph_id (str):
       agent_type (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -119,6 +150,7 @@ def sync_detailed(
     graph_id=graph_id,
     agent_type=agent_type,
     body=body,
+    mode=mode,
   )
 
   response = client.get_httpx_client().request(
@@ -134,21 +166,32 @@ def sync(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   """Execute specific agent
 
-   Execute a specific agent type directly.
+   Execute a specific agent type directly with intelligent execution strategy.
 
   Available agents:
   - **financial**: Financial analysis, SEC filings, accounting data
   - **research**: Deep research and comprehensive analysis
   - **rag**: Fast retrieval without AI (no credits required)
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   Use this endpoint when you know which agent you want to use.
 
   Args:
       graph_id (str):
       agent_type (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -164,6 +207,7 @@ def sync(
     agent_type=agent_type,
     client=client,
     body=body,
+    mode=mode,
   ).parsed
 
 
@@ -173,21 +217,32 @@ async def asyncio_detailed(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Response[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   """Execute specific agent
 
-   Execute a specific agent type directly.
+   Execute a specific agent type directly with intelligent execution strategy.
 
   Available agents:
   - **financial**: Financial analysis, SEC filings, accounting data
   - **research**: Deep research and comprehensive analysis
   - **rag**: Fast retrieval without AI (no credits required)
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   Use this endpoint when you know which agent you want to use.
 
   Args:
       graph_id (str):
       agent_type (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -202,6 +257,7 @@ async def asyncio_detailed(
     graph_id=graph_id,
     agent_type=agent_type,
     body=body,
+    mode=mode,
   )
 
   response = await client.get_async_httpx_client().request(**kwargs)
@@ -215,21 +271,32 @@ async def asyncio(
   *,
   client: AuthenticatedClient,
   body: AgentRequest,
+  mode: Union[None, ResponseMode, Unset] = UNSET,
 ) -> Optional[Union[AgentResponse, Any, ErrorResponse, HTTPValidationError]]:
   """Execute specific agent
 
-   Execute a specific agent type directly.
+   Execute a specific agent type directly with intelligent execution strategy.
 
   Available agents:
   - **financial**: Financial analysis, SEC filings, accounting data
   - **research**: Deep research and comprehensive analysis
   - **rag**: Fast retrieval without AI (no credits required)
 
+  **Execution Strategies (automatic):**
+  - Fast operations (<5s): Immediate synchronous response
+  - Medium operations (5-30s): SSE streaming with progress updates
+  - Long operations (>30s): Async Celery worker with operation tracking
+
+  **Response Mode Override:**
+  Use query parameter `?mode=sync|async` to override automatic strategy selection.
+
   Use this endpoint when you know which agent you want to use.
 
   Args:
       graph_id (str):
       agent_type (str):
+      mode (Union[None, ResponseMode, Unset]): Override execution mode: sync, async, stream, or
+          auto
       body (AgentRequest): Request model for agent interactions.
 
   Raises:
@@ -246,5 +313,6 @@ async def asyncio(
       agent_type=agent_type,
       client=client,
       body=body,
+      mode=mode,
     )
   ).parsed

robosystems_client/api/agent/get_agent_metadata.py

@@ -16,7 +16,7 @@ def _get_kwargs(
 ) -> dict[str, Any]:
   _kwargs: dict[str, Any] = {
     "method": "get",
-    "url": f"/v1/graphs/{graph_id}/agent/{agent_type}/metadata",
+    "url": f"/v1/graphs/{graph_id}/agent/{agent_type}",
   }
 
   return _kwargs

robosystems_client/api/agent/list_agents.py

@@ -28,7 +28,7 @@ def _get_kwargs(
 
   _kwargs: dict[str, Any] = {
     "method": "get",
-    "url": f"/v1/graphs/{graph_id}/agent/list",
+    "url": f"/v1/graphs/{graph_id}/agent",
     "params": params,
   }
 

robosystems_client/api/credits_/list_credit_transactions.py

@@ -141,7 +141,7 @@ def sync_detailed(
   No credits are consumed for viewing transaction history.
 
   Args:
-      graph_id (str):
+      graph_id (str): Graph database identifier
       transaction_type (Union[None, Unset, str]): Filter by transaction type (allocation,
           consumption, bonus, refund)
       operation_type (Union[None, Unset, str]): Filter by operation type (e.g., entity_lookup,
@@ -206,7 +206,7 @@ def sync(
   No credits are consumed for viewing transaction history.
 
   Args:
-      graph_id (str):
+      graph_id (str): Graph database identifier
       transaction_type (Union[None, Unset, str]): Filter by transaction type (allocation,
           consumption, bonus, refund)
       operation_type (Union[None, Unset, str]): Filter by operation type (e.g., entity_lookup,
@@ -266,7 +266,7 @@ async def asyncio_detailed(
   No credits are consumed for viewing transaction history.
 
   Args:
-      graph_id (str):
+      graph_id (str): Graph database identifier
       transaction_type (Union[None, Unset, str]): Filter by transaction type (allocation,
           consumption, bonus, refund)
       operation_type (Union[None, Unset, str]): Filter by operation type (e.g., entity_lookup,
@@ -329,7 +329,7 @@ async def asyncio(
   No credits are consumed for viewing transaction history.
 
   Args:
-      graph_id (str):
+      graph_id (str): Graph database identifier
       transaction_type (Union[None, Unset, str]): Filter by transaction type (allocation,
           consumption, bonus, refund)
       operation_type (Union[None, Unset, str]): Filter by operation type (e.g., entity_lookup,

robosystems_client/extensions/__init__.py

@@ -14,6 +14,14 @@ from .query_client import (
   QueryOptions,
   QueuedQueryError,
 )
+from .agent_client import (
+  AgentClient,
+  AgentResult,
+  QueuedAgentResponse,
+  AgentQueryRequest,
+  AgentOptions,
+  QueuedAgentError,
+)
 from .operation_client import (
   OperationClient,
   OperationStatus,
@@ -118,6 +126,13 @@ __all__ = [
   "QueryRequest",
   "QueryOptions",
   "QueuedQueryError",
+  # Agent Client
+  "AgentClient",
+  "AgentResult",
+  "QueuedAgentResponse",
+  "AgentQueryRequest",
+  "AgentOptions",
+  "QueuedAgentError",
   # Operation Client
   "OperationClient",
   "OperationStatus",
@@ -189,6 +204,16 @@ def stream_query(graph_id: str, query: str, parameters=None, chunk_size=None):
   return extensions.query.stream_query(graph_id, query, parameters, chunk_size)
 
 
+def agent_query(graph_id: str, message: str, context=None):
+  """Execute an agent query using the default extensions instance"""
+  return extensions.agent.query(graph_id, message, context)
+
+
+def analyze_financials(graph_id: str, message: str, on_progress=None):
+  """Execute financial agent using the default extensions instance"""
+  return extensions.agent.analyze_financials(graph_id, message, on_progress)
+
+
 # DataFrame convenience functions (if pandas is available)
 if (
   HAS_PANDAS

robosystems_client/extensions/agent_client.py

@@ -0,0 +1,526 @@
+"""Enhanced Agent Client with SSE support
+
+Provides intelligent agent execution with automatic strategy selection.
+"""
+
+from dataclasses import dataclass
+from typing import Dict, Any, Optional, Callable
+from datetime import datetime
+
+from ..api.agent.auto_select_agent import sync_detailed as auto_select_agent
+from ..api.agent.execute_specific_agent import sync_detailed as execute_specific_agent
+from ..models.agent_request import AgentRequest
+from ..models.agent_message import AgentMessage
+from .sse_client import SSEClient, SSEConfig, EventType
+
+
+@dataclass
+class AgentQueryRequest:
+  """Request object for agent queries"""
+
+  message: str
+  history: Optional[list] = None
+  context: Optional[Dict[str, Any]] = None
+  mode: Optional[str] = None  # 'quick', 'standard', 'extended', 'streaming'
+  enable_rag: Optional[bool] = None
+  force_extended_analysis: Optional[bool] = None
+
+
+@dataclass
+class AgentOptions:
+  """Options for agent execution"""
+
+  mode: Optional[str] = "auto"  # 'auto', 'sync', 'async'
+  max_wait: Optional[int] = None
+  on_progress: Optional[Callable[[str, Optional[int]], None]] = None
+
+
+@dataclass
+class AgentResult:
+  """Result from agent execution"""
+
+  content: str
+  agent_used: str
+  mode_used: str
+  metadata: Optional[Dict[str, Any]] = None
+  tokens_used: Optional[Dict[str, int]] = None
+  confidence_score: Optional[float] = None
+  execution_time: Optional[float] = None
+  timestamp: Optional[str] = None
+
+
+@dataclass
+class QueuedAgentResponse:
+  """Response when agent execution is queued"""
+
+  status: str
+  operation_id: str
+  message: str
+  sse_endpoint: Optional[str] = None
+
+
+class QueuedAgentError(Exception):
+  """Exception thrown when agent execution is queued and maxWait is 0"""
+
+  def __init__(self, queue_info: QueuedAgentResponse):
+    super().__init__("Agent execution was queued")
+    self.queue_info = queue_info
+
+
+class AgentClient:
+  """Enhanced agent client with SSE streaming support"""
+
+  def __init__(self, config: Dict[str, Any]):
+    self.config = config
+    self.base_url = config["base_url"]
+    self.headers = config.get("headers", {})
+    self.token = config.get("token")
+    self.sse_client: Optional[SSEClient] = None
+
+  def execute_query(
+    self,
+    graph_id: str,
+    request: AgentQueryRequest,
+    options: AgentOptions = None,
+  ) -> AgentResult:
+    """Execute agent query with automatic agent selection"""
+    if options is None:
+      options = AgentOptions()
+
+    # Build request data
+    agent_request = AgentRequest(
+      message=request.message,
+      history=[
+        AgentMessage(role=msg["role"], content=msg["content"])
+        for msg in (request.history or [])
+      ],
+      context=request.context,
+      mode=request.mode,
+      enable_rag=request.enable_rag,
+      force_extended_analysis=request.force_extended_analysis,
+    )
+
+    # Execute through the generated client
+    from ..client import AuthenticatedClient
+
+    if not self.token:
+      raise Exception("No API key provided. Set X-API-Key in headers.")
+
+    client = AuthenticatedClient(
+      base_url=self.base_url,
+      token=self.token,
+      prefix="",
+      auth_header_name="X-API-Key",
+      headers=self.headers,
+    )
+
+    try:
+      response = auto_select_agent(
+        graph_id=graph_id,
+        client=client,
+        body=agent_request,
+      )
+
+      # Check response type and handle accordingly
+      if hasattr(response, "parsed") and response.parsed:
+        response_data = response.parsed
+
+        # Handle both dict and attrs object responses
+        if isinstance(response_data, dict):
+          data = response_data
+        else:
+          # Response is an attrs object
+          data = response_data
+
+        # Check if this is an immediate response (sync or SSE execution)
+        has_content = False
+        if isinstance(data, dict):
+          has_content = "content" in data and "agent_used" in data
+        else:
+          has_content = hasattr(data, "content") and hasattr(data, "agent_used")
+
+        if has_content:
+          # Extract data from either dict or attrs object
+          if isinstance(data, dict):
+            return AgentResult(
+              content=data["content"],
+              agent_used=data["agent_used"],
+              mode_used=data["mode_used"],
+              metadata=data.get("metadata"),
+              tokens_used=data.get("tokens_used"),
+              confidence_score=data.get("confidence_score"),
+              execution_time=data.get("execution_time"),
+              timestamp=data.get("timestamp", datetime.now().isoformat()),
+            )
+          else:
+            # attrs object - access attributes directly
+            from ..types import UNSET
+
+            return AgentResult(
+              content=data.content if data.content is not UNSET else "",
+              agent_used=data.agent_used if data.agent_used is not UNSET else "unknown",
+              mode_used=data.mode_used.value
+              if hasattr(data.mode_used, "value")
+              else data.mode_used
+              if data.mode_used is not UNSET
+              else "standard",
+              metadata=data.metadata if data.metadata is not UNSET else None,
+              tokens_used=data.tokens_used if data.tokens_used is not UNSET else None,
+              confidence_score=data.confidence_score
+              if data.confidence_score is not UNSET
+              else None,
+              execution_time=data.execution_time
+              if data.execution_time is not UNSET
+              else None,
+              timestamp=data.timestamp
+              if hasattr(data, "timestamp") and data.timestamp is not UNSET
+              else datetime.now().isoformat(),
+            )
+
+        # Check if this is a queued response (async Celery execution)
+        is_queued = False
+        queued_response = None
+
+        if isinstance(data, dict):
+          is_queued = "operation_id" in data
+          if is_queued:
+            queued_response = QueuedAgentResponse(
+              status=data.get("status", "queued"),
+              operation_id=data["operation_id"],
+              message=data.get("message", "Agent execution queued"),
+              sse_endpoint=data.get("sse_endpoint"),
+            )
+        else:
+          is_queued = hasattr(data, "operation_id")
+          if is_queued:
+            from ..types import UNSET
+
+            queued_response = QueuedAgentResponse(
+              status=data.status if hasattr(data, "status") else "queued",
+              operation_id=data.operation_id,
+              message=data.message
+              if hasattr(data, "message") and data.message is not UNSET
+              else "Agent execution queued",
+              sse_endpoint=data.sse_endpoint
+              if hasattr(data, "sse_endpoint") and data.sse_endpoint is not UNSET
+              else None,
+            )
+
+        if is_queued and queued_response:
+          # If user doesn't want to wait, raise with queue info
+          if options.max_wait == 0:
+            raise QueuedAgentError(queued_response)
+
+          # Use SSE to monitor the operation
+          return self._wait_for_agent_completion(queued_response.operation_id, options)
+
+    except Exception as e:
+      if isinstance(e, QueuedAgentError):
+        raise
+
+      error_msg = str(e)
+      # Check for authentication errors
+      if (
+        "401" in error_msg or "403" in error_msg or "unauthorized" in error_msg.lower()
+      ):
+        raise Exception(f"Authentication failed during agent execution: {error_msg}")
+      else:
+        raise Exception(f"Agent execution failed: {error_msg}")
+
+    # Unexpected response format
+    raise Exception("Unexpected response format from agent endpoint")
+
+  def execute_agent(
+    self,
+    graph_id: str,
+    agent_type: str,
+    request: AgentQueryRequest,
+    options: AgentOptions = None,
+  ) -> AgentResult:
+    """Execute specific agent type"""
+    if options is None:
+      options = AgentOptions()
+
+    # Build request data
+    agent_request = AgentRequest(
+      message=request.message,
+      history=[
+        AgentMessage(role=msg["role"], content=msg["content"])
+        for msg in (request.history or [])
+      ],
+      context=request.context,
+      mode=request.mode,
+      enable_rag=request.enable_rag,
+      force_extended_analysis=request.force_extended_analysis,
+    )
+
+    # Execute through the generated client
+    from ..client import AuthenticatedClient
+
+    if not self.token:
+      raise Exception("No API key provided. Set X-API-Key in headers.")
+
+    client = AuthenticatedClient(
+      base_url=self.base_url,
+      token=self.token,
+      prefix="",
+      auth_header_name="X-API-Key",
+      headers=self.headers,
+    )
+
+    try:
+      response = execute_specific_agent(
+        graph_id=graph_id,
+        agent_type=agent_type,
+        client=client,
+        body=agent_request,
+      )
+
+      # Check response type and handle accordingly
+      if hasattr(response, "parsed") and response.parsed:
+        response_data = response.parsed
+
+        # Handle both dict and attrs object responses
+        if isinstance(response_data, dict):
+          data = response_data
+        else:
+          data = response_data
+
+        # Check if this is an immediate response
+        has_content = False
+        if isinstance(data, dict):
+          has_content = "content" in data and "agent_used" in data
+        else:
+          has_content = hasattr(data, "content") and hasattr(data, "agent_used")
+
+        if has_content:
+          # Extract data from either dict or attrs object
+          if isinstance(data, dict):
+            return AgentResult(
+              content=data["content"],
+              agent_used=data["agent_used"],
+              mode_used=data["mode_used"],
+              metadata=data.get("metadata"),
+              tokens_used=data.get("tokens_used"),
+              confidence_score=data.get("confidence_score"),
+              execution_time=data.get("execution_time"),
+              timestamp=data.get("timestamp", datetime.now().isoformat()),
+            )
+          else:
+            # attrs object
+            from ..types import UNSET
+
+            return AgentResult(
+              content=data.content if data.content is not UNSET else "",
+              agent_used=data.agent_used if data.agent_used is not UNSET else "unknown",
+              mode_used=data.mode_used.value
+              if hasattr(data.mode_used, "value")
+              else data.mode_used
+              if data.mode_used is not UNSET
+              else "standard",
+              metadata=data.metadata if data.metadata is not UNSET else None,
+              tokens_used=data.tokens_used if data.tokens_used is not UNSET else None,
+              confidence_score=data.confidence_score
+              if data.confidence_score is not UNSET
+              else None,
+              execution_time=data.execution_time
+              if data.execution_time is not UNSET
+              else None,
+              timestamp=data.timestamp
+              if hasattr(data, "timestamp") and data.timestamp is not UNSET
+              else datetime.now().isoformat(),
+            )
+
+        # Check if this is a queued response
+        is_queued = False
+        queued_response = None
+
+        if isinstance(data, dict):
+          is_queued = "operation_id" in data
+          if is_queued:
+            queued_response = QueuedAgentResponse(
+              status=data.get("status", "queued"),
+              operation_id=data["operation_id"],
+              message=data.get("message", "Agent execution queued"),
+              sse_endpoint=data.get("sse_endpoint"),
+            )
+        else:
+          is_queued = hasattr(data, "operation_id")
+          if is_queued:
+            from ..types import UNSET
+
+            queued_response = QueuedAgentResponse(
+              status=data.status if hasattr(data, "status") else "queued",
+              operation_id=data.operation_id,
+              message=data.message
+              if hasattr(data, "message") and data.message is not UNSET
+              else "Agent execution queued",
+              sse_endpoint=data.sse_endpoint
+              if hasattr(data, "sse_endpoint") and data.sse_endpoint is not UNSET
+              else None,
+            )
+
+        if is_queued and queued_response:
+          # If user doesn't want to wait, raise with queue info
+          if options.max_wait == 0:
+            raise QueuedAgentError(queued_response)
+
+          # Use SSE to monitor the operation
+          return self._wait_for_agent_completion(queued_response.operation_id, options)
+
+    except Exception as e:
+      if isinstance(e, QueuedAgentError):
+        raise
+
+      error_msg = str(e)
+      if (
+        "401" in error_msg or "403" in error_msg or "unauthorized" in error_msg.lower()
+      ):
+        raise Exception(f"Authentication failed during agent execution: {error_msg}")
+      else:
+        raise Exception(f"Agent execution failed: {error_msg}")
+
+    # Unexpected response format
+    raise Exception("Unexpected response format from agent endpoint")
+
+  def _wait_for_agent_completion(
+    self, operation_id: str, options: AgentOptions
+  ) -> AgentResult:
+    """Wait for agent completion and return final result"""
+    result = None
+    error = None
+    completed = False
+
+    # Set up SSE connection
+    sse_config = SSEConfig(base_url=self.base_url, headers=self.headers)
+    sse_client = SSEClient(sse_config)
+
+    def on_progress(data):
+      if options.on_progress:
+        options.on_progress(
+          data.get("message", "Processing..."), data.get("percentage")
+        )
+
+    def on_agent_started(data):
+      if options.on_progress:
+        options.on_progress(f"Agent {data.get('agent_type')} started", 0)
+
+    def on_agent_initialized(data):
+      if options.on_progress:
+        options.on_progress(f"{data.get('agent_name')} initialized", 10)
+
+    def on_agent_completed(data):
+      nonlocal result, completed
+      result = AgentResult(
+        content=data.get("content", ""),
+        agent_used=data.get("agent_used", "unknown"),
+        mode_used=data.get("mode_used", "standard"),
+        metadata=data.get("metadata"),
+        tokens_used=data.get("tokens_used"),
+        confidence_score=data.get("confidence_score"),
+        execution_time=data.get("execution_time"),
+        timestamp=data.get("timestamp", datetime.now().isoformat()),
+      )
+      completed = True
+
+    def on_completed(data):
+      nonlocal result, completed
+      if not result:
+        # Fallback to generic completion event
+        agent_result = data.get("result", data)
+        result = AgentResult(
+          content=agent_result.get("content", ""),
+          agent_used=agent_result.get("agent_used", "unknown"),
+          mode_used=agent_result.get("mode_used", "standard"),
+          metadata=agent_result.get("metadata"),
+          tokens_used=agent_result.get("tokens_used"),
+          confidence_score=agent_result.get("confidence_score"),
+          execution_time=agent_result.get("execution_time"),
+          timestamp=agent_result.get("timestamp", datetime.now().isoformat()),
+        )
+        completed = True
+
+    def on_error(err):
+      nonlocal error, completed
+      error = Exception(err.get("message", err.get("error", "Unknown error")))
+      completed = True
+
+    def on_cancelled():
+      nonlocal error, completed
+      error = Exception("Agent execution cancelled")
+      completed = True
+
+    # Register event handlers
+    sse_client.on(EventType.OPERATION_PROGRESS.value, on_progress)
+    sse_client.on("agent_started", on_agent_started)
+    sse_client.on("agent_initialized", on_agent_initialized)
+    sse_client.on("progress", on_progress)
+    sse_client.on("agent_completed", on_agent_completed)
+    sse_client.on(EventType.OPERATION_COMPLETED.value, on_completed)
+    sse_client.on(EventType.OPERATION_ERROR.value, on_error)
+    sse_client.on("error", on_error)
+    sse_client.on(EventType.OPERATION_CANCELLED.value, on_cancelled)
+
+    # Connect and wait
+    sse_client.connect(operation_id)
+
+    # Wait for completion
+    import time
+
+    while not completed:
+      if error:
+        sse_client.close()
+        raise error
+      time.sleep(0.1)
+
+    sse_client.close()
+    return result
+
+  def query(
+    self, graph_id: str, message: str, context: Dict[str, Any] = None
+  ) -> AgentResult:
+    """Convenience method for simple agent queries with auto-selection"""
+    request = AgentQueryRequest(message=message, context=context)
+    return self.execute_query(graph_id, request, AgentOptions(mode="auto"))
+
+  def analyze_financials(
+    self,
+    graph_id: str,
+    message: str,
+    on_progress: Optional[Callable[[str, Optional[int]], None]] = None,
+  ) -> AgentResult:
+    """Execute financial agent for financial analysis"""
+    request = AgentQueryRequest(message=message)
+    return self.execute_agent(
+      graph_id, "financial", request, AgentOptions(on_progress=on_progress)
+    )
+
+  def research(
+    self,
+    graph_id: str,
+    message: str,
+    on_progress: Optional[Callable[[str, Optional[int]], None]] = None,
+  ) -> AgentResult:
+    """Execute research agent for deep research"""
+    request = AgentQueryRequest(message=message)
+    return self.execute_agent(
+      graph_id, "research", request, AgentOptions(on_progress=on_progress)
+    )
+
+  def rag(
+    self,
+    graph_id: str,
+    message: str,
+    on_progress: Optional[Callable[[str, Optional[int]], None]] = None,
+  ) -> AgentResult:
+    """Execute RAG agent for fast retrieval"""
+    request = AgentQueryRequest(message=message)
+    return self.execute_agent(
+      graph_id, "rag", request, AgentOptions(on_progress=on_progress)
+    )
+
+  def close(self):
+    """Cancel any active SSE connections"""
+    if self.sse_client:
+      self.sse_client.close()
+      self.sse_client = None

robosystems_client/extensions/extensions.py

@@ -7,6 +7,7 @@ from dataclasses import dataclass
 from typing import Dict, Any, Optional, Callable
 
 from .query_client import QueryClient
+from .agent_client import AgentClient
 from .operation_client import OperationClient
 from .table_ingest_client import TableIngestClient
 from .graph_client import GraphClient
@@ -58,6 +59,7 @@ class RoboSystemsExtensions:
 
     # Initialize clients
     self.query = QueryClient(self.config)
+    self.agent = AgentClient(self.config)
     self.operations = OperationClient(self.config)
     self.tables = TableIngestClient(self.config)
     self.graphs = GraphClient(self.config)
@@ -88,6 +90,7 @@ class RoboSystemsExtensions:
   def close(self):
     """Clean up all active connections"""
     self.query.close()
+    self.agent.close()
     self.operations.close_all()
     self.tables.close()
     self.graphs.close()

robosystems_client/models/checkout_status_response.py

@@ -16,7 +16,8 @@ class CheckoutStatusResponse:
   Attributes:
       status (str): Checkout status: 'pending_payment', 'provisioning', 'completed', 'failed'
       subscription_id (str): Internal subscription ID
-      resource_id (Union[None, Unset, str]): Resource ID (graph_id or repository name) once provisioned
+      resource_id (Union[None, Unset, str]): Resource ID (graph_id for both graphs and repositories) once provisioned.
+          For repositories, this is the repository slug (e.g., 'sec')
       operation_id (Union[None, Unset, str]): SSE operation ID for monitoring provisioning progress
       error (Union[None, Unset, str]): Error message if checkout failed
   """

robosystems_client/models/create_checkout_request.py

@@ -20,7 +20,8 @@ class CreateCheckoutRequest:
   Attributes:
       plan_name (str): Billing plan name (e.g., 'kuzu-standard')
       resource_type (str): Resource type ('graph' or 'repository')
-      resource_config (CreateCheckoutRequestResourceConfig): Configuration for the resource to be provisioned
+      resource_config (CreateCheckoutRequestResourceConfig): Configuration for the resource to be provisioned. For
+          repositories: {'repository_name': 'graph_id'} where graph_id is the repository slug (e.g., 'sec')
   """
 
   plan_name: str

robosystems_client/models/create_checkout_request_resource_config.py

@@ -9,7 +9,10 @@ T = TypeVar("T", bound="CreateCheckoutRequestResourceConfig")
 
 @_attrs_define
 class CreateCheckoutRequestResourceConfig:
-  """Configuration for the resource to be provisioned"""
+  """Configuration for the resource to be provisioned. For repositories: {'repository_name': 'graph_id'} where graph_id
+  is the repository slug (e.g., 'sec')
+
+  """
 
   additional_properties: dict[str, Any] = _attrs_field(init=False, factory=dict)
 

{robosystems_client-0.2.12.dist-info → robosystems_client-0.2.13.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: robosystems-client
-Version: 0.2.12
+Version: 0.2.13
 Summary: Python Client for RoboSystems financial graph database API
 Author: RFS LLC
 License: MIT

{robosystems_client-0.2.12.dist-info → robosystems_client-0.2.13.dist-info}/RECORD

@@ -6,11 +6,11 @@ robosystems_client/sdk-config.yaml,sha256=Y_A8qSC2zHLYy6d443Rlgdkw2GleOSFjYvq_Qm
 robosystems_client/types.py,sha256=l5mTsR9GphXnb6qHvveUHNZ_GpiRMqweGNjgKmn6qXE,1349
 robosystems_client/api/__init__.py,sha256=zTSiG_ujSjAqWPyc435YXaX9XTlpMjiJWBbV-f-YtdA,45
 robosystems_client/api/agent/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
-robosystems_client/api/agent/auto_select_agent.py,sha256=LqCbvraxIRVNZj0deybh5MrihKmgDDx9LTcEyS7GJx8,11990
+robosystems_client/api/agent/auto_select_agent.py,sha256=6jiddkXrfm-JCc3E6CW0qVsSur0dfKkVeVlYttzfCqo,15096
 robosystems_client/api/agent/batch_process_queries.py,sha256=t_CSO2XTbKAFOWR-Ac8ALxu6ZmCL7ZnYOeDvTonwu2k,6785
-robosystems_client/api/agent/execute_specific_agent.py,sha256=HtwtHjYErWGRZjqnWeRGArX34Mcg-_dWgzk8onzlyQ4,6794
-robosystems_client/api/agent/get_agent_metadata.py,sha256=ZQi4EHiEDgYQRZ1-B6UGM7rlGRo7o5fY8zDhkhjkwlc,5827
-robosystems_client/api/agent/list_agents.py,sha256=w_9vFSwkGfboT0xLU2LmaU4cHuML7VoWEaWG588hv8U,6326
+robosystems_client/api/agent/execute_specific_agent.py,sha256=IqP08Vq-mpT_66i6XqRumVlGVfw4FzZzFJxdfyQkTSc,9608
+robosystems_client/api/agent/get_agent_metadata.py,sha256=CsAMH3vzVXo7KJ95zlf1oT5juLmjIWahsEmFkpG_9Kk,5818
+robosystems_client/api/agent/list_agents.py,sha256=ns_fWdfZxQlrD_IQHTIw5-tyqIxvmpnI1sXn6DgxoZo,6321
 robosystems_client/api/agent/recommend_agent.py,sha256=WK1826OQeGbLGPQX-xTzSHHVBVKLf-QtQ9gVP0ZjK7c,6689
 robosystems_client/api/auth/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
 robosystems_client/api/auth/check_password_strength.py,sha256=4oVo056LpbSGHVH733tjRdZFt0uJ_fJR7IFz1nvxB0E,4673
@@ -61,7 +61,7 @@ robosystems_client/api/credits_/check_credit_balance.py,sha256=0iPXBgsEQs_nWsZKw
 robosystems_client/api/credits_/check_storage_limits.py,sha256=mo0PRFLmwcVGjdlLBq2r02QcoVrmcH8EozV2RcFesA8,6187
 robosystems_client/api/credits_/get_credit_summary.py,sha256=-uvETiHAuFBDtzeIAc8KnRnf6irV74MnsKAWWOltZwo,6041
 robosystems_client/api/credits_/get_storage_usage.py,sha256=oFlj7Ziiopk9vXRWAtHHDCy_vtvufCNoOrtD9mkFMR0,6770
-robosystems_client/api/credits_/list_credit_transactions.py,sha256=QV4W9SMxgN24wlniCTskwamOkIJR_cIwUJK-4hPDGJ0,12218
+robosystems_client/api/credits_/list_credit_transactions.py,sha256=9Ny3tqu2nFTEa7jB8XHABxJjLL8dLPZu4ILRHcjMv9M,12322
 robosystems_client/api/graph_health/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
 robosystems_client/api/graph_health/get_database_health.py,sha256=aEUYDiUMQ-paxRrABb9xY3dgs_mW7loyTuz5Y4oX790,7318
 robosystems_client/api/graph_info/__init__.py,sha256=5vd9uJWAjRqa9xzxzYkLD1yoZ12Ld_bAaNB5WX4fbE8,56
@@ -137,10 +137,11 @@ robosystems_client/api/user/update_user.py,sha256=nSr6ZRKD_Wu1I_QwHWd9GGH1TLYluM
 robosystems_client/api/user/update_user_api_key.py,sha256=kIccWO3m6t7S6MNCQNndASq533nou-zhF9qg9sNrrZM,4688
 robosystems_client/api/user/update_user_password.py,sha256=djtS4Aqc0B2efYlqYhAwLyaQ8R1sTIkSP5XPMas5va0,5015
 robosystems_client/extensions/README.md,sha256=qfHFjdgA_J-zNXziNZE6M1MKJiwVkocBi01w_HhvzEk,16136
-robosystems_client/extensions/__init__.py,sha256=izFk2oW08XUKLAulpMwQS_4PrbhL_zsjVdXBiPx-XiU,5210
+robosystems_client/extensions/__init__.py,sha256=XYec7cxFRVLtTAG25MCHtg8Th9m5FsBb5J7q-aediK4,5900
+robosystems_client/extensions/agent_client.py,sha256=Db2C4hrakVsf6ScnBcNk6rte3Kwn4cQBEHsR_joWMTs,17750
 robosystems_client/extensions/auth_integration.py,sha256=ABOJ8aVjfHehNGNzim1iR9-Cdh7Mr22ce-WgWWeqJt0,6535
 robosystems_client/extensions/dataframe_utils.py,sha256=gK1bgkVqBF0TvWVdGQvqWrt-ur_Rw11j8uNtMoulLWE,12312
-robosystems_client/extensions/extensions.py,sha256=ROnCobUek4Dke9dVx2sTzNKhz309NOG40EDSYHtNmWs,6257
+robosystems_client/extensions/extensions.py,sha256=QkKIc6cU7uJ5unvH5bdrvq8RuAraqGHh7eY7wpwMVy8,6360
 robosystems_client/extensions/graph_client.py,sha256=OBi0xj0SLIRKLeSu_DiGt2ZakCmhggvNrMP3jdRfEgQ,10326
 robosystems_client/extensions/operation_client.py,sha256=B1qju-wWQrnrnVJixKGgsA_KEInviwJwdlJxzm_i7P0,13359
 robosystems_client/extensions/query_client.py,sha256=cX3e8EBoTeg4Lwm6edJYRULM2UmGpfqNX3f48S8TQbE,19430
@@ -196,7 +197,7 @@ robosystems_client/models/cancel_operation_response_canceloperation.py,sha256=ba
 robosystems_client/models/cancellation_response.py,sha256=2URj3ukcdjh5UvPpnSauP_CLz-9TLM4Il20MYBzzfTw,1955
 robosystems_client/models/check_credit_balance_response_checkcreditbalance.py,sha256=izJJIZJaZkfJY7pqYg7nBPEv9IgRpJ5WSw6hu7VUZEk,1304
 robosystems_client/models/checkout_response.py,sha256=NxmvkrjQrSGzhf3qCUILxw6KLezt_pS4TSGo8IyfRpM,4162
-robosystems_client/models/checkout_status_response.py,sha256=jA1197K_GlPPK3kFyntZ6SuXdgF2DyR0PBrn4MagiaY,3792
+robosystems_client/models/checkout_status_response.py,sha256=_XDA5ahmEwYyQJ7YDs253fp5U6g_RKkfBkk6K3F5osA,3877
 robosystems_client/models/connection_options_response.py,sha256=J-VjmGYJn_BOhuExZBlJIHXedyf_CXcoRf2XfklOnrk,2309
 robosystems_client/models/connection_provider_info.py,sha256=Im0k56k1USElC9G5m2g7elOJ5CHZ08lDOLg5vOmx_AA,6600
 robosystems_client/models/connection_provider_info_auth_type.py,sha256=cSRUkd90osfbj2MP5Hl8dinEoIXBPrCOIFGYYrk-4D0,201
@@ -207,8 +208,8 @@ robosystems_client/models/connection_response_provider.py,sha256=th7b2inab-PZWaQ
 robosystems_client/models/copy_operation_limits.py,sha256=S0j8lPVghl-ih5xI-oCHK1hBRZf7SeE7FiZEMjuXzEA,3059
 robosystems_client/models/create_api_key_request.py,sha256=aP-X8CtffeRUXDqG-WzM4gn8_DOwPt5CURmGYIbjgqY,2829
 robosystems_client/models/create_api_key_response.py,sha256=9cqlZDogqxdSXxxHT6PnfClTP-Q35CvfQjNIvPEe1Pw,1797
-robosystems_client/models/create_checkout_request.py,sha256=c5FjtddJ2vnzQxaDOhfNO34ZrqSuswoPjXYdVq-us04,2439
-robosystems_client/models/create_checkout_request_resource_config.py,sha256=J76EoSg2Pdz1741GwzAVfV9TrWzXJmAQCZnpdz76akc,1306
+robosystems_client/models/create_checkout_request.py,sha256=NoiSMuFMG24iMipMTwy34PnYyEt1x9fNauEVatIB1-s,2552
+robosystems_client/models/create_checkout_request_resource_config.py,sha256=-gYfuQmp61mGggvvMZe4t1YGl9CDuIN0_O49ONbz-qs,1415
 robosystems_client/models/create_connection_request.py,sha256=B9riNF1QK1P3RB680lFAJGsZtYbPHVc14u1TBnIv0QQ,5948
 robosystems_client/models/create_connection_request_provider.py,sha256=TBZm3ApK31i1jit4WUxqtFtJq-LYKqXeVAHJIJh9Slw,190
 robosystems_client/models/create_graph_request.py,sha256=THs5EEB8-cpfkyDUu0XzwuWMnScboE_ir3vrQ44mPJY,6174
@@ -392,7 +393,7 @@ robosystems_client/models/upgrade_subscription_request.py,sha256=Ph-Wu1pA6zOEi6j
 robosystems_client/models/user_graphs_response.py,sha256=k4zDipn-9HqwiJHUq8Si1XSemCDJv_t9SfTtJxc6w_k,2648
 robosystems_client/models/user_response.py,sha256=uMYsvPKLo5YUwsT-PV8Tu5qrFG81X8-ODBllFyX2C6E,3650
 robosystems_client/models/validation_error.py,sha256=R77OuQG2nJ3WDFfY--xbEhg6x1D7gAAp_1UdnG8Ka2A,1949
-robosystems_client-0.2.12.dist-info/METADATA,sha256=X9sdwC35xr9TCGACrEQMT7_Eh_cboFa_xulAfJq3P8U,3904
-robosystems_client-0.2.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-robosystems_client-0.2.12.dist-info/licenses/LICENSE,sha256=LjFqQPU4eQh7jAQ04SmE9eC0j74HCdXvzbo0hjW4mWo,1063
-robosystems_client-0.2.12.dist-info/RECORD,,
+robosystems_client-0.2.13.dist-info/METADATA,sha256=TYN9PHsu7MNUQJJ2lfmtnnR26gvDE914orgzefglUN4,3904
+robosystems_client-0.2.13.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+robosystems_client-0.2.13.dist-info/licenses/LICENSE,sha256=LjFqQPU4eQh7jAQ04SmE9eC0j74HCdXvzbo0hjW4mWo,1063
+robosystems_client-0.2.13.dist-info/RECORD,,