unique-toolkit 2026.20.0.dev7__tar.gz → 2026.20.0.dev9__tar.gz

{unique_toolkit-2026.20.0.dev7 → unique_toolkit-2026.20.0.dev9}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: unique-toolkit
-Version: 2026.20.0.dev7
+Version: 2026.20.0.dev9
 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>
@@ -16,7 +16,7 @@ Requires-Dist: sseclient>=0.0.27,<0.0.28
 Requires-Dist: openai>=1.105.0,<3
 Requires-Dist: platformdirs>=4.0.0,<5
 Requires-Dist: pillow>=12.1.1
-Requires-Dist: unique-sdk>=2026.20.0.dev8
+Requires-Dist: unique-sdk>=2026.20.0.dev9
 Requires-Dist: jambo>=0.1.2,<0.2
 Requires-Dist: jinja2>=3.1.6,<4
 Requires-Dist: docxtpl>=0.20.1,<0.21

{unique_toolkit-2026.20.0.dev7 → unique_toolkit-2026.20.0.dev9}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "unique_toolkit"
-version = "2026.20.0.dev7"
+version = "2026.20.0.dev9"
 description = ""
 readme = "README.md"
 requires-python = ">=3.12"
@@ -28,7 +28,7 @@ dependencies = [
     "openai>=1.105.0,<3",
     "platformdirs>=4.0.0,<5",
     "pillow>=12.1.1",
-    "unique-sdk>=2026.20.0.dev8",
+    "unique-sdk>=2026.20.0.dev9",
     "jambo>=0.1.2,<0.2",
     "jinja2>=3.1.6,<4",
     "docxtpl>=0.20.1,<0.21",
@@ -91,6 +91,7 @@ format = "ruff format ."
 test = "pytest"
 typecheck = "basedpyright"
 depcheck = "deptry ."
+check-imports = "lint-imports"
 coverage = "pytest --cov=unique_toolkit --cov-report=term-missing"
 ci-typecheck = { shell = "bash $(git rev-parse --show-toplevel)/.github/scripts/dev.sh typecheck" }
 ci-coverage = { shell = "bash $(git rev-parse --show-toplevel)/.github/scripts/dev.sh coverage" }
@@ -118,6 +119,120 @@ extend_exclude = ["docs", "tests", "unique_toolkit/.*/test", "unique_toolkit/.*/
 DEP002 = ["langchain", "fastapi", "starlette", "uvicorn"]
 DEP004 = ["langchain_openai", "langchain_core"]
 
+# -----------------------------------------------------------------------------
+# import-linter — enforces the layered architecture documented in
+# unique_toolkit/experimental/README.md. Contracts are scoped to the
+# experimental/ subpackage; the rest of the toolkit keeps its existing
+# (un-layered) shape until modules graduate into the new layout.
+#
+# Run:  uv run poe check-imports   (or: uv run lint-imports)
+#
+# Rules encoded below:
+#   1. integrations → resources → _internal   (layers)
+#   2. components → resources → _internal   (layers; peer of integrations)
+#   3. components never import integrations (keeps orchestration framework-agnostic)
+#   4. primitive resources are mutually independent
+#   5. primitives never import facades (dependency direction inside resources/)
+#   6. facades compose primitives only — never unique_sdk / components / integrations
+#   7. components never call unique_sdk directly (go through a resource)
+#   8. each integrations/<framework>/ stands alone — enabled when real modules land
+#
+# Preference rules from the README that are NOT machine-enforced (import-linter
+# is pass/fail, not tiered): integrations prefer facades over primitives;
+# integrations importing components is "discouraged but allowed".
+# -----------------------------------------------------------------------------
+[tool.importlinter]
+root_packages = ["unique_toolkit"]
+include_external_packages = true
+
+[[tool.importlinter.contracts]]
+name = "experimental: integrations stack (integrations → resources → _internal)"
+type = "layers"
+layers = [
+    "unique_toolkit.experimental.integrations",
+    "unique_toolkit.experimental.resources",
+    "unique_toolkit.experimental._internal",
+]
+
+[[tool.importlinter.contracts]]
+name = "experimental: components stack (components → resources → _internal)"
+type = "layers"
+layers = [
+    "unique_toolkit.experimental.components",
+    "unique_toolkit.experimental.resources",
+    "unique_toolkit.experimental._internal",
+]
+
+[[tool.importlinter.contracts]]
+name = "experimental: components never import integrations"
+type = "forbidden"
+source_modules = ["unique_toolkit.experimental.components"]
+forbidden_modules = ["unique_toolkit.experimental.integrations"]
+
+[[tool.importlinter.contracts]]
+name = "experimental: primitive resources are independent"
+type = "independence"
+modules = [
+    "unique_toolkit.experimental.resources.user",
+    "unique_toolkit.experimental.resources.group",
+    "unique_toolkit.experimental.resources.content_folder",
+    "unique_toolkit.experimental.resources.scheduled_task",
+]
+
+[[tool.importlinter.contracts]]
+name = "experimental: primitives never import facades"
+type = "forbidden"
+source_modules = [
+    "unique_toolkit.experimental.resources.user",
+    "unique_toolkit.experimental.resources.group",
+    "unique_toolkit.experimental.resources.content_folder",
+    "unique_toolkit.experimental.resources.scheduled_task",
+]
+forbidden_modules = ["unique_toolkit.experimental.resources.facades"]
+
+[[tool.importlinter.contracts]]
+name = "experimental: facades never import other facades"
+type = "independence"
+modules = ["unique_toolkit.experimental.resources.facades.*"]
+
+[[tool.importlinter.contracts]]
+name = "experimental: facades compose primitives only"
+type = "forbidden"
+source_modules = ["unique_toolkit.experimental.resources.facades"]
+forbidden_modules = [
+    "unique_sdk",
+    "unique_toolkit.experimental.components",
+    "unique_toolkit.experimental.integrations",
+]
+# Facades legitimately reach `unique_sdk` transitively through primitive
+# resources (that's the whole point). This flag restricts the check to
+# *direct* `import unique_sdk` statements inside facade modules.
+allow_indirect_imports = true
+
+[[tool.importlinter.contracts]]
+name = "experimental: components never call unique_sdk directly"
+type = "forbidden"
+source_modules = ["unique_toolkit.experimental.components"]
+forbidden_modules = ["unique_sdk"]
+# Components are allowed to reach `unique_sdk` indirectly through a
+# resource or an existing toolkit service; the rule only bans a *direct*
+# `import unique_sdk` inside a component module.
+allow_indirect_imports = true
+
+# Uncomment and populate once concrete integrations exist under
+# unique_toolkit/experimental/integrations/<framework>/.
+# [[tool.importlinter.contracts]]
+# name = "experimental: integrations are mutually independent"
+# type = "independence"
+# modules = [
+#     "unique_toolkit.experimental.integrations.openai",
+#     "unique_toolkit.experimental.integrations.langchain",
+# ]
+
+
+
+
+
 [tool.ruff]
 target-version = "py312"
 exclude = [".venv", "docs"]

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/README.md

@@ -0,0 +1,258 @@
+# `experimental/` — reorg proposal
+
+This subpackage is the **staging area for the next-generation toolkit
+layout**. Nothing here is stable; the public API, import paths, and class
+names may change without notice and are not covered by the toolkit's normal
+stability guarantees.
+
+The goal of the reorganization is to replace the current "organize by file
+type" layout with a layered layout where the **direction of dependencies is
+visible at the folder level**. If you know which layer something lives in,
+you know what it's allowed to import.
+
+> **Contract:** every module in `experimental/` belongs to exactly one
+> layer, and a layer may only import from layers *below* it. Violations are
+> bugs; please fix them as you find them.
+
+---
+
+## The stack
+
+```mermaid
+flowchart TD
+    integrations["<b>integrations/</b><br/><i>third-party framework glue</i>"]
+    components["<b>components/</b><br/><i>orchestration &amp; derived views</i>"]
+
+    subgraph resources ["<b>resources/</b>"]
+        direction TB
+        facades["<b>facades/</b><br/><i>resource-shaped aggregators</i><br/>(identity)"]
+        primitives["<b>primitives</b><br/><i>typed SDK wrappers</i><br/>(user, group, content_folder,<br/>scheduled_task, …)"]
+        facades --> primitives
+    end
+
+    internal["<b>_internal/</b><br/><i>package-private primitives</i>"]
+    sdk[("<b>unique_sdk</b><br/><i>external</i>")]
+
+    integrations ==> facades
+    integrations -.-> primitives
+    integrations -.-> components
+    components --> resources
+    resources --> internal
+    primitives -.-> sdk
+
+    classDef external fill:#f6f8fa,stroke-dasharray: 5 5
+    class sdk external
+```
+
+**Reading the arrows:**
+
+- **Solid arrows** are the default dependency path for a layer.
+- **Dotted arrows** are allowed but discouraged — use them when the default
+  path does not cover your case, and consider whether the missing path is
+  a signal that something should be refactored.
+- `integrations/` and `components/` are **peers**, not stacked. Both
+  sit directly above `resources/`. An integration's default path is a
+  facade (which is why `integrations ==> facades` is drawn bold); reaching
+  a primitive resource is fine when no facade fits; reaching into
+  `components/` is the escape hatch of last resort.
+- `components/` never imports `integrations/`. Orchestration must stay
+  framework-agnostic — that is the entire reason integrations are a
+  separate layer.
+
+---
+
+## What goes where
+
+### `_internal/` — package-private primitives
+
+Shared low-level helpers that are deliberately **not** part of the public
+API. Think: HTTP plumbing, Pydantic helpers, time/string/exception utilities.
+
+- **May import:** stdlib, third-party libs (Pydantic, etc.).
+- **Must not import:** anything else in `experimental/`. This is the
+  bottom of the stack; it would be a dependency inversion.
+- **Public exposure:** none. If something here is genuinely useful to
+  users, promote it into `resources/`, `components/`, or
+  `integrations/` — whichever layer fits — and re-export it there.
+
+### `resources/<name>/` — typed adapters over `unique_sdk`
+
+One subfolder per SDK resource family. The canonical shape is:
+
+```
+resources/<name>/
+    schemas.py     # Pydantic models for request/response payloads
+    functions.py   # (optional) free-standing sync + async call pairs
+    service.py     # stateful, keyword-only class over functions.py
+    __init__.py    # re-exports
+```
+
+A module belongs here **iff** it could be deleted without losing any
+functionality relative to raw `unique_sdk` usage — it's pure typing + a
+slightly nicer call surface, nothing more.
+
+- **May import:** `unique_sdk`, `_internal/`, stdlib, third-party libs.
+- **Must not import:** sibling resources (see `facades/` below for the
+  exception), `components/`, `integrations/`.
+- **Concrete examples in-tree today:** `user/`, `group/`,
+  `content_folder/`, `scheduled_task/`.
+- **Resources** should be stateless classes
+
+### `resources/facades/<name>/` — aggregating resources
+
+A **facade** (GoF pattern) is a resource-shaped object with no SDK calls
+of its own that composes two or more sibling resources behind a single
+`(user_id, company_id)` context. Constructor shape and keyword-only
+convention match the sibling resources, so callers cannot tell the
+difference at the call site.
+
+Facades are the **preferred entry point for `integrations/`** — they give
+framework adapters a single object to bridge instead of N resource
+services to wire up individually.
+
+- **May import:** two or more sibling `resources/<primitive>/` packages,
+  `_internal/`, stdlib, third-party libs.
+- **Must not import:** `unique_sdk` directly (go through a sibling
+  resource instead — a facade that calls the SDK directly is actually a
+  primitive resource with an identity crisis), `components/`,
+  `integrations/`.
+- **Test to decide "facade vs component":** if every public method is a
+  one-liner that forwards to a sub-resource attribute, it is a facade.
+  As soon as a method adds orchestration (parallel fan-out, caching,
+  derived views, retry/fallback, cross-resource validation), it belongs
+  in `components/` instead.
+- **Concrete example in-tree today:** `facades/identity/` composes
+  `user/` + `group/` behind `Identity.users` / `Identity.groups`.
+
+### `components/<name>/` — behaviour beyond the SDK
+
+Everything the SDK does not provide by itself: agent loops, evaluation,
+rule compilation, tokenization, data extraction, derived views (e.g. a
+trie over content), parallel pagination, post-processing.
+
+- **May import:** `resources/` (primitives and facades), `_internal/`,
+  stdlib, third-party libs.
+- **Must not import:** `integrations/`, `unique_sdk` directly (every SDK
+  call lives in a `resources/` module so there is exactly one place to
+  patch when the SDK changes).
+- **Concrete example in-tree today:** `components/content_tree/` — a
+  derived trie + fuzzy-search view over the `content` resource.
+
+### `integrations/<framework>/` — third-party framework adapters
+
+Leaf layer. One subfolder per external framework (OpenAI SDK, LangChain,
+LlamaIndex, …). Every module here is a thin adapter that maps toolkit
+types to a framework's types.
+
+- **May import (default path):** `resources/facades/` — the one-object
+  entry point that a framework adapter typically wants to bridge.
+- **May import (fine when no facade fits):** primitive `resources/<x>/`.
+- **May import (escape hatch — discouraged):** `components/`. If you
+  reach for this, stop and consider: is the orchestration you need truly
+  framework-specific (then it belongs inside this `integrations/<x>/`
+  module)? Or is it general-purpose orchestration that any caller would
+  want (then it stays in `components/`, and you import it, but
+  double-check whether another integration will need the same pass and
+  whether a facade could replace the dependency entirely)?
+- **Always may import:** `_internal/`, stdlib, third-party libs
+  (including the framework itself).
+- **Must not import:** another `integrations/<framework>/` — each
+  framework adapter stands alone. Share code via `_internal/` or by
+  lifting it into `components/`.
+- **Optional dependencies:** integrations that depend on libraries the
+  toolkit does not pin (e.g. LangChain) stay importable even when the
+  library is missing; the framework itself is loaded lazily inside the
+  adapter.
+
+---
+
+## Import-rule cheat sheet
+
+| From ↓ \ May import → | `_internal` | `resources/<primitive>` | `resources/facades` | `components` | `integrations` |
+| --- | :-: | :-: | :-: | :-: | :-: |
+| `_internal`                | —   | no  | no  | no  | no  |
+| `resources/<primitive>`    | yes | no¹ | no  | no  | no  |
+| `resources/facades`        | yes | **yes** | no² | no  | no  |
+| `components`             | yes | yes | yes | yes³ | no  |
+| `integrations/<framework>` | yes | ok⁴ | **yes** | discouraged⁵ | no⁶ |
+
+¹ A primitive resource imports only `unique_sdk`, not sibling resources.
+If two primitives need to call each other, you have discovered a facade.
+
+² Facades do not import other facades; they compose primitives. Stacking
+facades is an orchestration concern — that lives in `components/`.
+
+³ Importing a *sibling* module inside the same layer is fine when the
+dependency is genuinely intra-layer (one component building on another).
+Cross-layer is what the rules above constrain.
+
+⁴ Primitive resources are a fine fallback when no facade covers the
+integration's use case. Prefer the facade when one exists so there is a
+single bridge to maintain per framework.
+
+⁵ Allowed but flagged as a smell. Ask whether the orchestration you need
+is framework-specific (belongs in this integration) or general-purpose
+(stays in `components/`, possibly behind a new facade).
+
+⁶ One integration never imports another integration. Share via
+`_internal/` or promote to `components/`.
+
+---
+
+## Decision tree — "I'm adding new code"
+
+Walk the diagram top to bottom; the first **yes** wins. A **no** all the
+way to the bottom is a signal that the module probably does not belong in
+`experimental/` at all.
+
+```mermaid
+flowchart TD
+    start(["I'm adding new code"])
+    q1{"Calls <b>unique_sdk</b> directly?"}
+    q2{"Resource-shaped facade —<br/>composes 2+ primitives with<br/>one-liner delegation methods?"}
+    q3{"Adds behaviour beyond the SDK<br/>(orchestration, parallelism,<br/>derived views, evaluation, …)<br/><b>and</b> framework-agnostic?"}
+    q4{"Adapter for a specific<br/>third-party framework?"}
+    q5{"Shared primitive with<br/>no public API story?"}
+
+    primitive["<b>resources/&lt;name&gt;/</b><br/>primitive resource"]
+    facade["<b>resources/facades/&lt;name&gt;/</b>"]
+    component["<b>components/&lt;name&gt;/</b>"]
+    integration["<b>integrations/&lt;framework&gt;/</b>"]
+    internal["<b>_internal/</b>"]
+    discuss["<i>Probably not experimental/ at all —<br/>open a discussion first</i>"]
+
+    start --> q1
+    q1 -- yes --> primitive
+    q1 -- no --> q2
+    q2 -- yes --> facade
+    q2 -- no --> q3
+    q3 -- yes --> component
+    q3 -- no --> q4
+    q4 -- yes --> integration
+    q4 -- no --> q5
+    q5 -- yes --> internal
+    q5 -- no --> discuss
+
+    classDef target fill:#e7f5ff,stroke:#1971c2,stroke-width:2px,color:#0b4a80
+    classDef escape fill:#fff4e6,stroke:#e8590c,color:#7a3b00
+    class primitive,facade,component,integration,internal target
+    class discuss escape
+```
+
+---
+
+## Experimental ≠ "hidden"
+
+The point of `experimental/` is **staging**, not secrecy. Modules here are
+expected to graduate into the stable tree once:
+
+- their public API has survived at least one integration at a customer
+  site or internal app,
+- the naming and boundaries match the final-state convention documented
+  above,
+- they have tests and Google-style docstrings on public symbols.
+
+Graduation is a straight-through move: delete the `experimental/` ancestor
+from the import path, keep everything else identical. Because layers and
+sub-bucket names are the same in both places, the graduation diff is a
+`git mv` plus an import sweep — no architectural rework.

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/_internal/__init__.py

@@ -0,0 +1,21 @@
+"""Package-private primitives — not part of the public API.
+
+Replaces the current :mod:`unique_toolkit._common` junk drawer. Modules
+here are implementation details; anything users are expected to import must
+be promoted into :mod:`..resources`, :mod:`..components`, or
+:mod:`..integrations` first.
+
+Planned contents (current home → new home):
+
+* ``http``     ← :mod:`unique_toolkit._common.endpoint_builder`,
+  :mod:`unique_toolkit._common.endpoint_requestor`,
+  :mod:`unique_toolkit._common.api_calling`
+* ``pydantic`` ← :mod:`unique_toolkit._common.pydantic`,
+  :mod:`unique_toolkit._common.pydantic_helpers`,
+  :mod:`unique_toolkit._common.validators`,
+  :mod:`unique_toolkit._common.base_model_type_attribute`
+* ``utils``    ← :mod:`unique_toolkit._common.utils` plus the loose
+  modules in :mod:`unique_toolkit._common` (``_time_utils``,
+  ``string_utilities``, ``execution``, ``exception``, ``event_bus``,
+  ``referencing``, ``validate_required_values``, ``_base_service``)
+"""

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/components/__init__.py

@@ -0,0 +1,27 @@
+"""Components — orchestration and derived behaviour on top of :mod:`..resources`.
+
+Everything here adds behavior the SDK does not provide: orchestration,
+post-processing, evaluation, rule compilation, tokenization, etc. If a
+module could be deleted without losing any functionality relative to raw
+``unique_sdk`` usage, it belongs in :mod:`..resources`, not here.
+
+Planned contents (current home → new home):
+
+* ``agentic``                ← :mod:`unique_toolkit.agentic`
+  (subpackages: ``tools``, ``loop_runner``, ``evaluation``,
+  ``managers`` — collects the sibling ``*_manager`` packages —,
+  ``feature_flags`` — single canonical home, collapses duplicates in
+  :mod:`unique_toolkit.app.feature_flags` and
+  :mod:`unique_toolkit._common.feature_flags`)
+* ``data_extraction``        ← :mod:`unique_toolkit.data_extraction`
+* ``smart_rules``            ← :mod:`unique_toolkit.smart_rules`
+  + :mod:`unique_toolkit.content.smart_rules` (unified)
+* ``chunk_relevancy_sorter`` ← :mod:`unique_toolkit._common.chunk_relevancy_sorter`
+* ``config_checker``         ← :mod:`unique_toolkit._common.config_checker`
+* ``docx_generator``         ← :mod:`unique_toolkit._common.docx_generator`
+* ``tokenization``           ← :mod:`unique_toolkit._common.token`
+* ``content_tree``           ← :mod:`unique_toolkit.experimental.components.content_tree`
+  (re-export: :mod:`unique_toolkit.experimental.content_tree`); a derived
+  tree/fuzzy-search view over the ``content`` resource; does not wrap an SDK
+  endpoint of its own
+"""

{unique_toolkit-2026.20.0.dev7/unique_toolkit/experimental → unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/components}/content_tree/__init__.py

@@ -7,7 +7,7 @@
 
 Typical usage::
 
-    from unique_toolkit.experimental.content_tree import ContentTree
+    from unique_toolkit.experimental.components.content_tree import ContentTree
 
     tree = ContentTree.from_settings()
     print(await tree.render_visible_tree_async(max_depth=2))
@@ -16,16 +16,16 @@ Typical usage::
 The subpackage is split into three modules to mirror the rest of the
 ``content`` domain:
 
-- :mod:`unique_toolkit.experimental.content_tree.schemas` — data classes
+- :mod:`unique_toolkit.experimental.components.content_tree.schemas` — data classes
   (:class:`PathTrieNode`, :class:`FuzzyMatch`, :data:`MatchTarget`).
-- :mod:`unique_toolkit.experimental.content_tree.functions` — pure helpers
+- :mod:`unique_toolkit.experimental.components.content_tree.functions` — pure helpers
   for listing, scope-id resolution, trie construction, and ``tree(1)``-style
   formatting.
-- :mod:`unique_toolkit.experimental.content_tree.service` —
+- :mod:`unique_toolkit.experimental.components.content_tree.service` —
   :class:`ContentTree`, the orchestrating service with per-instance caching.
 """
 
-from unique_toolkit.experimental.content_tree.functions import (
+from unique_toolkit.experimental.components.content_tree.functions import (
     build_trie_from_resolved_paths,
     extract_scope_ids_from_content_infos,
     format_path_trie,
@@ -35,12 +35,12 @@ from unique_toolkit.experimental.content_tree.functions import (
     translate_scope_ids_async,
     translate_scope_ids_batch,
 )
-from unique_toolkit.experimental.content_tree.schemas import (
+from unique_toolkit.experimental.components.content_tree.schemas import (
     FuzzyMatch,
     MatchTarget,
     PathTrieNode,
 )
-from unique_toolkit.experimental.content_tree.service import ContentTree
+from unique_toolkit.experimental.components.content_tree.service import ContentTree
 
 __all__ = [
     "ContentTree",

{unique_toolkit-2026.20.0.dev7/unique_toolkit/experimental → unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/components}/content_tree/functions.py

@@ -1,6 +1,6 @@
 """Pure functions behind the content-tree view.
 
-These helpers are decoupled from :class:`~unique_toolkit.experimental.content_tree.service.ContentTree`
+These helpers are decoupled from :class:`~unique_toolkit.experimental.components.content_tree.service.ContentTree`
 so that other callers (scripts, notebooks, ad-hoc tooling) can compose the same
 listing + scope-id-resolution logic without constructing a service instance.
 
@@ -29,9 +29,9 @@ from unique_toolkit.content.functions import (
     get_folder_info_async,
 )
 from unique_toolkit.content.schemas import ContentInfo, PaginatedContentInfos
-from unique_toolkit.experimental.content_tree.schemas import PathTrieNode
+from unique_toolkit.experimental.components.content_tree.schemas import PathTrieNode
 
-_LOGGER = logging.getLogger(f"toolkit.experimental.content_tree.{__name__}")
+_LOGGER = logging.getLogger(f"toolkit.experimental.components.content_tree.{__name__}")
 
 
 def serialize_filter(metadata_filter: dict[str, Any] | None) -> str:

{unique_toolkit-2026.20.0.dev7/unique_toolkit/experimental → unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/components}/content_tree/schemas.py

@@ -5,10 +5,10 @@ These types describe the *shape* of a content-tree snapshot:
 - :class:`PathTrieNode` is the in-memory directory structure built from resolved
   file paths.
 - :class:`FuzzyMatch` is the result record returned by
-  :meth:`unique_toolkit.experimental.content_tree.service.ContentTree.search_visible_files_fuzzy_async`.
+  :meth:`unique_toolkit.experimental.components.content_tree.service.ContentTree.search_visible_files_fuzzy_async`.
 
 Kept free of behaviour so they can be imported and introspected without pulling
-in the SDK/HTTP stack used by :mod:`unique_toolkit.experimental.content_tree.functions`.
+in the SDK/HTTP stack used by :mod:`unique_toolkit.experimental.components.content_tree.functions`.
 """
 
 from __future__ import annotations

{unique_toolkit-2026.20.0.dev7/unique_toolkit/experimental → unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/components}/content_tree/service.py

@@ -12,7 +12,7 @@ user (via ``folderIdPath`` metadata) and exposes it through three lenses:
 The service is intentionally **decoupled** from
 :class:`~unique_toolkit.services.knowledge_base.KnowledgeBaseService`: it talks
 to the same backend through the functional helpers in
-:mod:`unique_toolkit.experimental.content_tree.functions` so it can be constructed and used
+:mod:`unique_toolkit.experimental.components.content_tree.functions` so it can be constructed and used
 on its own.
 """
 
@@ -28,13 +28,13 @@ from typing import TYPE_CHECKING, Any, Protocol, Self, overload
 from unique_toolkit._common.validate_required_values import validate_required_values
 from unique_toolkit.app.unique_settings import UniqueSettings
 from unique_toolkit.content.schemas import ContentInfo
-from unique_toolkit.experimental.content_tree.functions import (
+from unique_toolkit.experimental.components.content_tree.functions import (
     build_trie_from_resolved_paths,
     format_path_trie,
     resolve_visible_file_paths_core,
     serialize_filter,
 )
-from unique_toolkit.experimental.content_tree.schemas import (
+from unique_toolkit.experimental.components.content_tree.schemas import (
     FuzzyMatch,
     MatchTarget,
     PathTrieNode,
@@ -67,7 +67,7 @@ class ContentTree:
     """Resolve visible content paths, render trees, and search files.
 
     The service is a thin orchestrator around the functional helpers in
-    :mod:`unique_toolkit.experimental.content_tree.functions`. It takes the same identity
+    :mod:`unique_toolkit.experimental.components.content_tree.functions`. It takes the same identity
     parameters as the other toolkit services (``company_id`` / ``user_id`` /
     optional ``metadata_filter``) so it can be instantiated and tested without
     a :class:`~unique_toolkit.services.knowledge_base.KnowledgeBaseService`.

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/content_tree/__init__.py

@@ -0,0 +1,35 @@
+"""Convenience re-export; implementation in :mod:`..components.content_tree`."""
+
+from __future__ import annotations
+
+from unique_toolkit.experimental.components.content_tree.functions import (
+    build_trie_from_resolved_paths,
+    extract_scope_ids_from_content_infos,
+    format_path_trie,
+    get_all_content_infos_async,
+    resolve_visible_file_paths_core,
+    translate_scope_id_async,
+    translate_scope_ids_async,
+    translate_scope_ids_batch,
+)
+from unique_toolkit.experimental.components.content_tree.schemas import (
+    FuzzyMatch,
+    MatchTarget,
+    PathTrieNode,
+)
+from unique_toolkit.experimental.components.content_tree.service import ContentTree
+
+__all__ = [
+    "ContentTree",
+    "FuzzyMatch",
+    "MatchTarget",
+    "PathTrieNode",
+    "build_trie_from_resolved_paths",
+    "extract_scope_ids_from_content_infos",
+    "format_path_trie",
+    "get_all_content_infos_async",
+    "resolve_visible_file_paths_core",
+    "translate_scope_id_async",
+    "translate_scope_ids_async",
+    "translate_scope_ids_batch",
+]

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/identity/__init__.py

@@ -0,0 +1,38 @@
+"""Barrel for the :class:`Identity` facade and related types.
+
+The implementation lives in
+:mod:`unique_toolkit.experimental.resources.facades.identity`; this package
+re-exports the same public names for a shorter import path.
+"""
+
+from __future__ import annotations
+
+from unique_toolkit.experimental.resources.facades.identity.service import Identity
+from unique_toolkit.experimental.resources.group import (
+    GroupDeleted,
+    GroupInfo,
+    GroupMember,
+    GroupMembership,
+    Groups,
+    GroupWithConfiguration,
+)
+from unique_toolkit.experimental.resources.user import (
+    UserGroupMembership,
+    UserInfo,
+    Users,
+    UserWithConfiguration,
+)
+
+__all__ = [
+    "GroupDeleted",
+    "GroupInfo",
+    "GroupMember",
+    "GroupMembership",
+    "GroupWithConfiguration",
+    "Groups",
+    "Identity",
+    "UserGroupMembership",
+    "UserInfo",
+    "UserWithConfiguration",
+    "Users",
+]

unique_toolkit-2026.20.0.dev9/unique_toolkit/experimental/integrations/__init__.py

@@ -0,0 +1,12 @@
+"""Adapters for third-party frameworks.
+
+Renamed from ``framework_utilities`` to reflect that these subpackages are
+integrations with external libraries, not general-purpose utilities.
+
+Planned contents (current home → new home):
+
+* ``openai``    ← :mod:`unique_toolkit.framework_utilities.openai`
+* ``langchain`` ← :mod:`unique_toolkit.framework_utilities.langchain`
+  (remains an optional dependency, surfaced via a conditional re-export in
+  the top-level ``__init__``)
+"""