induscode 0.1.0__py3-none-any.whl

induscode/console/input/providers.py

@@ -0,0 +1,469 @@
+"""Composer autocomplete — slash + ``@``/path completion providers.
+
+Port of TS ``src/console/input/complete.ts`` in two layers:
+
+1. **The pure core** — :func:`complete_at` / :func:`apply_suggestion` and
+   the :class:`Suggestion` / :class:`TokenSpan` / :class:`CompletionResult`
+   shapes, ported verbatim (whitespace-delimited active token, slash-only-
+   at-buffer-start routing, ``@`` sigil stripping/re-application, dirs-first
+   sort, trailing-slash descent). The slash branch reads the M1 registry
+   through :func:`induscode.console_slash.match_prefix`; the path branch
+   lists through an injected :data:`~induscode.console.input.dir_reader.DirReader`
+   so the decision logic stays I/O-free and unit-testable.
+
+2. **The protocol adapters** — :class:`SlashCommandProvider`,
+   :class:`PathCompletionProvider`, and the :class:`ConsoleAutocompleteProvider`
+   router, implementing the framework's
+   :class:`indusagi.tui.autocomplete.AutocompleteProvider` protocol
+   (``async get_suggestions(lines, cursor_line, cursor_col)`` →
+   ``SuggestionResult | None``; ``apply_completion(...)`` → ``ApplyResult``)
+   so the wave-3 console hands one provider straight to the framework
+   ``PromptEditor``. ``apply_completion`` keeps the **TS splice semantics**
+   — the whole active-token span ``[start, end)`` is replaced (not just the
+   prefix before the caret, which is what the framework's own apply
+   strategy does) and the caret lands after the inserted value, so
+   accepting a directory (value ending ``/``) immediately re-offers the
+   next level on the editor's refresh.
+
+Mapping notes: :class:`Suggestion` → ``AutocompleteItem`` via
+:func:`to_autocomplete_item` (``detail`` → ``description``; ``is_dir`` is
+encoded by the trailing ``/`` on ``value``/``label``, the framework
+convention). ``SuggestionResult.prefix`` is the active token's stem (the
+text up to the caret), which keeps ``PromptEditor``'s best-match highlight
+and its ``prefix.startswith("/")`` slash-submit chaining working unchanged.
+"""
+
+from __future__ import annotations
+
+import asyncio
+from dataclasses import dataclass
+from typing import Literal, Sequence, TypeAlias
+
+from indusagi.tui.autocomplete import (
+    ApplyResult,
+    AutocompleteItem,
+    SuggestionResult,
+)
+
+from induscode.console_slash import SlashRegistry, match_prefix, tokens_of
+
+from .dir_reader import DirReader
+
+__all__ = [
+    "AppliedSuggestion",
+    "CompletionKind",
+    "CompletionResult",
+    "ConsoleAutocompleteProvider",
+    "PathCompletionProvider",
+    "SlashCommandProvider",
+    "Suggestion",
+    "TokenSpan",
+    "active_token",
+    "apply_suggestion",
+    "complete_at",
+    "to_autocomplete_item",
+]
+
+
+# ---------------------------------------------------------------------------
+# Suggestion shape (TS — verbatim)
+# ---------------------------------------------------------------------------
+
+#: Which source produced a batch of suggestions.
+CompletionKind: TypeAlias = Literal["slash", "path", "none"]
+
+
+@dataclass(frozen=True, slots=True)
+class Suggestion:
+    """One structured completion candidate.
+
+    ``value`` is the text spliced in when this suggestion is accepted
+    (already including any leading sigil — ``/`` for a command, ``@`` /
+    trailing slash for a path). ``label`` is what the completion window
+    shows; ``detail`` is the one-line description (a command summary, or a
+    ``directory``/``file`` hint). ``is_dir`` marks a directory so the
+    surface can keep the window open for further descent.
+    """
+
+    # The text spliced into the buffer when accepted.
+    value: str
+    # The primary text shown in the completion window.
+    label: str
+    # A one-line description shown beside the label.
+    detail: str
+    # Whether this path suggestion is a directory (False for slash commands).
+    is_dir: bool
+
+
+@dataclass(frozen=True, slots=True)
+class TokenSpan:
+    """The half-open ``[start, end)`` span of the buffer the active token
+    occupies. The surface replaces exactly this span when a suggestion is
+    applied, so the sigil and any preceding text are preserved."""
+
+    # Inclusive start offset of the active token.
+    start: int
+    # Exclusive end offset of the active token.
+    end: int
+
+
+@dataclass(frozen=True, slots=True)
+class CompletionResult:
+    """The full result of asking for completion at a caret position.
+
+    ``kind`` reports which source answered (``none`` when nothing applies),
+    ``span`` is the token to replace, and ``suggestions`` is the ranked
+    candidate list (empty when nothing matched).
+    """
+
+    # Which source produced the suggestions.
+    kind: CompletionKind
+    # The buffer span the active token occupies.
+    span: TokenSpan
+    # The ranked candidate list (possibly empty).
+    suggestions: tuple[Suggestion, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class AppliedSuggestion:
+    """The buffer rewritten by :func:`apply_suggestion`, plus the caret
+    placed at the end of the inserted value."""
+
+    buffer: str
+    caret: int
+
+
+def _no_completion(caret: int) -> CompletionResult:
+    """The inert result when no completion applies at the caret."""
+    return CompletionResult(kind="none", span=TokenSpan(caret, caret), suggestions=())
+
+
+# ---------------------------------------------------------------------------
+# Active-token extraction
+# ---------------------------------------------------------------------------
+
+#: Characters that terminate the active completion token.
+_BOUNDARY = frozenset({" ", "\t", "\n"})
+
+
+def active_token(buffer: str, caret: int) -> tuple[TokenSpan, str]:
+    """Find the whitespace-delimited token the caret sits within or at the
+    end of.
+
+    Pure: walks left from the caret to the previous boundary and right to
+    the next boundary, returning the enclosing span and the token's text up
+    to the caret (the ``stem``) — so completing mid-token replaces only the
+    prefix the user has typed.
+
+    :param buffer: the composer text
+    :param caret:  the caret offset within the buffer
+    """
+    start = caret
+    while start > 0 and buffer[start - 1] not in _BOUNDARY:
+        start -= 1
+    end = caret
+    while end < len(buffer) and buffer[end] not in _BOUNDARY:
+        end += 1
+    return TokenSpan(start=start, end=end), buffer[start:caret]
+
+
+# ---------------------------------------------------------------------------
+# Slash completion
+# ---------------------------------------------------------------------------
+
+
+def _complete_slash(stem: str, registry: SlashRegistry) -> tuple[Suggestion, ...]:
+    """Offer slash-command suggestions for a ``/``-prefixed stem.
+
+    Pure over the registry: the candidate set comes from
+    :func:`~induscode.console_slash.match_prefix` (case-insensitive prefix
+    over every token, registry order), then the TS ranking is applied — the
+    *first* matching token per command decides, and exact token matches
+    float to the front so the fully-typed command is always the default.
+    Each suggestion's ``value`` carries the leading slash back, and a
+    trailing space when the command takes args (so the caret lands ready
+    for input).
+    """
+    needle = stem[1:].lower()
+    exact: list[Suggestion] = []
+    prefix_hits: list[Suggestion] = []
+    for command in match_prefix(registry, stem[1:]):
+        hit = next(
+            (token for token in tokens_of(command) if token.lower().startswith(needle)),
+            None,
+        )
+        if hit is None:  # pragma: no cover - match_prefix guarantees a hit
+            continue
+        value = f"/{command.name} " if command.takes_args else f"/{command.name}"
+        suggestion = Suggestion(
+            value=value,
+            label=f"/{command.name}",
+            detail=command.summary,
+            is_dir=False,
+        )
+        if hit.lower() == needle:
+            exact.append(suggestion)
+        else:
+            prefix_hits.append(suggestion)
+    return (*exact, *prefix_hits)
+
+
+# ---------------------------------------------------------------------------
+# Path completion
+# ---------------------------------------------------------------------------
+
+
+def _split_path_stem(stem: str) -> tuple[str, str, str]:
+    """Split a path stem into the directory to list, the leaf prefix to
+    match, and the (possibly empty) ``@`` sigil.
+
+    For ``src/con`` the directory is ``src`` and the leaf is ``con``; for a
+    bare ``con`` the directory is ``.`` (the working dir); a trailing
+    separator (``src/``) lists ``src`` with an empty leaf. The sigil is
+    stripped first and re-applied by the caller on the produced ``value``.
+    """
+    sigil = "@" if stem.startswith("@") else ""
+    body = stem[len(sigil) :]
+    slash = body.rfind("/")
+    if slash < 0:
+        return ".", body, sigil
+    return body[:slash] or ".", body[slash + 1 :], sigil
+
+
+def _complete_path(stem: str, read_dir: DirReader) -> tuple[Suggestion, ...]:
+    """Offer file-path suggestions for a path-like stem.
+
+    Pure over the injected :data:`DirReader`: lists the resolved directory,
+    keeps entries whose leaf name starts with the typed prefix
+    (case-insensitively), sorts directories before files and then
+    alphabetically, and rebuilds each ``value`` as the full stem with the
+    matched leaf substituted. A directory suggestion appends a trailing
+    slash so the next accept descends into it.
+    """
+    directory, leaf, sigil = _split_path_stem(stem)
+    lower_leaf = leaf.lower()
+    prefix = "" if directory == "." else f"{directory}/"
+    matches = sorted(
+        (entry for entry in read_dir(directory) if entry.name.lower().startswith(lower_leaf)),
+        key=lambda entry: (not entry.is_dir, entry.name),
+    )
+    return tuple(
+        Suggestion(
+            value=f"{sigil}{prefix}{entry.name}{'/' if entry.is_dir else ''}",
+            label=f"{entry.name}{'/' if entry.is_dir else ''}",
+            detail="directory" if entry.is_dir else "file",
+            is_dir=entry.is_dir,
+        )
+        for entry in matches
+    )
+
+
+def _looks_like_path(stem: str) -> bool:
+    """Whether a stem should be routed to path completion: it carries the
+    ``@`` attachment sigil or already contains a path separator. A bare word
+    is left alone so plain prose never triggers a directory scan."""
+    return stem.startswith("@") or "/" in stem
+
+
+# ---------------------------------------------------------------------------
+# Entry points (pure core)
+# ---------------------------------------------------------------------------
+
+
+def complete_at(
+    buffer: str,
+    caret: int,
+    registry: SlashRegistry,
+    read_dir: DirReader,
+) -> CompletionResult:
+    """Compute the completion offering at a caret position.
+
+    Routes on the active token's stem: a ``/`` at buffer-start yields slash
+    completion (a slash mid-prose is a path separator or literal, not a
+    command); a ``@``/path-like stem yields path completion; anything else
+    yields the inert ``none``. Pure with respect to both sources — the
+    registry is data and the dir-reader is injected.
+
+    :param buffer:   the composer text
+    :param caret:    the caret offset within the buffer
+    :param registry: the slash-command registry to match against
+    :param read_dir: the directory reader the path branch lists through
+    """
+    span, stem = active_token(buffer, caret)
+
+    if stem.startswith("/") and span.start == 0:
+        return CompletionResult(kind="slash", span=span, suggestions=_complete_slash(stem, registry))
+
+    if _looks_like_path(stem):
+        return CompletionResult(kind="path", span=span, suggestions=_complete_path(stem, read_dir))
+
+    return _no_completion(caret)
+
+
+def apply_suggestion(
+    buffer: str, span: TokenSpan, suggestion: Suggestion
+) -> AppliedSuggestion:
+    """Splice an accepted suggestion back into the buffer.
+
+    Pure: replaces the active token's span with the suggestion's ``value``
+    and returns the rewritten buffer plus the caret placed at the end of the
+    inserted value. The surface re-runs :func:`complete_at` afterward so
+    descending into a directory (whose value ends in ``/``) immediately
+    offers the next level.
+
+    :param buffer:     the composer text the completion was computed against
+    :param span:       the token span returned by :func:`complete_at`
+    :param suggestion: the candidate the user accepted
+    """
+    rebuilt = buffer[: span.start] + suggestion.value + buffer[span.end :]
+    return AppliedSuggestion(buffer=rebuilt, caret=span.start + len(suggestion.value))
+
+
+def to_autocomplete_item(suggestion: Suggestion) -> AutocompleteItem:
+    """Project a console :class:`Suggestion` onto the framework
+    ``AutocompleteItem`` (``detail`` → ``description``; ``is_dir`` rides on
+    the trailing ``/`` of ``value``/``label``)."""
+    return AutocompleteItem(
+        value=suggestion.value,
+        label=suggestion.label,
+        description=suggestion.detail,
+    )
+
+
+# ---------------------------------------------------------------------------
+# Framework-protocol providers
+# ---------------------------------------------------------------------------
+
+
+def _line_at(lines: Sequence[str], index: int) -> str:
+    """``lines[i] || ""`` parity (out-of-range reads yield the empty string)."""
+    if 0 <= index < len(lines):
+        return lines[index] or ""
+    return ""
+
+
+def _apply_token_splice(
+    lines: Sequence[str], cursor_line: int, cursor_col: int, item: AutocompleteItem
+) -> ApplyResult:
+    """Commit an accepted item with the TS splice semantics: re-derive the
+    active token span on the current line, replace the whole span with the
+    item's value, and land the caret after it."""
+    line = _line_at(lines, cursor_line)
+    span, _stem = active_token(line, cursor_col)
+    rebuilt = line[: span.start] + item.value + line[span.end :]
+    new_lines = list(lines)
+    while len(new_lines) <= cursor_line:
+        new_lines.append("")
+    new_lines[cursor_line] = rebuilt
+    return ApplyResult(
+        lines=new_lines,
+        cursor_line=cursor_line,
+        cursor_col=span.start + len(item.value),
+    )
+
+
+def _to_result(suggestions: tuple[Suggestion, ...], stem: str) -> SuggestionResult | None:
+    if not suggestions:
+        return None
+    return SuggestionResult(
+        items=[to_autocomplete_item(suggestion) for suggestion in suggestions],
+        prefix=stem,
+    )
+
+
+def _is_slash_stem(cursor_line: int, span: TokenSpan, stem: str) -> bool:
+    """The TS buffer-start guard in the framework's line/col coordinates:
+    the slash must open the very first line."""
+    return cursor_line == 0 and span.start == 0 and stem.startswith("/")
+
+
+class SlashCommandProvider:
+    """``AutocompleteProvider`` over the slash registry (the TS slash
+    branch). Answers only when the active token is a ``/``-stem opening the
+    buffer; returns ``None`` everywhere else so a chained/path provider can
+    take over."""
+
+    def __init__(self, registry: SlashRegistry) -> None:
+        self._registry = registry
+
+    async def get_suggestions(
+        self, lines: list[str], cursor_line: int, cursor_col: int
+    ) -> SuggestionResult | None:
+        line = _line_at(lines, cursor_line)
+        span, stem = active_token(line, cursor_col)
+        if not _is_slash_stem(cursor_line, span, stem):
+            return None
+        return _to_result(_complete_slash(stem, self._registry), stem)
+
+    def apply_completion(
+        self,
+        lines: list[str],
+        cursor_line: int,
+        cursor_col: int,
+        item: AutocompleteItem,
+        prefix: str,
+    ) -> ApplyResult:
+        return _apply_token_splice(lines, cursor_line, cursor_col, item)
+
+
+class PathCompletionProvider:
+    """``AutocompleteProvider`` over an injected :data:`DirReader` (the TS
+    path branch). Answers only for ``@``-sigil or separator-bearing stems;
+    the directory listing runs on a worker thread so the UI never stalls
+    (the framework's fs idiom)."""
+
+    def __init__(self, read_dir: DirReader) -> None:
+        self._read_dir = read_dir
+
+    async def get_suggestions(
+        self, lines: list[str], cursor_line: int, cursor_col: int
+    ) -> SuggestionResult | None:
+        line = _line_at(lines, cursor_line)
+        _span, stem = active_token(line, cursor_col)
+        if not _looks_like_path(stem):
+            return None
+        suggestions = await asyncio.to_thread(_complete_path, stem, self._read_dir)
+        return _to_result(suggestions, stem)
+
+    def apply_completion(
+        self,
+        lines: list[str],
+        cursor_line: int,
+        cursor_col: int,
+        item: AutocompleteItem,
+        prefix: str,
+    ) -> ApplyResult:
+        return _apply_token_splice(lines, cursor_line, cursor_col, item)
+
+
+class ConsoleAutocompleteProvider:
+    """The :func:`complete_at` router as one framework provider: a slash
+    stem at buffer start wins (even a path-looking one like
+    ``/usr/local/bin`` — the TS routing, verbatim), then ``@``/path stems,
+    else nothing. This is the provider the wave-3 console hands to
+    ``PromptEditor``."""
+
+    def __init__(self, registry: SlashRegistry, read_dir: DirReader) -> None:
+        self._slash = SlashCommandProvider(registry)
+        self._path = PathCompletionProvider(read_dir)
+
+    async def get_suggestions(
+        self, lines: list[str], cursor_line: int, cursor_col: int
+    ) -> SuggestionResult | None:
+        line = _line_at(lines, cursor_line)
+        span, stem = active_token(line, cursor_col)
+        if _is_slash_stem(cursor_line, span, stem):
+            return await self._slash.get_suggestions(lines, cursor_line, cursor_col)
+        if _looks_like_path(stem):
+            return await self._path.get_suggestions(lines, cursor_line, cursor_col)
+        return None
+
+    def apply_completion(
+        self,
+        lines: list[str],
+        cursor_line: int,
+        cursor_col: int,
+        item: AutocompleteItem,
+        prefix: str,
+    ) -> ApplyResult:
+        return _apply_token_splice(lines, cursor_line, cursor_col, item)

induscode/console/mount.py

@@ -0,0 +1,137 @@
+"""Console mount — run the interactive surface and resolve the exit code.
+
+Port of TS ``src/console/mount.ts`` onto the framework's
+``mount_interactive`` pattern (``indusagi.ui_bridge.app``): the single entry
+point a run mode calls to take over the terminal. It resolves the colour
+scheme (an explicit override, else the ``colourScheme`` preference, else the
+default), pulls the matching pre-built :class:`~induscode.console.contract
+.ConsoleTheme` bundle (whose Textual Theme the app registers at mount — all
+four schemes are registered so the picker's live preview is a native
+retheme), assembles the slash registry (the built default catalog unless one
+is injected), constructs the :class:`~induscode.console.app.ConsoleApp`, and
+awaits ``App.run_async()``.
+
+Exit transcript: the TS Ink surface drew inline, so the conversation stayed
+in terminal scrollback after exit for free; Textual's alternate screen is
+erased when the app leaves. Once ``run_async`` returns (normal screen
+restored), the session transcript — the same content the ``MessageList``
+held — is re-rendered as plain Rich text and printed so the conversation
+survives in scrollback. ``transcript_file`` injects the destination (tests;
+default stdout); an empty session prints nothing at all.
+
+This module performs the only Textual mount in the console subsystem;
+everything it composes (the reducer, the theme engine, the slash registry,
+the input modules, the chrome widgets, the overlay flows) is pure or
+presentational, so the rest of the package stays testable without a running
+app. The repl runner reaches this mount through its injectable
+``set_console_mount`` seam (see ``induscode.boot.runners.repl_runner``).
+"""
+
+from __future__ import annotations
+
+from typing import IO, Callable
+
+from rich.console import Console
+from textual.app import AutopilotCallbackType
+
+from induscode.console_slash import SlashRegistry
+
+from .app import ConsoleApp
+from .contract import OverlayServices, SessionConductor, is_theme_scheme
+from .theme import resolve_theme
+
+__all__ = [
+    "mount_console",
+]
+
+
+def _resolve_scheme(scheme: str | None, services: OverlayServices | None) -> str | None:
+    """The scheme to mount with: an explicit override wins; otherwise the
+    ``colourScheme`` preference (when readable and recognised); otherwise
+    ``None`` so :func:`~induscode.console.theme.resolve_theme` falls back to
+    the default scheme. A corrupt preference never blanks the console."""
+    if scheme is not None:
+        return scheme
+    if services is None:
+        return None
+    try:
+        candidate = services.settings.get("colourScheme")
+    except Exception:
+        return None
+    if isinstance(candidate, str) and is_theme_scheme(candidate):
+        return candidate
+    return None
+
+
+def _default_registry() -> SlashRegistry:
+    """The built default slash catalog (assembled lazily so importing the
+    mount never triggers a filesystem discovery scan)."""
+    from .slash_commands import build_default_registry
+
+    return build_default_registry()
+
+
+async def mount_console(
+    conductor: SessionConductor,
+    services: OverlayServices | None = None,
+    *,
+    scheme: str | None = None,
+    slash: SlashRegistry | None = None,
+    initial_input: str | None = None,
+    verbose: bool = False,
+    on_exit: Callable[[], None] | None = None,
+    cwd: str | None = None,
+    headless: bool = False,
+    auto_pilot: AutopilotCallbackType | None = None,
+    transcript_file: IO[str] | None = None,
+) -> int:
+    """Render the interactive console for a session and resolve the process
+    exit code once the surface is dismissed.
+
+    Port of the TS ``mountConsole(conductor, opts)``: the options bag becomes
+    keyword arguments and Ink's ``render`` + ``waitUntilExit`` collapse into
+    ``App.run_async()``. Everything is optional with a sensible default: the
+    theme falls back to the preference / default scheme, the slash registry
+    to the built-in catalog, the seeds to empty. The conductor is the only
+    required input and is passed positionally; ``services`` carries the
+    runtime handles the modal overlays drive (absent on headless paths — the
+    overlays then settle inert).
+
+    ``headless`` / ``auto_pilot`` are forwarded to ``App.run_async`` so tests
+    can drive this real mount path under a ``Pilot`` without a TTY; both
+    default to the live-terminal behaviour.
+
+    :param conductor: the session this console drives
+    :param services: the overlay service bundle (settings, sessions, vault…)
+    :param scheme: an explicit colour-scheme override
+    :param slash: the slash registry to dispatch against
+    :param initial_input: an optional first user turn submitted on mount
+    :param verbose: whether to render verbose diagnostics in the banner
+    :param on_exit: invoked when the console asks the host process to exit
+    :param cwd: the workspace directory (defaults to the process cwd)
+    :param headless: run without a real terminal (tests)
+    :param auto_pilot: a Textual autopilot callback (tests)
+    :param transcript_file: where the exit transcript is printed (stdout)
+    :returns: the process exit code (``0`` on a clean interactive leave)
+    """
+    theme = resolve_theme(_resolve_scheme(scheme, services))
+    registry = slash if slash is not None else _default_registry()
+
+    app = ConsoleApp(
+        conductor,
+        theme=theme,
+        slash=registry,
+        services=services,
+        initial_input=initial_input,
+        verbose=verbose,
+        on_exit=on_exit,
+        cwd=cwd,
+    )
+    result = await app.run_async(headless=headless, auto_pilot=auto_pilot)
+
+    transcript = app.exit_transcript()
+    if transcript is not None:
+        console = Console() if transcript_file is None else Console(file=transcript_file)
+        console.print(transcript)
+
+    return 0 if result is None else int(result)

induscode/console/overlays/__init__.py

@@ -0,0 +1,94 @@
+"""Overlays subsystem — public barrel (port of TS ``src/console/overlays``).
+
+The TS barrel exported the ``OverlayHost`` mount point plus three
+always-mounted group components; under the Python dialog-API inversion
+(``ModalScreen[Result]`` dismissal instead of callback props — port plan
+analysis 02, risk 1) the host becomes :func:`open_overlay` — an awaited
+``push_screen_wait`` flow per :data:`~induscode.console.contract.ModalKind`
+returning a typed :class:`OverlayOutcome` — and the groups become the flow
+modules behind it (:mod:`.pickers`, :mod:`.sessions`, :mod:`.auth`). The
+console App imports the router from here rather than reaching into the
+individual modules; the pure mapping helpers are re-exported for tests and
+for the wave-3 ``ConsoleApp`` wiring.
+"""
+
+from .auth import (
+    PluginOverlayScreen,
+    PluginRequest,
+    login_provider_rows,
+    read_entry_mode,
+    read_plugin_request,
+    read_provider_id,
+    read_requested_provider,
+    run_oauth_flow,
+    run_plugin,
+    run_sign_in,
+    run_sign_out,
+    saved_account_rows,
+    seed_oauth_state,
+    select_provider_model,
+)
+from .pickers import (
+    THEME_CHOICES,
+    THEME_NAMES,
+    TOGGLE_VALUES,
+    authenticated_providers,
+    build_settings_items,
+    card_catalog_id,
+    list_model_refs,
+    read_scoped_payload,
+    ref_to_card,
+    run_model_picker,
+    run_scoped_models,
+    run_settings_picker,
+    run_theme_picker,
+)
+from .router import OVERLAY_HANDLERS, OverlayFlow, OverlayOutcome, open_overlay
+from .sessions import (
+    run_prior_turns,
+    run_session_picker,
+    run_tree_navigator,
+    to_session_info,
+    to_tree_option,
+    to_turn_option,
+)
+
+__all__ = [
+    "OVERLAY_HANDLERS",
+    "OverlayFlow",
+    "OverlayOutcome",
+    "PluginOverlayScreen",
+    "PluginRequest",
+    "THEME_CHOICES",
+    "THEME_NAMES",
+    "TOGGLE_VALUES",
+    "authenticated_providers",
+    "build_settings_items",
+    "card_catalog_id",
+    "list_model_refs",
+    "login_provider_rows",
+    "open_overlay",
+    "read_entry_mode",
+    "read_plugin_request",
+    "read_provider_id",
+    "read_requested_provider",
+    "read_scoped_payload",
+    "ref_to_card",
+    "run_model_picker",
+    "run_oauth_flow",
+    "run_plugin",
+    "run_prior_turns",
+    "run_scoped_models",
+    "run_session_picker",
+    "run_settings_picker",
+    "run_sign_in",
+    "run_sign_out",
+    "run_theme_picker",
+    "run_tree_navigator",
+    "saved_account_rows",
+    "seed_oauth_state",
+    "select_provider_model",
+    "to_session_info",
+    "to_tree_option",
+    "to_turn_option",
+]