chainlit-utils 0.0.3__py3-none-any.whl

chainlit_utils/__init__.py

@@ -0,0 +1 @@
+"""Reusable helpers for Chainlit applications."""

chainlit_utils/auth.py

@@ -0,0 +1,12 @@
+"""Authenticated-user helpers for Chainlit applications."""
+
+import chainlit as cl
+
+
+def authenticated_user_identifier() -> str:
+    """Return the unique identifier of the current authenticated user."""
+    user = cl.user_session.get("user")
+    identifier = getattr(user, "identifier", None)
+    if not isinstance(identifier, str) or not identifier:
+        raise RuntimeError("Chainlit request has no authenticated user.")
+    return identifier

chainlit_utils/chat.py

@@ -0,0 +1,59 @@
+"""Message and chat-history helpers for Chainlit applications."""
+
+from typing import cast
+
+import chainlit as cl
+from chainlit.types import ThreadDict
+from openai.types.chat import ChatCompletionMessageParam
+
+from chainlit_utils.settings import settings
+
+
+def mark_model_context_excluded(message: cl.Message | cl.AskActionMessage) -> None:
+    """Keep a UI-only message out of subsequent model requests."""
+    message.metadata = {
+        **(message.metadata or {}),
+        settings.MODEL_CONTEXT_EXCLUDED_KEY: True,
+    }
+
+
+async def send_ui_message(content: str) -> None:
+    """Send a UI-only message that must not become model context."""
+    message = cl.Message(content=content)
+    mark_model_context_excluded(message)
+    await message.send()
+
+
+def mark_persisted_errors_excluded(thread: ThreadDict) -> None:
+    """Preserve Chainlit's persisted error flag through context restore."""
+    for step in thread.get("steps", []):
+        if "message" not in step.get("type", "") or not step.get("isError"):
+            continue
+        metadata = step.get("metadata")
+        step["metadata"] = {
+            **(metadata if isinstance(metadata, dict) else {}),
+            settings.MODEL_CONTEXT_EXCLUDED_KEY: True,
+        }
+
+
+def text_only_chat_messages() -> list[ChatCompletionMessageParam]:
+    """Return Chainlit's role/content projection of the current chat.
+
+    This transcript is not a lossless OpenAI protocol ledger. Chainlit's native
+    projection does not retain fields such as ``tool_calls`` or ``tool_call_id``.
+    UI-only, failed, and cancelled assistant messages are omitted.
+    """
+    chainlit_messages = cl.chat_context.get()
+    openai_messages = cl.chat_context.to_openai()
+    return [
+        cast(ChatCompletionMessageParam, openai_message)
+        for chainlit_message, openai_message in zip(
+            chainlit_messages,
+            openai_messages,
+            strict=True,
+        )
+        if not chainlit_message.is_error
+        and not (chainlit_message.metadata or {}).get(
+            settings.MODEL_CONTEXT_EXCLUDED_KEY
+        )
+    ]

chainlit_utils/chat_settings.py

@@ -0,0 +1,137 @@
+"""Convert simple JSON Schema settings into Chainlit controls and JSON."""
+
+import json
+from collections.abc import Mapping
+from typing import Any
+
+from chainlit.input_widget import InputWidget, Select, Switch, TextInput
+
+
+class SettingsSerializationError(ValueError):
+    """Raised when selected chat settings cannot be serialized."""
+
+
+def settings_widgets(
+    json_schema: Mapping[str, Any],
+    defaults: Mapping[str, Any],
+    candidates: Mapping[str, Any] | None = None,
+) -> list[InputWidget]:
+    """Build widgets for direct scalar properties with concrete defaults."""
+    properties = json_schema.get("properties")
+    if not isinstance(properties, dict):
+        return []
+
+    candidates = candidates or {}
+    widgets: list[InputWidget] = []
+    for name, default in defaults.items():
+        widget = _widget_for_property(
+            name,
+            properties.get(name),
+            default,
+            candidates,
+        )
+        if widget is not None:
+            widgets.append(widget)
+    return widgets
+
+
+def serialize_settings(
+    defaults: Mapping[str, Any] | None,
+    values: Mapping[str, Any] | None,
+    *,
+    max_length: int | None = None,
+) -> str | None:
+    """Serialize non-default settings as compact JSON, or return ``None``."""
+    if max_length is not None and max_length < 0:
+        raise ValueError("max_length cannot be negative.")
+    if defaults is None or values is None:
+        return None
+
+    changed = {
+        name: values[name]
+        for name, default in defaults.items()
+        if name in values
+        and not (type(values[name]) is type(default) and values[name] == default)
+    }
+    if not changed:
+        return None
+
+    try:
+        encoded = json.dumps(
+            changed,
+            allow_nan=False,
+            ensure_ascii=False,
+            separators=(",", ":"),
+        )
+    except (TypeError, ValueError) as exc:
+        raise SettingsSerializationError(
+            "The selected settings cannot be encoded as JSON."
+        ) from exc
+    if max_length is not None and len(encoded) > max_length:
+        raise SettingsSerializationError(
+            f"The selected settings exceed the {max_length}-character limit."
+        )
+    return encoded
+
+
+def _widget_for_property(
+    name: str,
+    schema: Any,
+    default: Any,
+    candidates: Mapping[str, Any],
+) -> InputWidget | None:
+    """Build one widget from the small schema subset Chainlit can represent."""
+    if not name or not isinstance(schema, dict):
+        return None
+
+    label = str(schema.get("title") or name.replace("_", " ").title())
+    description = _optional_text(schema.get("description"))
+    schema_type = schema.get("type")
+    candidate = candidates.get(name)
+
+    if schema_type == "boolean":
+        if type(default) is not bool:
+            return None
+        initial = candidate if type(candidate) is bool else default
+        return Switch(
+            id=name,
+            label=label,
+            description=description,
+            initial=initial,
+        )
+
+    if schema_type != "string" or not isinstance(default, str):
+        return None
+
+    if "enum" in schema:
+        enum = schema["enum"]
+        if (
+            not isinstance(enum, list)
+            or not enum
+            or any(not isinstance(value, str) for value in enum)
+            or len(set(enum)) != len(enum)
+            or default not in enum
+        ):
+            return None
+        initial = (
+            candidate if isinstance(candidate, str) and candidate in enum else default
+        )
+        return Select(
+            id=name,
+            label=label,
+            description=description,
+            values=enum,
+            initial_value=initial,
+        )
+
+    initial = candidate if isinstance(candidate, str) else default
+    return TextInput(
+        id=name,
+        label=label,
+        description=description,
+        initial=initial,
+    )
+
+
+def _optional_text(value: Any) -> str | None:
+    return value if isinstance(value, str) else None

chainlit_utils/database.py

@@ -0,0 +1,139 @@
+"""Versioned PostgreSQL migrations for Chainlit conversation persistence."""
+
+from __future__ import annotations
+
+import asyncio
+import logging
+import os
+import re
+from dataclasses import dataclass
+from hashlib import sha256
+from pathlib import Path
+
+import asyncpg
+
+from chainlit_utils.settings import settings
+
+MIGRATIONS_DIR = Path(__file__).with_name("migrations")
+MIGRATION_LOCK_ID = 0x434C5554494C5301
+
+logger = logging.getLogger(__name__)
+
+
+class ChainlitMigrationError(RuntimeError):
+    """Raised when Chainlit migrations are missing, unknown, or changed."""
+
+
+@dataclass(frozen=True)
+class Migration:
+    """A checksum-protected SQL migration."""
+
+    version: str
+    checksum: str
+    sql: str
+
+
+def load_migrations(directory: Path | None = None) -> tuple[Migration, ...]:
+    """Load the bundled SQL migrations in version order."""
+    selected_directory = MIGRATIONS_DIR if directory is None else directory
+    migrations = []
+    for path in sorted(selected_directory.glob("*.sql")):
+        sql = path.read_text(encoding="utf-8")
+        migrations.append(
+            Migration(
+                version=path.stem,
+                checksum=sha256(sql.encode()).hexdigest(),
+                sql=sql,
+            )
+        )
+    if not migrations:
+        raise ChainlitMigrationError(
+            f"No Chainlit migrations found in {selected_directory}."
+        )
+    return tuple(migrations)
+
+
+async def apply_migrations(
+    connection: asyncpg.Connection,
+    migrations: tuple[Migration, ...] | None = None,
+) -> None:
+    """Apply each pending migration atomically and reject migration drift."""
+    quoted_table = _quoted_identifier(settings.MIGRATIONS_TABLE)
+    await connection.execute("SELECT pg_advisory_lock($1)", MIGRATION_LOCK_ID)
+    try:
+        await connection.execute(
+            f"""
+            CREATE TABLE IF NOT EXISTS {quoted_table} (
+                version TEXT PRIMARY KEY,
+                checksum TEXT NOT NULL,
+                applied_at TIMESTAMPTZ NOT NULL DEFAULT CURRENT_TIMESTAMP
+            )
+            """
+        )
+        rows = await connection.fetch(f"SELECT version, checksum FROM {quoted_table}")
+        applied = {row["version"]: row["checksum"] for row in rows}
+        selected_migrations = load_migrations() if migrations is None else migrations
+        known_versions = {migration.version for migration in selected_migrations}
+        unknown_versions = sorted(set(applied) - known_versions)
+        if unknown_versions:
+            joined_versions = ", ".join(unknown_versions)
+            raise ChainlitMigrationError(
+                "Database contains Chainlit migrations unknown to this release: "
+                f"{joined_versions}."
+            )
+
+        for migration in selected_migrations:
+            applied_checksum = applied.get(migration.version)
+            if applied_checksum == migration.checksum:
+                continue
+            if applied_checksum is not None:
+                raise ChainlitMigrationError(
+                    f"Applied Chainlit migration {migration.version!r} has changed."
+                )
+
+            async with connection.transaction():
+                # Bundled migrations are trusted assets and may contain multiple SQL
+                # statements. asyncpg executes the complete script as one command.
+                await connection.execute(migration.sql)
+                await connection.execute(
+                    f"""
+                    INSERT INTO {quoted_table} (version, checksum)
+                    VALUES ($1, $2)
+                    """,
+                    migration.version,
+                    migration.checksum,
+                )
+    finally:
+        await connection.execute("SELECT pg_advisory_unlock($1)", MIGRATION_LOCK_ID)
+
+
+async def setup_chainlit_schema(
+    database_url: str,
+) -> None:
+    """Initialize or migrate Chainlit's PostgreSQL schema."""
+    connection = await asyncpg.connect(database_url)
+    try:
+        await apply_migrations(connection)
+    finally:
+        await connection.close()
+
+
+def main() -> None:
+    """Apply pending migrations using the native ``DATABASE_URL`` setting."""
+    database_url = os.environ.get("DATABASE_URL")
+    if not database_url:
+        raise SystemExit("DATABASE_URL must be configured.")
+    logging.basicConfig(level=logging.INFO)
+    logger.info("Initializing PostgreSQL Chainlit persistence schema")
+    asyncio.run(setup_chainlit_schema(database_url))
+    logger.info("PostgreSQL Chainlit persistence schema is ready")
+
+
+def _quoted_identifier(value: str) -> str:
+    if re.fullmatch(r"[A-Za-z_][A-Za-z0-9_]*", value) is None:
+        raise ValueError(f"Invalid PostgreSQL migration table name: {value!r}.")
+    return f'"{value}"'
+
+
+if __name__ == "__main__":
+    main()

chainlit_utils/migrations/0001_chainlit_data_layer.sql

@@ -0,0 +1,132 @@
+-- Based on the official Chainlit PostgreSQL data-layer migration at commit
+-- 8844b1b318112961f8589b0614474a85530995df.
+
+CREATE EXTENSION IF NOT EXISTS "pgcrypto";
+
+CREATE TYPE "StepType" AS ENUM (
+    'assistant_message',
+    'embedding',
+    'llm',
+    'retrieval',
+    'rerank',
+    'run',
+    'system_message',
+    'tool',
+    'undefined',
+    'user_message'
+);
+
+CREATE TABLE "Element" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "threadId" TEXT,
+    "stepId" TEXT NOT NULL,
+    "metadata" JSONB NOT NULL,
+    "mime" TEXT,
+    "name" TEXT NOT NULL,
+    "objectKey" TEXT,
+    "url" TEXT,
+    "chainlitKey" TEXT,
+    "display" TEXT,
+    "size" TEXT,
+    "language" TEXT,
+    "page" INTEGER,
+    "props" JSONB,
+    CONSTRAINT "Element_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "User" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "metadata" JSONB NOT NULL,
+    "identifier" TEXT NOT NULL,
+    CONSTRAINT "User_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "Feedback" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "stepId" TEXT,
+    "name" TEXT NOT NULL,
+    "value" DOUBLE PRECISION NOT NULL,
+    "comment" TEXT,
+    CONSTRAINT "Feedback_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "Step" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "parentId" TEXT,
+    "threadId" TEXT,
+    "input" TEXT,
+    "metadata" JSONB NOT NULL,
+    "name" TEXT,
+    "output" TEXT,
+    "type" "StepType" NOT NULL,
+    "showInput" TEXT DEFAULT 'json',
+    "isError" BOOLEAN DEFAULT false,
+    "startTime" TIMESTAMP(3) NOT NULL,
+    "endTime" TIMESTAMP(3) NOT NULL,
+    CONSTRAINT "Step_pkey" PRIMARY KEY ("id")
+);
+
+CREATE TABLE "Thread" (
+    "id" TEXT NOT NULL DEFAULT gen_random_uuid(),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "deletedAt" TIMESTAMP(3),
+    "name" TEXT,
+    "metadata" JSONB NOT NULL,
+    "userId" TEXT,
+    CONSTRAINT "Thread_pkey" PRIMARY KEY ("id")
+);
+
+CREATE INDEX "Element_stepId_idx" ON "Element"("stepId");
+CREATE INDEX "Element_threadId_idx" ON "Element"("threadId");
+CREATE INDEX "User_identifier_idx" ON "User"("identifier");
+CREATE UNIQUE INDEX "User_identifier_key" ON "User"("identifier");
+CREATE INDEX "Feedback_createdAt_idx" ON "Feedback"("createdAt");
+CREATE INDEX "Feedback_name_idx" ON "Feedback"("name");
+CREATE INDEX "Feedback_stepId_idx" ON "Feedback"("stepId");
+CREATE INDEX "Feedback_value_idx" ON "Feedback"("value");
+CREATE INDEX "Feedback_name_value_idx" ON "Feedback"("name", "value");
+CREATE INDEX "Step_createdAt_idx" ON "Step"("createdAt");
+CREATE INDEX "Step_endTime_idx" ON "Step"("endTime");
+CREATE INDEX "Step_parentId_idx" ON "Step"("parentId");
+CREATE INDEX "Step_startTime_idx" ON "Step"("startTime");
+CREATE INDEX "Step_threadId_idx" ON "Step"("threadId");
+CREATE INDEX "Step_type_idx" ON "Step"("type");
+CREATE INDEX "Step_name_idx" ON "Step"("name");
+CREATE INDEX "Step_threadId_startTime_endTime_idx"
+    ON "Step"("threadId", "startTime", "endTime");
+CREATE INDEX "Thread_createdAt_idx" ON "Thread"("createdAt");
+CREATE INDEX "Thread_name_idx" ON "Thread"("name");
+
+ALTER TABLE "Element"
+    ADD CONSTRAINT "Element_stepId_fkey"
+    FOREIGN KEY ("stepId") REFERENCES "Step"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Element"
+    ADD CONSTRAINT "Element_threadId_fkey"
+    FOREIGN KEY ("threadId") REFERENCES "Thread"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Feedback"
+    ADD CONSTRAINT "Feedback_stepId_fkey"
+    FOREIGN KEY ("stepId") REFERENCES "Step"("id")
+    ON DELETE SET NULL ON UPDATE CASCADE;
+ALTER TABLE "Step"
+    ADD CONSTRAINT "Step_parentId_fkey"
+    FOREIGN KEY ("parentId") REFERENCES "Step"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Step"
+    ADD CONSTRAINT "Step_threadId_fkey"
+    FOREIGN KEY ("threadId") REFERENCES "Thread"("id")
+    ON DELETE CASCADE ON UPDATE CASCADE;
+ALTER TABLE "Thread"
+    ADD CONSTRAINT "Thread_userId_fkey"
+    FOREIGN KEY ("userId") REFERENCES "User"("id")
+    ON DELETE SET NULL ON UPDATE CASCADE;

chainlit_utils/migrations/0002_thread_tags.sql

@@ -0,0 +1,4 @@
+-- Official Chainlit data-layer migration 20250108095538_add_tags_to_thread.
+
+ALTER TABLE "Thread"
+    ADD COLUMN "tags" TEXT[] DEFAULT ARRAY[]::TEXT[];

chainlit_utils/migrations/0003_chainlit_2_1_0_command.sql

@@ -0,0 +1,5 @@
+-- Required by the official Chainlit 2.1.0 migration guide:
+-- https://docs.chainlit.io/guides/migration/2.1.0
+
+ALTER TABLE "Step"
+    ADD COLUMN IF NOT EXISTS "command" TEXT;

chainlit_utils/migrations/0004_chainlit_2_3_0_default_open.sql

@@ -0,0 +1,5 @@
+-- Required by the official Chainlit 2.3.0 migration guide:
+-- https://docs.chainlit.io/guides/migration/2.3.0
+
+ALTER TABLE "Step"
+    ADD COLUMN IF NOT EXISTS "defaultOpen" BOOLEAN;

chainlit_utils/migrations/0005_chainlit_2_9_4_modes.sql

@@ -0,0 +1,5 @@
+-- Required by the official Chainlit 2.9.4 migration guide:
+-- https://docs.chainlit.io/guides/migration/2.9.4
+
+ALTER TABLE "Step"
+    ADD COLUMN IF NOT EXISTS "modes" JSONB;

chainlit_utils/py.typed

@@ -0,0 +1 @@
+

chainlit_utils/settings.py

@@ -0,0 +1,30 @@
+"""Configuration for Chainlit utilities."""
+
+from pydantic import Field
+from pydantic_settings import BaseSettings, SettingsConfigDict
+
+
+class Settings(BaseSettings):
+    """Configuration shared by the reusable Chainlit helpers."""
+
+    model_config = SettingsConfigDict(
+        env_file=".env",
+        env_prefix="CHAINLIT_UTILS_",
+        env_file_encoding="utf-8",
+        extra="ignore",
+    )
+
+    MIGRATIONS_TABLE: str = Field(
+        default="_chainlit_utils_schema_migrations",
+        description="PostgreSQL table that records applied Chainlit migrations.",
+    )
+    MODEL_CONTEXT_EXCLUDED_KEY: str = Field(
+        default="chainlit_utils.exclude_from_model_context",
+        description=(
+            "Persisted message metadata key that excludes UI-only messages from "
+            "model context."
+        ),
+    )
+
+
+settings = Settings()

chainlit_utils-0.0.3.dist-info/METADATA

@@ -0,0 +1,125 @@
+Metadata-Version: 2.4
+Name: chainlit-utils
+Version: 0.0.3
+Summary: Reusable persistence and chat helpers for Chainlit applications
+Author: İlker SIĞIRCI
+Author-email: İlker SIĞIRCI <sigirci.ilker@gmail.com>
+License-Expression: MIT
+License-File: LICENSE
+Requires-Dist: asyncpg>=0.30.0
+Requires-Dist: chainlit>=2.11.1
+Requires-Dist: openai>=2.0.0
+Requires-Dist: pydantic-settings>=2.9.0
+Requires-Python: >=3.11, <3.15
+Description-Content-Type: text/markdown
+
+# chainlit-utils
+
+Small, reusable helpers for Chainlit applications:
+
+- versioned PostgreSQL migrations for Chainlit's official data layer;
+- exclusion of UI-only and failed messages from model context;
+- conversion of simple JSON Schema settings into Chainlit widgets;
+- compact serialization of changed chat settings; and
+- retrieval of the authenticated Chainlit user identifier.
+
+The package deliberately does not own model-provider protocols, application
+settings, login callbacks, or completion clients. Its own settings use the
+`CHAINLIT_UTILS_` environment-variable prefix.
+
+## Install
+
+```bash
+uv add chainlit-utils
+```
+
+For local development before publishing:
+
+```bash
+uv add --editable /path/to/chainlit-utils
+```
+
+## PostgreSQL persistence
+
+Chainlit uses `DATABASE_URL` to enable its native PostgreSQL data layer. Apply
+the matching schema before starting the application:
+
+```bash
+uv run --env-file .env chainlit-utils-migrate
+uv run --env-file .env chainlit run app.py
+```
+
+Migrations are checksum-protected and serialized with a PostgreSQL advisory
+lock. Existing applications can keep their current migration history table:
+
+```dotenv
+CHAINLIT_UTILS_MIGRATIONS_TABLE=_my_app_chainlit_schema_migrations
+```
+
+Review Chainlit's migration guidance before widening the supported Chainlit
+version range. The bundled migrations target Chainlit 2.11.1 or newer within
+the 2.x series.
+
+## Chat helpers
+
+```python
+import chainlit as cl
+
+from chainlit_utils.chat import (
+    mark_persisted_errors_excluded,
+    send_ui_message,
+    text_only_chat_messages,
+)
+
+
+@cl.on_chat_resume
+async def on_chat_resume(thread):
+    mark_persisted_errors_excluded(thread)
+
+
+@cl.on_message
+async def on_message(_message):
+    messages = text_only_chat_messages()
+    # Send messages to an OpenAI-compatible client.
+
+
+async def report_error(error: Exception):
+    await send_ui_message(f"Chat completion failed: {error}")
+```
+
+`text_only_chat_messages` uses Chainlit's native role/content projection. It is
+not a lossless tool-call ledger.
+
+UI-only messages use the
+`chainlit_utils.exclude_from_model_context` metadata key by default. Override it
+for an existing application without changing call sites:
+
+```dotenv
+CHAINLIT_UTILS_MODEL_CONTEXT_EXCLUDED_KEY=my_app.exclude_from_model_context
+```
+
+## Chat settings
+
+```python
+from chainlit_utils.chat_settings import settings_widgets, serialize_settings
+
+widgets = settings_widgets(json_schema, defaults, saved_values)
+await cl.ChatSettings(widgets).send()
+
+encoded = serialize_settings(defaults, selected_values, max_length=512)
+metadata = {"my_runtime_settings": encoded} if encoded is not None else {}
+```
+
+The widget adapter intentionally supports only booleans, string enums, and
+strings. The receiving application remains responsible for full schema
+validation.
+
+## Development
+
+```bash
+uv sync
+uv run pytest
+uv run ruff check src tests
+uv run ruff format --check src tests
+uv build
+```

chainlit_utils-0.0.3.dist-info/RECORD

@@ -0,0 +1,17 @@
+chainlit_utils/__init__.py,sha256=gYa2cUDDsPNpOBULLNe4swprv75HBIs0fv6vBdisd_s,50
+chainlit_utils/auth.py,sha256=bhaLiJMRI8nztQrbtladdgXqDNweUOfUeLpbTkSh45I,447
+chainlit_utils/chat.py,sha256=dRL9nWPRbegRzV2aMywiL-dVrFpTxWeXIzzhZcKLKKk,2084
+chainlit_utils/chat_settings.py,sha256=6B30_y0fNm_gZidVV0KemRbzF_EMxObaXOuPtArS5_w,4014
+chainlit_utils/database.py,sha256=V4OjTqkfDMyVmf8uQbduYmIDd28xzgDbAMqZT8rjtqI,4776
+chainlit_utils/migrations/0001_chainlit_data_layer.sql,sha256=v_KTwWGsXrd4fa6e39rKL6S9hshJ65Cbajsa5gvbdug,4590
+chainlit_utils/migrations/0002_thread_tags.sql,sha256=g8z073L4nR2ls3uCyekfqbRX-onVP9yxiGcOzJfZTVw,153
+chainlit_utils/migrations/0003_chainlit_2_1_0_command.sql,sha256=94WMN_OL3kHwdwrDH506fM5_JEEBimGqCXHtXGSEVcE,176
+chainlit_utils/migrations/0004_chainlit_2_3_0_default_open.sql,sha256=czf4vbqynSRQEphLnj0Q4FjLfEUrjq2AfPu-1IAUhVc,183
+chainlit_utils/migrations/0005_chainlit_2_9_4_modes.sql,sha256=lHSm-mWBrq4Lyg18Ji3ACI0TMrXfBhGPwfKJqujRazk,175
+chainlit_utils/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+chainlit_utils/settings.py,sha256=_2y0QCy0OD_9FaMulgx_rwNjlsJITwv7tyYiCK6lAM0,857
+chainlit_utils-0.0.3.dist-info/licenses/LICENSE,sha256=uciUysWaaLMcgVggvykngBytlTTwSRTJbYARZYfWcQU,1074
+chainlit_utils-0.0.3.dist-info/WHEEL,sha256=q9Wah2_CgP24mRNSlTyb0F8Yrbz55SzVl8eHLkZ_wvE,80
+chainlit_utils-0.0.3.dist-info/entry_points.txt,sha256=E_G-aGzXSoosTBswSx-5XI5RqqGSbbSgdvEMMFXdsOY,73
+chainlit_utils-0.0.3.dist-info/METADATA,sha256=Cfbuk3MIPLuSMLbvwxI37PiV0uxlFJ0mQNeEMi6Xcvk,3392
+chainlit_utils-0.0.3.dist-info/RECORD,,

chainlit_utils-0.0.3.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: uv 0.12.2
+Root-Is-Purelib: true
+Tag: py3-none-any

chainlit_utils-0.0.3.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[console_scripts]
+chainlit-utils-migrate = chainlit_utils.database:main
+

chainlit_utils-0.0.3.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026, İlker SIĞIRCI
+
+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.
+