unique_sdk 0.10.19__py3-none-any.whl → 0.10.71__py3-none-any.whl

unique_sdk/api_resources/_group.py

@@ -0,0 +1,429 @@
+from typing import (
+    Any,
+    ClassVar,
+    Dict,
+    List,
+    Literal,
+    NotRequired,
+    Optional,
+    TypedDict,
+    Unpack,
+    cast,
+)
+
+from unique_sdk._api_resource import APIResource
+from unique_sdk._request_options import RequestOptions
+
+
+class Group(APIResource["Group"]):
+    OBJECT_NAME: ClassVar[Literal["group"]] = "group"
+
+    class GetParams(RequestOptions):
+        """
+        Parameters for getting groups in a company.
+        """
+
+        skip: NotRequired[Optional[int]]
+        take: NotRequired[Optional[int]]
+        name: NotRequired[Optional[str]]
+
+    class CreateParams(RequestOptions):
+        """
+        Parameters for creating a group.
+        """
+
+        name: str
+        externalId: NotRequired[Optional[str]]
+        parentId: NotRequired[Optional[str]]
+
+    class UpdateParams(RequestOptions):
+        """
+        Parameters for updating a group.
+        """
+
+        name: NotRequired[Optional[str]]
+
+    class AddUsersParams(RequestOptions):
+        """
+        Parameters for adding users to a group.
+        """
+
+        userIds: List[str]
+
+    class RemoveUsersParams(RequestOptions):
+        """
+        Parameters for removing users from a group.
+        """
+
+        userIds: List[str]
+
+    class UpdateGroupConfigurationParams(RequestOptions):
+        """
+        Parameters for updating group configuration.
+        """
+
+        configuration: Dict[str, Any]
+
+    class GroupMember(TypedDict):
+        """
+        Represents a member of a group.
+        """
+
+        entityId: str
+
+    class GroupMembership(TypedDict):
+        """
+        Represents a membership relationship between a user and a group.
+        """
+
+        entityId: str
+        groupId: str
+        createdAt: str
+
+    class Group(TypedDict):
+        """
+        Represents a group in the company.
+        """
+
+        id: str
+        name: str
+        externalId: str
+        parentId: Optional[str]
+        members: Optional[List["Group.GroupMember"]]
+        createdAt: str
+        updatedAt: str
+
+    class GroupWithConfiguration(Group):
+        """
+        Represents a group in the company with configuration.
+        """
+
+        configuration: Dict[str, Any]
+
+    class Groups(TypedDict):
+        """
+        Response for getting groups.
+        """
+
+        groups: List["Group.Group"]
+
+    class DeleteResponse(TypedDict):
+        """
+        Response for deleting a group.
+        """
+
+        id: str
+
+    class AddUsersToGroupResponse(TypedDict):
+        """
+        Response for adding users to a group.
+        """
+
+        memberships: List["Group.GroupMembership"]
+
+    class RemoveUsersFromGroupResponse(TypedDict):
+        """
+        Response for removing users from a group.
+        """
+
+        success: bool
+
+    @classmethod
+    def create_group(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Group.CreateParams"],
+    ) -> "Group.Group":
+        """
+        Create a group in a company.
+        """
+        return cast(
+            "Group.Group",
+            cls._static_request(
+                "post",
+                "/groups",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def create_group_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Group.CreateParams"],
+    ) -> "Group.Group":
+        """
+        Async create a group in a company.
+        """
+        return cast(
+            "Group.Group",
+            await cls._static_request_async(
+                "post",
+                "/groups",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def get_groups(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Group.GetParams"],
+    ) -> "Group.Groups":
+        """
+        Get groups in a company.
+        """
+        return cast(
+            "Group.Groups",
+            cls._static_request(
+                "get",
+                "/groups",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def get_groups_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["Group.GetParams"],
+    ) -> "Group.Groups":
+        """
+        Async get groups in a company.
+        """
+        return cast(
+            "Group.Groups",
+            await cls._static_request_async(
+                "get",
+                "/groups",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def delete_group(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+    ) -> "Group.DeleteResponse":
+        """
+        Delete a group in a company.
+        """
+        return cast(
+            "Group.DeleteResponse",
+            cls._static_request(
+                "delete",
+                f"/groups/{group_id}",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    async def delete_group_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+    ) -> "Group.DeleteResponse":
+        """
+        Async delete a group in a company.
+        """
+        return cast(
+            "Group.DeleteResponse",
+            await cls._static_request_async(
+                "delete",
+                f"/groups/{group_id}",
+                user_id,
+                company_id,
+            ),
+        )
+
+    @classmethod
+    def update_group(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.UpdateParams"],
+    ) -> "Group.Group":
+        """
+        Update a group in a company.
+        """
+        return cast(
+            "Group.Group",
+            cls._static_request(
+                "patch",
+                f"/groups/{group_id}",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def update_group_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.UpdateParams"],
+    ) -> "Group.Group":
+        """
+        Async update a group in a company.
+        """
+        return cast(
+            "Group.Group",
+            await cls._static_request_async(
+                "patch",
+                f"/groups/{group_id}",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def add_users_to_group(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.AddUsersParams"],
+    ) -> "Group.AddUsersToGroupResponse":
+        """
+        Add users to a group in a company.
+        """
+        return cast(
+            "Group.AddUsersToGroupResponse",
+            cls._static_request(
+                "post",
+                f"/groups/{group_id}/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def add_users_to_group_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.AddUsersParams"],
+    ) -> "Group.AddUsersToGroupResponse":
+        """
+        Async add users to a group in a company.
+        """
+        return cast(
+            "Group.AddUsersToGroupResponse",
+            await cls._static_request_async(
+                "post",
+                f"/groups/{group_id}/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def remove_users_from_group(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.RemoveUsersParams"],
+    ) -> "Group.RemoveUsersFromGroupResponse":
+        """
+        Remove users from a group in a company.
+        """
+        return cast(
+            "Group.RemoveUsersFromGroupResponse",
+            cls._static_request(
+                "delete",
+                f"/groups/{group_id}/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def remove_users_from_group_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.RemoveUsersParams"],
+    ) -> "Group.RemoveUsersFromGroupResponse":
+        """
+        Async remove users from a group in a company.
+        """
+        return cast(
+            "Group.RemoveUsersFromGroupResponse",
+            await cls._static_request_async(
+                "delete",
+                f"/groups/{group_id}/users",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    def update_group_configuration(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.UpdateGroupConfigurationParams"],
+    ) -> "Group.GroupWithConfiguration":
+        """
+        Update group configuration for the specified group.
+        """
+        return cast(
+            "Group.GroupWithConfiguration",
+            cls._static_request(
+                "patch",
+                f"/groups/{group_id}/configuration",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def update_group_configuration_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        group_id: str,
+        **params: Unpack["Group.UpdateGroupConfigurationParams"],
+    ) -> "Group.GroupWithConfiguration":
+        """
+        Async update group configuration for the specified group.
+        """
+        return cast(
+            "Group.GroupWithConfiguration",
+            await cls._static_request_async(
+                "patch",
+                f"/groups/{group_id}/configuration",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )

unique_sdk/api_resources/_integrated.py

@@ -1,15 +1,29 @@
 from typing import (
+    TYPE_CHECKING,
     Any,
     ClassVar,
-    Dict,
     List,
     Literal,
+    NotRequired,
     Optional,
-    TypedDict,
+    Union,
+    Unpack,
     cast,
 )
 
-from typing_extensions import NotRequired, Unpack
+from typing_extensions import TypedDict
+
+# Avoid introducing a dependency on the openai sdk as it's only used for type hints
+if TYPE_CHECKING:
+    from openai.types.responses import (
+        ResponseIncludable,
+        ResponseInputParam,
+        ResponseOutputItem,
+        ResponseTextConfigParam,
+        ToolParam,
+        response_create_params,
+    )
+    from openai.types.shared_params import Metadata, Reasoning
 
 from unique_sdk._api_resource import APIResource
 from unique_sdk._request_options import RequestOptions
@@ -28,6 +42,7 @@ class Integrated(APIResource["Integrated"]):
         chunkId: str
         key: str
         title: NotRequired["str"]
+        description: NotRequired["str"]
         url: NotRequired["str"]
 
     class ChatCompletionRequestMessage(TypedDict, total=False):
@@ -35,63 +50,49 @@ class Integrated(APIResource["Integrated"]):
         content: str
         name: Optional[str]
 
-    class CreateStream(RequestOptions):
-        model: NotRequired[
-            Literal[
-                "AZURE_GPT_4_0613",
-                "AZURE_GPT_4_32K_0613",
-            ]
-        ]
-        timeout: NotRequired["int"]
-        messages: List["Integrated.ChatCompletionRequestMessage"]
+    class CommonIntegratedParams(RequestOptions):
+        model: NotRequired[str]
         searchContext: NotRequired[List["Integrated.SearchResult"]]
         chatId: str
         assistantId: str
         assistantMessageId: str
         userMessageId: str
         startText: NotRequired["str"]
-        debugInfo: NotRequired[Dict[str, Any]]
+        debugInfo: NotRequired[dict[str, Any]]
+
+    class CreateStream(CommonIntegratedParams):
+        timeout: NotRequired["int"]
+        messages: List["Integrated.ChatCompletionRequestMessage"]
 
     # For further details about the responses parameters, see the OpenAI API documentation.
-    class CreateStreamResponseParams(TypedDict):
-        debugInfo: Optional[Dict[str, Any]] = None
-        input: Any
-        model: str
-        searchContext: Optional[List["Integrated.SearchResult"]] = None
-        chatId: str
-        assistantMessageId: str
-        userMessageId: str
-        startText: str | None = None
-        include: Optional[
-            list[
-                Literal[
-                    "computer_call_output.output.image_url",
-                    "file_search_call.results",
-                    "message.input_image.image_url",
-                    "reasoning.encrypted_content",
-                ]
-            ]
-        ] = None
-        instructions: str | None = None
-        max_output_tokens: int | None = None
-        metadata: Optional[Dict[str, str]] = None
-        parallel_tool_calls: float | None = None
-        temperature: float | None = None
-        text: Any
-        tool_choice: Any
-        tools: Any
-        top_p: float | None = None
-        reasoning: Any
+    # Note that other parameters from openai.resources.responses.Response.create can be passed
+    class CreateStreamResponsesOpenaiParams(TypedDict):
+        include: NotRequired[list["ResponseIncludable"] | None]
+        instructions: NotRequired[str | None]
+        max_output_tokens: NotRequired[int | None]
+        metadata: NotRequired[Union["Metadata", None]]
+        parallel_tool_calls: NotRequired[bool | None]
+        temperature: NotRequired[float | None]
+        text: NotRequired["ResponseTextConfigParam"]
+        tool_choice: NotRequired["response_create_params.ToolChoice"]
+        tools: NotRequired[list["ToolParam"]]
+        top_p: NotRequired[float | None]
+        reasoning: NotRequired["Reasoning"]
+
+    class CreateStreamResponsesParams(CommonIntegratedParams):
+        input: Union[str, "ResponseInputParam"]
+        options: NotRequired["Integrated.CreateStreamResponsesOpenaiParams"]
 
     class ToolCall(TypedDict):
         id: str
-        name: str | None = None
-        arguments: str | None = None
+        name: str | None
+        arguments: str | None
 
     class ResponsesStreamResult(TypedDict):
         id: str
         message: Message
         toolCalls: List["Integrated.ToolCall"]
+        output: list["ResponseOutputItem"]
 
     @classmethod
     def chat_stream_completion(
@@ -146,7 +147,7 @@ class Integrated(APIResource["Integrated"]):
         cls,
         user_id: str,
         company_id: str,
-        **params: Unpack["Integrated.CreateStreamResponseParams"],
+        **params: Unpack["Integrated.CreateStreamResponsesParams"],
     ) -> "Integrated.ResponsesStreamResult":
         """
         Executes a call to the language model and streams to the chat in real-time.
@@ -154,7 +155,7 @@ class Integrated(APIResource["Integrated"]):
         In the form of [sourceX]. The reference documents must be given as a list in searchContext.
         """
         return cast(
-            "Integrated.Responses",
+            "Integrated.ResponsesStreamResult",
             cls._static_request(
                 "post",
                 "/integrated/chat/stream-responses",
@@ -169,7 +170,7 @@ class Integrated(APIResource["Integrated"]):
         cls,
         user_id: str,
         company_id: str,
-        **params: Unpack["Integrated.CreateStreamResponseParams"],
+        **params: Unpack["Integrated.CreateStreamResponsesParams"],
     ) -> "Integrated.ResponsesStreamResult":
         """
         Executes a call to the language model and streams to the chat in real-time.
@@ -177,7 +178,7 @@ class Integrated(APIResource["Integrated"]):
         In the form of [sourceX]. The reference documents must be given as a list in searchContext.
         """
         return cast(
-            "Integrated.Responses",
+            "Integrated.ResponsesStreamResult",
             cls._static_request(
                 "post",
                 "/integrated/chat/stream-responses",

unique_sdk/api_resources/_llm_models.py

@@ -0,0 +1,64 @@
+from typing import ClassVar, List, Literal, NotRequired, TypedDict, Unpack, cast
+
+from unique_sdk._api_resource import APIResource
+from unique_sdk._request_options import RequestOptions
+
+
+class LLMModels(APIResource["LLMModels"]):
+    OBJECT_NAME: ClassVar[Literal["llm-models"]] = "llm-models"
+
+    class GetParams(RequestOptions):
+        """
+        Parameters for getting available LLM models.
+        """
+
+        module: NotRequired[str | None]
+
+    class LLMModelsResponse(TypedDict):
+        """
+        Response for getting available LLM models.
+        """
+
+        models: List[str]
+
+    @classmethod
+    def get_models(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["LLMModels.GetParams"],
+    ) -> "LLMModels.LLMModelsResponse":
+        """
+        Get available LLM models.
+        """
+        return cast(
+            "LLMModels.LLMModelsResponse",
+            cls._static_request(
+                "get",
+                "/openai/models",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )
+
+    @classmethod
+    async def get_models_async(
+        cls,
+        user_id: str,
+        company_id: str,
+        **params: Unpack["LLMModels.GetParams"],
+    ) -> "LLMModels.LLMModelsResponse":
+        """
+        Async get available LLM models.
+        """
+        return cast(
+            "LLMModels.LLMModelsResponse",
+            await cls._static_request_async(
+                "get",
+                "/openai/models",
+                user_id,
+                company_id,
+                params=params,
+            ),
+        )

unique_sdk/api_resources/_mcp.py

@@ -59,6 +59,8 @@ class MCP(APIResource["MCP"]):
         """Parameters for calling an MCP tool."""
 
         name: str
+        messageId: str
+        chatId: str
         arguments: Dict[str, Any]
 
     # Response fields