polyaxon 2.0.0rc49__py3-none-any.whl → 2.4.0rc1__py3-none-any.whl

polyaxon/_sdk/api/agents_v1_api.py

@@ -1,4 +1,4 @@
-from typing import Optional
+from typing import Dict, Optional
 from typing_extensions import Annotated
 
 from clipped.compact.pydantic import Field, StrictInt, StrictStr, validate_arguments
@@ -6,14 +6,189 @@ from clipped.compact.pydantic import Field, StrictInt, StrictStr, validate_argum
 from polyaxon._schemas.lifecycle import V1Status
 from polyaxon._sdk.base_api import BaseApi
 from polyaxon._sdk.schemas.v1_agent import V1Agent
+from polyaxon._sdk.schemas.v1_agent_reconcile_body_request import (
+    V1AgentReconcileBodyRequest,
+)
 from polyaxon._sdk.schemas.v1_agent_state_response import V1AgentStateResponse
 from polyaxon._sdk.schemas.v1_agent_status_body_request import V1AgentStatusBodyRequest
 from polyaxon._sdk.schemas.v1_list_agents_response import V1ListAgentsResponse
 from polyaxon._sdk.schemas.v1_token import V1Token
 from polyaxon.exceptions import ApiTypeError
+from traceml.logging import V1Logs
 
 
 class AgentsV1Api(BaseApi):
+    @validate_arguments
+    def collect_agent_data(
+        self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        **kwargs
+    ) -> object:  # noqa: E501
+        """collect agent  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.collect_agent_data(namespace, owner, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param namespace: namespace (required)
+        :type namespace: str
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: object
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.collect_agent_data_with_http_info(
+            namespace, owner, uuid, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def collect_agent_data_with_http_info(
+        self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        **kwargs
+    ):  # noqa: E501
+        """collect agent  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.collect_agent_data_with_http_info(namespace, owner, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param namespace: namespace (required)
+        :type namespace: str
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["namespace", "owner", "uuid"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method collect_agent_data" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["namespace"]:
+            _path_params["namespace"] = _params["namespace"]
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "object",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/internal/v1/{namespace}/{owner}/agents/{uuid}/collect",
+            "POST",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
     @validate_arguments
     def create_agent(
         self,
@@ -905,26 +1080,47 @@ class AgentsV1Api(BaseApi):
         )
 
     @validate_arguments
-    def get_agent_state(
+    def get_agent_logs(
         self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         uuid: Annotated[
             StrictStr, Field(..., description="Uuid identifier of the entity")
         ],
+        service: Annotated[Optional[StrictStr], Field(description="Service.")] = None,
+        last_file: Annotated[
+            Optional[StrictStr], Field(description="last_file.")
+        ] = None,
+        force: Annotated[
+            Optional[bool], Field(description="Force query param.")
+        ] = None,
+        connection: Annotated[
+            Optional[StrictStr], Field(description="Connection to use.")
+        ] = None,
         **kwargs
-    ) -> V1AgentStateResponse:  # noqa: E501
-        """Get State (queues/runs)  # noqa: E501
+    ) -> V1Logs:  # noqa: E501
+        """Get run logs  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_agent_state(owner, uuid, async_req=True)
+        >>> thread = api.get_agent_logs(namespace, owner, uuid, service, last_file, force, connection, async_req=True)
         >>> result = thread.get()
 
+        :param namespace: namespace (required)
+        :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
         :param uuid: Uuid identifier of the entity (required)
         :type uuid: str
+        :param service: Service.
+        :type service: str
+        :param last_file: last_file.
+        :type last_file: str
+        :param force: Force query param.
+        :type force: bool
+        :param connection: Connection to use.
+        :type connection: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -938,32 +1134,55 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: V1AgentStateResponse
+        :rtype: V1Logs
         """
         kwargs["_return_http_data_only"] = True
-        return self.get_agent_state_with_http_info(owner, uuid, **kwargs)  # noqa: E501
+        return self.get_agent_logs_with_http_info(
+            namespace, owner, uuid, service, last_file, force, connection, **kwargs
+        )  # noqa: E501
 
     @validate_arguments
-    def get_agent_state_with_http_info(
+    def get_agent_logs_with_http_info(
         self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         uuid: Annotated[
             StrictStr, Field(..., description="Uuid identifier of the entity")
         ],
+        service: Annotated[Optional[StrictStr], Field(description="Service.")] = None,
+        last_file: Annotated[
+            Optional[StrictStr], Field(description="last_file.")
+        ] = None,
+        force: Annotated[
+            Optional[bool], Field(description="Force query param.")
+        ] = None,
+        connection: Annotated[
+            Optional[StrictStr], Field(description="Connection to use.")
+        ] = None,
         **kwargs
     ):  # noqa: E501
-        """Get State (queues/runs)  # noqa: E501
+        """Get run logs  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_agent_state_with_http_info(owner, uuid, async_req=True)
+        >>> thread = api.get_agent_logs_with_http_info(namespace, owner, uuid, service, last_file, force, connection, async_req=True)
         >>> result = thread.get()
 
+        :param namespace: namespace (required)
+        :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
         :param uuid: Uuid identifier of the entity (required)
         :type uuid: str
+        :param service: Service.
+        :type service: str
+        :param last_file: last_file.
+        :type last_file: str
+        :param force: Force query param.
+        :type force: bool
+        :param connection: Connection to use.
+        :type connection: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _return_http_data_only: response data without head status code
@@ -985,12 +1204,20 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(V1AgentStateResponse, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(V1Logs, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
-        _all_params = ["owner", "uuid"]
+        _all_params = [
+            "namespace",
+            "owner",
+            "uuid",
+            "service",
+            "last_file",
+            "force",
+            "connection",
+        ]
         _all_params.extend(
             [
                 "async_req",
@@ -1008,7 +1235,7 @@ class AgentsV1Api(BaseApi):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_agent_state" % _key
+                    " to method get_agent_logs" % _key
                 )
             _params[_key] = _val
         del _params["kwargs"]
@@ -1017,6 +1244,8 @@ class AgentsV1Api(BaseApi):
 
         # process the path parameters
         _path_params = {}
+        if _params["namespace"]:
+            _path_params["namespace"] = _params["namespace"]
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
         if _params["uuid"]:
@@ -1024,17 +1253,22 @@ class AgentsV1Api(BaseApi):
 
         # process the query parameters
         _query_params = []
+        if _params.get("service") is not None:  # noqa: E501
+            _query_params.append(("service", _params["service"]))
+        if _params.get("last_file") is not None:  # noqa: E501
+            _query_params.append(("last_file", _params["last_file"]))
+        if _params.get("force") is not None:  # noqa: E501
+            _query_params.append(("force", _params["force"]))
+        if _params.get("connection") is not None:  # noqa: E501
+            _query_params.append(("connection", _params["connection"]))
 
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -1044,14 +1278,14 @@ class AgentsV1Api(BaseApi):
         _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {
-            "200": "V1AgentStateResponse",
+            "200": "V1Logs",
             "204": "object",
             "403": "object",
             "404": "object",
         }
 
         return self.api_client.call_api(
-            "/api/v1/orgs/{owner}/agents/{uuid}/state",
+            "/streams/v1/{namespace}/{owner}/agents/{uuid}/logs",
             "GET",
             _path_params,
             _query_params,
@@ -1070,20 +1304,20 @@ class AgentsV1Api(BaseApi):
         )
 
     @validate_arguments
-    def get_agent_token(
+    def get_agent_state(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
         uuid: Annotated[
             StrictStr, Field(..., description="Uuid identifier of the entity")
         ],
         **kwargs
-    ) -> V1Token:  # noqa: E501
-        """Get agent token  # noqa: E501
+    ) -> V1AgentStateResponse:  # noqa: E501
+        """Get State (queues/runs)  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_agent_token(owner, uuid, async_req=True)
+        >>> thread = api.get_agent_state(owner, uuid, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
@@ -1103,32 +1337,531 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: V1Token
+        :rtype: V1AgentStateResponse
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.get_agent_state_with_http_info(owner, uuid, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_agent_state_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        **kwargs
+    ):  # noqa: E501
+        """Get State (queues/runs)  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_agent_state_with_http_info(owner, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(V1AgentStateResponse, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "uuid"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_agent_state" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+
+        # process the form parameters
+        _form_params = []
+        _files = {}
+
+        # process the body parameter
+        _body_params = None
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "V1AgentStateResponse",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/api/v1/orgs/{owner}/agents/{uuid}/state",
+            "GET",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def get_agent_statuses(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        entity: Annotated[
+            Optional[StrictStr],
+            Field(description="Entity: project name, hub name, registry name, ..."),
+        ] = None,
+        **kwargs
+    ) -> V1Status:  # noqa: E501
+        """Get Agent statuses  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_agent_statuses(owner, uuid, entity, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param entity: Entity: project name, hub name, registry name, ...
+        :type entity: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: V1Status
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.get_agent_statuses_with_http_info(
+            owner, uuid, entity, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def get_agent_statuses_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the sub-entity")
+        ],
+        entity: Annotated[
+            Optional[StrictStr],
+            Field(description="Entity: project name, hub name, registry name, ..."),
+        ] = None,
+        **kwargs
+    ):  # noqa: E501
+        """Get Agent statuses  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_agent_statuses_with_http_info(owner, uuid, entity, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the sub-entity (required)
+        :type uuid: str
+        :param entity: Entity: project name, hub name, registry name, ...
+        :type entity: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(V1Status, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "uuid", "entity"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_agent_statuses" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+        if _params.get("entity") is not None:  # noqa: E501
+            _query_params.append(("entity", _params["entity"]))
+
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "V1Status",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/api/v1/orgs/{owner}/agents/{uuid}/statuses",
+            "GET",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def get_agent_token(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        **kwargs
+    ) -> V1Token:  # noqa: E501
+        """Get agent token  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_agent_token(owner, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: V1Token
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.get_agent_token_with_http_info(owner, uuid, **kwargs)  # noqa: E501
+
+    @validate_arguments
+    def get_agent_token_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        **kwargs
+    ):  # noqa: E501
+        """Get agent token  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_agent_token_with_http_info(owner, uuid, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: tuple(V1Token, status_code(int), headers(HTTPHeaderDict))
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "uuid"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method get_agent_token" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+
+        # process the form parameters
+        _form_params = []
+        _files = {}
+
+        # process the body parameter
+        _body_params = None
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "V1Token",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/api/v1/orgs/{owner}/agents/{uuid}/token",
+            "GET",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
+    @validate_arguments
+    def get_global_state(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        **kwargs
+    ) -> V1AgentStateResponse:  # noqa: E501
+        """Get Global State (queues/runs)  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.get_global_state(owner, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: V1AgentStateResponse
         """
         kwargs["_return_http_data_only"] = True
-        return self.get_agent_token_with_http_info(owner, uuid, **kwargs)  # noqa: E501
+        return self.get_global_state_with_http_info(owner, **kwargs)  # noqa: E501
 
     @validate_arguments
-    def get_agent_token_with_http_info(
+    def get_global_state_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        uuid: Annotated[
-            StrictStr, Field(..., description="Uuid identifier of the entity")
-        ],
         **kwargs
     ):  # noqa: E501
-        """Get agent token  # noqa: E501
+        """Get Global State (queues/runs)  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_agent_token_with_http_info(owner, uuid, async_req=True)
+        >>> thread = api.get_global_state_with_http_info(owner, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param uuid: Uuid identifier of the entity (required)
-        :type uuid: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _return_http_data_only: response data without head status code
@@ -1150,12 +1883,12 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(V1Token, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(V1AgentStateResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
-        _all_params = ["owner", "uuid"]
+        _all_params = ["owner"]
         _all_params.extend(
             [
                 "async_req",
@@ -1173,7 +1906,7 @@ class AgentsV1Api(BaseApi):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_agent_token" % _key
+                    " to method get_global_state" % _key
                 )
             _params[_key] = _val
         del _params["kwargs"]
@@ -1184,22 +1917,16 @@ class AgentsV1Api(BaseApi):
         _path_params = {}
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
-        if _params["uuid"]:
-            _path_params["uuid"] = _params["uuid"]
 
         # process the query parameters
         _query_params = []
-
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
-
         # process the form parameters
         _form_params = []
         _files = {}
-
         # process the body parameter
         _body_params = None
-
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
@@ -1209,14 +1936,14 @@ class AgentsV1Api(BaseApi):
         _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {
-            "200": "V1Token",
+            "200": "V1AgentStateResponse",
             "204": "object",
             "403": "object",
             "404": "object",
         }
 
         return self.api_client.call_api(
-            "/api/v1/orgs/{owner}/agents/{uuid}/token",
+            "/api/v1/orgs/{owner}/agents/state",
             "GET",
             _path_params,
             _query_params,
@@ -1235,21 +1962,47 @@ class AgentsV1Api(BaseApi):
         )
 
     @validate_arguments
-    def get_global_state(
+    def inspect_agent(
         self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        service: Annotated[Optional[StrictStr], Field(description="Service.")] = None,
+        last_file: Annotated[
+            Optional[StrictStr], Field(description="last_file.")
+        ] = None,
+        force: Annotated[
+            Optional[bool], Field(description="Force query param.")
+        ] = None,
+        connection: Annotated[
+            Optional[StrictStr], Field(description="Connection to use.")
+        ] = None,
         **kwargs
-    ) -> V1AgentStateResponse:  # noqa: E501
-        """Get Global State (queues/runs)  # noqa: E501
+    ) -> object:  # noqa: E501
+        """Inspect an agent's service full conditions  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_global_state(owner, async_req=True)
+        >>> thread = api.inspect_agent(namespace, owner, uuid, service, last_file, force, connection, async_req=True)
         >>> result = thread.get()
 
+        :param namespace: namespace (required)
+        :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param service: Service.
+        :type service: str
+        :param last_file: last_file.
+        :type last_file: str
+        :param force: Force query param.
+        :type force: bool
+        :param connection: Connection to use.
+        :type connection: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -1263,27 +2016,55 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: V1AgentStateResponse
+        :rtype: object
         """
         kwargs["_return_http_data_only"] = True
-        return self.get_global_state_with_http_info(owner, **kwargs)  # noqa: E501
+        return self.inspect_agent_with_http_info(
+            namespace, owner, uuid, service, last_file, force, connection, **kwargs
+        )  # noqa: E501
 
     @validate_arguments
-    def get_global_state_with_http_info(
+    def inspect_agent_with_http_info(
         self,
+        namespace: Annotated[StrictStr, Field(..., description="namespace")],
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        service: Annotated[Optional[StrictStr], Field(description="Service.")] = None,
+        last_file: Annotated[
+            Optional[StrictStr], Field(description="last_file.")
+        ] = None,
+        force: Annotated[
+            Optional[bool], Field(description="Force query param.")
+        ] = None,
+        connection: Annotated[
+            Optional[StrictStr], Field(description="Connection to use.")
+        ] = None,
         **kwargs
     ):  # noqa: E501
-        """Get Global State (queues/runs)  # noqa: E501
+        """Inspect an agent's service full conditions  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.get_global_state_with_http_info(owner, async_req=True)
+        >>> thread = api.inspect_agent_with_http_info(namespace, owner, uuid, service, last_file, force, connection, async_req=True)
         >>> result = thread.get()
 
+        :param namespace: namespace (required)
+        :type namespace: str
         :param owner: Owner of the namespace (required)
         :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param service: Service.
+        :type service: str
+        :param last_file: last_file.
+        :type last_file: str
+        :param force: Force query param.
+        :type force: bool
+        :param connection: Connection to use.
+        :type connection: str
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _return_http_data_only: response data without head status code
@@ -1305,12 +2086,20 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: tuple(V1AgentStateResponse, status_code(int), headers(HTTPHeaderDict))
+        :rtype: tuple(object, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
-        _all_params = ["owner"]
+        _all_params = [
+            "namespace",
+            "owner",
+            "uuid",
+            "service",
+            "last_file",
+            "force",
+            "connection",
+        ]
         _all_params.extend(
             [
                 "async_req",
@@ -1328,7 +2117,7 @@ class AgentsV1Api(BaseApi):
             if _key not in _all_params:
                 raise ApiTypeError(
                     "Got an unexpected keyword argument '%s'"
-                    " to method get_global_state" % _key
+                    " to method inspect_agent" % _key
                 )
             _params[_key] = _val
         del _params["kwargs"]
@@ -1337,11 +2126,24 @@ class AgentsV1Api(BaseApi):
 
         # process the path parameters
         _path_params = {}
+        if _params["namespace"]:
+            _path_params["namespace"] = _params["namespace"]
         if _params["owner"]:
             _path_params["owner"] = _params["owner"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
 
         # process the query parameters
         _query_params = []
+        if _params.get("service") is not None:  # noqa: E501
+            _query_params.append(("service", _params["service"]))
+        if _params.get("last_file") is not None:  # noqa: E501
+            _query_params.append(("last_file", _params["last_file"]))
+        if _params.get("force") is not None:  # noqa: E501
+            _query_params.append(("force", _params["force"]))
+        if _params.get("connection") is not None:  # noqa: E501
+            _query_params.append(("connection", _params["connection"]))
+
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
         # process the form parameters
@@ -1358,14 +2160,14 @@ class AgentsV1Api(BaseApi):
         _auth_settings = ["ApiKey"]  # noqa: E501
 
         _response_types_map = {
-            "200": "V1AgentStateResponse",
+            "200": "object",
             "204": "object",
             "403": "object",
             "404": "object",
         }
 
         return self.api_client.call_api(
-            "/api/v1/orgs/{owner}/agents/state",
+            "/streams/v1/{namespace}/{owner}/agents/{uuid}/k8s_inspect",
             "GET",
             _path_params,
             _query_params,
@@ -2046,7 +2848,7 @@ class AgentsV1Api(BaseApi):
     def patch_agent_token(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[StrictStr, Field(..., description="Rntity")],
+        entity: Annotated[StrictStr, Field(..., description="Entity")],
         body: Annotated[V1Token, Field(..., description="Token body")],
         **kwargs
     ) -> V1Token:  # noqa: E501
@@ -2060,7 +2862,7 @@ class AgentsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Rntity (required)
+        :param entity: Entity (required)
         :type entity: str
         :param body: Token body (required)
         :type body: V1Token
@@ -2088,7 +2890,7 @@ class AgentsV1Api(BaseApi):
     def patch_agent_token_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[StrictStr, Field(..., description="Rntity")],
+        entity: Annotated[StrictStr, Field(..., description="Entity")],
         body: Annotated[V1Token, Field(..., description="Token body")],
         **kwargs
     ):  # noqa: E501
@@ -2102,7 +2904,7 @@ class AgentsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Rntity (required)
+        :param entity: Entity (required)
         :type entity: str
         :param body: Token body (required)
         :type body: V1Token
@@ -2221,6 +3023,186 @@ class AgentsV1Api(BaseApi):
             _request_auth=_params.get("_request_auth"),
         )
 
+    @validate_arguments
+    def reconcile_agent(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        body: V1AgentReconcileBodyRequest,
+        **kwargs
+    ) -> object:  # noqa: E501
+        """Reconcile agent  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.reconcile_agent(owner, uuid, body, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param body: (required)
+        :type body: V1AgentReconcileBodyRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: object
+        """
+        kwargs["_return_http_data_only"] = True
+        return self.reconcile_agent_with_http_info(
+            owner, uuid, body, **kwargs
+        )  # noqa: E501
+
+    @validate_arguments
+    def reconcile_agent_with_http_info(
+        self,
+        owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        uuid: Annotated[
+            StrictStr, Field(..., description="Uuid identifier of the entity")
+        ],
+        body: V1AgentReconcileBodyRequest,
+        **kwargs
+    ):  # noqa: E501
+        """Reconcile agent  # noqa: E501
+
+        This method makes a synchronous HTTP request by default. To make an
+        asynchronous HTTP request, please pass async_req=True
+
+        >>> thread = api.reconcile_agent_with_http_info(owner, uuid, body, async_req=True)
+        >>> result = thread.get()
+
+        :param owner: Owner of the namespace (required)
+        :type owner: str
+        :param uuid: Uuid identifier of the entity (required)
+        :type uuid: str
+        :param body: (required)
+        :type body: V1AgentReconcileBodyRequest
+        :param async_req: Whether to execute the request asynchronously.
+        :type async_req: bool, optional
+        :param _return_http_data_only: response data without head status code
+                                       and headers
+        :type _return_http_data_only: bool, optional
+        :param _preload_content: if False, the urllib3.HTTPResponse object will
+                                 be returned without reading/decoding response
+                                 data. Default is True.
+        :type _preload_content: bool, optional
+        :param _request_timeout: timeout setting for this request. If one
+                                 number provided, it will be total request
+                                 timeout. It can also be a pair (tuple) of
+                                 (connection, read) timeouts.
+        :param _request_auth: set to override the auth_settings for an a single
+                              request; this effectively ignores the authentication
+                              in the spec for a single request.
+        :type _request_auth: dict, optional
+        :type _content_type: string, optional: force content-type for the request
+        :return: Returns the result object.
+                 If the method is called asynchronously,
+                 returns the request thread.
+        :rtype: None
+        """
+
+        _params = locals()
+
+        _all_params = ["owner", "uuid", "body"]
+        _all_params.extend(
+            [
+                "async_req",
+                "_return_http_data_only",
+                "_preload_content",
+                "_request_timeout",
+                "_request_auth",
+                "_content_type",
+                "_headers",
+            ]
+        )
+
+        # validate the arguments
+        for _key, _val in _params["kwargs"].items():
+            if _key not in _all_params:
+                raise ApiTypeError(
+                    "Got an unexpected keyword argument '%s'"
+                    " to method reconcile_agent" % _key
+                )
+            _params[_key] = _val
+        del _params["kwargs"]
+
+        _collection_formats = {}
+
+        # process the path parameters
+        _path_params = {}
+        if _params["owner"]:
+            _path_params["owner"] = _params["owner"]
+        if _params["uuid"]:
+            _path_params["uuid"] = _params["uuid"]
+
+        # process the query parameters
+        _query_params = []
+        # process the header parameters
+        _header_params = dict(_params.get("_headers", {}))
+        # process the form parameters
+        _form_params = []
+        _files = {}
+        # process the body parameter
+        _body_params = None
+        if _params["body"]:
+            _body_params = _params["body"]
+
+        # set the HTTP header `Accept`
+        _header_params["Accept"] = self.api_client.select_header_accept(
+            ["application/json"]
+        )  # noqa: E501
+
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get(
+            "_content_type",
+            self.api_client.select_header_content_type(["application/json"]),
+        )
+        if _content_types_list:
+            _header_params["Content-Type"] = _content_types_list
+
+        # authentication setting
+        _auth_settings = ["ApiKey"]  # noqa: E501
+
+        _response_types_map = {
+            "200": "V1Agent",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
+
+        return self.api_client.call_api(
+            "/api/v1/orgs/{owner}/agents/{uuid}/reconcile",
+            "PATCH",
+            _path_params,
+            _query_params,
+            _header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            response_types_map=_response_types_map,
+            auth_settings=_auth_settings,
+            async_req=_params.get("async_req"),
+            _return_http_data_only=_params.get("_return_http_data_only"),  # noqa: E501
+            _preload_content=_params.get("_preload_content", True),
+            _request_timeout=_params.get("_request_timeout"),
+            collection_formats=_collection_formats,
+            _request_auth=_params.get("_request_auth"),
+        )
+
     @validate_arguments
     def sync_agent(
         self,
@@ -2399,18 +3381,21 @@ class AgentsV1Api(BaseApi):
     def cron_agent(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        body: Annotated[Optional[Dict], Field(..., description="Cron body")] = None,
         **kwargs
-    ) -> None:  # noqa: E501
+    ) -> V1AgentStateResponse:  # noqa: E501
         """Global Cron agent  # noqa: E501
 
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.cron_agent(owner, async_req=True)
+        >>> thread = api.cron_agent(owner, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
+        :param body: Cron body (required)
+        :type body: object
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _preload_content: if False, the urllib3.HTTPResponse object will
@@ -2424,15 +3409,16 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: None
+        :rtype: V1AgentStateResponse
         """
         kwargs["_return_http_data_only"] = True
-        return self.cron_agent_with_http_info(owner, **kwargs)  # noqa: E501
+        return self.cron_agent_with_http_info(owner, body, **kwargs)  # noqa: E501
 
     @validate_arguments
     def cron_agent_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
+        body: Annotated[Optional[Dict], Field(..., description="Cron body")] = None,
         **kwargs
     ):  # noqa: E501
         """Cron agent  # noqa: E501
@@ -2440,11 +3426,13 @@ class AgentsV1Api(BaseApi):
         This method makes a synchronous HTTP request by default. To make an
         asynchronous HTTP request, please pass async_req=True
 
-        >>> thread = api.cron_agent_with_http_info(owner, async_req=True)
+        >>> thread = api.cron_agent_with_http_info(owner, body, async_req=True)
         >>> result = thread.get()
 
         :param owner: Owner of the namespace (required)
         :type owner: str
+        :param body: Cron body (required)
+        :type body: object
         :param async_req: Whether to execute the request asynchronously.
         :type async_req: bool, optional
         :param _return_http_data_only: response data without head status code
@@ -2466,12 +3454,12 @@ class AgentsV1Api(BaseApi):
         :return: Returns the result object.
                  If the method is called asynchronously,
                  returns the request thread.
-        :rtype: None
+        :rtype: tuple(V1AgentStateResponse, status_code(int), headers(HTTPHeaderDict))
         """
 
         _params = locals()
 
-        _all_params = ["owner"]
+        _all_params = ["owner", "body"]
         _all_params.extend(
             [
                 "async_req",
@@ -2510,15 +3498,30 @@ class AgentsV1Api(BaseApi):
         _files = {}
         # process the body parameter
         _body_params = None
+        if _params["body"]:
+            _body_params = _params["body"]
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.api_client.select_header_accept(
             ["application/json"]
         )  # noqa: E501
 
+        # set the HTTP header `Content-Type`
+        _content_types_list = _params.get(
+            "_content_type",
+            self.api_client.select_header_content_type(["application/json"]),
+        )
+        if _content_types_list:
+            _header_params["Content-Type"] = _content_types_list
+
         # authentication setting
         _auth_settings = ["ApiKey"]  # noqa: E501
 
-        _response_types_map = {}
+        _response_types_map = {
+            "200": "V1AgentStateResponse",
+            "204": "object",
+            "403": "object",
+            "404": "object",
+        }
 
         return self.api_client.call_api(
             "/api/v1/orgs/{owner}/agents/cron",
@@ -2901,7 +3904,7 @@ class AgentsV1Api(BaseApi):
     def update_agent_token(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[StrictStr, Field(..., description="Rntity")],
+        entity: Annotated[StrictStr, Field(..., description="Entity")],
         body: Annotated[V1Token, Field(..., description="Token body")],
         **kwargs
     ) -> V1Token:  # noqa: E501
@@ -2915,7 +3918,7 @@ class AgentsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Rntity (required)
+        :param entity: Entity (required)
         :type entity: str
         :param body: Token body (required)
         :type body: V1Token
@@ -2943,7 +3946,7 @@ class AgentsV1Api(BaseApi):
     def update_agent_token_with_http_info(
         self,
         owner: Annotated[StrictStr, Field(..., description="Owner of the namespace")],
-        entity: Annotated[StrictStr, Field(..., description="Rntity")],
+        entity: Annotated[StrictStr, Field(..., description="Entity")],
         body: Annotated[V1Token, Field(..., description="Token body")],
         **kwargs
     ):  # noqa: E501
@@ -2957,7 +3960,7 @@ class AgentsV1Api(BaseApi):
 
         :param owner: Owner of the namespace (required)
         :type owner: str
-        :param entity: Rntity (required)
+        :param entity: Entity (required)
         :type entity: str
         :param body: Token body (required)
         :type body: V1Token