inferenceport-cli 1.0.0__py3-none-any.whl

ipx/commands/featherless.py

@@ -0,0 +1,252 @@
+"""ipx featherless - Featherless model deployments, personal or for an organization.
+
+In an organization context (`ipx auth context <org>` or --org) every command acts on the organization's
+deployments: the fee is billed to the org wallet and every member that may spend on the org can call the model.
+Use --personal to work on your own deployments instead.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Dict, List, Optional
+
+import click
+from rich.text import Text
+
+from ipx import ui
+from ipx.app import App, pass_app
+from ipx.clickx import IpxGroup
+from ipx.errors import IpxError
+
+STATE_STYLE = {"warm": "ok", "loading": "warn", "cold": "bad"}
+LIVE = ("active", "cancelled_pending")
+
+
+def hf(model: str) -> str:
+    """Model ids are written `Author/Model` or `hf/Author/Model`; the API wants the prefixed form."""
+    m = model.strip()
+    return m if m.startswith("hf/") else f"hf/{m}"
+
+
+def bare(model: str) -> str:
+    m = model.strip()
+    return m[3:] if m.startswith("hf/") else m
+
+
+def base(app: App) -> str:
+    """Deployments endpoint for the active context: the organization's, or the personal one."""
+    org = app.org
+    return f"/v1/orgs/{org}/deployments" if org else "/v1/deploy"
+
+
+def auth(app: App) -> None:
+    """Organization routes need an interactive session; personal ones also accept a personal API key."""
+    app.require_jwt("Organization deployments") if app.org else app.require_login()
+
+
+def owner_label(app: App) -> str:
+    return f"organization {app.org}" if app.org else "your account"
+
+
+def money(v: Any) -> str:
+    try:
+        return f"${float(v):.2f}"
+    except (TypeError, ValueError):
+        return "—"
+
+
+def date(v: Any) -> str:
+    return str(v)[:10] if v else "—"
+
+
+def status_text(s: Any) -> Text:
+    s = str(s or "")
+    style = {"active": "ok", "cancelled_pending": "warn"}.get(s, "muted")
+    return Text("canceling" if s == "cancelled_pending" else s or "—", style=style)
+
+
+def state_text(s: Any) -> Text:
+    s = str(s or "")
+    label = {"warm": "warm", "loading": "initializing", "cold": "cold"}.get(s, s or "—")
+    return Text(label, style=STATE_STYLE.get(s, "muted"))
+
+
+def deployments_of(d: Any) -> List[Dict[str, Any]]:
+    """Rows from a list response, whatever the envelope (bare list, or data/deployments/models/items)."""
+    rows = d
+    if isinstance(d, dict):
+        rows = next((d[k] for k in ("data", "deployments", "models", "items") if isinstance(d.get(k), list)), [])
+    return [x for x in (rows or []) if isinstance(x, dict)]
+
+
+def meta_of(d: Any) -> Dict[str, Any]:
+    return d if isinstance(d, dict) else {}
+
+
+def show_deployment(x: Dict[str, Any], title: Optional[str] = None) -> None:
+    rows = [
+        ("Model", x.get("featherless_model_id")),
+        ("Call as", x.get("display_model_id")),
+        ("Status", status_text(x.get("status"))),
+        ("Model state", state_text(x.get("model_state")) if x.get("model_state") else None),
+        ("Context", f"{int(x['context_length']):,} tokens" if x.get("context_length") else None),
+        ("Monthly fee", money(x.get("monthly_fee"))),
+        ("Prompt / completion", f"{money(x.get('pricing_prompt_per_million'))} / {money(x.get('pricing_completion_per_million'))} per M tokens"),
+        ("Cycle", f"{date(x.get('billing_cycle_start'))} → {date(x.get('billing_cycle_end'))}"),
+        ("Owner", f"org {x['org_id']}" if x.get("org_id") else "personal"),
+        ("ID", x.get("id")),
+    ]
+    ui.console.print(ui.kv_panel(title or str(x.get("featherless_model_id") or "Deployment"), [r for r in rows if r[1] is not None]))
+
+
+@click.group("featherless", cls=IpxGroup, section="Cloud", short_help="Featherless deployments (personal or organization)",
+             examples=["ipx featherless models --search qwen", "ipx featherless deploy Qwen/Qwen2.5-7B-Instruct",
+                       "ipx featherless list", "ipx -O acme featherless deploy meta-llama/Llama-3.1-8B-Instruct",
+                       "ipx featherless cancel 3f2a…"])
+def group() -> None:
+    """Deploy any model from Featherless AI and manage your deployments.
+
+    A deployment costs $0.50/month and token usage is billed at Featherless rates plus a small markup, always from
+    paid credits. With an organization context the deployment belongs to the organization and bills its wallet;
+    only owners and admins can deploy, cancel, restore and terminate. Call a deployed model with the id shown by
+    `ipx featherless list` (hf/Author/Model) through any chat command.
+    """
+
+
+@group.command("models", short_help="Browse the Featherless catalog")
+@click.option("-s", "--search", help="Only models whose id contains this text.")
+@click.option("--page", type=click.IntRange(1), default=1, show_default=True)
+@click.option("--limit", type=click.IntRange(1, 200), default=25, show_default=True)
+@pass_app
+def models(app: App, search: Optional[str], page: int, limit: int) -> None:
+    """Search the catalog of deployable models with their prices (no sign-in needed)."""
+    d = app.api.get("/v1/deploy/models", params={"search": search, "page": page, "limit": limit}, auth=False, org=False) or {}
+
+    def render(d: Any) -> None:
+        rows = []
+        meta = meta_of(d)
+        for m in deployments_of(d):
+            ours = m.get("our_pricing_per_million") or {}
+            rows.append((m.get("featherless_model_id") or m.get("id"), f"{int(m['context_length']):,}" if m.get("context_length") else "—",
+                         money(ours.get("input")), money(ours.get("output"))))
+        ui.console.print(ui.make_table(["Model", "Context", "In $/M", "Out $/M"], rows,
+                                       title=f"Featherless models · {meta.get('total', len(rows)):,} found · page {meta.get('page', page)}/{meta.get('total_pages', 1)}",
+                                       right=["Context", "In $/M", "Out $/M"]))
+
+    app.out(d, render)
+
+
+@group.command("status", short_help="Is a model warm or cold?")
+@click.argument("model")
+@pass_app
+def status(app: App, model: str) -> None:
+    """Whether MODEL is loaded (warm), loading, or cold. Cold models take 5-15 minutes on the first request."""
+    d = app.api.get(f"/v1/deploy/model-status/{bare(model)}", auth=False, org=False) or {}
+    app.out(d, lambda x: ui.console.print(ui.kv_panel(bare(model), [("State", state_text(x.get("state")))] +
+                                                      [(k, v) for k, v in x.items() if k != "state" and not isinstance(v, (dict, list))])))
+
+
+@group.command("list", short_help="Deployments in the current context")
+@click.option("--all", "show_all", is_flag=True, help="Include cancelled, expired and removed deployments.")
+@pass_app
+def list_(app: App, show_all: bool) -> None:
+    """List deployments for the active context (organization, or personal with --personal)."""
+    auth(app)
+    d = app.api.get(base(app), org=False) or {}
+    rows = deployments_of(d)
+    shown = rows if show_all else [x for x in rows if x.get("status") in LIVE]
+
+    def render(_: Any) -> None:
+        if not shown:
+            ui.info(f"No {'' if show_all else 'active '}deployments for {owner_label(app)}. Deploy one with `ipx featherless deploy <model>`.")
+            return
+        ui.console.print(ui.make_table(
+            ["ID", "Call as", "Status", "State", "Fee", "Renews"],
+            [(x.get("id"), x.get("display_model_id") or hf(str(x.get("featherless_model_id") or "")), status_text(x.get("status")), state_text(x.get("model_state")) if x.get("model_state") else "—",
+              money(x.get("monthly_fee")), date(x.get("billing_cycle_end"))) for x in shown],
+            title=f"Featherless deployments · {owner_label(app)} ({len(shown)})"))
+
+    app.out(d if show_all else {**meta_of(d), "data": shown, "total": len(shown)}, render)
+
+
+@group.command("get", short_help="Show one deployment")
+@click.argument("deployment_id")
+@pass_app
+def get(app: App, deployment_id: str) -> None:
+    """Details of a deployment: pricing, billing cycle and model state."""
+    auth(app)
+    d = app.api.get(f"{base(app)}/{deployment_id}", org=False) or {}
+    app.out(d, show_deployment)
+
+
+@group.command("deploy", short_help="Deploy a model", examples=["ipx featherless deploy Qwen/Qwen2.5-7B-Instruct", "ipx -O acme featherless deploy hf/Qwen/Qwen2.5-7B-Instruct -y"])
+@click.argument("model")
+@pass_app
+def deploy(app: App, model: str) -> None:
+    """Deploy MODEL (Author/Model) for $0.50/month, charged now to your wallet or the organization's."""
+    auth(app)
+    mid = hf(model)
+    state = None
+    try:
+        state = (app.api.get(f"/v1/deploy/model-status/{bare(mid)}", auth=False, org=False) or {}).get("state")
+    except IpxError:
+        pass
+    if not app.json:
+        ui.console.print(f"Deploying [bold]{bare(mid)}[/bold] for {owner_label(app)}"
+                         + (f" · currently [bold]{state}[/bold]" if state else "") + ".")
+        if state in ("cold", "loading"):
+            ui.warn("This model is not loaded yet; the first request can take 5-15 minutes.")
+    if not ui.confirm(f"Charge the $0.50 monthly fee to {owner_label(app)}?", default=False):
+        raise click.Abort()
+    d = app.api.post(base(app), {"model_id": mid}, org=False, timeout=180) or {}
+
+    def render(x: Dict[str, Any]) -> None:
+        ui.ok(x.get("message") or f"Deployed {bare(mid)}.")
+        if x.get("deployment"):
+            show_deployment(x["deployment"])
+        if x.get("disclaimer"):
+            ui.dim(x["disclaimer"])
+
+    app.out(d, render)
+
+
+def _action(name: str, verb: str, method: str, suffix: str, past: str, confirm: Optional[str] = None) -> None:
+    @group.command(name, short_help=f"{verb} a deployment")
+    @click.argument("deployment_id")
+    @pass_app
+    def _cmd(app: App, deployment_id: str) -> None:
+        auth(app)
+        if confirm and not ui.confirm(confirm.format(id=deployment_id, owner=owner_label(app))):
+            raise click.Abort()
+        r = app.api.request(method, f"{base(app)}/{deployment_id}{suffix}", json={} if method == "POST" else None, org=False)
+        d = r.json() if r.body else {}
+        app.out(d, lambda x: ui.ok((x or {}).get("message") or past))
+
+    _cmd.__doc__ = {
+        "cancel": "Stop renewing a deployment. Access continues until the end of the billing cycle.",
+        "restore": "Undo a cancel while the deployment is still in its paid cycle.",
+        "terminate": "End a deployment immediately. This cannot be undone and the fee is not refunded.",
+    }[name]
+
+
+_action("cancel", "Cancel", "POST", "/cancel", "Deployment cancelled.", "Cancel deployment {id} for {owner} at the end of its cycle?")
+_action("restore", "Restore", "POST", "/uncancel", "Deployment restored.")
+_action("terminate", "Terminate", "DELETE", "", "Deployment terminated.", "Terminate deployment {id} for {owner} right now? This cannot be undone.")
+group.alias("uncancel", "restore")
+group.alias("delete", "terminate")
+
+
+@group.command("usage", short_help="Tokens and credits used by a deployment")
+@click.argument("deployment_id")
+@pass_app
+def usage(app: App, deployment_id: str) -> None:
+    """Token usage and credits charged for a deployment in its current history."""
+    auth(app)
+    d = app.api.get(f"{base(app)}/{deployment_id}/usage", org=False) or {}
+    app.out(d, lambda x: ui.console.print(ui.kv_panel(x.get("featherless_model_id") or "Deployment usage", [
+        ("Call as", x.get("display_model_id")), ("Status", status_text(x.get("status"))),
+        ("Input tokens", ui.fmt_num(x.get("total_input_tokens"))), ("Output tokens", ui.fmt_num(x.get("total_output_tokens"))),
+        ("Credits charged", ui.fmt_credits(x.get("total_credits_charged"))),
+        ("Cycle", f"{date(x.get('billing_cycle_start'))} → {date(x.get('billing_cycle_end'))}")])))
+
+
+COMMANDS = [group]

ipx/commands/gen.py

@@ -0,0 +1,3 @@
+"""ipx gen - Lightning, the subscription-backed API (see cloudgen for the shared definition)."""
+
+from ipx.commands.cloudgen import gen_group as group  # noqa: F401

ipx/commands/imports.py

@@ -0,0 +1,198 @@
+"""ipx import - add Hugging Face Spaces and websites to the desktop app's library."""
+
+from __future__ import annotations
+
+import colorsys
+import html
+import json
+import random
+import re
+import uuid
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+from urllib.parse import urlparse
+
+import click
+
+from ipx import ui
+from ipx.app import App, pass_app
+from ipx.clickx import IpxGroup
+from ipx.config import desktop_data_dir
+from ipx.errors import ApiError, IpxError
+from ipx.http import raw_request
+
+EMOJIS = ["🌐", "🚀", "🧠", "🎨", "📚", "🛠️", "💡", "🔭", "🧪", "🎧", "🗺️", "⚡"]
+
+
+def sanitize(s: str) -> str:
+    return re.sub(r"[^a-zA-Z0-9]", "_", s)
+
+
+def folder(kind: str) -> Path:
+    d = desktop_data_dir() / ("spaces" if kind == "space" else "websites")
+    d.mkdir(parents=True, exist_ok=True)
+    return d
+
+
+def readable_color() -> str:
+    h, s, v = random.random(), random.uniform(0.45, 0.7), random.uniform(0.75, 0.95)
+    r, g, b = (int(c * 255) for c in colorsys.hsv_to_rgb(h, s, v))
+    return f"#{r:02x}{g:02x}{b:02x}"
+
+
+def read_imports(kind: Optional[str] = None) -> List[Dict[str, Any]]:
+    out = []
+    for k in ("space", "website"):
+        if kind and k != kind:
+            continue
+        for p in sorted(folder(k).glob("*.import")):
+            try:
+                d = json.loads(p.read_text(encoding="utf-8"))
+                if isinstance(d, dict):
+                    d["_file"] = str(p)
+                    out.append(d)
+            except (OSError, ValueError):
+                continue
+    return out
+
+
+def fetch_title(url: str) -> Optional[str]:
+    try:
+        r = raw_request("GET", url, headers={"Accept": "text/html"}, timeout=8)
+        m = re.search(r"<title[^>]*>(.*?)</title>", r.text[:200_000], re.I | re.S)  # type: ignore[union-attr]
+        return html.unescape(re.sub(r"\s+", " ", m.group(1)).strip()) if m else None
+    except IpxError:
+        return None
+
+
+@click.group("import", cls=IpxGroup, section="Local", short_help="Add Spaces and websites to the desktop app",
+             examples=["ipx import space black-forest-labs/FLUX.1-schnell", "ipx import website https://excalidraw.com --title Excalidraw",
+                       "ipx import list", "ipx import rm https://excalidraw.com"])
+def group() -> None:
+    """Add Hugging Face Spaces and websites to the InferencePort desktop app.
+
+    Imports are written to the desktop app's library folder, so they show up under "Installed" next time the app
+    loads that page (restart the app if it is already open). They work without the app being installed, too: the
+    folder is created and picked up whenever you install it.
+    """
+
+
+@group.command("space", examples=["ipx import space stabilityai/stable-diffusion"])
+@click.argument("repo", metavar="USER/REPO")
+@pass_app
+def space(app: App, repo: str) -> None:
+    """Import a Hugging Face Space."""
+    repo = re.sub(r"^https?://huggingface\.co/spaces/", "", repo).strip("/")
+    if repo.count("/") != 1:
+        raise IpxError("Use the form user/space-name.", "Example: black-forest-labs/FLUX.1-schnell")
+    author, name = repo.split("/")
+    try:
+        with ui.status("Reading Space metadata…"):
+            api = raw_request("GET", f"https://huggingface.co/api/spaces/{author}/{name}", timeout=15).json() or {}  # type: ignore[union-attr]
+    except ApiError as e:
+        if e.status == 404:
+            raise IpxError(f"Space {repo} was not found on Hugging Face.")
+        raise
+    card = api.get("cardData") or {}
+    cfg = {
+        "type": "space",
+        "title": re.sub(r"\b\w", lambda m: m.group(0).upper(), re.sub(r"[-_]", " ", name)),
+        "author": author,
+        "emoji": card.get("emoji") or "🧠",
+        "background": f"linear-gradient(to right, {card.get('colorFrom') or '#3178c6'}, {card.get('colorTo') or '#90caf9'})",
+        "sdk": api.get("sdk") or "unknown",
+        "short_description": card.get("short_description") or "",
+    }
+    path = folder("space") / f"{sanitize(author)}____{sanitize(cfg['title'])}.import"
+    path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    app.out({**cfg, "file": str(path)}, lambda _: ui.ok(f"Imported Space [bold]{repo}[/bold] → {path.name}"))
+
+
+@group.command("website", examples=["ipx import website https://huggingface.co --title \"Hugging Face\""])
+@click.argument("url")
+@click.option("--title", help="Display name (default: the page title).")
+@click.option("--emoji", help="Card emoji (default: random).")
+@pass_app
+def website(app: App, url: str, title: Optional[str], emoji: Optional[str]) -> None:
+    """Import a website as an app card."""
+    if not url.startswith(("http://", "https://")):
+        url = "https://" + url
+    parsed = urlparse(url)
+    if not parsed.netloc:
+        raise IpxError("That does not look like a URL.", "Example: https://example.com")
+    existing = [i for i in read_imports("website") if i.get("url") == url]
+    if existing:
+        raise IpxError(f"{url} is already imported.", "Remove it first with `ipx import rm`.")
+    if not title:
+        with ui.status("Fetching page title…"):
+            title = fetch_title(url) or parsed.netloc
+    cfg = {
+        "type": "website", "title": title[:80], "author": "", "emoji": emoji or random.choice(EMOJIS),
+        "background": f"linear-gradient(to right, {readable_color()}, {readable_color()})",
+        "sdk": "unknown", "short_description": "", "url": url,
+    }
+    path = folder("website") / f"{uuid.uuid4()}.import"
+    path.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    app.out({**cfg, "file": str(path)}, lambda _: ui.ok(f"Imported website [bold]{title}[/bold] ({url})"))
+
+
+@group.command("file", short_help="Import a shared .import file")
+@click.argument("path", type=click.Path(exists=True, dir_okay=False))
+@pass_app
+def file_(app: App, path: str) -> None:
+    """Import an `.import` file someone shared from the desktop app."""
+    try:
+        cfg = json.loads(Path(path).read_text(encoding="utf-8"))
+    except ValueError:
+        raise IpxError("That file is not valid JSON.")
+    if not isinstance(cfg, dict) or cfg.get("type") not in ("space", "website") or not cfg.get("title"):
+        raise IpxError("Not an InferencePort import file.", "It must have a type of space or website, and a title.")
+    if cfg["type"] == "website" and not str(cfg.get("url", "")).startswith(("http://", "https://")):
+        raise IpxError("The website import has no valid URL.")
+    name = (f"{sanitize(cfg.get('author', ''))}____{sanitize(cfg['title'])}.import" if cfg["type"] == "space" else f"{uuid.uuid4()}.import")
+    dest = folder(cfg["type"]) / name
+    dest.write_text(json.dumps(cfg, indent=2), encoding="utf-8")
+    app.out({"file": str(dest)}, lambda _: ui.ok(f"Imported [bold]{cfg['title']}[/bold]"))
+
+
+@group.command("list", short_help="What is imported")
+@click.option("--type", "kind", type=click.Choice(["space", "website"]))
+@pass_app
+def list_(app: App, kind: Optional[str]) -> None:
+    """List imported Spaces and websites."""
+    items = read_imports(kind)
+
+    def render(_: Any) -> None:
+        if not items:
+            ui.info("Nothing imported yet. Try `ipx import space user/repo` or `ipx import website <url>`.")
+            return
+        rows = [(i.get("emoji"), i.get("type"), i.get("title"), (f"{i['author']}/…" if i.get("type") == "space" and i.get("author") else i.get("url")), i.get("sdk") if i.get("type") == "space" else "")
+                for i in items]
+        ui.console.print(ui.make_table(["", "Type", "Title", "Source", "SDK"], rows, title=f"Imports ({len(items)})"))
+
+    app.out([{k: v for k, v in i.items()} for i in items], render)
+
+
+@group.command("rm", short_help="Remove an import")
+@click.argument("target", metavar="URL|USER/REPO|TITLE")
+@pass_app
+def rm(app: App, target: str) -> None:
+    """Remove an imported website (by URL or title) or Space (by user/repo or title)."""
+    t = target.strip().lower()
+    hits = []
+    for i in read_imports():
+        keys = {str(i.get("url", "")).lower(), str(i.get("title", "")).lower(), f"{i.get('author', '')}/{i.get('title', '')}".lower()}
+        if i.get("type") == "space":
+            keys.add(f"{i.get('author', '')}/{str(i.get('title', '')).replace(' ', '-')}".lower())
+        if t in keys:
+            hits.append(i)
+    if not hits:
+        raise IpxError(f"Nothing imported matches “{target}”.", "See `ipx import list`.")
+    if len(hits) > 1 and not ui.STATE["yes"]:
+        raise IpxError(f"{len(hits)} imports match “{target}”.", "Use the exact URL, or pass --yes to remove all of them.")
+    for i in hits:
+        Path(i["_file"]).unlink(missing_ok=True)
+        ui.ok(f"Removed [bold]{i.get('title')}[/bold]")
+
+
+COMMANDS = [group]

ipx/commands/local.py

@@ -0,0 +1,88 @@
+"""ipx local - chat with and prompt models running on this machine."""
+
+from __future__ import annotations
+
+import sys
+from typing import Any, Dict, Iterator, List, Optional
+
+import click
+
+from ipx import chat as chatmod
+from ipx import ui
+from ipx.app import App, pass_app
+from ipx.clickx import IpxGroup
+from ipx.errors import IpxError
+from ipx.local import Ollama
+
+
+def _backend(oll: Ollama):
+    def backend(messages: List[Dict[str, Any]], model: Optional[str]) -> Iterator[chatmod.Event]:
+        total = 0
+        for ev in oll.chat(model or "", messages):
+            m = ev.get("message") or {}
+            if m.get("thinking"):
+                yield "think", m["thinking"]
+            if m.get("content"):
+                yield "text", m["content"]
+            if ev.get("done"):
+                total = int(ev.get("prompt_eval_count") or 0) + int(ev.get("eval_count") or 0)
+                yield "usage", {"tokens": total}
+
+    return backend
+
+
+def _pick_model(app: App, oll: Ollama, model: Optional[str]) -> str:
+    if model:
+        return model
+    default = app.cfg.get("default_local_model")
+    installed = [m["name"] for m in oll.list()]
+    if default and default in installed:
+        return default
+    if not installed:
+        raise IpxError("No local models installed.", "Pull one first: `ipx model pull llama3.2`.")
+    if len(installed) == 1:
+        return installed[0]
+    if ui.is_tty():
+        return ui.choose("Which model?", [(n, n) for n in installed])
+    raise IpxError("Several models are installed; specify one.", "Installed: " + ", ".join(installed))
+
+
+@click.group("local", cls=IpxGroup, section="Local", short_help="Chat with local models",
+             examples=["ipx local chat llama3.2", "ipx local text llama3.2 \"Explain monads in one sentence\""])
+def group() -> None:
+    """Run chat and one-off prompts against models on this machine. Free, private and offline."""
+
+
+@group.command("chat")
+@click.argument("model", required=False)
+@click.option("--system", help="System prompt.")
+@pass_app
+def chat_(app: App, model: Optional[str], system: Optional[str]) -> None:
+    """Interactive chat with a local model."""
+    oll = Ollama(app.cfg.ollama_url)
+    model = _pick_model(app, oll, model)
+    chatmod.run_repl(title="Local chat", subtitle="running on this machine · private", backend=_backend(oll), model=model,
+                     system=system, list_models=lambda: [m["name"] for m in oll.list()])
+
+
+@group.command("text")
+@click.argument("model")
+@click.argument("prompt", required=False)
+@click.option("--system", help="System prompt.")
+@click.option("--stdin", "use_stdin", is_flag=True, help="Append standard input to the prompt.")
+@pass_app
+def text_(app: App, model: str, prompt: Optional[str], system: Optional[str], use_stdin: bool) -> None:
+    """One-off generation. Pipe-friendly: the answer goes to stdout."""
+    parts = []
+    if use_stdin or prompt == "-":
+        parts.append(sys.stdin.read().strip())
+    if prompt and prompt != "-":
+        parts.append(prompt)
+    full = "\n\n".join(p for p in parts if p)
+    if not full:
+        raise IpxError("No prompt given.", "Pass it as an argument or pipe it in with `-`.")
+    oll = Ollama(app.cfg.ollama_url)
+    chatmod.one_shot(backend=_backend(oll), prompt=full, model=model, system=system, as_json=app.json)
+
+
+COMMANDS = [group]