stapel-chat 0.1.0__tar.gz

stapel_chat-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Stapel contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

stapel_chat-0.1.0/PKG-INFO

@@ -0,0 +1,93 @@
+Metadata-Version: 2.4
+Name: stapel-chat
+Version: 0.1.0
+Summary: Conversations, messaging and support chat for the Stapel framework
+License: MIT
+Project-URL: Homepage, https://github.com/usestapel/stapel-chat
+Project-URL: Repository, https://github.com/usestapel/stapel-chat
+Project-URL: Documentation, https://github.com/usestapel/stapel-chat#readme
+Project-URL: Changelog, https://github.com/usestapel/stapel-chat/blob/main/CHANGELOG.md
+Project-URL: Issues, https://github.com/usestapel/stapel-chat/issues
+Keywords: django,stapel,chat,messaging,support
+Classifier: Development Status :: 3 - Alpha
+Classifier: Framework :: Django
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Typing :: Typed
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: stapel-core<0.11,>=0.10
+Provides-Extra: channels
+Requires-Dist: stapel-core[channels]<0.11,>=0.10; extra == "channels"
+Provides-Extra: all
+Requires-Dist: stapel-core[channels]<0.11,>=0.10; extra == "all"
+Dynamic: license-file
+
+# stapel-chat
+
+Conversations, messaging and support chat for the [Stapel](https://github.com/usestapel)
+framework — a reusable Django app you mount in a host project.
+
+One model backs three kinds of thread: **direct** (1:1, idempotent by
+participant pair), **group**, and **support** (a customer↔operator thread with a
+queue and assignment lifecycle). Messages carry a monotonic per-conversation
+**seq** that is the canonical anchor for history pagination and the resume
+cursor for realtime — so nothing depends on a socket staying up.
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "stapel_core.django.apps.CommonDjangoConfig",
+    "stapel_core.django.users",
+    "rest_framework",
+    "stapel_chat",
+]
+
+# urls.py
+urlpatterns = [
+    path("chat/", include("stapel_chat.urls")),
+]
+```
+
+## What you get
+
+- **Conversations** — `POST /chat/api/conversations` (`direct` / `group` /
+  `support`); direct is get-or-create by participant pair. `GET` lists your
+  conversations (anchor-paginated) with `unread_count`.
+- **Messages** — `GET/POST /chat/api/conversations/{id}/messages`. History is
+  anchored on `seq` (newest-first, both directions). Sending allocates the next
+  `seq` and emits `chat.message` in one transaction.
+- **Read markers** — `POST /chat/api/conversations/{id}/read` (`upto_seq`).
+- **Support** — `GET /chat/api/support/queue`,
+  `POST .../support/conversations/{id}/{assign,resolve,reopen}`.
+- **Realtime (optional)** — `stapel_chat.consumers.ChatConsumer` over Channels:
+  `hello{last_seq}` → replay by seq → live delivery. Install the extra:
+
+  ```
+  pip install 'stapel-chat[channels]'
+  ```
+
+  and wire it behind `stapel_core.django.jwt.channels.JWTAuthMiddlewareStack` in
+  your `asgi.py`.
+
+## Configuration (`STAPEL_CHAT`)
+
+| Key | Default | Meaning |
+|---|---|---|
+| `CHAT_KINDS` | `["direct","group","support"]` | Enabled thread kinds (drop `support` to disable the operator queue) |
+| `ATTACHMENTS` | `True` | Allow opaque attachment keys on messages |
+| `MAX_BODY_LENGTH` | `4000` | Hard cap on a text body |
+| `SCOPE_PROVIDER` | `stapel_chat.scope.DefaultScopeProvider` | Resolve/enforce the opaque `scope_key` (e.g. per workspace) |
+
+See [MODULE.md](MODULE.md) for the extension seams, comm surface and
+anti-patterns.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

stapel_chat-0.1.0/README.md

@@ -0,0 +1,62 @@
+# stapel-chat
+
+Conversations, messaging and support chat for the [Stapel](https://github.com/usestapel)
+framework — a reusable Django app you mount in a host project.
+
+One model backs three kinds of thread: **direct** (1:1, idempotent by
+participant pair), **group**, and **support** (a customer↔operator thread with a
+queue and assignment lifecycle). Messages carry a monotonic per-conversation
+**seq** that is the canonical anchor for history pagination and the resume
+cursor for realtime — so nothing depends on a socket staying up.
+
+```python
+INSTALLED_APPS = [
+    # ...
+    "stapel_core.django.apps.CommonDjangoConfig",
+    "stapel_core.django.users",
+    "rest_framework",
+    "stapel_chat",
+]
+
+# urls.py
+urlpatterns = [
+    path("chat/", include("stapel_chat.urls")),
+]
+```
+
+## What you get
+
+- **Conversations** — `POST /chat/api/conversations` (`direct` / `group` /
+  `support`); direct is get-or-create by participant pair. `GET` lists your
+  conversations (anchor-paginated) with `unread_count`.
+- **Messages** — `GET/POST /chat/api/conversations/{id}/messages`. History is
+  anchored on `seq` (newest-first, both directions). Sending allocates the next
+  `seq` and emits `chat.message` in one transaction.
+- **Read markers** — `POST /chat/api/conversations/{id}/read` (`upto_seq`).
+- **Support** — `GET /chat/api/support/queue`,
+  `POST .../support/conversations/{id}/{assign,resolve,reopen}`.
+- **Realtime (optional)** — `stapel_chat.consumers.ChatConsumer` over Channels:
+  `hello{last_seq}` → replay by seq → live delivery. Install the extra:
+
+  ```
+  pip install 'stapel-chat[channels]'
+  ```
+
+  and wire it behind `stapel_core.django.jwt.channels.JWTAuthMiddlewareStack` in
+  your `asgi.py`.
+
+## Configuration (`STAPEL_CHAT`)
+
+| Key | Default | Meaning |
+|---|---|---|
+| `CHAT_KINDS` | `["direct","group","support"]` | Enabled thread kinds (drop `support` to disable the operator queue) |
+| `ATTACHMENTS` | `True` | Allow opaque attachment keys on messages |
+| `MAX_BODY_LENGTH` | `4000` | Hard cap on a text body |
+| `SCOPE_PROVIDER` | `stapel_chat.scope.DefaultScopeProvider` | Resolve/enforce the opaque `scope_key` (e.g. per workspace) |
+
+See [MODULE.md](MODULE.md) for the extension seams, comm surface and
+anti-patterns.
+
+## License
+
+MIT — see [LICENSE](LICENSE).

stapel_chat-0.1.0/__init__.py

@@ -0,0 +1,11 @@
+"""stapel-chat — conversations, messaging and support chat for Stapel.
+
+A generic messaging core: ``Conversation`` (direct / group / support),
+``Message`` (monotonic per-conversation ``seq``, text or system), per-participant
+read markers, an idempotent direct-conversation primitive, anchor-paginated
+history and conversation lists, and a support layer (queue → assign → resolve →
+reopen) built on the same model. Realtime delivery is an optional Channels
+consumer; correctness never depends on it (clients replay by ``seq``).
+"""
+
+default_app_config = "stapel_chat.apps.ChatConfig"

stapel_chat-0.1.0/_capabilities.py

@@ -0,0 +1,41 @@
+"""stapel-chat capabilities.json emitter — thin shim over stapel_tools.capabilities."""
+from pathlib import Path
+
+from stapel_tools.capabilities import axis_group_rules, run_capabilities_cli
+
+
+def main(argv=None):
+    from stapel_chat._codegen import _configure
+
+    _configure()
+    from stapel_chat.conf import DEFAULTS
+    from stapel_chat.urls import GATE_REGISTRY
+
+    # Three CTO-facing config axes (capability-config.md §16), all behavioral
+    # (they widen/narrow what endpoints accept, they do not unmount any URL):
+    #   CHAT_KINDS    (list) — which conversation kinds are offered
+    #   ATTACHMENTS   (bool) — whether messages may carry attachment keys
+    #   MAX_BODY_LENGTH (int→enum kind) — hard cap on a text body
+    # SCOPE_PROVIDER is the one extension seam (curated in
+    # docs/capabilities.meta.json), not an axis.
+    axes = {"CHAT_KINDS", "ATTACHMENTS", "MAX_BODY_LENGTH"}
+    return run_capabilities_cli(
+        argv,
+        repo=Path(__file__).resolve().parent,
+        canonical_prefix="/chat",
+        defaults=DEFAULTS,
+        registry=GATE_REGISTRY,
+        is_axis=lambda k: k in axes,
+        axis_group=axis_group_rules(
+            exact={
+                "CHAT_KINDS": "chat.kinds",
+                "ATTACHMENTS": "chat.attachments",
+                "MAX_BODY_LENGTH": "chat.limits",
+            }
+        ),
+        prog="stapel-chat-capabilities",
+    )
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stapel_chat-0.1.0/_codegen.py

@@ -0,0 +1,117 @@
+"""stapel-chat contract-emission harness (contract-pipeline.md §2-3).
+
+Emits the module's own contract triad into ``docs/`` from a single-module
+``{chat + core}`` Django instance mounted at the canonical ``chat/api/``
+prefix:
+
+  docs/schema.json   drf-spectacular OpenAPI, this module only, canonical prefix
+  docs/flows.json    generate_flow_docs machine artifact ([] — no @flow_step here)
+  docs/errors.json   generate_error_keys registry
+
+Copied from stapel-calendar's adaptation of the stapel-auth reference
+implementation; the *mechanism* is stapel_tools.codegen (shared), this file is
+the thin per-module *config*.
+
+Usage:
+    python -m stapel_chat._codegen --out docs        # `make contract`
+"""
+from __future__ import annotations
+
+import argparse
+import os
+import sys
+from pathlib import Path
+
+
+def _configure() -> None:
+    """Configure + boot the single-module Django instance for emission."""
+    repo_root = os.path.dirname(os.path.abspath(__file__))
+    sys.path[:] = [p for p in sys.path if os.path.abspath(p or os.getcwd()) != repo_root]
+
+    from django.conf import settings
+
+    if not settings.configured:
+        from stapel_chat._codegen_settings import settings_kwargs
+
+        settings.configure(
+            **settings_kwargs(root_urlconf="stapel_chat.codegen_urls", contract=True)
+        )
+
+    import django
+
+    django.setup()
+
+    # Pin SCHEMA_PATH_PREFIX to the aggregate-style common prefix so operationIds
+    # match the convention every other pair-backend uses (see calendar's etalon
+    # note); the path keys keep /chat/api/ on both sides.
+    from drf_spectacular.settings import spectacular_settings
+
+    from stapel_chat._codegen_settings import CODEGEN_SCHEMA_PATH_PREFIX
+
+    spectacular_settings.SCHEMA_PATH_PREFIX = CODEGEN_SCHEMA_PATH_PREFIX
+
+    # Register drf-spectacular's JWT cookie-auth extension explicitly — this
+    # module mounts alone (no sibling triggers it), and every chat endpoint
+    # requires IsAuthenticated, so without it the schema would emit without the
+    # `security: [{"JWTCookieAuth": []}]` entry (a real contract gap). Same
+    # precedent as stapel-calendar / stapel-profiles.
+    from stapel_core.django.openapi.swagger import _register_jwt_auth_extension
+
+    _register_jwt_auth_extension()
+
+
+def _require_python_312() -> None:
+    """Abort emission if not running the pinned 3.12 interpreter.
+
+    drf-spectacular's rendering of component descriptions (``Optional[X]`` vs
+    ``X | None``) depends on the Python minor version — contracts emitted on
+    anything other than 3.12 produce false diffs against the committed
+    docs/*.json.
+    """
+    if sys.version_info[:2] != (3, 12):
+        got = f"{sys.version_info.major}.{sys.version_info.minor}"
+        raise SystemExit(
+            f"stapel-chat contract emission ABORTED: running Python {got}, but "
+            "contracts must be emitted on Python 3.12 (the CI/monolith pin). "
+            "drf-spectacular renders component descriptions (Optional[X] vs "
+            "X | None) differently across Python minor versions, so emitting on "
+            "any other minor produces false diffs against the committed "
+            "docs/*.json. Re-run under a 3.12 interpreter."
+        )
+
+
+def main(argv: list[str] | None = None) -> int:
+    _require_python_312()
+
+    parser = argparse.ArgumentParser(
+        prog="stapel-chat-contract",
+        description="Emit this module's contract triad (schema.json + flows.json "
+        "+ errors.json) into --out, canonical /chat/api/ prefix.",
+    )
+    parser.add_argument(
+        "--out",
+        default="docs",
+        help="Output directory for the triad (default: docs).",
+    )
+    args = parser.parse_args(argv)
+
+    _configure()
+
+    from stapel_tools.codegen import emit_errors, emit_flows, emit_schema
+
+    out = Path(args.out)
+    out.mkdir(parents=True, exist_ok=True)
+    paths = emit_schema(out / "schema.json")
+    flows = emit_flows(out / "flows.json")
+    errors = emit_errors(out / "errors.json")
+
+    print(
+        f"stapel-chat contract: {paths} paths, {flows} flows, {errors} error keys "
+        f"→ {out}/",
+        file=sys.stderr,
+    )
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

stapel_chat-0.1.0/_codegen_settings.py

@@ -0,0 +1,106 @@
+"""Single-module Django settings for stapel-chat's harnesses.
+
+Single source of truth for the ``settings.configure(...)`` block shared by:
+
+  - the pytest suite (``conftest.py``) — mounts chat on its *bare* test urlconf
+    (``stapel_chat.tests.urls`` -> ``chat/`` -> the module's own ``api/*``); and
+  - the contract-emission harness (``_codegen.py`` / ``make contract``) — mounts
+    chat on its *canonical* public API prefix (``stapel_chat.codegen_urls`` ->
+    ``chat/`` -> the same ``api/*`` paths) and enables drf-spectacular, so the
+    emitted ``schema.json`` / ``flows.json`` paths are byte-identical to what a
+    host mounting this module would serve (contract-pipeline.md §2).
+
+Keeping one copy here means the harness and the tests can never drift in their
+``INSTALLED_APPS`` / comm config. Copied from stapel-calendar's adaptation of
+the stapel-auth etalon; tailored to this module (no gdpr/social_django/JWT/
+Twilio — chat carries none of that, but it needs the in-process comm bus +
+schema validation the tests rely on).
+"""
+from __future__ import annotations
+
+
+def settings_kwargs(
+    *,
+    root_urlconf: str = "stapel_chat.tests.urls",
+    contract: bool = False,
+) -> dict:
+    """Return the ``settings.configure(**kwargs)`` for a single-module chat
+    instance. ``contract=True`` swaps in the production ``REST_FRAMEWORK`` (the
+    canonical stapel-core config) so the emitted schema is byte-identical to a
+    real host's."""
+    if contract:
+        rest_framework = {
+            "DEFAULT_AUTHENTICATION_CLASSES": [
+                "stapel_core.django.jwt.authentication.JWTCookieAuthentication",
+            ],
+            "DEFAULT_PERMISSION_CLASSES": [
+                "stapel_core.django.api.permissions.IsServiceRequest",
+                "stapel_core.django.api.permissions.IsSuperUser",
+            ],
+            "DEFAULT_RENDERER_CLASSES": [
+                "rest_framework.renderers.JSONRenderer",
+                "rest_framework.renderers.BrowsableAPIRenderer",
+            ],
+            "DEFAULT_SCHEMA_CLASS": "stapel_core.django.openapi.schemas.PermissionAwareAutoSchema",
+            "EXCEPTION_HANDLER": "stapel_core.django.api.errors.stapel_exception_handler",
+        }
+    else:
+        rest_framework = None
+
+    kwargs = dict(
+        SECRET_KEY="test-secret-key-not-for-production",
+        INSTALLED_APPS=[
+            "django.contrib.contenttypes",
+            "django.contrib.auth",
+            "django.contrib.sessions",
+            "django.contrib.admin",
+            "django.contrib.messages",
+            "stapel_core.django.apps.CommonDjangoConfig",
+            "stapel_core.django.users",
+            "rest_framework",
+            "drf_spectacular",
+            "stapel_chat",
+        ],
+        AUTH_USER_MODEL="users.User",
+        DATABASES={
+            "default": {
+                "ENGINE": "django.db.backends.sqlite3",
+                "NAME": ":memory:",
+            }
+        },
+        DEFAULT_AUTO_FIELD="django.db.models.BigAutoField",
+        USE_TZ=True,
+        ROOT_URLCONF=root_urlconf,
+        CACHES={
+            "default": {
+                "BACKEND": "django.core.cache.backends.locmem.LocMemCache",
+            }
+        },
+        # Synchronous in-process comm with schema validation ON, so the
+        # committed contracts in schemas/ are enforced by the tests.
+        STAPEL_BUS_BACKEND="stapel_core.bus.backends.memory.MemoryBus",
+        STAPEL_COMM={
+            "OUTBOX_ENABLED": False,
+            "ACTION_TRANSPORT": "inprocess",
+            "VALIDATE_SCHEMAS": True,
+        },
+        # In-memory Channels layer so the realtime consumer tests can exercise
+        # group fan-out without a broker.
+        CHANNEL_LAYERS={
+            "default": {"BACKEND": "channels.layers.InMemoryChannelLayer"},
+        },
+        MIGRATION_MODULES={
+            "users": None,
+            "chat": None,
+        },
+    )
+    if rest_framework is not None:
+        kwargs["REST_FRAMEWORK"] = rest_framework
+    return kwargs
+
+
+# The multi-module common path prefix drf-spectacular auto-detects in a
+# multi-module aggregate. Forced on the drf-spectacular settings singleton by
+# the harness so a single-module instance derives the same style of
+# operationIds. Uniform across all pair-backends.
+CODEGEN_SCHEMA_PATH_PREFIX = "/"

stapel_chat-0.1.0/actions.py

@@ -0,0 +1,25 @@
+"""Action subscriptions of stapel-chat.
+
+Handlers must be idempotent: delivery is at-least-once (outbox retries, broker
+redelivery). Consumes contracts live in ``schemas/consumes/``.
+"""
+import logging
+
+from stapel_core.comm import on_action
+
+logger = logging.getLogger(__name__)
+
+
+@on_action("user.deleted")
+def handle_user_deleted(event):
+    """Erase this module's PII when an account deletion is executed: the user's
+    authored messages, their conversation participations, and any direct
+    conversation that becomes empty as a result."""
+    from .gdpr import ChatGDPRProvider
+
+    user_id = event.payload.get("user_id")
+    if not user_id:
+        logger.error("user.deleted event without user_id: %s", event.event_id)
+        return
+    ChatGDPRProvider().delete(user_id)
+    logger.info("chat data erased for deleted user %s", user_id)

stapel_chat-0.1.0/admin.py

@@ -0,0 +1,26 @@
+"""Admin registrations for stapel-chat (observability; kept minimal)."""
+from django.contrib import admin
+
+from .models import Conversation, ConversationParticipant, Message
+
+
+class ParticipantInline(admin.TabularInline):
+    model = ConversationParticipant
+    extra = 0
+    fields = ("user", "role", "last_read_seq")
+
+
+@admin.register(Conversation)
+class ConversationAdmin(admin.ModelAdmin):
+    list_display = ("id", "kind", "scope_key", "support_status", "assigned_operator", "last_seq")
+    list_filter = ("kind", "support_status")
+    search_fields = ("id", "scope_key")
+    inlines = [ParticipantInline]
+
+
+@admin.register(Message)
+class MessageAdmin(admin.ModelAdmin):
+    list_display = ("conversation", "seq", "kind", "sender", "created_at")
+    list_filter = ("kind",)
+    search_fields = ("conversation__id", "body")
+    date_hierarchy = "created_at"

stapel_chat-0.1.0/apps.py

@@ -0,0 +1,26 @@
+from django.apps import AppConfig
+
+
+class ChatConfig(AppConfig):
+    name = "stapel_chat"
+    label = "chat"
+    verbose_name = "Chat and messaging"
+    default_auto_field = "django.db.models.BigAutoField"
+
+    def ready(self):
+        # Import-time side effects: comm actions/functions, system checks,
+        # error-key registration. Keep each in its own module. Realtime
+        # (consumers.py) is deliberately NOT imported here — Channels is an
+        # optional extra and an HTTP-only host must not pay for it.
+        from . import actions  # noqa: F401
+        from . import checks  # noqa: F401
+        from . import errors  # noqa: F401
+        from . import functions  # noqa: F401
+
+        # GDPR: register the per-app data handler (monolith in-process mode).
+        from stapel_core.gdpr import gdpr_registry
+
+        from .gdpr import ChatGDPRProvider
+
+        if not any(p.section == "chat" for p in gdpr_registry.providers):
+            gdpr_registry.register(ChatGDPRProvider())

stapel_chat-0.1.0/checks.py

@@ -0,0 +1,73 @@
+"""Django system checks for stapel-chat configuration.
+
+Policy (docs/library-standard.md §3.7): E-level for configuration the service
+cannot run with; W-level for entries that only degrade lazily.
+
+- SCOPE_PROVIDER unimportable / not a ScopeProvider -> E (create & list cannot
+  resolve/filter scope).
+- CHAT_KINDS not a subset of {direct, group, support} -> E (an unknown kind
+  would be un-creatable and confuse the capability report).
+- MAX_BODY_LENGTH not a positive int -> E (would reject or admit bodies
+  nonsensically).
+"""
+from django.core import checks
+
+_VALID_KINDS = {"direct", "group", "support"}
+
+
+@checks.register(checks.Tags.compatibility)
+def check_scope_provider(app_configs, **kwargs):
+    from .conf import chat_settings
+    from .scope import ScopeProvider
+
+    try:
+        provider = chat_settings.SCOPE_PROVIDER
+    except Exception as exc:
+        return [
+            checks.Error(
+                f"STAPEL_CHAT['SCOPE_PROVIDER'] could not be imported: {exc}",
+                id="stapel_chat.E001",
+            )
+        ]
+    target = provider if isinstance(provider, type) else type(provider)
+    if not issubclass(target, ScopeProvider):
+        return [
+            checks.Error(
+                "STAPEL_CHAT['SCOPE_PROVIDER'] must be a ScopeProvider subclass",
+                id="stapel_chat.E002",
+            )
+        ]
+    return []
+
+
+@checks.register(checks.Tags.compatibility)
+def check_chat_kinds(app_configs, **kwargs):
+    from .conf import chat_settings
+
+    kinds = chat_settings.CHAT_KINDS
+    if not isinstance(kinds, (list, tuple)) or not kinds or (
+        set(kinds) - _VALID_KINDS
+    ):
+        return [
+            checks.Error(
+                "STAPEL_CHAT['CHAT_KINDS'] must be a non-empty subset of "
+                "{direct, group, support}.",
+                id="stapel_chat.E003",
+            )
+        ]
+    return []
+
+
+@checks.register(checks.Tags.compatibility)
+def check_max_body_length(app_configs, **kwargs):
+    from .conf import chat_settings
+
+    value = chat_settings.MAX_BODY_LENGTH
+    if not isinstance(value, int) or isinstance(value, bool) or value < 1:
+        return [
+            checks.Error(
+                "STAPEL_CHAT['MAX_BODY_LENGTH'] must be a positive integer.",
+                id="stapel_chat.E004",
+            )
+        ]
+    return []

stapel_chat-0.1.0/codegen_urls.py

@@ -0,0 +1,19 @@
+"""Canonical-prefix URLconf for contract emission (contract-pipeline.md §2).
+
+stapel-chat's own ``urls.py`` already bakes ``api/`` into every path
+(``api/conversations``, ``api/support/queue``, ...) and documents its expected
+host mount::
+
+    path("chat/", include("stapel_chat.urls"))
+
+This harness urlconf reproduces exactly that mount, so drf-spectacular emits
+``/chat/api/...`` paths — the same ``<mod>/api/`` shape every pair-backend uses.
+Chat is validated standalone (no monolith slice yet; contract-pipeline.md §9
+fallback path applies).
+"""
+from django.conf.urls import include
+from django.urls import path
+
+urlpatterns = [
+    path("chat/", include("stapel_chat.urls")),
+]