dragon-cli 0.2.0__tar.gz

dragon_cli-0.2.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 JPEDROPS092
+
+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.

dragon_cli-0.2.0/PKG-INFO

@@ -0,0 +1,147 @@
+Metadata-Version: 2.4
+Name: dragon-cli
+Version: 0.2.0
+Summary: CLI to chat with local GGUF LLMs, with MCP tool-calling and SQLite conversation history.
+Author: JPEDROPS092
+License-Expression: MIT
+Project-URL: Homepage, https://jpedrops092.github.io/dragon-cli-ai-local/
+Project-URL: Repository, https://github.com/JPEDROPS092/dragon-cli-ai-local
+Project-URL: Issues, https://github.com/JPEDROPS092/dragon-cli-ai-local/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: rich
+Requires-Dist: huggingface_hub
+Requires-Dist: psutil
+Requires-Dist: mcp
+Requires-Dist: fastapi
+Requires-Dist: starlette
+Requires-Dist: uvicorn
+Requires-Dist: fastapi
+Provides-Extra: llm
+Requires-Dist: llama-cpp-python; extra == "llm"
+Dynamic: license-file
+
+# Dragon CLI
+
+![1785346956957](image/README/1785346956957.png)
+
+[![License: MIT](https://img.shields.io/github/license/JPEDROPS092/dragon-cli-ai-local)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+[![Docs](<https://img.shields.io/badge/docs-GitHub%20Pages-7fe0d1>)](https://jpedrops092.github.io/dragon-cli-ai-local/)
+[![GitHub stars](https://img.shields.io/github/stars/JPEDROPS092/dragon-cli-ai-local?style=social)](https://github.com/JPEDROPS092/dragon-cli-ai-local/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/JPEDROPS092/dragon-cli-ai-local)](https://github.com/JPEDROPS092/dragon-cli-ai-local/issues)
+
+Chat with local GGUF LLMs (100% CPU, via `llama-cpp-python`), with optional
+MCP (Model Context Protocol) tool-calling and a SQLite-backed conversation
+history.
+
+## Install
+
+```bash
+pip install -e .
+dragon-cli-install-llm
+```
+
+This exposes a `dragon-cli` command. `llama-cpp-python` is intentionally kept
+out of the core dependencies, since it ships as C++ source on PyPI for many
+platforms — a plain `pip install` would try to compile it locally and fail
+without a C/C++ toolchain (Visual Studio Build Tools on Windows, gcc on
+Linux, Xcode command line tools on macOS).
+
+`dragon-cli-install-llm` detects your OS/architecture (Windows, Linux, or
+macOS) and installs a prebuilt CPU wheel instead, so a compiler usually isn't
+needed at all. If no prebuilt wheel is available for your exact
+platform/Python combination, it prints the toolchain to install and the
+fallback command to run.
+
+If you already have a working C/C++ toolchain and would rather build from
+source yourself, skip the installer and use the extra instead:
+`pip install -e ".[llm]"`.
+
+You can also run it without installing:
+
+```bash
+python dragon_cli.py
+# or
+python -m dragon_cli
+```
+
+## Usage
+
+```bash
+dragon-cli                       # model menu + chat
+dragon-cli --model 2             # skip the model menu
+dragon-cli --list                # just list the model catalog
+dragon-cli --no-mcp              # disable MCP connectors
+dragon-cli --resume 3            # resume saved conversation #3
+dragon-cli --list-conversations  # list saved conversations and exit
+dragon-cli --db path/to/other.db # use a different conversation database
+dragon-cli --serve               # serve the model over HTTP instead of chatting
+dragon-cli --serve --port 8080   # custom port (default: 8000)
+dragon-cli --serve --host 0.0.0.0  # expose beyond localhost (e.g. to your LAN) — opt-in only
+```
+
+## HTTP server (`--serve`)
+
+`dragon-cli --serve` loads a model and exposes it over a minimal
+OpenAI-compatible HTTP API instead of starting the interactive chat. It's
+built on FastAPI, so interactive docs come for free:
+
+- `GET /` — landing page with usage examples
+- `GET /docs` — Swagger UI
+- `GET /redoc` — ReDoc
+- `GET /openapi.json` — raw OpenAPI schema
+- `GET /v1/models` — lists the currently loaded model
+- `POST /v1/chat/completions` — same shape as OpenAI's endpoint, streaming
+  (`"stream": true`, server-sent events) and non-streaming both supported,
+  request body validated (422 with a clear error on malformed input)
+
+Point any OpenAI-compatible client/SDK at `http://127.0.0.1:8000/v1` (adjust
+host/port to match `--host`/`--port`) and it works without extra glue code.
+This mode does **not** expose MCP tool-calling — it's the model only,
+kept intentionally simple and predictable. It also binds to `127.0.0.1` by
+default (only reachable from your own machine); pass `--host 0.0.0.0`
+explicitly if you want it reachable from other devices on your network.
+
+## In-chat commands
+
+| Command                    | Description                         |
+| -------------------------- | ----------------------------------- |
+| `/help`                  | show available commands             |
+| `/models`                | list the model catalog              |
+| `/tools`                 | list connected MCP tools            |
+| `/mcp`                   | show MCP server connection status   |
+| `/clear`                 | clear the current in-memory history |
+| `/new [title]`           | start a new conversation            |
+| `/list`                  | list saved conversations            |
+| `/resume <id>`           | resume a saved conversation         |
+| `/rename <id> <title>`   | rename a saved conversation         |
+| `/delete <id>`           | delete a saved conversation         |
+| `/search <text>`         | search saved messages for text      |
+| `/export <id> [md\|json]` | export a conversation to a file     |
+| `/exit`, `/quit`       | end the program                     |
+
+Every message is autosaved to SQLite (`dragon_cli.db` by default) as soon as
+it's sent, so nothing is lost if the process crashes.
+
+## MCP connectors
+
+On first run, an example `mcp_servers.json` is created in the working
+directory. Edit it to point at your MCP servers and restart to connect.
+
+## Project layout
+
+```
+src/dragon_cli/
+├── cli.py            # argparse entry point
+├── app.py             # model selection + orchestration
+├── setup_llm.py        # cross-platform llama-cpp-python installer
+├── server.py            # OpenAI-compatible HTTP server (--serve)
+├── banner.py            # ASCII banner
+├── config.py             # shared paths/colors
+├── models/            # model catalog, download, loading
+├── mcp/                # MCP server manager + tool-call parsing
+├── storage/            # SQLite conversation store
+└── chat/                # chat session, streaming, slash commands
+```

dragon_cli-0.2.0/README.md

@@ -0,0 +1,123 @@
+# Dragon CLI
+
+![1785346956957](image/README/1785346956957.png)
+
+[![License: MIT](https://img.shields.io/github/license/JPEDROPS092/dragon-cli-ai-local)](LICENSE)
+[![Python 3.10+](https://img.shields.io/badge/python-3.10%2B-blue)](https://www.python.org/)
+[![Docs](<https://img.shields.io/badge/docs-GitHub%20Pages-7fe0d1>)](https://jpedrops092.github.io/dragon-cli-ai-local/)
+[![GitHub stars](https://img.shields.io/github/stars/JPEDROPS092/dragon-cli-ai-local?style=social)](https://github.com/JPEDROPS092/dragon-cli-ai-local/stargazers)
+[![GitHub issues](https://img.shields.io/github/issues/JPEDROPS092/dragon-cli-ai-local)](https://github.com/JPEDROPS092/dragon-cli-ai-local/issues)
+
+Chat with local GGUF LLMs (100% CPU, via `llama-cpp-python`), with optional
+MCP (Model Context Protocol) tool-calling and a SQLite-backed conversation
+history.
+
+## Install
+
+```bash
+pip install -e .
+dragon-cli-install-llm
+```
+
+This exposes a `dragon-cli` command. `llama-cpp-python` is intentionally kept
+out of the core dependencies, since it ships as C++ source on PyPI for many
+platforms — a plain `pip install` would try to compile it locally and fail
+without a C/C++ toolchain (Visual Studio Build Tools on Windows, gcc on
+Linux, Xcode command line tools on macOS).
+
+`dragon-cli-install-llm` detects your OS/architecture (Windows, Linux, or
+macOS) and installs a prebuilt CPU wheel instead, so a compiler usually isn't
+needed at all. If no prebuilt wheel is available for your exact
+platform/Python combination, it prints the toolchain to install and the
+fallback command to run.
+
+If you already have a working C/C++ toolchain and would rather build from
+source yourself, skip the installer and use the extra instead:
+`pip install -e ".[llm]"`.
+
+You can also run it without installing:
+
+```bash
+python dragon_cli.py
+# or
+python -m dragon_cli
+```
+
+## Usage
+
+```bash
+dragon-cli                       # model menu + chat
+dragon-cli --model 2             # skip the model menu
+dragon-cli --list                # just list the model catalog
+dragon-cli --no-mcp              # disable MCP connectors
+dragon-cli --resume 3            # resume saved conversation #3
+dragon-cli --list-conversations  # list saved conversations and exit
+dragon-cli --db path/to/other.db # use a different conversation database
+dragon-cli --serve               # serve the model over HTTP instead of chatting
+dragon-cli --serve --port 8080   # custom port (default: 8000)
+dragon-cli --serve --host 0.0.0.0  # expose beyond localhost (e.g. to your LAN) — opt-in only
+```
+
+## HTTP server (`--serve`)
+
+`dragon-cli --serve` loads a model and exposes it over a minimal
+OpenAI-compatible HTTP API instead of starting the interactive chat. It's
+built on FastAPI, so interactive docs come for free:
+
+- `GET /` — landing page with usage examples
+- `GET /docs` — Swagger UI
+- `GET /redoc` — ReDoc
+- `GET /openapi.json` — raw OpenAPI schema
+- `GET /v1/models` — lists the currently loaded model
+- `POST /v1/chat/completions` — same shape as OpenAI's endpoint, streaming
+  (`"stream": true`, server-sent events) and non-streaming both supported,
+  request body validated (422 with a clear error on malformed input)
+
+Point any OpenAI-compatible client/SDK at `http://127.0.0.1:8000/v1` (adjust
+host/port to match `--host`/`--port`) and it works without extra glue code.
+This mode does **not** expose MCP tool-calling — it's the model only,
+kept intentionally simple and predictable. It also binds to `127.0.0.1` by
+default (only reachable from your own machine); pass `--host 0.0.0.0`
+explicitly if you want it reachable from other devices on your network.
+
+## In-chat commands
+
+| Command                    | Description                         |
+| -------------------------- | ----------------------------------- |
+| `/help`                  | show available commands             |
+| `/models`                | list the model catalog              |
+| `/tools`                 | list connected MCP tools            |
+| `/mcp`                   | show MCP server connection status   |
+| `/clear`                 | clear the current in-memory history |
+| `/new [title]`           | start a new conversation            |
+| `/list`                  | list saved conversations            |
+| `/resume <id>`           | resume a saved conversation         |
+| `/rename <id> <title>`   | rename a saved conversation         |
+| `/delete <id>`           | delete a saved conversation         |
+| `/search <text>`         | search saved messages for text      |
+| `/export <id> [md\|json]` | export a conversation to a file     |
+| `/exit`, `/quit`       | end the program                     |
+
+Every message is autosaved to SQLite (`dragon_cli.db` by default) as soon as
+it's sent, so nothing is lost if the process crashes.
+
+## MCP connectors
+
+On first run, an example `mcp_servers.json` is created in the working
+directory. Edit it to point at your MCP servers and restart to connect.
+
+## Project layout
+
+```
+src/dragon_cli/
+├── cli.py            # argparse entry point
+├── app.py             # model selection + orchestration
+├── setup_llm.py        # cross-platform llama-cpp-python installer
+├── server.py            # OpenAI-compatible HTTP server (--serve)
+├── banner.py            # ASCII banner
+├── config.py             # shared paths/colors
+├── models/            # model catalog, download, loading
+├── mcp/                # MCP server manager + tool-call parsing
+├── storage/            # SQLite conversation store
+└── chat/                # chat session, streaming, slash commands
+```

dragon_cli-0.2.0/pyproject.toml

@@ -0,0 +1,42 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "dragon-cli"
+version = "0.2.0"
+description = "CLI to chat with local GGUF LLMs, with MCP tool-calling and SQLite conversation history."
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+authors = [{ name = "JPEDROPS092" }]
+dependencies = [
+    "rich",
+    "huggingface_hub",
+    "psutil",
+    "mcp",
+    "fastapi",
+    "starlette",
+    "uvicorn",
+    "fastapi"
+]
+
+[project.optional-dependencies]
+# llama-cpp-python ships as C++ source on PyPI for many platforms, so pulling
+# it in as a hard dependency makes `pip install -e .` try to compile it and
+# fail without a C/C++ toolchain. Install it separately with
+# `dragon-cli-install-llm` (auto-detects OS/GPU, uses optimal prebuilt wheels),
+# or via this extra if you already have a working compiler: pip install -e ".[llm]"
+llm = ["llama-cpp-python"]
+
+[project.urls]
+Homepage = "https://jpedrops092.github.io/dragon-cli-ai-local/"
+Repository = "https://github.com/JPEDROPS092/dragon-cli-ai-local"
+Issues = "https://github.com/JPEDROPS092/dragon-cli-ai-local/issues"
+
+[project.scripts]
+dragon-cli = "dragon_cli.cli:main"
+dragon-cli-install-llm = "dragon_cli.setup_llm:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]

dragon_cli-0.2.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dragon_cli-0.2.0/src/dragon_cli/__init__.py

@@ -0,0 +1,5 @@
+__version__ = "0.2.0"
+
+from ._cuda import preload_cuda_runtime
+
+preload_cuda_runtime()

dragon_cli-0.2.0/src/dragon_cli/__main__.py

@@ -0,0 +1,4 @@
+from .cli import main
+
+if __name__ == "__main__":
+    main()

dragon_cli-0.2.0/src/dragon_cli/_cuda.py

@@ -0,0 +1,42 @@
+"""Preload CUDA runtime shared libraries shipped via pip wheels.
+
+The GPU-enabled llama-cpp-python wheel links against libcudart/libcublas/
+libnvrtc, which the pip ``nvidia-*-cu12`` packages install under
+``site-packages/nvidia/*/lib`` (not on the system library path). Loading them
+here by absolute path with ``RTLD_GLOBAL`` lets libllama.so resolve them
+without LD_LIBRARY_PATH. No-op when the libs are already resolvable or absent
+(e.g. the CPU-only wheel).
+
+Kept dependency-free (stdlib only) so it can run at package import time
+without risking circular imports.
+"""
+
+import ctypes
+import glob
+import os
+import sys
+
+_CUDA_SONAMES = (
+    "libcudart.so.12",
+    "libcublas.so.12",
+    "libcublasLt.so.12",
+    "libnvrtc.so.12",
+)
+
+
+def preload_cuda_runtime() -> None:
+    loaded: set[str] = set()
+    for entry in sys.path:
+        nvidia_dir = os.path.join(entry, "nvidia")
+        if not entry or not os.path.isdir(nvidia_dir):
+            continue
+        for soname in _CUDA_SONAMES:
+            if soname in loaded:
+                continue
+            for match in glob.glob(os.path.join(nvidia_dir, "*", "lib", soname)):
+                try:
+                    ctypes.CDLL(match, mode=ctypes.RTLD_GLOBAL)
+                    loaded.add(soname)
+                    break
+                except OSError:
+                    continue

dragon_cli-0.2.0/src/dragon_cli/app.py

@@ -0,0 +1,123 @@
+"""Async orchestration: model selection, MCP startup, and the chat session."""
+
+from pathlib import Path
+
+from .chat import ChatSession, chat_loop
+from .config import C_RED, C_RESET
+from .mcp import MCPManager
+from .models import MODEL_CATALOG, available_ram_gb, download_model, list_catalog, load_llm
+from .storage import ConversationStore
+
+
+def _gpu_layers_arg(args) -> int | None:
+    """Translate ``--n-gpu-layers`` into a ``load_llm`` override.
+
+    The CLI default is -1 (auto). Any value >= 0 is an explicit override
+    (0 = CPU only, >0 = exact layer count). None means "let the runtime
+    auto-decide".
+    """
+    n = getattr(args, "n_gpu_layers", -1)
+    return n if n is not None and n >= 0 else None
+
+
+def choose_model(args) -> dict | None:
+    # Handle --auto flag for automatic model selection
+    if getattr(args, 'auto', False):
+        from .recommendation import ModelRecommender
+        recommender = ModelRecommender()
+        best_model = recommender.recommend_best(priority=getattr(args, 'priority', 'balanced'))
+        
+        if best_model:
+            print(f"\n{C_RESET}Auto-selected model based on your hardware:")
+            print(f"  → {best_model['name']}")
+            reason = recommender.get_recommendation_reason(best_model)
+            print(f"  {C_DIM}Why: {reason}{C_RESET}\n")
+            return best_model
+        else:
+            print(f"{C_RED}[error]{C_RESET} No compatible models found for your hardware.")
+            # Fall back to manual selection
+            pass
+
+    # Skip the plain catalog print when a model was already chosen upstream
+    # (e.g. by the rich interactive menu), so the user doesn't see it twice.
+    if not args.model:
+        list_catalog()
+    if args.model:
+        choice = args.model
+    else:
+        try:
+            choice = int(input("\nChoose a model number: ").strip())
+        except (ValueError, EOFError, KeyboardInterrupt):
+            print("Invalid choice.")
+            return None
+    if not (1 <= choice <= len(MODEL_CATALOG)):
+        print("Number not in the catalog.")
+        return None
+    model = MODEL_CATALOG[choice - 1]
+    ram = available_ram_gb()
+    if 0 < ram < model["ram_min_gb"]:
+        ok = input(f"{C_RED}[warning]{C_RESET} Model needs ~{model['ram_min_gb']} GB, "
+                   f"you have {ram:.1f} GB free. Continue? (y/N) ").strip().lower()
+        if ok != "y":
+            return None
+    return model
+
+
+def print_conversations(store: ConversationStore) -> None:
+    conversations = store.list()
+    if not conversations:
+        print("No conversations yet.")
+        return
+    for c in conversations:
+        print(f"  #{c.id}  {c.title}  ({c.message_count} msgs, updated {c.updated_at})")
+
+
+async def run(args) -> None:
+    if args.serve:
+        model = choose_model(args)
+        if not model:
+            return
+        path = download_model(model)
+        llm = load_llm(path, model["ctx"], model_info=model,
+                       gpu_layers=_gpu_layers_arg(args),
+                       force_cpu=getattr(args, "cpu", False),
+                       force_gpu=getattr(args, "gpu", False))
+        from .server import run_server
+        await run_server(llm, model["name"], args.host, args.port)
+        return
+
+    store = ConversationStore(Path(args.db))
+
+    if args.list_conversations:
+        print_conversations(store)
+        store.close()
+        return
+
+    model = choose_model(args)
+    if not model:
+        store.close()
+        return
+
+    path = download_model(model)
+    llm = load_llm(path, model["ctx"], model_info=model,
+                   gpu_layers=_gpu_layers_arg(args),
+                   force_cpu=getattr(args, "cpu", False),
+                   force_gpu=getattr(args, "gpu", False))
+
+    mcp = MCPManager()
+    if not args.no_mcp:
+        await mcp.start()
+
+    session = ChatSession(llm, mcp, store, model["name"])
+    if args.resume is not None:
+        if not session.resume(args.resume):
+            print(f"{C_RED}[error]{C_RESET} No conversation with id {args.resume}, starting a new one.")
+            session.start_new()
+    else:
+        session.start_new()
+
+    try:
+        await chat_loop(session)
+    finally:
+        await mcp.stop()
+        store.close()

dragon_cli-0.2.0/src/dragon_cli/banner.py

@@ -0,0 +1,96 @@
+"""ASCII dragon banner shown at startup."""
+
+BANNER = r'''
+    _,_
+  /7/Y/^\
+  vuVV|C)|                        __ _
+    \|^ /                       .'  Y '>,
+    )| \)                      / _   _   \
+   //)|\\                      )(_) (_)(|}
+  / ^| \ \                     {  4A   } /
+ //^| || \\                     \uLuJJ/\l
+>//||| |\\\|                    |3    p)/
+| """""  7/>l__ _____ ____      /nnm_n//
+L>_   _-< 7/|_-__,__-)\,__)(".  \_>-<_/D
+)D" Y "c)  9)       //V     \_"-._.__G<D     __
+\  ||    . _/       (       \ "-._"> G<D-_.-"_=)_
+ ) __   / /         "      _/.__ />_c__.-__<"/ ( \
+ | | |  |(|               < "-._"> _.G_.___)\   \7\
+  \"=" // |              (,"-.__.|\ \<.__.-" )   \ \
+   '---'  |              |,"-.__"| \!"-.__.-".\   \ \
+     |_;._/              (_"-.__"'\ \"-.__.-".|    \_\
+     )(" V                \"-.__"'|\ \-.__.-".)     \ \
+        (                  "-.__'"\_\ \.__.-"./      \ l
+         )                  ".__"">>G\ \__.-">        V )
+  AI PROVIDERS                 ""  G<\ \_.-"        ./7
+                                     G<\ \          ///
+                                ___  G<D\ \        /7^
+                              /".-_"-"G"<\ \__    ///))
+                              ||,-_ "     '.\_"- /// (\
+                              | (_)  _   "/ __7 |X/   V
+                             /\__""-/ "\ _""c_"GBV
+                            _)(  ""'    "--.c__>D'
+                           /  /             )E_>"
+                         _/  (             |  \()
+                        / \ /              |  |
+                        /\\|               |  |
+                       / '((               |  |
+                      /  / )\              \  |
+                     /  y  \y              |Y |
+                    /  /    (              |  |
+                   L ."     |              |  /
+                  | \(                     |  |
+                   \_|                     |  |
+                   |  \                    { "|
+                   | ||                    |  |
+                   |x||                    \_,/
+                   } ||                    / \'
+                   | ||                    |_/
+                   | (|                    | }\
+                   | ||                    } ||
+                   | ||                    | ||
+                   | ||                    |\||
+                   / ||                    | ||
+                   | ||                    ( |!
+                   | |/                    ) ||
+                 _/   \                    | }|
+             _.-"_ ( )|   jjs              ! ||
+          c_"-_-"_    )                    | ||
+           c,-_-'_--""                     { ||
+           "C(_/"                          \ /|
+                                           (! )
+                                           /| \
+                                          /  |(
+                                         /7||\\
+                                        ()U cUu"
+'''
+
+SUBTITLE = "  DRAGON CLI — local LLM + MCP  |  /help for commands"
+
+# Compact mascot icon shown as a splash on the interactive menu. Raw string so
+# the backslashes in the art are preserved verbatim.
+ICON = r""",--.
+                          {    }
+                          K,   }
+                         /  `Y`
+                    _   /   /
+                   {_'-K.__/
+                     `/-.__L._
+                     /  ' /`\_}
+                    /  ' /     -AI PROVIDERS-
+            ____   /  ' /
+     ,-'~~~~    ~~/  ' /_
+   ,'             ``~~~%%',
+  (                     %  Y
+ {                      %% I
+{      -                 %  `.
+|       ',                %  )
+|        |   ,..__      __. Y
+|    .,_./  Y ' / ^Y   J   )|
+\           |' /   |   |   ||
+ \          L_/    . _ (_,.'(
+  \,   ,      ^^""' / |      )
+    \_  \          /,L]     /
+      '-_`-,       ` `   ./`
+         `-(_            )
+             ^^\..___,.--`"""

dragon_cli-0.2.0/src/dragon_cli/chat/__init__.py

@@ -0,0 +1,4 @@
+from .session import ChatSession, chat_loop
+from .streaming import generate_streaming
+
+__all__ = ["ChatSession", "chat_loop", "generate_streaming"]