@quadiusai/dsh-greenharness 0.1.0 → 0.1.1

package/GETTING-STARTED.md

@@ -14,22 +14,33 @@ Then start `dsh web` as usual. That's it. GreenHarness is now on.
 
 ## 2. Add your API keys and pick your models (no files to edit)
 
-Use DSH's own screens:
+1. In DSH web, open **Settings > Models**. Add your provider (for example NVIDIA) and paste your API key. DSH stores it.
+2. In the chat box, type:
 
-1. In DSH web, open **Settings → Models**.
-2. Add your provider (for example your NVIDIA/Brev endpoint) and paste your API key. DSH stores it for you.
-3. Use DSH's model chooser to pick the **cheap (small)** model for normal chats.
-4. Tell GreenHarness which model is the **strong (large)** one by typing in the chat box:
+```
+/greenharness models
+```
+
+You get a numbered list of every model DSH knows:
+
+```
+MODELS YOU CAN CHOOSE FROM
+   1. Nemotron 3 Ultra 550B A55B   (NVIDIA, id nvidia/nemotron-3-ultra-550b-a55b)
+   2. Nemotron 3 Bolt E4B          (NVIDIA, id nvidia/nemotron-3-bolt-e4b)
+```
+
+3. Pick by number:
 
 ```
-/greenharness large <provider> <model>
+/greenharness small 2       the cheap model, for easy steps
+/greenharness large 1       the strong model, for hard steps
 ```
 
-Example: `/greenharness large nemo-large lightning-30b`
+You can also type part of the name instead of a number, for example `/greenharness large nvidia Nemotron 3 Ultra`. Optionally add a thinking level at the end: `low`, `medium`, `high`.
 
-The cheap model is whatever DSH is already using. GreenHarness remembers it automatically. If you want to set it yourself: `/greenharness small <provider> <model>`.
+If you skip the large model, GreenHarness still saves tokens. It just won't switch models.
 
-If you skip step 4, GreenHarness still saves tokens. It just won't switch models.
+> **Important:** the command must be the only thing you send. Type it, then press Enter. If the chat shows "Thinking..." and runs commands, DSH treated your line as a normal message, which means the plugin isn't loaded. Update to the latest version and restart `dsh web`.
 
 ## 3. See it working
 
@@ -60,7 +71,9 @@ Model calls: 12. Switches between models: 2.
 |---|---|
 | `/greenharness` | Show the summary above |
 | `/greenharness off` / `on` | Pause or resume everything |
-| `/greenharness large <provider> <model>` | Pick the strong model (turns switching on) |
+| `/greenharness models` | List your models, numbered |
+| `/greenharness large <number or name>` | Pick the strong model (turns switching on) |
+| `/greenharness small <number or name>` | Pick the cheap model |
 | `/greenharness routing off` | Stop switching models |
 | `/greenharness distill off` | Stop shortening long output |
 | `/greenharness help` | List every command |
@@ -69,8 +82,9 @@ Changes last until DSH restarts.
 
 ## 5. If something looks wrong
 - **No `/greenharness` command:** run the install line again, then restart `dsh web`.
-- **"Not set" for the strong model:** run `/greenharness large ...` (step 2).
+- **"Not set" for the strong model:** run `/greenharness models`, then `/greenharness large <number>`.
+- **"DSH has no models to list":** add your key and models in Settings > Models first.
 - **Needs Node 22.19 or newer.**
 
 ## Honest limits
-The summary is text in the chat. DSH doesn't offer plugins a way to add their own panel, so there's no separate graphical dashboard. Savings numbers are estimates. The `/greenharness` command in the web chat has been tested only through unit tests and DSH start-up, not by clicking through the live page.
+The summary is text in the chat. DSH doesn't offer plugins a way to add their own panel, so there's no separate graphical dashboard. Savings numbers are estimates. The `/greenharness models` and `large` commands are tested with simulated model lists, and the plugin loads in a real `dsh web`. I could not click through a live chat without a real API key.

package/README.md

@@ -18,7 +18,9 @@ That is the whole setup. The package declares itself as a DSH bundle, so DSH tur
 |---|---|
 | `/greenharness` | Status: what is on, and what it has done in this process. |
 | `/greenharness on` / `off` | Resume or pause every mechanism. |
-| `/greenharness large <provider> <model> [effort]` | Turn on model routing. The small model is whatever DSH already uses; this one is the large model that failing tests escalate to. |
+| `/greenharness models` | List the models DSH knows, numbered. |
+| `/greenharness large <number or name> [effort]` | Turn on model routing. The small model is whatever DSH already uses; this one is the large model that failing tests escalate to. |
+| `/greenharness small <number or name>` | Set the small model. |
 | `/greenharness small <provider> <model> [effort]` | Set the small model explicitly. |
 | `/greenharness routing on` / `off` | Switch routing without losing the models. |
 | `/greenharness distill` / `dedupe` / `loop` `on` / `off` | Switch one mechanism. |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quadiusai/dsh-greenharness",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "GreenHarness: a DeepSeek Harness (dsh) plugin that cuts token, GPU and dollar cost in multi-step agent workflows. Install with one command; control it with /greenharness.",
   "type": "module",
   "main": "src/index.mjs",

package/src/control.mjs

@@ -11,26 +11,39 @@
 const TOGGLES = new Set(['distill', 'dedupe', 'loop', 'routing'])
 
 export const HELP = [
-  'GreenHarness commands (settings last until DSH restarts):',
-  '  /greenharness                 status: what is on, and what it has done so far',
-  '  /greenharness on | off        resume or pause every mechanism',
-  '  /greenharness large <provider> <model> [effort]',
-  '                                turn on model routing with this large model',
-  '  /greenharness small <provider> <model> [effort]',
-  '                                set the small model (default: the model DSH uses)',
-  '  /greenharness routing on | off',
-  '  /greenharness distill on | off   shorten long command output',
-  '  /greenharness dedupe on | off    replace a repeated file read with a pointer',
-  '  /greenharness loop on | off      block a repeated failing command',
-  '  /greenharness help',
+  'GREENHARNESS: HOW TO USE IT',
+  '',
+  'It starts saving tokens on its own. These commands let you steer it.',
+  '',
+  'SEE WHAT IT IS DOING',
+  '  /greenharness                 summary: tokens saved, progress bar, models',
+  '',
+  'CHOOSE MODELS (the cheap one for easy steps, a strong one for hard steps)',
+  '  /greenharness models          list the models you have set up in DSH, numbered',
+  '  /greenharness large 3         use model number 3 from that list as the strong model',
+  '  /greenharness large nvidia Nemotron 3 Ultra',
+  '                                or type part of its name, the provider first is optional',
+  '  /greenharness small 1         set the cheap model (default: whatever DSH already uses)',
+  '  Add API keys first in DSH: Settings > Models.',
+  '',
+  'TURN THINGS ON OR OFF',
+  '  /greenharness on | off        resume or pause everything',
+  '  /greenharness routing on|off  switching between the cheap and strong model',
+  '  /greenharness distill on|off  shorten very long command output',
+  '  /greenharness dedupe on|off   replace a repeated file read with a short pointer',
+  '  /greenharness loop on|off     stop a command that keeps failing the same way',
+  '',
+  'Settings last until DSH restarts.',
 ].join('\n')
 
+const EFFORTS = new Set(['minimal', 'low', 'medium', 'high', 'xhigh', 'max'])
+
 /**
  * Parse the text after `/greenharness`.
  * @param {string} rawInput
  * @returns {{ action: 'status' | 'help' } | { action: 'pause', paused: boolean }
  *   | { action: 'toggle', mechanism: string, enabled: boolean }
- *   | { action: 'tier', tier: 'small' | 'large', route: { provider: string, model: string, reasoningEffort: string } }
+ *   | { action: 'models' } | { action: 'tier', tier: 'small' | 'large', args: string[] }
  *   | { action: 'error', message: string }}
  */
 export function parseCommand(rawInput = '') {
@@ -47,10 +60,8 @@ export function parseCommand(rawInput = '') {
     if (args.length !== 1 || (value !== 'on' && value !== 'off')) return usage(`/greenharness ${verb} on|off`)
     return { action: 'toggle', mechanism: verb, enabled: value === 'on' }
   }
-  if (verb === 'large' || verb === 'small') {
-    if (args.length < 2 || args.length > 3) return usage(`/greenharness ${verb} <provider> <model> [effort]`)
-    return { action: 'tier', tier: verb, route: { provider: args[0], model: args[1], reasoningEffort: args[2] ?? '' } }
-  }
+  if (verb === 'models') return args.length === 0 ? { action: 'models' } : usage('/greenharness models')
+  if (verb === 'large' || verb === 'small') return { action: 'tier', tier: verb, args }
   return { action: 'error', message: `Unknown command "${first}". Try /greenharness help.` }
 }
 
@@ -58,9 +69,9 @@ export function parseCommand(rawInput = '') {
  * Run one command and return the reply DSH shows.
  * @param {string} rawInput
  * @param {{ control: { paused: boolean }, settings: any, runtime: { stats(): Record<string, number> } }} host
- * @returns {{ kind: 'success' | 'error', text: string }}
+ * @returns {Promise<{ kind: 'success' | 'error', text: string }>}
  */
-export function runCommand(rawInput, host) {
+export async function runCommand(rawInput, host) {
   const command = parseCommand(rawInput)
   switch (command.action) {
     case 'error': return fail(command.message)
@@ -70,6 +81,7 @@ export function runCommand(rawInput, host) {
       host.control.paused = command.paused
       return ok(command.paused ? 'GreenHarness paused. Tool output and model routing are left alone.' : 'GreenHarness resumed.')
     case 'toggle': return toggle(command, host)
+    case 'models': return showModels(host)
     case 'tier': return setTier(command, host)
     default: return fail('Unknown command. Try /greenharness help.')
   }
@@ -104,9 +116,10 @@ export function statusText({ control, settings, runtime }) {
     '',
     `Models: small = ${small_}, large = ${describe(settings.tiers.large)}. Routing ${onOff(settings.routing.enabled)}.`,
     `Features: shorten output ${onOff(settings.distill.enabled)}, repeated reads ${onOff(settings.readDedupe.enabled)}, loop stop ${onOff(settings.loopBreaker.enabled)}.`,
-    settings.tiers.large ? '' : 'Tip: pick a big model with  /greenharness large <provider> <model>  to save more.',
+    ...(settings.tiers.large ? [] : ['Next step: type /greenharness models, then /greenharness large <number> to add a strong model.']),
+    'All commands: /greenharness help',
   )
-  return lines.filter((l, i, a) => !(l === '' && (i === a.length - 1))).join('\n')
+  return lines.join('\n')
 }
 
 /** A 20-cell text progress bar. @param {number} fraction 0..1 */
@@ -129,14 +142,102 @@ function toggle({ mechanism, enabled }, { settings }) {
   return ok(`${mechanism === 'loop' ? 'Loop breaker' : mechanism[0].toUpperCase() + mechanism.slice(1)} ${onOff(enabled)}.`)
 }
 
-/** @param {{ tier: 'small' | 'large', route: object }} command @param {{ settings: any }} host */
-function setTier({ tier, route }, { settings }) {
-  settings.tiers[tier] = route
+const norm = text => String(text).toLowerCase().replace(/[^a-z0-9]/g, '')
+
+/**
+ * Every model DSH knows about, numbered. Providers that cannot list models are skipped quietly.
+ * @param {{ llm?: any }} host
+ * @returns {Promise<{ n: number, provider: string, providerName: string, id: string, name: string }[]>}
+ */
+async function loadListing(host) {
+  const entries = []
+  if (host.llm === undefined) return entries
+  for (const provider of host.llm.listProviders()) {
+    let models = []
+    try {
+      models = await host.llm.listModels(provider.id)
+    } catch {
+      continue
+    }
+    for (const model of models) {
+      entries.push({ n: entries.length + 1, provider: provider.id, providerName: provider.name, id: model.id, name: model.name })
+    }
+  }
+  host.listing = entries
+  return entries
+}
+
+const row = e => `  ${String(e.n).padStart(2)}. ${e.name}   (${e.providerName}, id ${e.id})`
+
+/** @param {{ llm?: any, listing?: any[] }} host */
+async function showModels(host) {
+  const entries = await loadListing(host)
+  if (entries.length === 0) {
+    return ok([
+      'DSH has no models to list yet.',
+      'Add your API key and models first: open Settings > Models in DSH, then run /greenharness models again.',
+    ].join('\n'))
+  }
+  return ok([
+    'MODELS YOU CAN CHOOSE FROM',
+    ...entries.map(row),
+    '',
+    'Pick the strong one:   /greenharness large <number>      e.g. /greenharness large 3',
+    'Pick the cheap one:    /greenharness small <number>',
+  ].join('\n'))
+}
+
+/**
+ * Work out which model the user meant: a list number, or words from its name with an optional
+ * provider first and an optional reasoning effort last.
+ * @param {string[]} args
+ * @param {{ llm?: any, listing?: any[] }} host
+ * @returns {Promise<{ route: { provider: string, model: string, reasoningEffort: string }, label: string } | { error: string }>}
+ */
+async function resolveModel(args, host) {
+  let effort = ''
+  if (args.length > 1 && EFFORTS.has(args[args.length - 1].toLowerCase())) effort = args[args.length - 1].toLowerCase()
+  const words = effort === '' ? args : args.slice(0, -1)
+  if (words.length === 0) return { error: 'Which model? Run /greenharness models to see the list, then use its number.' }
+  const entries = host.listing?.length ? host.listing : await loadListing(host)
+  const pick = e => ({ route: { provider: e.provider, model: e.id, reasoningEffort: effort }, label: `${e.name} (${e.providerName})` })
+  if (words.length === 1 && /^\d+$/.test(words[0])) {
+    const hit = entries.find(e => e.n === Number(words[0]))
+    return hit ? pick(hit) : { error: `There is no model number ${words[0]}. Run /greenharness models to see the list.` }
+  }
+  if (host.llm === undefined) {
+    if (words.length < 2) return { error: 'Use: /greenharness large <provider> <model>' }
+    return { route: { provider: words[0], model: words.slice(1).join(' '), reasoningEffort: effort }, label: `${words[0]}/${words.slice(1).join(' ')}` }
+  }
+  const providers = host.llm.listProviders()
+  const owner = providers.find(p => norm(p.id) === norm(words[0]) || norm(p.name) === norm(words[0]))
+  const rest = owner ? words.slice(1) : words
+  const pool = owner ? entries.filter(e => e.provider === owner.id) : entries
+  const query = norm(rest.join(''))
+  if (query === '') return { error: `Which model from ${owner.name}? Run /greenharness models to see the list.` }
+  const exact = pool.filter(e => norm(e.id) === query || norm(e.name) === query)
+  const near = exact.length > 0 ? exact : pool.filter(e => norm(e.id).includes(query) || norm(e.name).includes(query))
+  if (near.length === 1) return pick(near[0])
+  if (near.length > 1) {
+    return { error: ['That matches several models. Pick one by number:', ...near.map(row)].join('\n') }
+  }
+  if (owner && rest.length === 1) {
+    return { route: { provider: owner.id, model: rest[0], reasoningEffort: effort }, label: `${rest[0]} (${owner.name}, typed id)` }
+  }
+  return { error: `I could not find a model matching "${rest.join(' ')}". Run /greenharness models to see what DSH has. Add keys and models in Settings > Models.` }
+}
+
+/** @param {{ tier: 'small' | 'large', args: string[] }} command @param {{ settings: any, llm?: any, listing?: any[] }} host */
+async function setTier({ tier, args }, host) {
+  if (args.length === 0) return showModels(host)
+  const found = await resolveModel(args, host)
+  if ('error' in found) return fail(found.error)
+  host.settings.tiers[tier] = found.route
   if (tier === 'large') {
-    settings.routing.enabled = true
-    return ok(`Large model set to ${route.provider}/${route.model}. Routing is on: calls escalate to it after failing tests.`)
+    host.settings.routing.enabled = true
+    return ok(`Strong model set to ${found.label}.\nSwitching is ON: GreenHarness will use it when the cheap model keeps failing tests, then go back.\nType /greenharness to watch it work.`)
   }
-  return ok(`Small model set to ${route.provider}/${route.model}.`)
+  return ok(`Cheap model set to ${found.label}.`)
 }
 
 /** @param {string} message */

package/src/index.mjs

@@ -25,7 +25,7 @@ import { runCommand } from './control.mjs'
 export const name = 'greenharness'
 
 /** Needs the command registry to offer `/greenharness`. */
-export const inject = ['commands']
+export const inject = ['commands', 'llm']
 
 // Every field defaults to empty: an absent tier is an empty route, and normalizeSettings decides.
 const route = z.object({
@@ -144,7 +144,7 @@ export function apply(ctx, config) {
     }
   })
 
-  registerCommand(ctx, { control, settings, runtime })
+  registerCommand(ctx, { control, settings, runtime, llm: ctx.llm })
 
   ctx.on('session/event', (session, event) => {
     try {
@@ -166,7 +166,8 @@ function registerCommand(ctx, host) {
     yield ctx.commands.register({
       definitionId: '@quadiusai/dsh-greenharness',
       name: 'greenharness',
-      description: 'Control GreenHarness: status, on/off, model routing, and each mechanism',
+      description: 'GreenHarness: see tokens saved, choose cheap and strong models, switch features (try: help)',
+      input: { hint: 'help | models | large <number> | small <number> | on | off' },
       handler: (invocation) => runCommand(invocation.rawInput, host),
     })
   }, 'greenharness command')