unique-toolkit 2026.38.0.dev2__tar.gz → 2026.38.0.dev4__tar.gz

{unique_toolkit-2026.38.0.dev2 → unique_toolkit-2026.38.0.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.38.0.dev2
+Version: 2026.38.0.dev4
 Summary: 
 Author: Cedric Klinkert, Martin Fadler, Sadique Sheik, Fabian Schläpfer, Pascal Hauri, Ejiroghene Oki-Peter, Rami Azouz, Ricardo Visini, Sanzio Monti
 Author-email: Cedric Klinkert <cedric.klinkert@unique.ch>, Martin Fadler <martin.fadler@unique.ch>, Sadique Sheik <sadique@unique.ch>, Fabian Schläpfer <fabian@unique.ch>, Pascal Hauri <pascal@unique.ch>, Ejiroghene Oki-Peter <oki-peter.ejiroghene@unique.ai>, Rami Azouz <rami.ext@unique.ch>, Ricardo Visini <ricardo.visini@unique.ch>, Sanzio Monti <sanzio.monti@unique.ai>

{unique_toolkit-2026.38.0.dev2 → unique_toolkit-2026.38.0.dev4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.38.0.dev2"
+version = "2026.38.0.dev4"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"

{unique_toolkit-2026.38.0.dev2 → unique_toolkit-2026.38.0.dev4}/unique_toolkit/experimental/components/content_tree/functions.py

@@ -19,14 +19,21 @@ from __future__ import annotations
 import asyncio
 import json
 import logging
-from collections.abc import Awaitable, Callable
+from collections.abc import Awaitable, Callable, Mapping
 from pathlib import PurePosixPath
-from typing import Any
+from typing import Any, cast
 
 import unique_sdk
 from typing_extensions import deprecated
 
 from unique_toolkit.content.schemas import BaseFolderInfo, ContentInfo
+from unique_toolkit.content.smart_rules import (
+    AndStatement,
+    Operator,
+    OrStatement,
+    UniqueQL,
+    parse_uniqueql,
+)
 from unique_toolkit.experimental.components.content_tree.schemas import (
     FolderWalkSnapshot,
     PathTrieNode,
@@ -69,6 +76,137 @@ def _parse_content_infos_payload(payload: Any) -> tuple[list[ContentInfo], int]:
     return files, total
 
 
+_NULLISH_OPERATORS = {
+    Operator.IS_NULL.value,
+    Operator.IS_NOT_NULL.value,
+    Operator.IS_EMPTY.value,
+    Operator.IS_NOT_EMPTY.value,
+}
+
+
+def _content_uniqueql_record(info: ContentInfo) -> dict[str, Any]:
+    dumped = info.model_dump(by_alias=True, mode="json")
+    metadata = dumped.get("metadata") or {}
+    if not isinstance(metadata, dict):
+        metadata = {}
+    record = {
+        key: value
+        for key, value in dumped.items()
+        if key != "metadata" and value is not None
+    }
+    record["metadata"] = metadata
+    for key, value in metadata.items():
+        record.setdefault(key, value)
+    return record
+
+
+def _uniqueql_fill_nullish_values(node: Any) -> Any:
+    """Statement.value cannot be None; documented isNull/isEmpty UniqueQL uses null."""
+    if not isinstance(node, dict):
+        return node
+    if "and" in node:
+        return {
+            **node,
+            "and": [_uniqueql_fill_nullish_values(item) for item in node["and"]],
+        }
+    if "or" in node:
+        return {
+            **node,
+            "or": [_uniqueql_fill_nullish_values(item) for item in node["or"]],
+        }
+    filled = dict(node)
+    if filled.get("operator") in _NULLISH_OPERATORS and filled.get("value") is None:
+        filled["value"] = True
+    if isinstance(filled.get("value"), dict):
+        filled["value"] = _uniqueql_fill_nullish_values(filled["value"])
+    return filled
+
+
+def _uniqueql_matches(record: Mapping[str, Any], query: UniqueQL) -> bool:
+    if isinstance(query, AndStatement):
+        return bool(query.and_list) and all(
+            _uniqueql_matches(record, child) for child in query.and_list
+        )
+    if isinstance(query, OrStatement):
+        return bool(query.or_list) and any(
+            _uniqueql_matches(record, child) for child in query.or_list
+        )
+    actual: Any = record
+    for key in query.path:
+        if not isinstance(actual, Mapping):
+            actual = None
+            break
+        actual = actual.get(key)
+    expected = query.value
+    operator = query.operator
+    is_empty = actual is None or actual in ("", [], {})
+    match operator:
+        case Operator.EQUALS:
+            return actual == expected
+        case Operator.NOT_EQUALS:
+            return actual != expected
+        case Operator.CONTAINS:
+            try:
+                return expected in cast(Any, actual)
+            except TypeError:
+                return False
+        case Operator.NOT_CONTAINS:
+            try:
+                return expected not in cast(Any, actual)
+            except TypeError:
+                return True
+        case Operator.IN:
+            return isinstance(expected, list) and actual in expected
+        case Operator.NOT_IN:
+            return isinstance(expected, list) and actual not in expected
+        case Operator.OVERLAPS:
+            return (
+                isinstance(actual, list)
+                and isinstance(expected, list)
+                and any(item in actual for item in expected)
+            )
+        case Operator.NOT_OVERLAPS:
+            return not (
+                isinstance(actual, list)
+                and isinstance(expected, list)
+                and any(item in actual for item in expected)
+            )
+        case Operator.GREATER_THAN:
+            try:
+                return cast(Any, actual) > expected
+            except TypeError:
+                return False
+        case Operator.GREATER_THAN_OR_EQUAL:
+            try:
+                return cast(Any, actual) >= expected
+            except TypeError:
+                return False
+        case Operator.LESS_THAN:
+            try:
+                return cast(Any, actual) < expected
+            except TypeError:
+                return False
+        case Operator.LESS_THAN_OR_EQUAL:
+            try:
+                return cast(Any, actual) <= expected
+            except TypeError:
+                return False
+        case Operator.IS_NULL:
+            return actual is None
+        case Operator.IS_NOT_NULL:
+            return actual is not None
+        case Operator.IS_EMPTY:
+            return is_empty
+        case Operator.IS_NOT_EMPTY:
+            return not is_empty
+        case Operator.NESTED:
+            return (
+                isinstance(expected, (AndStatement, OrStatement))
+                and isinstance(actual, Mapping)
+                and _uniqueql_matches(actual, expected)
+            )
+
+
 def _propagate_wait_interrupt(result: object) -> None:
     """Re-raise timeout/cancellation so callers can return a partial snapshot."""
     if isinstance(result, (asyncio.CancelledError, TimeoutError)):
@@ -139,7 +277,8 @@ async def _list_direct_children_async(
 
     ``scope_id=None`` is the knowledge-base root. ``Content.get_infos`` without
     ``parentId`` lists the **entire** catalog, so root only fetches folders.
-    Files are listed per folder with ``parentId``.
+    Files are listed per folder with ``parentId``. Unique rejects ``parentId``
+    with ``metadataFilter``, so UniqueQL is applied to the returned files.
     """
     parent_params: dict[str, Any] = {}
     if scope_id:
@@ -164,23 +303,38 @@ async def _list_direct_children_async(
     if not scope_id:
         return await folders_task
 
+    parsed_filter = (
+        parse_uniqueql(_uniqueql_fill_nullish_values(metadata_filter))
+        if metadata_filter
+        else None
+    )
+
     async def _content_page(skip: int) -> Any:
-        params = dict(parent_params)
-        if metadata_filter:
-            params["metadataFilter"] = metadata_filter
         return await unique_sdk.Content.get_infos_async(
             user_id=user_id,
             company_id=company_id,
             skip=skip,
             take=step_size,
-            **params,
+            **parent_params,
         )
 
+    def _parse_content_page(payload: Any) -> tuple[list[ContentInfo], int]:
+        files, total = _parse_content_infos_payload(payload)
+        # Keep parentId listing + local UniqueQL until UniqueQL/folderId metadata
+        # listing is equivalent (soft-delete/versioning); then drop this record filter.
+        if parsed_filter is not None:
+            files = [
+                info
+                for info in files
+                if _uniqueql_matches(_content_uniqueql_record(info), parsed_filter)
+            ]
+        return files, total
+
     folder_result, file_result = await asyncio.gather(
         folders_task,
         _paginate_parent_listing(
             _content_page,
-            _parse_content_infos_payload,
+            _parse_content_page,
             step_size=step_size,
             max_concurrent_requests=max_concurrent_page_fetches,
             on_page=on_files,

{unique_toolkit-2026.38.0.dev2 → unique_toolkit-2026.38.0.dev4}/unique_toolkit/experimental/components/internal_search/base/service.py

@@ -75,12 +75,26 @@ class InternalSearchBaseService(  # pyright: ignore[reportImplicitAbstractClass]
             )
         )
 
-        results = await asyncio.gather(
-            *[self._search_single_query(query=q) for q in search_queries],
-            return_exceptions=True,
+        # TaskGroup awaits cancelled children so httpcore can release the connection.
+        results: list[SearchStringResult | BaseException | None] = [None] * len(
+            search_queries
         )
 
-        found = self._collect_results(results, search_queries)
+        async def _run(i: int, query: str) -> None:
+            try:
+                results[i] = await self._search_single_query(query=query)
+            except Exception as exc:
+                # not BaseException: CancelledError must reach the group
+                results[i] = exc
+
+        async with asyncio.TaskGroup() as tg:
+            for i, query in enumerate(search_queries):
+                tg.create_task(_run(i, query))
+
+        found = self._collect_results(
+            [r for r in results if r is not None],
+            search_queries,
+        )
         return await self._finalize_run(
             search_queries,
             found,

{unique_toolkit-2026.38.0.dev2 → unique_toolkit-2026.38.0.dev4}/unique_toolkit/language_model/infos.py

@@ -110,6 +110,7 @@ class LanguageModelName(StrEnum):
     GROK_4_1_FAST_NON_REASONING = "litellm:grok-4-1-fast-non-reasoning"
     GROK_4_1_FAST_REASONING = "litellm:grok-4-1-fast-reasoning"
     GROK_4_5 = "litellm:grok-4-5"
+    GROK_4_6 = "litellm:grok-4-6"
     LITELLM_OPENAI_GPT_5 = "litellm:openai-gpt-5"
     LITELLM_OPENAI_GPT_5_MINI = "litellm:openai-gpt-5-mini"
     LITELLM_OPENAI_GPT_5_NANO = "litellm:openai-gpt-5-nano"
@@ -2195,6 +2196,33 @@ class LanguageModelInfo(BaseModel):
                     published_at=date(2026, 7, 16),
                     supported_reasoning_efforts=["low", "medium", "high"],
                 )
+            case LanguageModelName.GROK_4_6:
+                # Specs from https://docs.x.ai/developers/grok-4-6
+                # Announcement date from https://x.ai/news/grok-4-6
+                return cls(
+                    name=model_name,
+                    capabilities=[
+                        ModelCapabilities.FUNCTION_CALLING,
+                        ModelCapabilities.REASONING,
+                        ModelCapabilities.STREAMING,
+                        ModelCapabilities.STRUCTURED_OUTPUT,
+                        ModelCapabilities.VISION,
+                    ],
+                    provider=LanguageModelProvider.LITELLM,
+                    family=ModelFamily.XAI,
+                    version="grok-4-6",
+                    encoder_name=EncoderName.O200K_BASE,  # TODO: Update encoder with grok tokenizer
+                    token_limits=LanguageModelTokenLimits(
+                        # Context window is 500_000, we leave 20_000 tokens as buffer due to tokenizer mismatch
+                        # Assign 90% for input and 10% for output
+                        token_limit_input=int(480_000 * 0.9),
+                        token_limit_output=int(480_000 * 0.1),
+                    ),
+                    info_cutoff_at=date(2026, 1, day=1),
+                    published_at=date(2026, 8, 12),
+                    supported_reasoning_efforts=["low", "medium", "high", "xhigh"],
+                    default_options={"reasoning_effort": "high"},
+                )
             case LanguageModelName.LITELLM_OPENAI_GPT_5:
                 return cls(
                     name=model_name,