feat(ai): Add support for AI features

jira: GDAI-185
risk: low

Author: malmiron

gooddata-sdk/gooddata_sdk/compute/service.py

@@ -2,13 +2,18 @@
 from __future__ import annotations
 
 import logging
+from typing import Any
 
 from gooddata_api_client import ApiException
 from gooddata_api_client.model.afm_cancel_tokens import AfmCancelTokens
 from gooddata_api_client.model.chat_history_request import ChatHistoryRequest
 from gooddata_api_client.model.chat_history_result import ChatHistoryResult
 from gooddata_api_client.model.chat_request import ChatRequest
 from gooddata_api_client.model.chat_result import ChatResult
+from gooddata_api_client.model.json_api_llm_endpoint_out_document import JsonApiLlmEndpointOutDocument
+from gooddata_api_client.model.json_api_llm_endpoint_out_list import JsonApiLlmEndpointOutList
+from gooddata_api_client.model.search_request import SearchRequest
+from gooddata_api_client.model.search_result import SearchResult
 
 from gooddata_sdk.client import GoodDataApiClient
 from gooddata_sdk.compute.model.execution import Execution, ExecutionDefinition, ResultCacheMetadata
@@ -26,6 +31,7 @@ class ComputeService:
     def __init__(self, api_client: GoodDataApiClient):
         self._api_client = api_client
         self._actions_api = self._api_client.actions_api
+        self._entities_api = self._api_client.entities_api
 
     def for_exec_def(self, workspace_id: str, exec_def: ExecutionDefinition) -> Execution:
         """
@@ -91,17 +97,27 @@ def ai_chat(self, workspace_id: str, question: str) -> ChatResult:
         response = self._actions_api.ai_chat(workspace_id, chat_request, _check_return_type=False)
         return response
 
-    def ai_chat_history(self, workspace_id: str, chat_history_interaction_id: int = 0) -> ChatHistoryResult:
+    def ai_chat_history(
+        self, workspace_id: str, chat_history_interaction_id: str | None = None, thread_id_suffix: str | None = None
+    ) -> ChatHistoryResult:
         """
         Get chat history with AI in GoodData workspace.
 
         Args:
             workspace_id: workspace identifier
-            chat_history_interaction_id: collect history starting from this interaction id
+            chat_history_interaction_id: collect history starting from this interaction id. If None, complete chat history is returned.
+            thread_id_suffix: suffix to identify a specific chat thread. If provided, chat_history_interaction_id is ignored.
         Returns:
-            str: Chat history response
+            ChatHistoryResult: Chat history response containing interactions and other metadata
         """
-        chat_history_request = ChatHistoryRequest(chat_history_interaction_id=chat_history_interaction_id)
+
+        if chat_history_interaction_id is None:
+            chat_history_interaction_id = ""
+        if thread_id_suffix is None:
+            thread_id_suffix = ""
+        chat_history_request = ChatHistoryRequest(
+            chat_history_interaction_id=chat_history_interaction_id, reset=False, thread_id_suffix=thread_id_suffix
+        )
         response = self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
         return response
 
@@ -115,6 +131,76 @@ def ai_chat_history_reset(self, workspace_id: str) -> None:
         chat_history_request = ChatHistoryRequest(reset=True)
         self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
 
+    def ai_chat_history_feedback(
+        self,
+        workspace_id: str,
+        user_feedback: str,
+        chat_history_interaction_id: str,
+        thread_id_suffix: str | None = None,
+    ) -> None:
+        """
+        Provide feedback for a specific chat history interaction.
+
+        Args:
+            workspace_id: workspace identifier
+            user_feedback: feedback to provide ("POSITIVE", "NEGATIVE" or "NONE")
+            chat_history_interaction_id: interaction id to provide feedback for
+            thread_id_suffix: suffix to identify a specific chat thread
+        """
+        if thread_id_suffix is None:
+            thread_id_suffix = ""
+        chat_history_request = ChatHistoryRequest(
+            user_feedback=user_feedback,
+            chat_history_interaction_id=chat_history_interaction_id,
+            thread_id_suffix=thread_id_suffix,
+            reset=False,
+        )
+        self._actions_api.ai_chat_history(workspace_id, chat_history_request, _check_return_type=False)
+
+    def ai_search(
+        self,
+        workspace_id: str,
+        question: str,
+        deep_search: bool | None = None,
+        limit: int | None = None,
+        object_types: list[str] | None = None,
+        relevant_score_threshold: float | None = None,
+        title_to_descriptor_ratio: float | None = None,
+    ) -> SearchResult:
+        """
+        Search for metadata objects using similarity search.
+
+        Args:
+            workspace_id: workspace identifier
+            question: keyword/sentence input for search
+            deep_search: turn on deep search - if true, content of complex objects will be searched as well
+            limit: maximum number of results to return
+            object_types: list of object types to search for. Enum items: "attribute", "metric", "fact",
+                "label", "date", "dataset", "visualization" and "dashboard"
+            relevant_score_threshold: minimum relevance score threshold for results
+            title_to_descriptor_ratio: ratio of title score to descriptor score
+
+        Returns:
+            SearchResult: Search results
+
+        Note:
+            Default values for optional parameters are documented in the AI Search endpoint of the GoodData API.
+        """
+        search_params: dict[str, Any] = {}
+        if deep_search is not None:
+            search_params["deep_search"] = deep_search
+        if limit is not None:
+            search_params["limit"] = limit
+        if object_types is not None:
+            search_params["object_types"] = object_types
+        if relevant_score_threshold is not None:
+            search_params["relevant_score_threshold"] = relevant_score_threshold
+        if title_to_descriptor_ratio is not None:
+            search_params["title_to_descriptor_ratio"] = title_to_descriptor_ratio
+        search_request = SearchRequest(question=question, **search_params)
+        response = self._actions_api.ai_search(workspace_id, search_request, _check_return_type=False)
+        return response
+
     def cancel_executions(self, executions: dict[str, dict[str, str]]) -> None:
         """
         Try to cancel given executions using the cancel api endpoint.
@@ -132,3 +218,187 @@ def cancel_executions(self, executions: dict[str, dict[str, str]]) -> None:
                 )
         except ApiException as e:
             print("Exception when calling ActionsApi->cancel_executions: %s\n", e)
+
+    def metadata_sync(self, workspace_id: str, async_req: bool = False) -> None:
+        """
+        Sync metadata to other services.
+
+        Args:
+            workspace_id: workspace identifier
+            async_req: if True, the metadata sync will be performed asynchronously
+        """
+        self._actions_api.metadata_sync(workspace_id, async_req=async_req, _check_return_type=False)
+
+    def get_llm_endpoint(self, id: str) -> JsonApiLlmEndpointOutDocument:
+        """
+        Get LLM endpoint by ID.
+
+        Args:
+            id: LLM endpoint identifier
+
+        Returns:
+            JsonApiLlmEndpointOutDocument: Retrieved LLM endpoint
+        """
+        return self._entities_api.get_entity_llm_endpoints(id, _check_return_type=False)
+
+    def list_llm_endpoints(
+        self,
+        filter: str | None = None,
+        page: int | None = None,
+        size: int | None = None,
+        sort: list[str] | None = None,
+        meta_include: list[str] | None = None,
+    ) -> JsonApiLlmEndpointOutList:
+        """
+        List all LLM endpoints.
+
+        Args:
+            filter: Optional filter string
+            page: Zero-based page index (0..N)
+            size: The size of the page to be returned
+            sort: Sorting criteria in the format: property,(asc|desc). Multiple sort criteria are supported.
+            meta_include: Include Meta objects
+
+        Returns:
+            JsonApiLlmEndpointOutList: List of LLM endpoints
+
+        Note:
+            Default values for optional parameters are documented in the LLM endpoints of the GoodData API.
+        """
+        kwargs: dict[str, Any] = {}
+        if filter is not None:
+            kwargs["filter"] = filter
+        if page is not None:
+            kwargs["page"] = page
+        if size is not None:
+            kwargs["size"] = size
+        if sort is not None:
+            kwargs["sort"] = sort
+        if meta_include is not None:
+            kwargs["meta_include"] = meta_include
+        kwargs["_check_return_type"] = False
+
+        return self._entities_api.get_all_entities_llm_endpoints(**kwargs)
+
+    def create_llm_endpoint(
+        self,
+        id: str,
+        title: str,
+        token: str,
+        description: str | None = None,
+        provider: str | None = None,
+        base_url: str | None = None,
+        llm_organization: str | None = None,
+        llm_model: str | None = None,
+        workspaces_ids: list[str] | None = None,
+    ) -> JsonApiLlmEndpointOutDocument:
+        """
+        Create a new LLM endpoint.
+
+        Args:
+            id: Identifier of the LLM endpoint
+            title: User-facing title of the LLM Provider
+            token: The token to use to connect to the LLM provider
+            description: Optional user-facing description of the LLM endpoint
+            provider: Optional LLM provider name (e.g., "openai")
+            base_url: Optional base URL for custom LLM endpoint
+            llm_organization: Optional LLM organization identifier
+            llm_model: Optional LLM default model override
+            workspaces_ids: Optional list of workspace IDs for which LLM endpoint is valid.
+                If empty, it is valid for all workspaces.
+
+        Returns:
+            JsonApiLlmEndpointOutDocument: Created LLM endpoint
+        """
+
+        llm_endpoint_document: dict[str, Any] = {
+            "data": {
+                "id": id,
+                "type": "llmEndpoint",
+                "attributes": {
+                    "title": title,
+                    "token": token,
+                },
+            }
+        }
+
+        if description is not None:
+            llm_endpoint_document["data"]["attributes"]["description"] = description
+        if provider is not None:
+            llm_endpoint_document["data"]["attributes"]["provider"] = provider
+        if base_url is not None:
+            llm_endpoint_document["data"]["attributes"]["baseUrl"] = base_url
+        if llm_organization is not None:
+            llm_endpoint_document["data"]["attributes"]["llmOrganization"] = llm_organization
+        if llm_model is not None:
+            llm_endpoint_document["data"]["attributes"]["llmModel"] = llm_model
+        if workspaces_ids is not None:
+            llm_endpoint_document["data"]["attributes"]["workspacesIds"] = workspaces_ids
+
+        return self._entities_api.create_entity_llm_endpoints(llm_endpoint_document, _check_return_type=False)
+
+    def update_llm_endpoint(
+        self,
+        id: str,
+        title: str | None = None,
+        token: str | None = None,
+        description: str | None = None,
+        provider: str | None = None,
+        base_url: str | None = None,
+        llm_organization: str | None = None,
+        llm_model: str | None = None,
+        workspaces_ids: list[str] | None = None,
+    ) -> JsonApiLlmEndpointOutDocument:
+        """
+        Update an existing LLM endpoint.
+
+        Args:
+            id: Identifier of the LLM endpoint
+            title: User-facing title of the LLM Provider
+            token: The token to use to connect to the LLM provider
+            description: User-facing description of the LLM endpoint
+            provider: LLM provider name (e.g., "openai")
+            base_url: Base URL for custom LLM endpoint
+            llm_organization: LLM organization identifier
+            llm_model: LLM default model override
+            workspaces_ids: List of workspace IDs for which LLM endpoint is valid.
+                If empty, it is valid for all workspaces.
+
+        Returns:
+            JsonApiLlmEndpointOutDocument: Updated LLM endpoint
+        """
+        llm_endpoint_document: dict[str, Any] = {
+            "data": {
+                "id": id,
+                "type": "llmEndpoint",
+                "attributes": {},
+            }
+        }
+
+        if title is not None:
+            llm_endpoint_document["data"]["attributes"]["title"] = title
+        if token is not None:
+            llm_endpoint_document["data"]["attributes"]["token"] = token
+        if description is not None:
+            llm_endpoint_document["data"]["attributes"]["description"] = description
+        if provider is not None:
+            llm_endpoint_document["data"]["attributes"]["provider"] = provider
+        if base_url is not None:
+            llm_endpoint_document["data"]["attributes"]["baseUrl"] = base_url
+        if llm_organization is not None:
+            llm_endpoint_document["data"]["attributes"]["llmOrganization"] = llm_organization
+        if llm_model is not None:
+            llm_endpoint_document["data"]["attributes"]["llmModel"] = llm_model
+        if workspaces_ids is not None:
+            llm_endpoint_document["data"]["attributes"]["workspacesIds"] = workspaces_ids
+
+        return self._entities_api.update_entity_llm_endpoints(id, llm_endpoint_document, _check_return_type=False)
+
+    def delete_llm_endpoint(self, id: str) -> None:
+        """
+        Delete an LLM endpoint.
+
+        Args:
+            id: LLM endpoint identifier
+        """
+        self._entities_api.delete_entity_llm_endpoints(id, _check_return_type=False)