superwise-api 4.16.0__tar.gz → 4.17.0__tar.gz

{superwise_api-4.16.0 → superwise_api-4.17.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: superwise-api
-Version: 4.16.0
+Version: 4.17.0
 Summary: Superwise SDK for Python
 License: MIT
 Keywords: OpenAPI,SuperwiseSDK
@@ -14,6 +14,7 @@ Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Requires-Dist: Pillow (>=10.0.0,<11.0.0)
 Requires-Dist: aenum (>=3.1.11)
+Requires-Dist: jsonschema (>=4.26.0,<5.0.0)
 Requires-Dist: pydantic (>=2.10.4,<3.0.0)
 Requires-Dist: pydantic-settings (>=2.7.0,<3.0.0)
 Requires-Dist: python-dateutil (>=2.8.2)

{superwise_api-4.16.0 → superwise_api-4.17.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 packages = [{ include = "superwise_api", from = "." }]
-version = "4.16.0"
+version = "4.17.0"
 include = ["superwise_api/client/py.typed"]
 
 [tool.poetry.dependencies]
@@ -11,6 +11,7 @@ aenum = ">=3.1.11"
 requests = "^2.32.0"
 pydantic-settings = "^2.7.0"
 Pillow = "^10.0.0"
+jsonschema = "^4.26.0"
 
 
 [tool.poetry.group.dev.dependencies]

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/client/api_client.py

@@ -7,7 +7,7 @@ import re
 import tempfile
 import uuid
 from multiprocessing.pool import ThreadPool
-from typing import Optional
+
 from urllib.parse import quote
 
 from dateutil.parser import parse
@@ -774,7 +774,7 @@ class ApiClient:
             **kwargs,
         )
 
-    def put(self, resource_path: str, data: Optional[dict] = None, **kwargs) -> BaseModel:
+    def put(self, resource_path: str, data: dict | None = None, **kwargs) -> BaseModel:
         _params = locals()
 
         _all_params = ["async_req", "_request_auth", "_content_type", "_headers", "response_types_map"]
@@ -860,11 +860,19 @@ class ApiClient:
         )
 
     def post(
-        self, resource_path: str, data: Optional[dict] = None, query_params: dict | None = None, **kwargs
+        self, resource_path: str, data: dict | None = None, query_params: dict | None = None, **kwargs
     ) -> BaseModel:
         _params = locals()
 
-        _all_params = ["files", "async_req", "_request_auth", "_content_type", "_headers", "response_types_map"]
+        _all_params = [
+            "files",
+            "async_req",
+            "_request_auth",
+            "_content_type",
+            "_headers",
+            "response_types_map",
+            "post_params",
+        ]
         if "model_name" in kwargs:
             _all_params.append("model_name")
 
@@ -884,18 +892,21 @@ class ApiClient:
         # process the header parameters
         _header_params = dict(_params.get("_headers", {}))
         # process the form parameters
-        _form_params = []
+        _form_params = _params.get("post_params", [])
         _files = kwargs.get("files", {})
         # process the body parameter
         _body_params = None
-        if data is not None:
+        if data is not None and not _form_params:
             _body_params = data
 
         # set the HTTP header `Accept`
         _header_params["Accept"] = self.select_header_accept(["application/json"])
 
         # set the HTTP header `Content-Type`
-        _content_types_list = _params.get("_content_type", self.select_header_content_type(["application/json"]))
+        if _form_params:
+            _content_types_list = "multipart/form-data"
+        else:
+            _content_types_list = _params.get("_content_type", self.select_header_content_type(["application/json"]))
         if _content_types_list:
             _header_params["Content-Type"] = _content_types_list
 
@@ -924,7 +935,7 @@ class ApiClient:
         )
 
     def delete(
-        self, resource_path: str, model_name: str, entity_id: str, query_params: Optional[dict] = None, **kwargs
+        self, resource_path: str, model_name: str, entity_id: str, query_params: dict | None = None, **kwargs
     ) -> BaseModel:
         _params = locals()
 
@@ -1151,14 +1162,16 @@ class ApiClient:
         self,
         resource_path: str,
         response_model,
-        data: Optional[dict] = None,
+        data: dict | None = None,
+        post_params: list | None = None,
         **kwargs,
     ):
         """Performs a streaming POST request and yields parsed response objects.
 
         :param resource_path: Path to method endpoint.
         :param response_model: Model class to deserialize each line to.
-        :param data: Request body data.
+        :param data: Request body data (JSON).
+        :param post_params: Multipart form-data fields (list of tuples). Mutually exclusive with data.
         :param kwargs: Additional arguments (_headers, _request_timeout, _request_auth).
         :yields: Parsed response_model instances.
         :raises StreamingError: If an error event is received in the stream.
@@ -1175,7 +1188,7 @@ class ApiClient:
 
         # Set content type and accept headers
         _header_params["Accept"] = "application/x-ndjson"
-        _header_params["Content-Type"] = "application/json"
+        _header_params["Content-Type"] = "multipart/form-data" if post_params else "application/json"
 
         # Handle authentication
         _request_auth = _params.get("_request_auth")
@@ -1196,6 +1209,7 @@ class ApiClient:
             url,
             headers=_header_params,
             body=data,
+            post_params=post_params,
             _request_timeout=_params.get("_request_timeout"),
         )
 

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/client/rest.py

@@ -404,6 +404,7 @@ class RESTClientObject:
         url,
         headers=None,
         body=None,
+        post_params=None,
         _request_timeout=None,
     ):
         """Perform a streaming POST request.
@@ -411,6 +412,7 @@ class RESTClientObject:
         :param url: http request url
         :param headers: http request headers
         :param body: request json body
+        :param post_params: multipart/form-data fields (list of tuples)
         :param _request_timeout: timeout setting for this request
         :return: StreamingRESTResponse object for iterating over lines
         """
@@ -424,18 +426,30 @@ class RESTClientObject:
                 timeout = urllib3.Timeout(connect=_request_timeout[0], read=_request_timeout[1])
 
         try:
-            request_body = None
-            if body is not None:
-                request_body = json.dumps(body)
-
-            r = self.pool_manager.request(
-                "POST",
-                url,
-                body=request_body,
-                preload_content=False,
-                timeout=timeout,
-                headers=headers,
-            )
+            if post_params:
+                # Remove Content-Type so urllib3 sets it with the multipart boundary
+                headers = {k: v for k, v in headers.items() if k != "Content-Type"}
+                r = self.pool_manager.request(
+                    "POST",
+                    url,
+                    fields=post_params,
+                    encode_multipart=True,
+                    preload_content=False,
+                    timeout=timeout,
+                    headers=headers,
+                )
+            else:
+                request_body = None
+                if body is not None:
+                    request_body = json.dumps(body)
+                r = self.pool_manager.request(
+                    "POST",
+                    url,
+                    body=request_body,
+                    preload_content=False,
+                    timeout=timeout,
+                    headers=headers,
+                )
         except urllib3.exceptions.SSLError as e:
             msg = "{0}\n{1}".format(type(e).__name__, str(e))
             raise ApiException(status=0, reason=msg)

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/entities/agent.py

@@ -1,7 +1,10 @@
+import io
+import json
 from typing import Iterator
-from typing import Optional
+
 from typing import Sequence
 
+from PIL import Image
 from pydantic import conint
 
 from superwise_api.client.api_client import ApiClient
@@ -42,6 +45,42 @@ class AgentApi(CoreEntitiyApi):
         super().__init__(api_client)
         self._playground_resource_path = "/v1/application-playground"
 
+    def _detect_image_type(self, image_bytes: bytes) -> tuple[str, str]:
+        try:
+            with Image.open(io.BytesIO(image_bytes)) as img:
+                format_name = img.format
+                if format_name is None:
+                    raise ValueError("Could not detect image format")
+                format_map = {
+                    "JPEG": ("image/jpeg", "jpg"),
+                    "PNG": ("image/png", "png"),
+                    "WEBP": ("image/webp", "webp"),
+                }
+                if format_name in format_map:
+                    return format_map[format_name]
+                raise ValueError(f"Unsupported image format: {format_name}. Supported formats: JPEG, PNG, WEBP")
+        except ValueError:
+            raise
+        except Exception:
+            raise ValueError("Image type not allowed. Only PNG, JPEG, and WebP are supported.")
+
+    def _validate_images(self, images: list[bytes]) -> None:
+        if len(images) > 3:
+            raise ValueError(f"Maximum 3 images allowed, got {len(images)}")
+        for idx, img in enumerate(images):
+            if not isinstance(img, bytes):
+                raise ValueError(f"Image at index {idx} must be bytes, got {type(img)}")
+            if len(img) > 20 * 1024 * 1024:
+                raise ValueError(f"Image at index {idx} exceeds the 20MB size limit")
+            self._detect_image_type(img)
+
+    def _build_image_fields(self, images: list[bytes]) -> list[tuple]:
+        fields = []
+        for i, img in enumerate(images):
+            media_type, ext = self._detect_image_type(img)
+            fields.append(("images", (f"image{i}.{ext}", img, media_type)))
+        return fields
+
     def create(
         self,
         name: str,
@@ -228,7 +267,7 @@ class AgentApi(CoreEntitiyApi):
         )
 
     def get_versions(
-        self, agent_id: str, name: Optional[str] = None, created_by: Optional[str] = None, **kwargs
+        self, agent_id: str, name: str | None = None, created_by: str | None = None, **kwargs
     ) -> list[Version]:
         """
         Retrieves agent entities.
@@ -260,12 +299,12 @@ class AgentApi(CoreEntitiyApi):
 
     def get(
         self,
-        name: Optional[str] = None,
-        created_by: Optional[str] = None,
-        prompt: Optional[str] = None,
-        dataset_id: Optional[str] = None,
-        page: Optional[conint(strict=True, ge=1)] = None,
-        size: Optional[conint(strict=True, le=500, ge=1)] = None,
+        name: str | None = None,
+        created_by: str | None = None,
+        prompt: str | None = None,
+        dataset_id: str | None = None,
+        page: conint(strict=True, ge=1) | None = None,
+        size: conint(strict=True, le=500, ge=1) | None = None,
         **kwargs,
     ) -> Page:
         """
@@ -337,7 +376,12 @@ class AgentApi(CoreEntitiyApi):
 
     @BaseApi.raise_exception
     def ask_playground(
-        self, input: str, agent_config: AgentConfig, chat_history: Optional[Sequence[dict]] = None, **kwargs
+        self,
+        input: str,
+        agent_config: AgentConfig,
+        chat_history: Sequence[dict] | None = None,
+        images: list[bytes] | None = None,
+        **kwargs,
     ) -> AskResponsePayload:
         """
         Performs ask request in playground mode.
@@ -346,16 +390,31 @@ class AgentApi(CoreEntitiyApi):
             input (str): The input to the model.
             agent_config (AgentConfig): The type of the agent and connected tools/context.
             chat_history (Sequence[dict], optional): The chat history.
+            images (list[bytes], optional): Up to 3 images (PNG, JPEG, WEBP, max 20MB each).
 
         Returns:
             AskResponsePayload: The response payload.
         """
+        response_types_map = {"200": AskResponsePayload, "422": "HTTPValidationError"}
+        if images:
+            self._validate_images(images)
+            fields = [
+                ("input", input),
+                ("chat_history", json.dumps(chat_history or [])),
+                ("config", agent_config.model_dump_json(by_alias=True)),
+            ]
+            fields.extend(self._build_image_fields(images))
+            return self.api_client.post(
+                resource_path=self._playground_resource_path + "/ask",
+                post_params=fields,
+                response_types_map=response_types_map,
+                **kwargs,
+            )
         payload = {
             "config": agent_config,
             "input": input,
             "chat_history": chat_history or [],
         }
-        response_types_map = {"200": AskResponsePayload, "422": "HTTPValidationError"}
         return self.api_client.post(
             resource_path=self._playground_resource_path + "/ask",
             data=payload,
@@ -369,9 +428,10 @@ class AgentApi(CoreEntitiyApi):
         agent_id: str,
         input: str,
         api_token: str | None = None,
-        chat_history: Optional[Sequence[dict]] = None,
+        chat_history: Sequence[dict] | None = None,
         context_id: str | None = None,
         metadata: dict | None = None,
+        images: list[bytes] | None = None,
         **kwargs,
     ) -> AskResponsePayload:
         """
@@ -382,13 +442,35 @@ class AgentApi(CoreEntitiyApi):
             input (str): The input to the model.
             api_token (str): The API token of the agent.
             chat_history (Sequence[dict], optional): The chat history.
+            context_id (str, optional): The context ID for the conversation.
+            metadata (dict, optional): Additional metadata.
+            images (list[bytes], optional): Up to 3 images (PNG, JPEG, WEBP, max 20MB each).
 
         Returns:
             AskResponsePayload: The response payload.
         """
-        payload = {"input": input, "chat_history": chat_history or [], "context_id": context_id, "metadata": metadata}
-        headers = {"x-api-token": api_token} if api_token else {}
         response_types_map = {"200": AskResponsePayload, "422": "HTTPValidationError"}
+        if images:
+            self._validate_images(images)
+        headers = {"x-api-token": api_token} if api_token else {}
+        if images:
+            fields = [
+                ("input", input),
+                ("chat_history", json.dumps(chat_history or [])),
+            ]
+            if context_id is not None:
+                fields.append(("context_id", context_id))
+            if metadata is not None:
+                fields.append(("metadata", json.dumps(metadata)))
+            fields.extend(self._build_image_fields(images))
+            return self.api_client.post(
+                resource_path=f"/v1/app-worker/{agent_id}/v1/ask",
+                post_params=fields,
+                response_types_map=response_types_map,
+                _headers=headers,
+                **kwargs,
+            )
+        payload = {"input": input, "chat_history": chat_history or [], "context_id": context_id, "metadata": metadata}
         return self.api_client.post(
             resource_path=f"/v1/app-worker/{agent_id}/v1/ask",
             data=payload,
@@ -401,8 +483,9 @@ class AgentApi(CoreEntitiyApi):
         self,
         input: str,
         agent_config: AgentConfig,
-        chat_history: Optional[Sequence[dict]] = None,
-        guardrails: Optional[list[str]] = None,
+        chat_history: Sequence[dict] | None = None,
+        guardrails: list[str] | None = None,
+        images: list[bytes] | None = None,
         **kwargs,
     ) -> Iterator[StreamedResponse]:
         """
@@ -413,6 +496,7 @@ class AgentApi(CoreEntitiyApi):
             agent_config (AgentConfig): The type of the agent and connected tools/context.
             chat_history (Sequence[dict], optional): The chat history.
             guardrails (list[str], optional): List of guardrail IDs to apply.
+            images (list[bytes], optional): Up to 3 images (PNG, JPEG, WEBP, max 20MB each).
 
         Yields:
             StreamedResponse: Individual streaming events (system, guardrails, llm, tool, response).
@@ -420,6 +504,23 @@ class AgentApi(CoreEntitiyApi):
         Raises:
             StreamingError: If an error event is received in the stream.
         """
+        if images:
+            self._validate_images(images)
+        if images:
+            fields = [
+                ("input", input),
+                ("chat_history", json.dumps(chat_history or [])),
+                ("config", agent_config.model_dump_json(by_alias=True)),
+            ]
+            if guardrails:
+                fields.append(("guardrails", json.dumps(guardrails)))
+            fields.extend(self._build_image_fields(images))
+            return self.api_client.post_stream(
+                resource_path=self._playground_resource_path + "/ask/stream",
+                response_model=StreamedResponse,
+                post_params=fields,
+                **kwargs,
+            )
         payload = {
             "config": agent_config,
             "input": input,
@@ -439,9 +540,10 @@ class AgentApi(CoreEntitiyApi):
         agent_id: str,
         input: str,
         api_token: str | None = None,
-        chat_history: Optional[Sequence[dict]] = None,
+        chat_history: Sequence[dict] | None = None,
         context_id: str | None = None,
         metadata: dict | None = None,
+        images: list[bytes] | None = None,
         **kwargs,
     ) -> Iterator[StreamedResponse]:
         """
@@ -454,6 +556,7 @@ class AgentApi(CoreEntitiyApi):
             chat_history (Sequence[dict], optional): The chat history.
             context_id (str, optional): The context ID for the conversation.
             metadata (dict, optional): Additional metadata.
+            images (list[bytes], optional): Up to 3 images (PNG, JPEG, WEBP, max 20MB each).
 
         Yields:
             StreamedResponse: Individual streaming events (system, guardrails, llm, tool, response).
@@ -461,8 +564,27 @@ class AgentApi(CoreEntitiyApi):
         Raises:
             StreamingError: If an error event is received in the stream.
         """
-        payload = {"input": input, "chat_history": chat_history or [], "context_id": context_id, "metadata": metadata}
+        if images:
+            self._validate_images(images)
         headers = {"x-api-token": api_token} if api_token else {}
+        if images:
+            fields = [
+                ("input", input),
+                ("chat_history", json.dumps(chat_history or [])),
+            ]
+            if context_id is not None:
+                fields.append(("context_id", context_id))
+            if metadata is not None:
+                fields.append(("metadata", json.dumps(metadata)))
+            fields.extend(self._build_image_fields(images))
+            return self.api_client.post_stream(
+                resource_path=f"/v1/app-worker/{agent_id}/v1/ask/stream",
+                response_model=StreamedResponse,
+                post_params=fields,
+                _headers=headers,
+                **kwargs,
+            )
+        payload = {"input": input, "chat_history": chat_history or [], "context_id": context_id, "metadata": metadata}
         return self.api_client.post_stream(
             resource_path=f"/v1/app-worker/{agent_id}/v1/ask/stream",
             response_model=StreamedResponse,

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/entities/dataset.py

@@ -5,7 +5,7 @@ from pydantic import conint
 
 from superwise_api.client.models.page import Page
 from superwise_api.entities.base import BaseApi, CoreEntitiyApi
-from superwise_api.models.dataset.dataset import Dataset, SqlQueryResponse
+from superwise_api.models.dataset.dataset import Dataset, NaturalLanguageQueryResponse, SqlQueryResponse
 from superwise_api.models.dataset.dataset_schema import RecordLogMessage
 from superwise_api.models.dataset_source.dataset_source import DatasetSource
 from superwise_api.models.dataset_source.dataset_source import IngestType
@@ -288,6 +288,14 @@ class DatasetApi(CoreEntitiyApi):
             _preload_content=True,
         )
 
+    def update_record_in_dataset(self, dataset_id: str, key_field: str, key_value: str, record: dict, **kwargs):
+        """Update a record via ``POST /{dataset_id}/update`` (async; waits for row then publishes)."""
+        return self.api_client.post(
+            resource_path=f"{self._resource_path}/{dataset_id}/update",
+            data={"key_field": key_field, "key_value": key_value, "record": record},
+            **kwargs,
+        )
+
     def get_media(self, dataset_id: str, image_id: str, thumbnail: bool = False, **kwargs) -> tuple[str, bytes]:
         """Retrieve a single image from a dataset.
 
@@ -353,3 +361,49 @@ class DatasetApi(CoreEntitiyApi):
             response_types_map=response_types_map,
             **kwargs,
         )
+
+    def execute_nl_query(self, query: str, dataset_ids: list[str], **kwargs) -> NaturalLanguageQueryResponse:
+        """
+        Convert a natural language request to SQL and execute it.
+
+        Args:
+            query (str): Plain English description of the data you want.
+            dataset_ids (list[str]): Dataset IDs to scope the query.
+            **kwargs: Arbitrary keyword arguments passed to the API client.
+
+        Returns:
+            NaturalLanguageQueryResponse: Contains the generated SQL, a valid flag,
+                optional error message, and query data.
+        """
+        return self._post_nl_query(query=query, dataset_ids=dataset_ids, generate_only=False, **kwargs)
+
+    def generate_nl_query(self, query: str, dataset_ids: list[str], **kwargs) -> NaturalLanguageQueryResponse:
+        """
+        Convert a natural language request to SQL without executing it.
+
+        Args:
+            query (str): Plain English description of the data you want.
+            dataset_ids (list[str]): Dataset IDs to scope the query.
+            **kwargs: Arbitrary keyword arguments passed to the API client.
+
+        Returns:
+            NaturalLanguageQueryResponse: Contains the generated SQL and a valid flag.
+                Data is always None.
+        """
+        return self._post_nl_query(query=query, dataset_ids=dataset_ids, generate_only=True, **kwargs)
+
+    def _post_nl_query(
+        self, query: str, dataset_ids: list[str], generate_only: bool, **kwargs
+    ) -> NaturalLanguageQueryResponse:
+        response_types_map = {
+            "200": NaturalLanguageQueryResponse,
+            "400": None,
+            "422": None,
+            "500": None,
+        }
+        return self.api_client.post(
+            resource_path=self._resource_path + "/nl-query",
+            data={"query": query, "dataset_ids": dataset_ids, "generate_only": generate_only},
+            response_types_map=response_types_map,
+            **kwargs,
+        )

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/entities/destination.py

@@ -2,7 +2,14 @@ from typing import Optional
 
 from superwise_api.client.models.page import Page
 from superwise_api.entities.base import BaseApi
-from superwise_api.models.destination.destination import Destination, SlackDestinationParams
+from superwise_api.models.destination.destination import (
+    Destination,
+    TeamsDestinationTestRequest,
+    SlackDestinationTestRequest,
+    EmailDestinationTestRequest,
+    DestinationParams,
+    DestinationType,
+)
 
 
 class DestinationApi(BaseApi):
@@ -43,20 +50,34 @@ class DestinationApi(BaseApi):
         """
         return super().delete(_id=destination_id, **kwargs)
 
-    def create(self, name: str, integration_id: str, params: SlackDestinationParams, **kwargs) -> dict:
+    def create(
+        self,
+        name: str,
+        integration_type: DestinationType,
+        params: DestinationParams,
+        integration_id: str | None = None,
+        **kwargs,
+    ) -> Destination:
         """
         Creates a new destination.
 
         Args:
             name (str): The name of the destination.
-            integration_id (str): The id of the integration.
-            params (dict): The parameters of the destination.
+            integration_type (str): The type of the integration.
+            params (DestinationParams): The parameters of the destination.
+            integration_id (str | None): The id of the integration. Required for Slack destinations.
             **kwargs: Arbitrary keyword arguments.
 
         Returns:
             Destination: The created destination.
         """
-        data = {k: v for k, v in dict(name=name, integration_id=integration_id, params=params).items() if v is not None}
+        data = {
+            k: v
+            for k, v in dict(
+                name=name, integration_id=integration_id, integration_type=integration_type, params=params
+            ).items()
+            if v is not None
+        }
         return self.api_client.create(
             resource_path=self._resource_path, model_class=Destination, model_name=self._model_name, data=data, **kwargs
         )
@@ -106,14 +127,33 @@ class DestinationApi(BaseApi):
             **kwargs,
         )
 
+    def test_connection(
+        self,
+        request: TeamsDestinationTestRequest | SlackDestinationTestRequest | EmailDestinationTestRequest,
+        **kwargs,
+    ) -> None:
+        """
+        Test a webhook connection by sending a test notification.
+
+        Args:
+            request (TeamsDestinationTestRequest | SlackDestinationTestRequest | EmailDestinationTestRequest): The test connection request payload.
+            **kwargs: Arbitrary keyword arguments.
+        """
+        self.api_client.post(
+            resource_path=f"{self._resource_path}/test",
+            data=request.model_dump(),
+            response_types_map={"204": None},
+            **kwargs,
+        )
+
     def update(
         self,
         destination_id: str,
         *,
         name: Optional[str] = None,
-        params: Optional[SlackDestinationParams] = None,
+        params: DestinationParams | None = None,
         **kwargs,
-    ) -> dict:
+    ) -> Destination:
         """
         Updates a destination.
 

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/models/agent/agent.py

@@ -6,12 +6,15 @@ from typing import Literal
 from typing import Optional
 from typing import TypeAlias
 
+from jsonschema import Draft7Validator, SchemaError
+
 from pydantic import BaseModel, ConfigDict
 from pydantic import Discriminator
 from pydantic import Field
 from pydantic import field_validator
 from pydantic import HttpUrl
 from pydantic import UUID4
+import pydantic
 
 from superwise_api.models import SuperwiseEntity
 from superwise_api.models.agent.flowise import FlowiseCredentialUserInput
@@ -99,6 +102,15 @@ class AgentType(str, Enum):
     FLOWISE = "Flowise"
 
 
+class ReactAgentResponseMode(str, Enum):
+    TEXT = "text"
+    JSON_SCHEMA = "json_schema"
+
+
+class ReactAgentResponseJsonSchema(BaseModel):
+    model_config = ConfigDict(extra="allow")
+
+
 class SuperwiseConfig(SuperwiseEntity):
     framework: Literal[Framework.SUPERWISE.value] = Framework.SUPERWISE.value
     show_cites: bool = Field(default=False)
@@ -109,6 +121,28 @@ class SuperwiseConfig(SuperwiseEntity):
 class ReactAgentConfig(SuperwiseConfig):
     type: Literal[AgentType.REACT_AGENT.value] = AgentType.REACT_AGENT.value
     tools: List[ToolDef]
+    response_mode: ReactAgentResponseMode = Field(default=ReactAgentResponseMode.TEXT.value)
+    json_schema_response: ReactAgentResponseJsonSchema | None = None
+
+    @pydantic.model_validator(mode="after")
+    def validate_json_schema_response(self) -> "ReactAgentConfig":
+        if self.response_mode != ReactAgentResponseMode.JSON_SCHEMA:
+            return self
+
+        if self.json_schema_response is None:
+            raise ValueError("'json_schema_response' is required when response_mode is 'json_schema'")
+
+        schema_dict = self.json_schema_response.model_dump(exclude_none=True)
+
+        if "properties" not in schema_dict:
+            raise ValueError("'properties' is required in the schema")
+
+        try:
+            Draft7Validator.check_schema(schema_dict)
+        except SchemaError as e:
+            raise ValueError(f"Schema validation error: {e.message}") from e
+
+        return self
 
 
 AdvancedAgentConfig: TypeAlias = ReactAgentConfig

superwise_api-4.17.0/superwise_api/models/agent/feedback.py

@@ -0,0 +1,16 @@
+from uuid import UUID
+
+from superwise_api.models import SuperwiseEntity
+
+
+class EventFeedbackData(SuperwiseEntity):
+    interaction_id: UUID
+    question: str
+    answer: str
+    is_positive: bool
+    negative_feedback_category_harmful: bool
+    negative_feedback_category_untrue: bool
+    negative_feedback_category_unhelpful: bool
+    negative_feedback_category_other: bool
+    feedback_description: str
+    agent_id: str

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/models/agent/playground.py

@@ -70,6 +70,9 @@ class AskResponsePayload(SuperwiseEntity):
     metadata: Union[ResponseMetadata, Empty] = Field(
         default=Empty(), description="The metadata associated with the response."
     )
+    interaction_id: Optional[str] = Field(
+        default=None, description="Unique identifier for this interaction, used for feedback."
+    )
 
     @classmethod
     def from_dict(cls, data: dict) -> "AskResponsePayload":

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/models/dataset/dataset.py

@@ -88,3 +88,7 @@ class SqlQueryResponse(SuperwiseEntity):
         None,
         description="Query results. None when validate_only=True or when validation fails.",
     )
+
+
+class NaturalLanguageQueryResponse(SqlQueryResponse):
+    sql: str | None = Field(None, description="The SQL generated from your natural language query")

superwise_api-4.17.0/superwise_api/models/destination/destination.py

@@ -0,0 +1,82 @@
+from datetime import datetime
+from enum import Enum
+from typing import Union, Annotated
+from uuid import UUID
+
+from pydantic import field_serializer, ConfigDict, BaseModel, Discriminator
+
+from superwise_api.models import SuperwiseEntity
+
+
+class DestinationType(str, Enum):
+    SLACK = "slack"
+    TEAMS = "teams"
+    EMAIL = "email"
+
+
+class SlackDestinationParams(SuperwiseEntity):
+    channel_id: str
+
+
+class TeamsDestinationParams(SuperwiseEntity):
+    webhook_url: str
+
+
+class EmailDestinationParams(SuperwiseEntity):
+    emails: list[str]
+
+
+class DestinationBase(BaseModel):
+    model_config = ConfigDict(use_enum_values=True)
+    integration_type: DestinationType
+
+
+class TeamsDestinationTestRequest(TeamsDestinationParams, DestinationBase):
+    integration_type: DestinationType = DestinationType.TEAMS.value
+
+
+class SlackDestinationTestRequest(SlackDestinationParams, DestinationBase):
+    integration_type: DestinationType = DestinationType.SLACK.value
+    integration_id: UUID
+
+
+class EmailDestinationTestRequest(EmailDestinationParams, DestinationBase):
+    integration_type: DestinationType = DestinationType.EMAIL.value
+
+
+DestinationParams = Union[SlackDestinationParams, TeamsDestinationParams, EmailDestinationParams]
+DestinationTestRequest = Annotated[
+    TeamsDestinationTestRequest,
+    SlackDestinationTestRequest,
+    EmailDestinationTestRequest,
+    Discriminator("integration_type"),
+]
+
+
+class Destination(SuperwiseEntity):
+    id: UUID
+    name: str
+    integration_id: UUID
+    params: SlackDestinationParams | TeamsDestinationParams | EmailDestinationParams
+    updated_at: datetime
+    created_at: datetime
+    created_by: str
+    tenant_id: str
+
+    @field_serializer("created_at", "updated_at")
+    def serialize_dt(self, dt: datetime) -> str:
+        return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3]
+
+    def to_dict(self) -> dict:
+        dict_ = self.model_dump(exclude_none=True)
+        return dict_
+
+    @classmethod
+    def from_dict(cls, dict_: dict) -> "Destination":
+        if "webhook_url" in dict_["params"]:
+            dict_["params"] = TeamsDestinationParams(**dict_["params"])
+        elif "emails" in dict_["params"]:
+            dict_["params"] = EmailDestinationParams(**dict_["params"])
+        else:
+            dict_["params"] = SlackDestinationParams(**dict_["params"])
+        return cls(**dict_)

{superwise_api-4.16.0 → superwise_api-4.17.0}/superwise_api/models/integration/integration.py

@@ -7,6 +7,8 @@ from pydantic import BaseModel
 
 class IntegrationType(str, Enum):
     SLACK = "slack"
+    TEAMS = "teams"
+    EMAIL = "email"
 
 
 class Integration(BaseModel):

superwise_api-4.16.0/superwise_api/models/agent/feedback.py

@@ -1,41 +0,0 @@
-from uuid import UUID, uuid4
-
-from superwise_api.models import SuperwiseEntity
-
-
-class EventFeedbackData(SuperwiseEntity):
-    answer_id: UUID
-    question: str
-    answer: str
-    is_positive: bool
-    negative_feedback_category_harmful: bool
-    negative_feedback_category_untrue: bool
-    negative_feedback_category_unhelpful: bool
-    negative_feedback_category_other: bool
-    feedback_description: str
-    agent_id: str
-
-
-def create_event_feedback(
-    agent_id: str,
-    question: str,
-    answer: str,
-    is_positive: bool = True,
-    negative_feedback_category_harmful: bool = False,
-    negative_feedback_category_untrue: bool = False,
-    negative_feedback_category_unhelpful: bool = False,
-    negative_feedback_category_other: bool = False,
-    feedback_description: str = "",
-) -> EventFeedbackData:
-    return EventFeedbackData(
-        agent_id=agent_id,
-        answer_id=uuid4(),
-        question=question,
-        answer=answer,
-        is_positive=is_positive,
-        negative_feedback_category_harmful=negative_feedback_category_harmful,
-        negative_feedback_category_untrue=negative_feedback_category_untrue,
-        negative_feedback_category_unhelpful=negative_feedback_category_unhelpful,
-        negative_feedback_category_other=negative_feedback_category_other,
-        feedback_description=feedback_description,
-    )

superwise_api-4.16.0/superwise_api/models/destination/destination.py

@@ -1,37 +0,0 @@
-from datetime import datetime
-from uuid import UUID
-
-from pydantic import field_serializer
-
-from superwise_api.models import SuperwiseEntity
-
-
-class SlackDestinationParams(SuperwiseEntity):
-    channel_id: str
-
-    def to_dict(self):
-        return self.model_dump()
-
-
-class Destination(SuperwiseEntity):
-    id: UUID
-    name: str
-    integration_id: UUID
-    params: SlackDestinationParams
-    updated_at: datetime
-    created_at: datetime
-    created_by: str
-    tenant_id: str
-
-    @field_serializer("created_at", "updated_at")
-    def serialize_dt(self, dt: datetime) -> str:
-        return dt.strftime("%Y-%m-%dT%H:%M:%S.%f")[:-3]
-
-    def to_dict(self) -> dict:
-        dict_ = self.model_dump(exclude_none=True)
-        return dict_
-
-    @classmethod
-    def from_dict(cls, dict_: dict) -> "Destination":
-        dict_["params"] = SlackDestinationParams(**dict_["params"])
-        return cls(**dict_)