ksapi 3.5.2__tar.gz → 3.6.0__tar.gz

{ksapi-3.5.2 → ksapi-3.6.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ksapi
-Version: 3.5.2
+Version: 3.6.0
 Summary: Knowledge Stack API
 Home-page: 
 Author: OpenAPI Generator community

{ksapi-3.5.2 → ksapi-3.6.0}/ksapi/__init__.py

@@ -14,11 +14,12 @@
 """  # noqa: E501
 
 
-__version__ = "3.5.2"
+__version__ = "3.6.0"
 
 # Define package exports
 __all__ = [
     "AgentApi",
+    "DiagnosticsApi",
     "FeedbackApi",
     "MemoryApi",
     "SkillsApi",
@@ -173,6 +174,10 @@ __all__ = [
     "DataSourceSyncResponse",
     "DataSourceTableResponse",
     "DefinitionOutputStat",
+    "DiagnosticTraceFailureReason",
+    "DiagnosticTraceItem",
+    "DiagnosticTraceStatus",
+    "DiagnosticsResponse",
     "DiffFormat",
     "DiffRow",
     "DiffRowType",
@@ -406,6 +411,7 @@ __all__ = [
     "ToolDisplayType",
     "ToolPart",
     "ToolStatus",
+    "TraceKind",
     "TranscriptionResponse",
     "TransferOwnerRequest",
     "TransferOwnerResponse",
@@ -475,6 +481,7 @@ __all__ = [
 
 # import apis into sdk package
 from ksapi.api.agent_api import AgentApi as AgentApi
+from ksapi.api.diagnostics_api import DiagnosticsApi as DiagnosticsApi
 from ksapi.api.feedback_api import FeedbackApi as FeedbackApi
 from ksapi.api.memory_api import MemoryApi as MemoryApi
 from ksapi.api.skills_api import SkillsApi as SkillsApi
@@ -633,6 +640,10 @@ from ksapi.models.data_source_schema_response import DataSourceSchemaResponse as
 from ksapi.models.data_source_sync_response import DataSourceSyncResponse as DataSourceSyncResponse
 from ksapi.models.data_source_table_response import DataSourceTableResponse as DataSourceTableResponse
 from ksapi.models.definition_output_stat import DefinitionOutputStat as DefinitionOutputStat
+from ksapi.models.diagnostic_trace_failure_reason import DiagnosticTraceFailureReason as DiagnosticTraceFailureReason
+from ksapi.models.diagnostic_trace_item import DiagnosticTraceItem as DiagnosticTraceItem
+from ksapi.models.diagnostic_trace_status import DiagnosticTraceStatus as DiagnosticTraceStatus
+from ksapi.models.diagnostics_response import DiagnosticsResponse as DiagnosticsResponse
 from ksapi.models.diff_format import DiffFormat as DiffFormat
 from ksapi.models.diff_row import DiffRow as DiffRow
 from ksapi.models.diff_row_type import DiffRowType as DiffRowType
@@ -866,6 +877,7 @@ from ksapi.models.timeseries_point import TimeseriesPoint as TimeseriesPoint
 from ksapi.models.tool_display_type import ToolDisplayType as ToolDisplayType
 from ksapi.models.tool_part import ToolPart as ToolPart
 from ksapi.models.tool_status import ToolStatus as ToolStatus
+from ksapi.models.trace_kind import TraceKind as TraceKind
 from ksapi.models.transcription_response import TranscriptionResponse as TranscriptionResponse
 from ksapi.models.transfer_owner_request import TransferOwnerRequest as TransferOwnerRequest
 from ksapi.models.transfer_owner_response import TransferOwnerResponse as TransferOwnerResponse

{ksapi-3.5.2 → ksapi-3.6.0}/ksapi/api/__init__.py

@@ -2,6 +2,7 @@
 
 # import apis into api package
 from ksapi.api.agent_api import AgentApi
+from ksapi.api.diagnostics_api import DiagnosticsApi
 from ksapi.api.feedback_api import FeedbackApi
 from ksapi.api.memory_api import MemoryApi
 from ksapi.api.skills_api import SkillsApi

ksapi-3.6.0/ksapi/api/diagnostics_api.py

@@ -0,0 +1,566 @@
+"""
+    Knowledge Stack API
+
+    Knowledge Stack backend API for authentication and knowledge management.  ## Integrating (RPA / machine clients)  **Base URL.** Knowledge Stack is self-hosted — point at your own deployment host (see `servers`). The `localhost` entry is for local development only.  **Authentication.** Send `Authorization: Bearer <api-key>` on every request. Mint an API key once via `POST /v1/api-keys` from a signed-in browser session; the raw `sk-user-...` secret is returned **only** at creation, so store it then. A key inherits its owning user's live tenant role and path permissions — create RPA keys from a least-privilege user, and set `expires_at` for rotation. The `ks_uat` cookie scheme is browser-only and cannot be used by headless clients.  **Async work is polled, not pushed.** There are no outbound webhooks. - `POST /v1/documents/ingest` returns `201` immediately with a `workflow_id`;   poll `GET /v1/system-jobs/document_versions/{workflow_id}` until `status` is   terminal (anything other than `pending`/`processing`). The `Location` response   header points at this poll resource. - `POST /v1/workflow-runs/{run_id}/start` returns `202`; poll   `GET /v1/workflow-runs/{run_id}` until `execution_state` is `COMPLETED` or   `FAILED`. The `Location` header points at the run resource. - `POST /v1/agent/ask` is **synchronous** — it blocks until the agent finishes   and returns the answer inline. Use a generous HTTP timeout.  **Pagination.** List endpoints accept `limit`/`offset` and return `{items, total, limit, offset}`.  **Errors.** Every non-2xx body is `{detail, code, request_id}`. `code` is a stable value from a closed set (see the `ErrorResponse` schema's `code` enum) — branch on it rather than parsing `detail`. Quota rejections return `429` with a `Retry-After` header; transient lock contention returns a retryable `503`. Quote `request_id` (also the `x-request-id` response header) to support.  **Idempotency.** `POST /v1/workflow-runs` accepts an `idempotency_key` to dedupe retried run creation. `agent/ask` charges one message *before* running and does not refund a client-cancelled call. 
+
+    The version of the OpenAPI document: 0.1.0
+    Generated by OpenAPI Generator (https://openapi-generator.tech)
+
+    Do not edit the class manually.
+"""  # noqa: E501
+
+
+import warnings
+from pydantic import validate_call, Field, StrictFloat, StrictStr, StrictInt
+from typing import Any, Dict, List, Optional, Tuple, Union
+from typing_extensions import Annotated
+
+from uuid import UUID
+from ksapi.models.diagnostics_response import DiagnosticsResponse
+
+from ksapi.api_client import ApiClient, RequestSerialized
+from ksapi.api_response import ApiResponse
+from ksapi.rest import RESTResponseType
+
+
+class DiagnosticsApi:
+    """NOTE: This class is auto generated by OpenAPI Generator
+    Ref: https://openapi-generator.tech
+
+    Do not edit the class manually.
+    """
+
+    def __init__(self, api_client=None) -> None:
+        if api_client is None:
+            api_client = ApiClient.get_default()
+        self.api_client = api_client
+
+
+    @validate_call
+    def compute_thread_diagnostics(
+        self,
+        thread_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> DiagnosticsResponse:
+        """Compute Thread Diagnostics Handler
+
+        Stats and trace links for every turn; a run's thread answers as its run.
+
+        :param thread_id: (required)
+        :type thread_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_thread_diagnostics_serialize(
+            thread_id=thread_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def compute_thread_diagnostics_with_http_info(
+        self,
+        thread_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[DiagnosticsResponse]:
+        """Compute Thread Diagnostics Handler
+
+        Stats and trace links for every turn; a run's thread answers as its run.
+
+        :param thread_id: (required)
+        :type thread_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_thread_diagnostics_serialize(
+            thread_id=thread_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def compute_thread_diagnostics_without_preload_content(
+        self,
+        thread_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Compute Thread Diagnostics Handler
+
+        Stats and trace links for every turn; a run's thread answers as its run.
+
+        :param thread_id: (required)
+        :type thread_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_thread_diagnostics_serialize(
+            thread_id=thread_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _compute_thread_diagnostics_serialize(
+        self,
+        thread_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if thread_id is not None:
+            _path_params['thread_id'] = thread_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'cookieAuth', 
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/diagnostics/threads/{thread_id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+
+
+
+    @validate_call
+    def compute_workflow_run_diagnostics(
+        self,
+        run_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> DiagnosticsResponse:
+        """Compute Workflow Run Diagnostics Handler
+
+        Stats and trace links for the run's attempts and every turn in its thread.
+
+        :param run_id: (required)
+        :type run_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_workflow_run_diagnostics_serialize(
+            run_id=run_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        ).data
+
+
+    @validate_call
+    def compute_workflow_run_diagnostics_with_http_info(
+        self,
+        run_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> ApiResponse[DiagnosticsResponse]:
+        """Compute Workflow Run Diagnostics Handler
+
+        Stats and trace links for the run's attempts and every turn in its thread.
+
+        :param run_id: (required)
+        :type run_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_workflow_run_diagnostics_serialize(
+            run_id=run_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        response_data.read()
+        return self.api_client.response_deserialize(
+            response_data=response_data,
+            response_types_map=_response_types_map,
+        )
+
+
+    @validate_call
+    def compute_workflow_run_diagnostics_without_preload_content(
+        self,
+        run_id: UUID,
+        _request_timeout: Union[
+            None,
+            Annotated[StrictFloat, Field(gt=0)],
+            Tuple[
+                Annotated[StrictFloat, Field(gt=0)],
+                Annotated[StrictFloat, Field(gt=0)]
+            ]
+        ] = None,
+        _request_auth: Optional[Dict[StrictStr, Any]] = None,
+        _content_type: Optional[StrictStr] = None,
+        _headers: Optional[Dict[StrictStr, Any]] = None,
+        _host_index: Annotated[StrictInt, Field(ge=0, le=0)] = 0,
+    ) -> RESTResponseType:
+        """Compute Workflow Run Diagnostics Handler
+
+        Stats and trace links for the run's attempts and every turn in its thread.
+
+        :param run_id: (required)
+        :type run_id: UUID
+        :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.
+        :type _request_timeout: int, tuple(int, int), optional
+        :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
+        :param _content_type: force content-type for the request.
+        :type _content_type: str, Optional
+        :param _headers: set to override the headers for a single
+                         request; this effectively ignores the headers
+                         in the spec for a single request.
+        :type _headers: dict, optional
+        :param _host_index: set to override the host_index for a single
+                            request; this effectively ignores the host_index
+                            in the spec for a single request.
+        :type _host_index: int, optional
+        :return: Returns the result object.
+        """ # noqa: E501
+
+        _param = self._compute_workflow_run_diagnostics_serialize(
+            run_id=run_id,
+            _request_auth=_request_auth,
+            _content_type=_content_type,
+            _headers=_headers,
+            _host_index=_host_index
+        )
+
+        _response_types_map: Dict[str, Optional[str]] = {
+            '200': "DiagnosticsResponse",
+            '422': "HTTPValidationError",
+        }
+        response_data = self.api_client.call_api(
+            *_param,
+            _request_timeout=_request_timeout
+        )
+        return response_data.response
+
+
+    def _compute_workflow_run_diagnostics_serialize(
+        self,
+        run_id,
+        _request_auth,
+        _content_type,
+        _headers,
+        _host_index,
+    ) -> RequestSerialized:
+
+        _host = None
+
+        _collection_formats: Dict[str, str] = {
+        }
+
+        _path_params: Dict[str, str] = {}
+        _query_params: List[Tuple[str, str]] = []
+        _header_params: Dict[str, Optional[str]] = _headers or {}
+        _form_params: List[Tuple[str, str]] = []
+        _files: Dict[
+            str, Union[str, bytes, List[str], List[bytes], List[Tuple[str, bytes]]]
+        ] = {}
+        _body_params: Optional[bytes] = None
+
+        # process the path parameters
+        if run_id is not None:
+            _path_params['run_id'] = run_id
+        # process the query parameters
+        # process the header parameters
+        # process the form parameters
+        # process the body parameter
+
+
+        # set the HTTP header `Accept`
+        if 'Accept' not in _header_params:
+            _header_params['Accept'] = self.api_client.select_header_accept(
+                [
+                    'application/json'
+                ]
+            )
+
+
+        # authentication setting
+        _auth_settings: List[str] = [
+            'cookieAuth', 
+            'bearerAuth'
+        ]
+
+        return self.api_client.param_serialize(
+            method='POST',
+            resource_path='/v1/diagnostics/workflow-runs/{run_id}',
+            path_params=_path_params,
+            query_params=_query_params,
+            header_params=_header_params,
+            body=_body_params,
+            post_params=_form_params,
+            files=_files,
+            auth_settings=_auth_settings,
+            collection_formats=_collection_formats,
+            _host=_host,
+            _request_auth=_request_auth
+        )
+
+

{ksapi-3.5.2 → ksapi-3.6.0}/ksapi/api_client.py

@@ -91,7 +91,7 @@ class ApiClient:
             self.default_headers[header_name] = header_value
         self.cookie = cookie
         # Set default User-Agent.
-        self.user_agent = 'OpenAPI-Generator/3.5.2/python'
+        self.user_agent = 'OpenAPI-Generator/3.6.0/python'
         self.client_side_validation = configuration.client_side_validation
 
     def __enter__(self):

{ksapi-3.5.2 → ksapi-3.6.0}/ksapi/configuration.py

@@ -562,7 +562,7 @@ conf = ksapi.Configuration(
                "OS: {env}\n"\
                "Python Version: {pyversion}\n"\
                "Version of the API: 0.1.0\n"\
-               "SDK Package Version: 3.5.2".\
+               "SDK Package Version: 3.6.0".\
                format(env=sys.platform, pyversion=sys.version)
 
     def get_host_settings(self) -> List[HostSetting]:

{ksapi-3.5.2 → ksapi-3.6.0}/ksapi/models/__init__.py

@@ -117,6 +117,10 @@ from ksapi.models.data_source_schema_response import DataSourceSchemaResponse
 from ksapi.models.data_source_sync_response import DataSourceSyncResponse
 from ksapi.models.data_source_table_response import DataSourceTableResponse
 from ksapi.models.definition_output_stat import DefinitionOutputStat
+from ksapi.models.diagnostic_trace_failure_reason import DiagnosticTraceFailureReason
+from ksapi.models.diagnostic_trace_item import DiagnosticTraceItem
+from ksapi.models.diagnostic_trace_status import DiagnosticTraceStatus
+from ksapi.models.diagnostics_response import DiagnosticsResponse
 from ksapi.models.diff_format import DiffFormat
 from ksapi.models.diff_row import DiffRow
 from ksapi.models.diff_row_type import DiffRowType
@@ -350,6 +354,7 @@ from ksapi.models.timeseries_point import TimeseriesPoint
 from ksapi.models.tool_display_type import ToolDisplayType
 from ksapi.models.tool_part import ToolPart
 from ksapi.models.tool_status import ToolStatus
+from ksapi.models.trace_kind import TraceKind
 from ksapi.models.transcription_response import TranscriptionResponse
 from ksapi.models.transfer_owner_request import TransferOwnerRequest
 from ksapi.models.transfer_owner_response import TransferOwnerResponse