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

unique_sdk-0.10.19.dist-info/METADATA

@@ -1,1774 +0,0 @@
-Metadata-Version: 2.1
-Name: unique_sdk
-Version: 0.10.19
-Summary: 
-License: MIT
-Author: Martin Fadler
-Author-email: martin.fadler@unique.ch
-Requires-Python: >=3.11,<4.0
-Classifier: License :: OSI Approved :: MIT License
-Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.11
-Classifier: Programming Language :: Python :: 3.12
-Requires-Dist: requests (>=2.32.3,<3.0.0)
-Requires-Dist: typing-extensions (>=4.9.0,<5.0.0)
-Description-Content-Type: text/markdown
-
-# Unique Python SDK
-
-Unique FinanceGPT is a tailored solution for the financial industry, designed to increase productivity by automating manual workloads through AI and ChatGPT solutions.
-
-The Unique Python SDK provides access to the public API of Unique FinanceGPT. It also enables verification of Webhook signatures to ensure the authenticity of incoming Webhook requests.
-
-## Table of Contents
-
-1. [Installation](#installation)
-2. [Requirements](#requirements)
-3. [Usage Instructions](#usage-instructions)
-4. [Webhook Triggers](#webhook-triggers)
-5. [Available API Resources](#available-api-resources)
-   - [Content](#content)
-   - [Message](#message)
-   - [Chat Completion](#chat-completion)
-   - [Embeddings](#embeddings)
-   - [Acronyms](#acronyms)
-   - [Search](#search)
-   - [Search String](#search-string)
-   - [Short Term Memory](#short-term-memory)
-   - [Message Assessment](#message-assessment)
-   - [Folder](#folder)
-   - [Space](#space)
-6. [UniqueQL](#uniqueql)
-   - [Query Structure](#uniqueql-query-structure)
-   - [Metadata Filtering](#metadata-filtering)
-7. [Util functions](#utils)
-   - [Chat History](#chat-history)
-   - [File Io](#file-io)
-   - [Sources](#sources)
-   - [token](#token)
-   - [Chat In Space](#chat-in-space)
-8. [Error Handling](#error-handling)
-9. [Examples](#examples)
-
-## Installation
-
-Install UniqueSDK and its peer dependency `requests` and when planning to run async requests also `httpx` or `aiohttp` via pip using the following commands:
-
-```bash
-pip install unique_sdk
-pip install requests
-```
-
-Optional for async requests:
-
-```bash
-pip install httpx
-```
-
-or
-
-```bash
-pip install aiohttp
-```
-
-## Requirements
-
-- Python >=3.11 (Other Python versions 3.6+ might work but are not tested)
-- requests (peer dependency. Other HTTP request libraries might be supported in the future)
-- Unique App-ID & API Key
-
-Please contact your customer success manager at Unique for your personal developer App-ID & API Key.
-
-## Usage instructions
-
-The library needs to be configured with your Unique `app_id` & `api_key`. Additionally, each individual request must be scoped to a User and provide a `user_id` & `company_id`.
-
-```python
-import unique_sdk
-unique_sdk.api_key = "ukey_..."
-unique_sdk.app_id = "app_..."
-```
-
-The SDK includes a set of classes for API resources. Each class contains CRUD methods to interact with the resource.
-
-### Example
-
-```python
-import unique_sdk
-unique_sdk.api_key = "ukey_..."
-unique_sdk.app_id = "app_..."
-
-# list messages for a single chat
-messages = unique_sdk.Message.list(
-    user_id=user_id,
-    company_id=company_id,
-    chatId=chat_id,
-)
-
-print(messages.data[0].text)
-```
-
-## Webhook Triggers
-
-A core functionality of FinanceGPT is the ability for users to engage in an interactive chat feature. SDK developers can hook into this chat to provide new functionalities.
-
-Your App (refer to `app-id` in [Requirements](#requirements)) must be subscribed to each individual Unique event in order to receive a webhook.
-
-Each webhook sent by Unique includes a set of headers:
-
-```yaml
-X-Unique-Id: evt_... # Event id, same as in the body.
-X-Unique-Signature: ... # A HMAC-SHA256 hex signature of the entire body.
-X-Unique-Version: 1.0.0 # Event payload version.
-X-Unique-Created-At: 1705960141 # Unix timestamp (seconds) of the delivery time.
-X-Unique-User-Id: ... # The user who initiated the message.
-X-Unique-Company-Id: ... # The company to which the user belongs.
-```
-
-### Success & Retry on Failure
-
-- Webhooks are considered successfully delivered if your endpoint returns a status code between `200` and `299`.
-- If your endpoint returns a status code of `300` - `399`, `429`, or `500` - `599`, Unique will retry the delivery of the webhook with an exponential backoff up to five times.
-- If your endpoint returns any other status (e.g., `404`), it is marked as expired and will not receive any further requests.
-
-### Webhook Signature Verification
-
-The webhook body, containing a timestamp of the delivery time, is signed with HMAC-SHA256. Verify the signature by constructing the `event` with the `unique_sdk.Webhook` class:
-
-```python
-from http import HTTPStatus
-from flask import Flask, jsonify, request
-import unique_sdk
-
-endpoint_secret = "YOUR_ENDPOINT_SECRET"
-
-@app.route("/webhook", methods=["POST"])
-def webhook():
-    event = None
-    payload = request.data
-
-    sig_header = request.headers.get("X-Unique-Signature")
-    timestamp = request.headers.get("X-Unique-Created-At")
-
-    if not sig_header or not timestamp:
-        print("⚠️  Webhook signature or timestamp headers missing.")
-        return jsonify(success=False), HTTPStatus.BAD_REQUEST
-
-    try:
-        event = unique_sdk.Webhook.construct_event(
-            payload, sig_header, timestamp, endpoint_secret
-        )
-    except unique_sdk.SignatureVerificationError as e:
-        print("⚠️  Webhook signature verification failed. " + str(e))
-        return jsonify(success=False), HTTPStatus.BAD_REQUEST
-```
-
-The `construct_event` method will compare the signature and raise a `unique_sdk.SignatureVerificationError` if the signature does not match. It will also raise this error if the `createdAt` timestamp is outside of a default tolerance of 5 minutes. Adjust the `tolerance` by passing a fifth parameter to the method (tolerance in seconds), e.g.:
-
-```python
-event = unique_sdk.Webhook.construct_event(
-    payload, sig_header, timestamp, endpoint_secret, 0
-)
-```
-
-### Available Unique Events
-
-#### User Message Created
-
-```json
-{
-  "id": "evt_...", // see header
-  "version": "1.0.0", // see header
-  "event": "unique.chat.user-message.created", // The name of the event
-  "createdAt": "1705960141", // see header
-  "userId": "...", // see header
-  "companyId": "...", // see header
-  "payload": {
-    "chatId": "chat_...", // The id of the chat
-    "assistantId": "assistant_...", // The id of the selected assistant
-    "text": "Hello, how can I help you?" // The user message
-  }
-}
-```
-
-This webhook is triggered for every new chat message sent by the user. This event occurs regardless of whether it is the first or a subsequent message in a chat. Use the `unique_sdk.Message` class to retrieve other messages from the same `chatId` or maintain a local state of the messages in a single chat.
-
-This trigger can be used in combination with assistants marked as `external`. Those assistants will not execute any logic, enabling your code to respond to the user message and create an answer.
-
-#### External Module Chosen
-
-```json
-{
-  "id": "evt_...",
-  "version": "1.0.0",
-  "event": "unique.chat.external-module.chosen",
-  "createdAt": "1705960141", // Unix timestamp (seconds)
-  "userId": "...",
-  "companyId": "...",
-  "payload": {
-    "name": "example-sdk", // The name of the module selected by the module chooser
-    "description": "Example SDK", // The description of the module
-    "configuration": {}, // Module configuration in JSON format
-    "chatid": "chat_...", // The chat ID
-    "assistantId:": "assistant_...", // The assistant ID
-    "userMessage": {
-      "id": "msg_...",
-      "text": "Hello World!", // The user message leading to the module selection
-      "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
-    },
-    "assistantMessage": {
-      "id": "msg_...",
-      "createdAt": "2024-01-01T00:00:00.000Z" // ISO 8601
-    }
-  }
-}
-```
-
-This Webhook is triggered when the Unique FinanceGPT AI selects an external module as the best response to a user message. The module must be marked as `external` and available for the assistant used in the chat to be selected by the AI.
-
-Unique's UI will create an empty `assistantMessage` below the user message and update this message with status updates.
-
-**The SDK is expected to modify this assistantMessage with its answer to the user message.**
-
-```python
-unique_sdk.Message.modify(
-    user_id=user_id,
-    company_id=company_id,
-    id=assistant_message_id,
-    chatId=chat_id,
-    text="Here is your answer.",
-)
-```
-
-## Available API Resources
-
-- [Content](#content)
-- [Message](#message)
-- [Chat Completion](#chat-completion)
-- [Embeddings](#embeddings)
-- [Acronyms](#acronyms)
-- [Search](#search)
-- [Search String](#search-string)
-- [Short Term Memory](#short-term-memory)
-- [Message Assessment](#message-assessment)
-- [Folder](#folder)
-- [Space](#space)
-
-Most of the API services provide an asynchronous version of the method. The async methods are suffixed with `_async`.
-
-### Content
-
-#### `unique_sdk.Content.search`
-
-Allows you to load full content/files from the knowledge-base of unique with the rights of the userId and companyId. Provided a `where` query for filtering. Filtering can be done on any of the following fields: `
-
-- `id`
-- `key`
-- `ownerId`
-- `title`
-- `url`
-
-Here an example of retrieving all files that contain the number 42 in the `title` or the `key` typically this is used to search by filename.
-
-```python
-unique_sdk.Content.search(
-    user_id=userId,
-    company_id=companyId,
-    where={
-        "OR": [
-            {
-                "title": {
-                    "contains": "42",
-                },
-            },
-            {
-                "key": {
-                    "contains": "42",
-                },
-            },
-        ],
-    },
-    chatId=chatId,
-)
-```
-
-#### `unique_sdk.Content.get_info`
-
-[Deprecated, use `unique_sdk.Content.get_infos` instead.] Allows you to get content info. To filter the results you can define a metadata filter in UniqueQL language. Find out more about it in the UniqueQL section. An example of a metadata filter defined with UniqueQL is the following:
-
-```python
-    metadataFilter: {
-        "or": [
-            {
-                "and": [
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "folderIdPath"
-                        ],
-                        "value": "uniquepathid://test_id"
-                    },
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "title"
-                        ],
-                        "value": "ai"
-                    }
-                ]
-            }
-        ]
-    },
-```
-
-Pagination is also enabled for this functionality, and the default number of returned results is 50 with no entries skipped. Use the following paramteres to get the desired page:`
-
-- `skip`
-- `take`
-
-Here is an example of retrieving the first 3 content infos that contain the value `uniquepathid://scope_abcdibgznc4bkdcx120zm5d` in the `folderIdPath` metadata and the value `ai` for the `title` metadata.
-
-```python
-content_info_result = unique_sdk.Content.get_info(
-    user_id=user_id,
-    company_id=company_id,
-    metadataFilter={
-        "or": [
-            {
-                "and": [
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "folderIdPath"
-                        ],
-                        "value": "uniquepathid://scope_abcdibgznc4bkdcx120zm5d"
-                    },
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "title"
-                        ],
-                        "value": "ai"
-                    }
-                ]
-            }
-        ]
-    },
-    skip=0,
-    take=3,
-)
-```
-
-#### `unique_sdk.Content.get_infos`
-
-Allows you to get content infos. To filter the results you can define a either metadata filter in UniqueQL language or specify a parentId. If both are defined, the function will throw an error.
-
-I f you want to learn more about UniqueQL, you can find out more about it in the [UniqueQL](#uniqueql) section. An example of a metadata filter defined with UniqueQL is the following:
-
-```python
-    metadataFilter: {
-        "or": [
-            {
-                "and": [
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "folderIdPath"
-                        ],
-                        "value": "uniquepathid://test_id"
-                    },
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "title"
-                        ],
-                        "value": "ai"
-                    }
-                ]
-            }
-        ]
-    },
-```
-
-Pagination is also enabled for this functionality, and the default number of returned results is 50 with no entries skipped. Use the following paramteres to get the desired page:`
-
-- `skip`
-- `take`
-
-Here is an example of retrieving the first 3 content infos that contain the value `uniquepathid://scope_abcdibgznc4bkdcx120zm5d` in the `folderIdPath` metadata and the value `ai` for the `title` metadata.
-
-```python
-content_info_result = unique_sdk.Content.get_infos(
-    user_id=user_id,
-    company_id=company_id,
-    metadataFilter={
-        "or": [
-            {
-                "and": [
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "folderIdPath"
-                        ],
-                        "value": "uniquepathid://scope_abcdibgznc4bkdcx120zm5d"
-                    },
-                    {
-                        "operator": "contains",
-                        "path": [
-                            "title"
-                        ],
-                        "value": "ai"
-                    }
-                ]
-            }
-        ]
-    },
-    skip=0,
-    take=3,
-)
-```
-
-Here is an example of retrieving the contents based on a parentId.
-
-```python
-content_info_result = unique_sdk.Content.get_infos(
-    user_id=user_id,
-    company_id=company_id,
-    parentId="scope_ahefgj389srjbfejkkk98u"
-)
-```
-
-#### `unique_sdk.Content.upsert`
-
-Enables upload of a new Content into the Knowledge base of unique into a specific scope with `scopeId` or a specific `chatId`. One of the two must be set.
-
-Typical usage is the following. That creates a Content and uploads a file
-
-```python
-
-createdContent = upload_file(
-    userId,
-    companyId,
-    "/path/to/file.pdf",
-    "test.pdf",
-    "application/pdf",
-    "scope_stcj2osgbl722m22jayidx0n",
-    ingestionConfig={
-        "chunkMaxTokens": 1000,
-        "chunkStrategy": "default",
-        "uniqueIngestionMode": "standard",
-    },
-    metadata={
-        "folderIdPath": "uniquepathid://scope_id"
-    }
-)
-
-def upload_file(
-    userId,
-    companyId,
-    path_to_file,
-    displayed_filename,
-    mimeType,
-    scope_or_unique_path,
-    ingestion_config=None,
-    metadata=None,
-):
-    size = os.path.getsize(path_to_file)
-    createdContent = unique_sdk.Content.upsert(
-        user_id=userId,
-        company_id=companyId,
-        input={
-            "key": displayed_filename,
-            "title": displayed_filename,
-            "mimeType": mimeType,
-            "ingestionConfig": ingestionConfig,
-            "metadata": metadata,
-        },
-        scopeId=scope_or_unique_path,
-    )
-
-    uploadUrl = createdContent.writeUrl
-
-    # upload to azure blob storage SAS url uploadUrl the pdf file translatedFile make sure it is treated as a application/pdf
-    with open(path_to_file, "rb") as file:
-        requests.put(
-            uploadUrl,
-            data=file,
-            headers={
-                "X-Ms-Blob-Content-Type": mimeType,
-                "X-Ms-Blob-Type": "BlockBlob",
-            },
-        )
-
-    unique_sdk.Content.upsert(
-        user_id=userId,
-        company_id=companyId,
-        input={
-            "key": displayed_filename,
-            "title": displayed_filename,
-            "mimeType": mimeType,
-            "byteSize": size,
-            "ingestionConfig": ingestionConfig,
-            "metadata": metadata,
-        },
-        scopeId=scope_or_unique_path,
-        readUrl=createdContent.readUrl,
-    )
-
-    return createdContent
-
-```
-
-#### `unique_sdk.Content.ingest_magic_table_sheets`
-
-Allows you to ingest a magic table sheet, each row is processed and converted into a content.
-```python
-    params = {
-      "user_id": user_id,
-      "company_id": company_id,
-      "data": [
-         {
-            "rowId": "2",
-            "columns": [
-               {"columnId": "0", "columnName": "Section", "content": "Other"},
-               {"columnId": "1", "columnName": "Question", "content": "What do you know?"},
-               {
-                  "columnId": "2",
-                  "columnName": "Knowledge Base Answer",
-                  "content": "Lorem Ipsum is simply dummy texktop publishing software.",
-               },
-            ],
-         },
-      ],
-      "ingestionConfiguration": {
-         "columnIdsInMetadata": ["1", "2"],
-         "columnIdsInChunkText": ["1", "2"],
-      },
-      "metadata": {
-         "libraryName": "foo",
-      },
-      "scopeId": scope_id,
-      "sheetName": "Sheet1",
-   }
-
-    unique_sdk.Content.ingest_magic_table_sheets(**params)
-```
-
-#### `unique_sdk.Content.update` (Compatible with release >.36)
-
-Allows you to update a file specified by its `contentId`.
-
-- `contentId` the id of the file to be updated
-
-Currently, the following updates are supported:
-
-Title update:
-- `title` optional, allows updating the title of the folder
-
-Move the file to a different folder. this can be done by specifying either the `ownerId`.
-- `ownerId` optional, allows moving the file to a different folder. Represents the new folder for the file and it should be the id of a folder e.g.: `scope_dhjfieurfloakmdle`. 
-
-
-Example of moving a file specified by its content id.
-
-```python
-unique_sdk.Content.update(
-    user_id=user_id,
-    company_id=company_id,
-    contentId="cont_ok2343q5owbce80w78hudawu5",
-    ownerId="scope_e68yz5asho7glfh7c7d041el"
-)
-```
-
-Example of moving a file and updating its title.
-
-```python
-unique_sdk.Content.update(
-    user_id=user_id,
-    company_id=company_id,
-    contentId="cont_ok2343q5owbce80w78hudawu5",
-    ownerId="scope_e68yz5asho7glfh7c7d041el",
-    title="Revision Deck (1)"
-)
-```
-
-#### `unique_sdk.Content.delete` (Compatible with release >.36)
-
-Allows you to delete a file by its `contentId`. If the file is part of a chat, the `chatId` also needs do be set.
-
-- `contentId` the id of the file to be deleted
-- `chatId` optional, the id of the chat where the file is. Only needed if the file is part of a chat
-
-Example of deleting a file from a chat.
-
-```python
-unique_sdk.Content.delete(
-    user_id=user_id,
-    company_id=company_id,
-    contentId="cont_ok2343q5owbce80w78hudawu5",
-    chatId="chat_v3xfa7liv876h89vuiibus1"
-)
-```
-
-### Message
-
-#### `unique_sdk.Message.list`
-
-Retrieve a list of messages for a provided `chatId`.
-
-```python
-messages = unique_sdk.Message.list(
-    user_id=user_id,
-    company_id=company_id,
-    chatId=chat_id,
-)
-```
-
-#### `unique_sdk.Message.retrieve`
-
-Get a single chat message.
-
-```python
-message = unique_sdk.Message.retrieve(
-    user_id=user_id,
-    company_id=company_id,
-    id=message_id,
-    chatId=chat_id,
-)
-```
-
-#### `unique_sdk.Message.create`
-
-Create a new message in a chat.
-
-```python
-message = unique_sdk.Message.create(
-    user_id=user_id,
-    company_id=company_id,
-    chatId=chat_id,
-    assistantId=assistant_id,
-    text="Hello.",
-    role="ASSISTANT",
-)
-```
-
-#### `unique_sdk.Message.modify`
-
-Modify an existing chat message.
-
-ℹ️ if you modify the debugInfo only do it on the user message as this is the only place that is displayed in the frontend.
-
-```python
-message = unique_sdk.Message.modify(
-    user_id=user_id,
-    company_id=company_id,
-    id=message_id,
-    chatId=chat_id,
-    text="Updated message text"
-)
-```
-
-#### `unique_sdk.Message.delete`
-
-Delete a chat message.
-
-```python
-message = unique_sdk.Message.delete(
-    message_id,
-    user_id=user_id,
-    company_id=company_id,
-    chatId=chat_id,
-)
-```
-
-#### `unique_sdk.Integrated.stream`
-
-Streams the answer to the chat frontend. Given the messages.
-
-if the stream creates [source0] it is referenced with the references from the search context.
-
-E.g.
-
-```
-Hello this information is from [srouce1]
-```
-
-adds the reference at index 1 and then changes the text to:
-
-```
-Hello this information is from <sub>0</sub>
-```
-
-```python
-unique_sdk.Integrated.chat_stream_completion(
-    user_id=userId,
-    company_id=companyId,
-    assistantMessageId=assistantMessageId,
-    userMessageId=userMessageId,
-    messages=[
-        {
-            "role": "system",
-            "content": "be friendly and helpful"
-        },
-        {
-            "role": "user",
-            "content": "hello"
-        }
-    ],
-    chatId=chatId,
-
-    searchContext=  [
-        {
-            "id": "ref_qavsg0dcl5cbfwm1fvgogrvo",
-            "chunkId": "0",
-            "key": "some reference.pdf : 8,9,10,11",
-            "sequenceNumber": 1,
-            "url": "unique://content/cont_p8n339trfsf99oc9f36rn4wf"
-        }
-    ],  # optional
-    debugInfo={
-        "hello": "test"
-    }, # optional
-    startText= "I want to tell you about: ", # optional
-    model= "AZURE_GPT_4_32K_0613", # optional
-    timeout=8000,  # optional in ms
-    options={
-                "temperature": 0.5
-            } # optional
-)
-```
-
-**Warning:** Currently, the deletion of a chat message does not automatically sync with the user UI. Users must refresh the chat page to view the updated state. This issue will be addressed in a future update of our API.
-
-
-#### `unique_sdk.Integrated.responses_stream`
-
-Streams the answer to the chat frontend using the Responses API. Given the messages.
-
-if the stream creates [source0] it is referenced with the references from the search context.
-
-E.g.
-
-```
-Hello this information is from [source1]
-```
-
-adds the reference at index 1 and then changes the text to:
-
-```
-Hello this information is from <sub>0</sub>
-```
-
-```python
-unique_sdk.Integrated.responses_stream(
-    user_id=userId,
-    company_id=companyId,
-    model="AZURE_o3_2025_0416",
-    assistantMessageId=assistantMessageId,
-    userMessageId=userMessageId,
-    input="Tell me about the curious case of neural text degeneration",
-    chatId=chatId,
-)
-```
-
-**Warning:** Currently, the deletion of a chat message does not automatically sync with the user UI. Users must refresh the chat page to view the updated state. This issue will be addressed in a future update of our API.
-
-### Chat Completion
-
-#### `unique_sdk.ChatCompletion.create`
-
-Send a prompt to an AI model supported by Unique FinanceGPT and receive a result. The `messages` attribute must follow the [OpenAI API format](https://platform.openai.com/docs/api-reference/chat).
-
-```python
-chat_completion = unique_sdk.ChatCompletion.create(
-    company_id=company_id,
-    user_id=user_id
-    model="AZURE_GPT_35_TURBO",
-    messages=[
-        {"role": "system", "content": "You are a helpful assistant."},
-        {"role": "user", "content": "Hello!"},
-    ],
-    options={
-            "temperature": 0.5
-        } # optional
-)
-```
-
-### Embeddings
-
-#### `unique_sdk.Embeddings.create`
-
-Sends an array of `text` to the AI model for embedding. And retrieve a vector of embeddings.
-
-```python
-result = unique_sdk.Embeddings.create(
-    user_id=user_id,
-    company_id=company_id,
-    texts=["hello", "hello"],
-)
-print(result.embeddings[0][0])
-```
-
-### Acronyms
-
-#### `unique_sdk.Acronyms.get`
-
-Fetches the acronyms defined on the company. Often used to replace in user prompts, so the acronym is resolved to give better guidance to the LLM during completion.
-
-```python
-result = unique_sdk.Acronyms.get(
-    user_id=user_id,
-    company_id=company_id,
-)
-print(result)
-```
-
-### Search
-
-#### `unique_sdk.Search.create`
-
-Search the Unique FinanceGPT Knowledge database for RAG (Retrieval-Augmented Generation). The API supports vector search and a `searchType` that combines vector and full-text search, enhancing the precision of search results.
-
-These are the options are available for `searchType`:
-
-- `VECTOR`
-- `COMBINED`
-
-`limit` (max 1000) and `page` are optional for iterating over results.
-`chatOnly` Restricts the search exclusively to documents uploaded within the chat.
-`scopeIds` Specifies a collection of scope IDs to confine the search.
-`language` Optional. The language specification for full text search.
-`reranker` Optional. The reranker service to be used for re-ranking the search results.
-`chatId` Optional, adds the documents uploaded in this chat to the scope of searched documents.
-`scoreThreshold` Optional, sets the minimum similarity score for search results to be considered. Using 0 is recommended.
-
-```python
-search = unique_sdk.Search.create(
-    user_id=user_id,
-    company_id=company_id,
-    chatId=chat_id
-    searchString="What is the meaning of life, the universe and everything?",
-    searchType="VECTOR",
-    chatOnly=false,
-    scopeIds=["scope_..."],
-    language="German",
-    reranker={"deploymentName": "my_deployment"},
-    limit=20,
-    page=1
-    scoreThreshold=0
-)
-```
-
-### Search String
-
-#### `unique_sdk.SearchString.create`
-
-User messages are sometimes suboptimal as input prompts for vector or full-text knowledge base searches. This is particularly true as a conversation progresses and a user question may lack crucial context for a successful search.
-
-This API transforms and translates (into English) the user's message into an ideal search string for use in the [Search.create](#unique_sdksearchcreate) API method.
-
-Adding a `chatId` or `messages` as arguments allows the message history to provide additional context to the search string. For example, "Who is the author?" will be expanded to "Who is the author of the book 'The Hitchhiker's Guide to the Galaxy'?" if previous messages referenced the book.
-
-```python
-search_string = unique_sdk.SearchString.create(
-    user_id=user_id,
-    company_id=company_id,
-    prompt="Was ist der Sinn des Lebens, des Universums und des ganzen Rests?",
-    chat_id=chat_id
-)
-```
-
-### Short Term Memory
-
-For saving data in between chats there is the Short Term Memory functionality to save small data in between rounds of chat e.g. language, search results and so on.
-For this 10k chars can be used. You can save a short term memory for a chat `chatId` or for a message `messageId`.
-you need to provide an `memoryName` as an identifier.
-
-you can then save it and retreive it live defined below.
-
-
-#### `unique_sdk.ShortTermMemory.create`
-
-```python
-c = unique_sdk.ShortTermMemory.create(
-    user_id=user_id,
-    company_id=company_id,
-    data="hello",
-    chatId="chat_x0xxtj89f7drjp4vmued3q",
-    # messageId = "msg_id",
-    memoryName="your memory name",
-)
-print(c)
-```
-
-#### `unique_sdk.ShortTermMemory.find-latest`
-
-```python
-m = unique_sdk.ShortTermMemory.find_latest(
-    user_id=user_id,
-    company_id=company_id,
-    chatId="chat_x0xxtj89f7drjp4vmued3q",
-     # messageId = "msg_id",
-    memoryName="your memory name",
-)
-print(m)
-```
-
-### Message Assessment
-
-Used to create and modify message assessments for tracking hallucinations and compliance evaluations of assistant messages.
-
-#### `unique_sdk.MessageAssessment.create`
-
-Create a new message assessment for an assistant message.
-
-```python
-assessment = unique_sdk.MessageAssessment.create(
-    user_id=user_id,
-    company_id=company_id,
-    assistant_message_id="msg_...",
-    status="DONE",
-    explanation="This response contains incorrect information about...",
-    label="RED",
-    type="HALLUCINATION",
-    title="Hallucination detected",
-    isVisible=True
-)
-```
-
-#### `unique_sdk.MessageAssessment.modify` 
-
-Modify an existing message assessment.
-
-```python
-assessment = unique_sdk.MessageAssessment.modify(
-    user_id=user_id,
-    company_id=company_id,
-    assistant_message_id="msg_...",
-    status="DONE",
-    explanation="Updated explanation...",
-    label="RED",
-    title="update title"
-    type="HALLUCINATION"
-)
-```
-
-### Folder
-
-#### `unique_sdk.Folder.get_info`
-
-Get a folder by scope id or by path.
-
-By scope id:
-
-```python
-unique_sdk.Folder.get_info(
-   user_id=user_id,
-   company_id=company_id,
-   scopeId="scope_w78wfn114va9o22s13r03yq",
-)
-```
-
-By path:
-
-```python
-unique_sdk.Folder.get_info(
-   user_id=user_id,
-   company_id=company_id,
-   folderPath="/Company/Atlas/Due Dilligence/Arch,
-)
-```
-
-#### `unique_sdl.Folder.get_infos`
-
-Get paginated folders info based on parentId. If the parentId is not defined, the root folders will be returned.
-
-```python
-unique_sdk.Folder.get_infos(
-    user_id=user_id,
-    company_id=company_id,
-    take=10,                                    #optional
-    skip=5,                                     #optional
-    parentId="scope_s18seqpnltf35niydg77xgyp"   #optional
-)
-```
-
-#### `unique_sdk.Folder.create_paths`
-
-Create each folder in the provided list of paths if it does not already exist.
-
-```python
-unique_sdk.Folder.create_paths(
-   user_id=user_id,
-   company_id=company_id,
-   paths=["/unique/path1", "/unique/path2"],
-)
-```
-
-#### `unique_sdk.Folder.update_ingestion_config`
-
-Allows you to update the ingestion config of a folder and choose whether to apply to the subscopes or not: `
-
-- `ingestionConfig`
-- `applyToSubScopes`
-
-The update can be done by referencing the folder by id or by path. If none of them are provided. the API will return an error. If both of them are provided, the scope id will take precedence.
-
-Example of updating the ingestion config of a folder and its subfolders using the id.
-
-```python
-unique_sdk.Folder.update_ingestion_config(
-    user_id=user_id,
-    company_id=company_id,
-    scopeId="scope_qbnkde820dbmuw2900,
-    ingestionConfig={
-        "chunkStrategy": "default",
-        "uniqueIngestionMode": "standard",
-    },
-    applyToSubScopes=True
-)
-```
-
-Example of updating the ingestion config of a folder and its subfolders using the path.
-
-```python
-unique_sdk.Folder.update_ingestion_config(
-    user_id=user_id,
-    company_id=company_id,
-    folderPath="/Company/folder1/folder2",
-    ingestionConfig={
-        "chunkStrategy": "default",
-        "uniqueIngestionMode": "standard",
-    },
-    applyToSubScopes=True
-)
-```
-
-#### `unique_sdk.Folder.add_access`
-
-Allows you to add access to a folder and apply to the subfolders or not: `
-
-- `scopeAccesses`
-- `applyToSubScopes`
-
-The update can be done by referencing the folder by id or by path. If none of them are provided. the API will return an error. If both of them are provided, the scope id will take precedence.
-
-Example of adding access to a folder and its subfolders using the id.
-
-```python
-unique_sdk.Folder.add_access(
-    user_id=user_id,
-    company_id=company_id,
-    scopeId="scope_231e4kjn4foffww34",
-    scopeAccesses=[
-        {
-            "entityId": "group_id",
-            "type": "WRITE",
-            "entityType": "GROUP",
-        }
-    ],
-    applyToSubScopes=True,
-)
-```
-
-Example of adding access to a folder and its subfolders using the folder path.
-
-```python
-unique_sdk.Folder.add_access(
-    user_id=user_id,
-    company_id=company_id,
-    folderPath="/Company/folder1/folder2"
-    scopeAccesses=[
-        {
-            "entityId": "group_id",
-            "type": "WRITE",
-            "entityType": "GROUP",
-        }
-    ],
-    applyToSubScopes=True,
-)
-```
-
-#### `unique_sdk.Folder.remove_access`
-
-Allows you to delete access from a folder and apply to the subfolders or not:
-
-- `scopeAccesses`
-- `applyToSubScopes`
-
-The update can be done by referencing the folder by id or by path. If none of them are provided. the API will return an error. If both of them are provided, the scope id will take precedence.
-
-
-Example of deleting the access from a folder and its subfolders using the id.
-
-```python
-unique_sdk.Folder.remove_access(
-    user_id=user_id,
-    company_id=company_id,
-    scopeId="scope_dwekjnf3330woioppm,
-    scopeAccesses=[
-        {
-            "entityId": "group_id",
-            "type": "WRITE",
-            "entityType": "GROUP",
-        }
-    ],
-    applyToSubScopes=True,
-)
-```
-
-
-Example of deleting the access from a folder and its subfolders using the path.
-
-```python
-unique_sdk.Folder.remove_access(
-    user_id=user_id,
-    company_id=company_id,
-    folderPath="/Company/folder1/folder2"
-    scopeAccesses=[
-        {
-            "entityId": "group_id",
-            "type": "WRITE",
-            "entityType": "GROUP",
-        }
-    ],
-    applyToSubScopes=True,
-)
-```
-
-#### `unique_sdk.Folder.delete` (Compatible with release >.36)
-
-Given a `scopeId` or `folderPath`, the function deletes the folder. If the folder is not empty or if the user has no WRITE access, the delete will fail.
-
-If `recursive` is set to true, the function also deletes its subfolders and its contents, behaving exactly like the `rm -rf`. In case a subfolder has no write access, that folder is considered as failed to delete and the function continues with the other subfolders. At the end, the function returns a list of `successFolders` and `failedFolders`.
-
-Examples:
-Deleting recursively by scope id:
-
-```python
-unique_sdk.Folder.delete(
-   user_id=user_id,
-   company_id=company_id,
-   scopeId="scope_w78wfn114va9o22s13r03yq",
-   recursive=True
-)
-```
-
-Deleting by path (non-recursive):
-
-```python
-unique_sdk.Folder.delete(
-   user_id=user_id,
-   company_id=company_id,
-   folderPath="/Company/Atlas/Due Dilligence/Arch",
-)
-```
-
-### Space
-
-#### `unique_sdk.Space.delete_chat`
-
-Delete a space chat by id. If the chat does not exist, the function will return an error.
-
-```python
-unique_sdk.Space.delete_chat(
-    user_id=user_id,
-    company_id=company_id,
-    chat_id="chat_dejfhe729br398",
-)
-```
-
-## UniqueQL
-
-[UniqueQL](https://unique-ch.atlassian.net/wiki/x/coAXHQ) is an advanced query language designed to enhance search capabilities within various search modes such as Vector, Full-Text Search (FTS), and Combined. This query language enables users to perform detailed searches by filtering through metadata attributes like filenames, URLs, dates, and more. UniqueQL is versatile and can be translated into different query formats for various database systems, including PostgreSQL and Qdrant.
-
-### UniqueQL Query Structure
-
-A UniqueQL query is composed of a path, an operator, and a value. The path specifies the metadata attribute to be filtered, the operator defines the type of comparison, and the value provides the criteria for the filter.
-
-A metadata filter can be designed with UniqueQL's `UQLOperator` and `UQLCombinator` as follows:
-
-```python
-metadata_filter = {
-        "path": ['diet', '*'],
-        "operator": UQLOperator.NESTED,
-        "value": {
-            UQLCombinator.OR : [
-                {
-                    UQLCombinator.OR: [
-                        {
-                            "path": ['food'],
-                            "operator": UQLOperator.EQUALS,
-                            "value": "meat",
-                        },
-                        {
-                            "path": ['food'],
-                            "operator": UQLOperator.EQUALS,
-                            "value": 'vegis',
-                        },
-                    ],
-                },
-                {
-                    "path": ['likes'],
-                    "operator": UQLOperator.EQUALS,
-                    "value": true,
-                },
-            ],
-        },
-    }
-```
-
-### Metadata Filtering
-
-A metadata filter such as the one designed above can be used in a `Search.create` call by passing it the `metaDataFilter` parameter.
-
-```python
-    search_results = unique_sdk.Search.create(
-        user_id=user_id,
-        company_id=company_id,
-        chatId=chat_id,
-        searchString=search_string,
-        searchType="COMBINED",
-        # limit=2,
-        metaDataFilter=metadata_filter,
-    )
-```
-
-## Utils
-
-- [Chat History](#chat-history)
-- [File Io](#file-io)
-- [Sources](#sources)
-- [token](#token)
-- [Chat In Space](#chat-in-space)
-
-### Chat History
-
-#### `unique_sdk.utils.chat_history.load_history`
-
-A helper function that makes sure the chat history is fully loaded and cut to the size of the token window that it fits into the next round of chat interactions.
-
-- `maxTokens` max tokens of the model used
-- `percentOfMaxTokens`=0.15 % max history in % of `maxTokens`
-- `maxMessages`=4, maximal number of messages included in the history.
-
-this method also directly returns a correct formatted history that can be used in the next chat round.
-
-```python
-history = unique_sdk.utils.chat_history.load_history(
-    userId,
-    companyId,
-    chatId
-)
-```
-
-#### `unique_sdk.utils.chat_history.convert_chat_history_to_injectable_string`
-
-convert history into a string that can be injected into a prompt. it als returns the token length of the converted history.
-
-```
-chat_history-string, chat_context_token_length = unique_sdk.utils.chat_history.convert_chat_history_to_injectable_string(
-    history
-)
-```
-
-### File Io
-
-Interacting with the knowledge-base.
-
-#### `unique_sdk.utils.file_io.download_content`
-
-download files and save them into a folder in `/tmp`
-
-for example using the readUrl from a content.
-
-```python
-pdfFile = download_content(
-    companyId=companyId,
-    userId=userId,
-    content_id="cont_12412",
-    filename="hello.pdf",
-    chat_id=None # If specified, it downloads it from the chat
-)
-```
-
-#### `unique_sdk.utils.file_io.upload_file`
-
-Allows for uploading files that then get ingested in a scope or a chat.
-
-```python
-createdContent = upload_file(
-    companyId=companyId,
-    userId=userId,
-    path_to_file="/tmp/hello.pdf",
-    displayed_filename="hello.pdf",
-    mime_type="application/pdf",
-    scope_or_unique_path="scope_stcj2osgbl722m22jayidx0n",
-    chat_id=None,
-)
-```
-
-### Sources
-
-#### `unique_sdk.utils.sources.merge_sources`
-
-Merges multiple search results based on their 'id', removing redundant document and info markers.
-
-This function groups search results by their 'id' and then concatenates their texts,
-cleaning up any document or info markers in subsequent chunks beyond the first one.
-
-Parameters:
-
-- searchContext (list): A list of dictionaries, each representing a search result with 'id' and 'text' keys.
-
-Returns:
-
-- list: A list of dictionaries with merged texts for each unique 'id'.
-
-`searchContext` is an list of search objects that are returned by the search.
-
-```python
-search = unique_sdk.Search.create(
-    user_id=userId,
-    company_id=companyId,
-    chatId=chatId,
-    searchString="Who is Harry P?",
-    searchType="COMBINED",
-    scopeIds="scope_dsf...",
-    limit=30,
-    chatOnly=False,
-)
-
-searchContext = unique_sdk.utils.token.pick_search_results_for_token_window(
-        search["data"], config["maxTokens"] - historyLength
-    )
-
-searchContext = unique_sdk.utils.sources.merge_sources(search)
-
-```
-
-#### `unique_sdk.utils.sources.sort_sources`
-
-Sort sources by order of appearance in documents
-
-```python
-
-search = unique_sdk.Search.create(
-    user_id=userId,
-    company_id=companyId,
-    chatId=chatId,
-    searchString="Who is Harry P?",
-    searchType="COMBINED",
-    scopeIds="scope_dsf...",
-    limit=30,
-    chatOnly=False,
-)
-
-searchContext = unique_sdk.utils.token.pick_search_results_for_token_window(
-        search["data"], config["maxTokens"] - historyLength
-    )
-
-searchContext = unique_sdk.utils.sources.sort_sources(search)
-```
-
-#### `unique_sdk.utils.sources.post_process_sources`
-
-Post-processes the provided text by converting source references into superscript numerals (required
-format by backend to display sources in the chat window)
-
-This function searches the input text for patterns that represent source references (e.g., [source1])
-and replaces them with superscript tags, incrementing the number by one.
-
-Parameters:
-
-- text (str): The text to be post-processed.
-
-Returns:
-
-- str: The text with source references replaced by superscript numerals.
-
-Examples:
-
-- postprocessSources("This is a reference [source0]") will return "This is a reference <sup>1</sup>".
-
-```python
-
-text_with_sup = post_process_sources(text)
-```
-
-### Token
-
-#### unique_sdk.utils.token.pick_search_results_for_token_window
-
-Selects and returns a list of search results that fit within a specified token limit.
-
-This function iterates over a list of search results, each with a 'text' field, and
-encodes the text using a predefined encoding scheme. It accumulates search results
-until the token limit is reached or exceeded.
-
-Parameters:
-
-- searchResults (list): A list of dictionaries, each containing a 'text' key with string value.
-- tokenLimit (int): The maximum number of tokens to include in the output.
-
-Returns:
-
-- list: A list of dictionaries representing the search results that fit within the token limit.
-
-```python
-search = unique_sdk.Search.create(
-    user_id=userId,
-    company_id=companyId,
-    chatId=chatId,
-    searchString="Who is Harry P?",
-    searchType="COMBINED",
-    scopeIds="scope_dsf...",
-    limit=30,
-    chatOnly=False,
-)
-
-searchContext = unique_sdk.utils.token.pick_search_results_for_token_window(
-        search["data"], config["maxTokens"] - historyLength
-    )
-```
-
-#### unique_sdk.utils.token.count_tokens
-
-Counts the number of tokens in the provided text.
-
-This function encodes the input text using a predefined encoding scheme
-and returns the number of tokens in the encoded text.
-
-Parameters:
-
-- text (str): The text to count tokens for.
-
-Returns:
-
-- int: The number of tokens in the text.
-
-```python
-hello = "hello you!"
-searchContext = unique_sdk.utils.token.count_tokens(hello)
-```
-
-### Chat In Space
-
-#### `unique_sdk.utils.chat_in_space.send_message_and_wait_for_completion`
-
-The following script enables you to chat within a space using an assistant. You must provide an `assistantId` (e.g., `assistant_hjcdga64bkcjnhu4`) and the message `text` to initiate the conversation. You can send the message in an existing chat by specifying a `chat_id`, or omit the `chat_id` to automatically create a new chat session. Check the optional parameteres list for more configs.
-
-The script sends a prompt asynchronously and continuously polls for completion, which is determined when the `stoppedStreamingAt` field of the message becomes non-null.
-
-**Optional parameters:**
-- `tool_choices`: A list of tool names to be used for the message (e.g., `["WebSearch"]`). If not provided, no tools will be used. The tools supported right now are `WebSearch` and `InternalSearch`.
-- `scope_rules`: A filter to specify the scope rules for the message, allowing you to restrict the context or data sources available to the assistant. The filter is written in UniqueQL language. Find out more about the language in the UniqueQL section.
-- `chat_id`: The ID of the chat where the message should be sent. If omitted, a new chat will be created.
-- `poll_interval`: The number of seconds to wait between polling attempts (default: `1` second).
-- `max_wait`: The maximum number of seconds to wait for the message to complete (default: `60` seconds).
-- `stop_condition`: Defines when to expect a response back, when the assistant stop streaming or when it completes the message. (default: "stoppedStreamingAt")
-
-The script ensures you can flexibly interact with spaces in new or ongoing chats, with fine-grained control over tools, context, and polling behavior.
-
-```python
-from unique_sdk.utils.chat_in_space import send_message_and_wait_for_completion
-latest_message = await send_message_and_wait_for_completion(
-    user_id=user_id,
-    company_id=company_id,
-    assistant_id=assistant_id,
-    text="Tell me a short story.",
-    chat_id=chat_id,                # Optional - if no chat id is specified, a new chat will be created
-    tool_choices=["WebSearch"],
-    scope_rules={
-        "or": [
-            {
-                "operator": "in",
-                "path": [
-                    "contentId"
-                ],
-                "value": [
-                    "cont_u888z7cazxxm4lugfdjq7pks"
-                ]
-            },
-            {
-                "operator": "contains",
-                "path": [
-                    "folderIdPath"
-                ],
-                "value": "uniquepathid://scope_btfo28b3eeelwh5obwgea71bl/scope_fn56ta67knd6w4medgq3028fx"
-            }
-        ]
-    },
-    stop_condition = "completedAt" # If not specified, stoppedStreamingAt will be set by default
-)
-```
-
-#### `unique_sdk.utils.chat_in_space.chat_against_file`
-
-The following script enables you to chat against a file.
-
-You must provide the following parameters:
-- `assistantId`: The assistant to be used for the chat.
-- `path_to_file`: The local path of the file to be uploaded.
-- `displayed_filename`: The name of the file to be displayed.
-- `mime_type`: The mime type of the ifle to be uploaded.
-- `text`: The text to be sent to the chat for chatting against the file.
-
-The script creates a chat and uploads the file to it. It then keeps polling the `ingestionState` field of the message, waiting for it to reach `FINISHED`, signaling the upload is complete. Once the file uploads successfully, the script sends the text, continues polling for completion, and finally retrieves the response message.
-
-**Optional parameters:**
-- `poll_interval`: The number of seconds to wait between polling attempts (default: `1` second).
-- `max_wait`: The maximum number of seconds to wait for the message to complete (default: `60` seconds).
-
-Example of chatting against a PDF. (The usage can be extended to any supported file type)
-
-```python
-latest_message = await unique_sdk.utils.chat_in_space.chat_against_file(
-    user_id=user_id,
-    company_id=company_id,
-    assistant_id="assistant_hjcdga64bkcjnhu4",
-    path_to_file="/files/hello.pdf",
-    displayed_filename="hello.pdf"
-    mime_type="application/pdf"
-    text="Give me a bullet point summary of the file.",
-)
-```
-
-#### `unique_sdk.utils.chat_in_space.wait_for_ingestion_completion`
-
-The following script enables you to wait for the ingestion of a file. This should be used carefully as it continuously polls for the status. In case of bigger files, adjust the `poll_interval` and `max_waits`.
-
-You must provide the following parameter:
-- `content_id`: The id of the content to check.
-
-The script polls until the content ingestion is finished or the maximum wait time is reached and throws in case ingestion fails. The function assumes that the content exists.
-
-**Optional parameters:**
-- `chat_id`: In case the content is uploaded to a chat, the `chat_id` must be provided.
-- `poll_interval`: The number of seconds to wait between polling attempts (default: `1` second).
-- `max_wait`: The maximum number of seconds to wait for the message to complete (default: `60` seconds).
-
-Example of waiting for the ingestion of a file in the Knowledge Base.
-
-```python
-await unique_sdk.utils.chat_in_space.wait_for_ingestion_completion(
-    user_id=user_id,
-    company_id=company_id,
-    content_id="cont_ddlezvag4kzxudfr24lrjc5mx",
-)
-```
-
-## Error Handling
-
-## Examples
-
-An example Flask app demonstrating the usage of each API resource and how to interact with Webhooks is available in our repository at `/examples/custom-assistant`.
-
-## Credits
-
-This is a _fork_ / inspired-by the fantastic Stripe Python SDK (https://github.com/stripe/stripe-python).
-
-# Changelog
-
-All notable changes to this project will be documented in this file.
-
-The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/), 
-and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
-
-## [0.10.19] - 2025-09-02
-- Improve `send_message_and_wait_for_completion`:
-    - Add option to select stop_condition `["stoppedStreamingAt", "completedAt"]`. 
-    - Load `debugInfo` from `last_user_message` for better developer experience.
-
-## [0.10.18] - 2025-09-02
-- Temporarily remove support for update and delete files by filePath.
-
-## [0.10.17] - 2025-09-01
-- Add function to update a file
-
-## [0.10.16] - 2025-08-31
-- Add function to delete a content.
-
-## [0.10.15] - 2025-08-28
-- Add default values for message log types
-
-## [0.10.14] - 2025-08-28
-- Add function to delete folders and files recursively
-
-## [0.10.13] - 2025-08-24
-- Add functions to create, get and update a message eecution and create and update a message log.
-
-## [0.10.12] - 2025-08-24
-- Switch to using Content get info deprecated endpoint to make sure we support older release versions.
-
-## [0.10.11] - 2025-08-24
-- Enforce usage of ruff using pipeline
-
-## [0.10.10] - 2025-08-18
-- Fix wrong name of references in `Space.Message`. 
-- Fix wrong name of assessment in `Space.Message`.
-- Remove default values for `text`, `originalText` and `debugInfo` in `Space.Message` as these don't have an effect.
-
-## [0.10.9] - 2025-08-15
-- Add script to wait for content ingestion finished.
-
-## [0.10.8] - 2025-08-13
-- Add support for Agentic Table.
-
-## [0.10.7] - 2025-08-13
-- Make metadata optional when uploading a file.
-
-## [0.10.6] - 2025-08-06
-- Make tools optional for running an agent.
-
-## [0.10.5] - 2025-08-06
-- Get paginated files and folders info.
-
-## [0.10.4] - 2025-08-05
-- Add support for reasoning API with streaming within a chat.
-
-## [0.10.3] - 2025-08-05
-- Expose scoreThreshold param for search.
-
-## [0.10.2] - 2025-08-05
-- Add script to chat against file.
-
-## [0.10.1] - 2025-08-05
-- Allow deletion of a space chat.
-
-## [0.10.0] - 2025-08-04
-- Add MCP support
-
-## [0.9.42] - 2025-07-31
-- Fix wrong chat in space example.
-
-## [0.9.41] - 2025-07-31
-- Fix double-slash error in open ai proxy script.
-
-## [0.9.40] - 2025-07-22
-- Fixed bug where get requests send body with the request. This is not allowed by WAF policies.
-
-## [0.9.39] - 2025-07-18
-- Add script to chat in a space.
-
-## [0.9.38] - 2025-07-18
-- [Experimental] Add support for Unique OpenAI proxy. You can now use the OpenAI SDK directly through Unique. Checkout how to do this and a few examples here: `tutorials/unique_basics/sdk_examples/openai_scripts.py`.
-
-## [0.9.37] - 2025-07-10
-- Add `sheetName` property to the `MagicTableSheetIngestParams` object used by function that ingests magic table sheets.
-
-## [0.9.36] - 2025-06-23
-- Allow passing a user id when creating chat completions. This is optional and it does not impact the current behaviour.
-
-## [0.9.35] - 2025-06-18
-- Allow scope access updates (add/remove) on folder based on scope id or path.
-
-## [0.9.34] - 2025-06-17
-- Allow ingestion config updates on folder based on scope id or path.
-
-## [0.9.33] - 2025-06-11
-- Add function to get a folder by id or by path.
-
-## [0.9.32] - 2025-06-11
-- Add function to ingest magic table sheets.
-
-## [0.9.31] - 2025-05-21
-- Add function to update folder access (add or remove).
-
-## [0.9.30] - 2025-05-21
-- Add function to update folder ingestion config.
-
-## [0.9.29] - 2025-05-20
-- Add function to create folder paths if they do not exist.
-
-## [0.9.28] - 2025-05-20
-- Add function to search content info. This also allows filtering content info by metadata info.
-
-## [0.9.27] - 2025-05-14
-- Add the possibility to specify metadata when creating or updating a Content.
-
-## [0.9.26] - 2025-05-13
-- Add the possibility to specify ingestionConfig when creating or updating a Content.
-
-## [0.9.25] - 2025-05-02
-- Fixed typos in `README.md`, including incorrect `sdk.utils` imports and code example errors.
-
-## [0.9.24] - 2025-04-23
-- Make `chatId` property in `Search.CreateParams` optional
-
-## [0.9.23] - 2025-03-25
-- Define programming language classifier explicitly for python 3.11
-
-## [0.9.22] - 2025-02-25
-- update the retry_on_error to only `APIError` and `APIConnectionError` update the `resp["error"]` to be `resp.get("error")` to avoid key error
-
-## [0.9.21] - 2025-02-21
-- Add title parameter and change labels in `MessageAssessment`
-
-## [0.9.20] - 2025-02-01
-- Add url parameter to `MessageAssessment.create_async` and `MessageAssessment.modify_async`
-
-## [0.9.19] - 2025-01-31
-- Add `MessageAssessment` resource
-
-## [0.9.18] - 2025-01-22
-- Removed `Invalid response body from API` from `retry_dict` as it's our own artificail error.
-
-## [0.9.17] - 2025-01-03
-- BREAKING CHANGE!! Removed unused `id` from `ShortTermMemory` create and find methods.
-
-## [0.9.16] - 2024-12-19
-- Corrected return type of `Search.create` and `Search.create_async` to `List[Search]`
-- Retry on `Connection aborted` error
-
-## [0.9.15] - 2024-12-06
-- Add `Internal server error` and `You can retry your request` to the retry logic
-
-## [0.9.14] - 2024-12-06
-- Add `contentIds` to `Search.create` and `Search.create_async`
-
-## [0.9.13] - 2024-10-23
-- Add retry for `5xx` errors, add additional error message.
-
-## [0.9.12] - 2024-11-21
-- Include original error message in returned exceptions
-
-## [0.9.11] - 2024-11-18
-- Add  `ingestionConfig` to `UpsertParams.Input` parameters 
-
-## [0.9.10] - 2024-10-23
-- Remove `temperature` parameter from `Integrated.chat_stream_completion`, `Integrated.chat_stream_completion_async`, `ChatCompletion.create` and `ChatCompletion.create_async` methods. To use `temperature` parameter, set the attribute in `options` parameter instead.
-
-## [0.9.9] - 2024-10-23
-- Revert deletion of `Message.retrieve` method
-
-## [0.9.8] - 2024-10-16
-- Add `retries` for `_static_request` and `_static_request_async` in `APIResource` - When the error messages contains either  `"problem proxying the request"`,
-        or `"Upstream service reached a hard timeout"`,
-## [0.9.7] - 2024-09-23
-- Add `completedAt` to `CreateParams` of `Message`
-
-## [0.9.6] - 2024-09-03
-- Added `metaDataFilter` to `Search` parameters.
-
-## [0.9.5] - 2024-08-07
-- Add `completedAt` to `ModifyParams`
-
-## [0.9.4] - 2024-07-31
-- Add `close` and `close_async` to `http_client`
-- Make `httpx` the default client for async requests
-
-## [0.9.3] - 2024-07-31
-- `Search.create`, `Message`, `ChatCompletion` parameters that were marked `NotRequired` are now also `Optional`
-
-## [0.9.2] - 2024-07-30
-- Bug fix in `Search.create`: langugage -> language 
-
-## [0.9.1] - 2024-07-30
-- Added parameters to `Search.create` and `Search.create_async`
-    - `language` for full text search
-    - `reranker` to reranker search results
-
-## [0.9.0] - 2024-07-29
-- Added the possibility to make async requests to the unique APIs using either aiohttp or httpx as client
-