@neta-art/cohub-cli 6.10.0 → 6.11.0

package/README.md

@@ -227,6 +227,8 @@ cohub search "query" --limit 20 --json
 
 ## Models and multimodal generation
 
+`models ls` prints each LLM's per-million-token cost (`$3 /M input · $15 /M output`, with cache rates when declared) and hides models marked `hidden`. `models ls --model-type multimodal` prints each model's unit price (`$0.04 / image`, `$0.10–$0.50 / second`); use `--json` for the raw `pricing` object (`unit`, `amount` or `min`/`max`, optional `note`).
+
 ```bash
 cohub models ls --json
 cohub models ls --model-type multimodal --json

package/dist/commands/models.d.ts

@@ -1,2 +1,28 @@
 import type { Command } from "commander";
+import { type PublicGenerationDeclaration } from "@neta-art/cohub";
+type MultimodalModelSummary = Pick<PublicGenerationDeclaration, "model" | "title" | "description" | "pricing">;
+export declare function toMultimodalModelSummary(model: PublicGenerationDeclaration): MultimodalModelSummary;
+export type GenerationModelPricing = NonNullable<PublicGenerationDeclaration["pricing"]>;
+/**
+ * Render a display-only unit price, e.g. `$0.04 / image` or `$0.10–$0.50 / second`,
+ * optionally suffixed with a qualifier note.
+ *
+ * The raw `pricing` object is preserved in `--json` for machines; this string
+ * targets humans and agents reading the table output.
+ */
+export declare function formatGenerationPrice(pricing: GenerationModelPricing): string;
+/**
+ * Render per-million-token LLM cost, e.g. `$3 /M input · $15 /M output`,
+ * appending cache rates only when the model declares them.
+ */
+export declare function formatLlmModelCost(model: Record<string, unknown>): string;
+/**
+ * Drop hidden models from LLM discovery, mirroring generation models and the web
+ * picker. Providers left with no visible model are removed so the catalog shape
+ * matches what is actually shown. Explicit `true` is the only hidden signal.
+ */
+export declare function filterHiddenLlmModels<T extends {
+    model: Record<string, unknown>;
+}>(catalog: Record<string, T[]>): Record<string, T[]>;
 export declare function registerModels(program: Command): void;
+export {};

package/dist/commands/models.js

@@ -1,11 +1,13 @@
 import { filterDiscoverableGenerationModels, filterGenerationDeclarationsByPolicy, getAllowedGenerationModelIds, parseGenerationPolicyFromEnv, } from "@neta-art/cohub";
 import { createClient } from "../client.js";
 import { table, json as outJson, jsonRequested, error, handleHttp } from "../output.js";
-function toMultimodalModelSummary(model) {
+export function toMultimodalModelSummary(model) {
     return {
         model: model.model,
         ...(model.title ? { title: model.title } : {}),
         ...(model.description ? { description: model.description } : {}),
+        // Keep pricing structured for `--json`; the human table formats it separately.
+        ...(model.pricing ? { pricing: model.pricing } : {}),
     };
 }
 function printSection(title, lines) {
@@ -15,6 +17,88 @@ function printSection(title, lines) {
     for (const line of lines)
         console.log(`  ${line}`);
 }
+const PRICE_UNIT_LABELS = {
+    image: "image",
+    second: "second",
+    request: "request",
+    "1m_tokens": "1M tokens",
+};
+/** USD amounts stay compact while preserving the precision the value actually needs. */
+function formatUsdAmount(value) {
+    const magnitude = Math.abs(value);
+    const isWholeDollar = magnitude >= 1 && Number.isInteger(value);
+    const fractionDigits = value === 0 || isWholeDollar ? 0 : magnitude < 0.01 ? 4 : 2;
+    return `$${value.toLocaleString("en-US", { minimumFractionDigits: fractionDigits, maximumFractionDigits: fractionDigits })}`;
+}
+/**
+ * Render a display-only unit price, e.g. `$0.04 / image` or `$0.10–$0.50 / second`,
+ * optionally suffixed with a qualifier note.
+ *
+ * The raw `pricing` object is preserved in `--json` for machines; this string
+ * targets humans and agents reading the table output.
+ */
+export function formatGenerationPrice(pricing) {
+    const unit = PRICE_UNIT_LABELS[pricing.unit];
+    const value = typeof pricing.amount === "number"
+        ? formatUsdAmount(pricing.amount)
+        : pricing.min === pricing.max
+            ? formatUsdAmount(pricing.min)
+            : `${formatUsdAmount(pricing.min)}\u2013${formatUsdAmount(pricing.max)}`;
+    const base = `${value} / ${unit}`;
+    return pricing.note ? `${base} \u00b7 ${pricing.note}` : base;
+}
+/** LLM catalog entries carry cost as an untyped `model.cost` bag; validate it before use. */
+function readLlmModelCost(model) {
+    const cost = model.cost;
+    if (!cost || typeof cost !== "object")
+        return null;
+    const { input, output, cacheRead, cacheWrite } = cost;
+    if (typeof input !== "number" || typeof output !== "number")
+        return null;
+    return {
+        input,
+        output,
+        ...(typeof cacheRead === "number" ? { cacheRead } : {}),
+        ...(typeof cacheWrite === "number" ? { cacheWrite } : {}),
+    };
+}
+/** Zero or absent per-token components carry no signal, so they are omitted. */
+function formatLlmCostValue(value) {
+    return typeof value === "number" && Number.isFinite(value) && value !== 0 ? formatUsdAmount(value) : null;
+}
+/**
+ * Render per-million-token LLM cost, e.g. `$3 /M input · $15 /M output`,
+ * appending cache rates only when the model declares them.
+ */
+export function formatLlmModelCost(model) {
+    const cost = readLlmModelCost(model);
+    if (!cost)
+        return "";
+    const parts = [
+        [cost.input, "input"],
+        [cost.output, "output"],
+        [cost.cacheRead, "cache read"],
+        [cost.cacheWrite, "cache write"],
+    ];
+    return parts.flatMap(([value, label]) => {
+        const formatted = formatLlmCostValue(value);
+        return formatted ? [`${formatted} /M ${label}`] : [];
+    }).join(" \u00b7 ");
+}
+/**
+ * Drop hidden models from LLM discovery, mirroring generation models and the web
+ * picker. Providers left with no visible model are removed so the catalog shape
+ * matches what is actually shown. Explicit `true` is the only hidden signal.
+ */
+export function filterHiddenLlmModels(catalog) {
+    const visible = {};
+    for (const [provider, entries] of Object.entries(catalog)) {
+        const models = entries.filter((entry) => entry.model.hidden !== true);
+        if (models.length > 0)
+            visible[provider] = models;
+    }
+    return visible;
+}
 function formatContentSpec(spec) {
     const details = [];
     const roles = spec.roles;
@@ -58,6 +142,8 @@ function printMultimodalModel(model) {
     printSection("Model", [model.model]);
     if (model.description)
         printSection("Description", [model.description]);
+    if (model.pricing)
+        printSection("Pricing", [formatGenerationPrice(model.pricing)]);
     printSection("Input", model.content.input.map(formatContentSpec));
     const parameterLines = Object.entries(model.parameters ?? {}).flatMap(([name, spec]) => formatParameter(name, spec));
     printSection("Parameters", parameterLines);
@@ -103,6 +189,11 @@ Examples:
                 table(models, [
                     { key: "model", label: "Model" },
                     { key: "title", label: "Title" },
+                    {
+                        key: "pricing",
+                        label: "Price",
+                        format: (value) => (value ? formatGenerationPrice(value) : ""),
+                    },
                     { key: "description", label: "Description" },
                 ]);
                 return;
@@ -111,15 +202,22 @@ Examples:
                 return error("Invalid model type", "Use --model-type llm or --model-type multimodal");
             }
             const catalog = await client.models.list();
+            const visibleCatalog = filterHiddenLlmModels(catalog);
             if (jsonRequested(opts))
-                return outJson(catalog);
-            // catalog is Record<provider, ModelCatalogEntry[]>
-            for (const [provider, entries] of Object.entries(catalog)) {
+                return outJson(visibleCatalog);
+            if (Object.keys(visibleCatalog).length === 0)
+                return console.log("  (empty)");
+            for (const [provider, entries] of Object.entries(visibleCatalog)) {
                 console.log(`\n  ${provider}`);
                 console.log(`  ${"─".repeat(provider.length)}`);
-                table(entries, [
+                table(entries.map((entry) => ({
+                    id: entry.id,
+                    provider: entry.provider,
+                    cost: formatLlmModelCost(entry.model),
+                })), [
                     { key: "id", label: "ID" },
                     { key: "provider", label: "Provider" },
+                    { key: "cost", label: "Cost" },
                 ]);
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@neta-art/cohub-cli",
-  "version": "6.10.0",
+  "version": "6.11.0",
   "description": "CLI for Cohub — spaces, sessions, and agent collaboration.",
   "type": "module",
   "license": "Apache-2.0",
@@ -15,11 +15,11 @@
     "NOTICE"
   ],
   "dependencies": {
-    "@neta-art/generation": "^0.1.26",
+    "@neta-art/generation": "^0.1.27",
     "commander": "^15.0.0",
     "pixi.js": "^8.20.1",
     "sharp": "^0.35.4",
-    "@neta-art/cohub": "8.13.0"
+    "@neta-art/cohub": "8.14.0"
   },
   "publishConfig": {
     "access": "public"