@aragon-agent/cli 0.6.24 → 0.6.25

package/dist/ui/overlays/model-probe-view.js

@@ -0,0 +1,225 @@
+/**
+ * The probe's VIEW MODEL (model-profile-connection-test §3.2 / §6.3).
+ *
+ * Pure functions only: the editor's row list, the result sentences, the candidate
+ * ordering and the two number formatters. Rendering and input both read
+ * `editorRows()`, so "which row am I on" has exactly one definition and inserting a
+ * row can no longer shift `apiKey` off index 6 by arithmetic.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import { PROBE_LIMITS } from '../../agent/model-probe-limits.js';
+import { resolveDraftKey } from '../../agent/model-probe.js';
+import { profileEndpointSummary } from './ModelProfilePicker.js';
+export const EDITOR_FIELDS = ['name', 'provider', 'model', 'contextWindow', 'baseUrl',
+    'credentialMode', 'apiKey'];
+export const EDITOR_LABELS = ['Name', 'Provider', 'Model', 'Context window', 'Base URL',
+    'Credential mode', 'API key'];
+function idleView(hasKey) {
+    return { kind: 'idle', reason: hasKey ? 'no_result' : 'no_key' };
+}
+function hasKey(target) {
+    return Boolean(target.apiKey && target.apiKey.trim().length > 0);
+}
+/** Whether pressing a probe action can produce anything at all (AC-12 / AC-15). */
+export function canProbe(view) {
+    return !(view.kind === 'idle' && (view.reason === 'no_key' || view.reason === 'unavailable'));
+}
+function testView(test, target, probe) {
+    if (!probe)
+        return { kind: 'idle', reason: 'unavailable' };
+    if (test.phase === 'testing') {
+        return test.targetId === probe.targetFingerprint(target)
+            ? { kind: 'testing' } : idleView(hasKey(target));
+    }
+    if (test.phase === 'tested') {
+        return test.outcome.targetId === probe.targetFingerprint(target)
+            ? { kind: 'result', outcome: test.outcome } : idleView(hasKey(target));
+    }
+    return idleView(hasKey(target));
+}
+function discoveryView(state, target, probe) {
+    if (!probe)
+        return { kind: 'idle' };
+    if (state.phase === 'discovering') {
+        return state.connectionId === probe.connectionFingerprint(target) ? { kind: 'discovering' }
+            : { kind: 'idle' };
+    }
+    if (state.phase === 'discovered') {
+        return state.outcome.connectionId === probe.connectionFingerprint(target)
+            ? { kind: 'discovery', outcome: state.outcome } : { kind: 'idle' };
+    }
+    return { kind: 'idle' };
+}
+/**
+ * Filter both slots down to what the CURRENT target may honestly claim (§4.6).
+ *
+ * A `OK 812 ms` that describes a model the user has since edited is worse than no
+ * result at all, so a fingerprint mismatch degrades to `idle` - no effect, no
+ * reset call, no cross-page synchronisation.
+ */
+export function visibleProbeViews(test, discovery, target, probe) {
+    return { test: testView(test, target, probe), discovery: discoveryView(discovery, target, probe) };
+}
+/** The exact target a draft would use - the resolved key included (§4.2.1). */
+export function editorProbeTarget(editor, apiKeys) {
+    return {
+        provider: editor.provider,
+        model: editor.model,
+        baseUrl: editor.baseUrl.trim().length > 0 ? editor.baseUrl.trim() : null,
+        apiKey: resolveDraftKey({ credentialMode: editor.credentialMode, draftKey: editor.apiKey,
+            existingKey: editor.original.apiKey, sharedKey: apiKeys[editor.provider] }),
+    };
+}
+/** `812 ms` / `1.4 s` - one decimal only once a second has passed. */
+export function latencyLabel(ms) {
+    const safe = Number.isFinite(ms) && ms >= 0 ? ms : 0;
+    return safe < 1000 ? `${Math.round(safe)} ms` : `${(safe / 1000).toFixed(1)} s`;
+}
+/** `128K` / `1M` / `auto` - `auto` when the vendor did not report a window. */
+export function windowLabel(window) {
+    if (!window || !Number.isFinite(window))
+        return 'auto';
+    if (window >= 1_000_000) {
+        const millions = window / 1_000_000;
+        return `${Number.isInteger(millions) ? millions : millions.toFixed(1)}M`;
+    }
+    if (window >= 1000)
+        return `${Math.round(window / 1000)}K`;
+    return String(Math.round(window));
+}
+/**
+ * Clean and order a discovered list: one row per id, and the model the draft
+ * already names first, so "which one am I on" is answerable without scrolling.
+ */
+export function rankCandidates(models, currentModel) {
+    const seen = new Set();
+    const unique = [];
+    for (const model of models) {
+        if (model.id.length === 0 || seen.has(model.id))
+            continue;
+        seen.add(model.id);
+        unique.push(model);
+    }
+    const wanted = currentModel.trim().toLowerCase();
+    if (wanted.length === 0)
+        return unique;
+    const matches = (model) => model.id.toLowerCase() === wanted;
+    const prefixed = (model) => model.id.toLowerCase().startsWith(wanted);
+    return [...unique.filter(matches), ...unique.filter((model) => !matches(model) && prefixed(model)),
+        ...unique.filter((model) => !matches(model) && !prefixed(model))];
+}
+function usagePart(outcome) {
+    if (!outcome.usage)
+        return '';
+    return ` | ${outcome.usage.inputTokens} in / ${outcome.usage.outputTokens} out`;
+}
+function fixLine(outcome) {
+    if (outcome.kind === 'auth')
+        return 'Fix: edit API key, or set Credential mode to Shared.';
+    if (outcome.kind !== 'model_not_found')
+        return undefined;
+    const reach = outcome.availableModels;
+    return `Fix: choose Discover models.${reach === undefined ? ''
+        : ` This key can reach ${reach} models.`}`;
+}
+function resultLines(outcome, target) {
+    const name = `${target.provider}:${target.model.trim()}`;
+    if (outcome.ok) {
+        const head = `Last test: ${name} OK in ${latencyLabel(outcome.latencyMs)}${usagePart(outcome)}`;
+        const reply = outcome.reply ? `Reply: "${outcome.reply}"` : undefined;
+        const reach = outcome.reply || outcome.availableModels === undefined ? undefined
+            : `This key can reach ${outcome.availableModels} models.`;
+        const second = reply ?? reach;
+        return second ? [head, second] : [head];
+    }
+    const head = `Last test: FAILED - ${outcome.detail ?? 'The connection test failed.'}`;
+    const fix = fixLine(outcome);
+    return fix ? [head, fix] : [head];
+}
+/** At most TWO rows: the verdict, then what to do about it (§3.1 / D-11). */
+export function probeLines(view, target) {
+    if (view.kind === 'result')
+        return resultLines(view.outcome, target).slice(0, 2);
+    if (view.kind === 'idle') {
+        if (view.reason === 'unavailable')
+            return ['Connection test is unavailable in this session.'];
+        if (view.reason === 'no_key')
+            return ['No key yet: set API key, or use Credential mode Shared.'];
+        return ['Not tested for this profile yet.'];
+    }
+    return [];
+}
+/** Colour for the result rows; the status WORDS carry the meaning without colour. */
+export function probeTone(view) {
+    if (view.kind !== 'result')
+        return 'muted';
+    return view.outcome.ok ? 'ok' : 'fail';
+}
+function fieldValue(editor, field) {
+    if (field === 'apiKey') {
+        if (editor.credentialMode === 'replace') {
+            return editor.apiKey ? 'Configured (replacement)' : '(type replacement)';
+        }
+        return editor.credentialMode === 'keep' ? 'Configured (unchanged)' : 'Shared / environment';
+    }
+    if (field === 'credentialMode')
+        return editor.credentialMode;
+    return editor[field] || (field === 'name' ? '(defaults to model)'
+        : field === 'contextWindow' ? '(auto)' : field === 'baseUrl'
+            ? '(provider default)' : '(required)');
+}
+function actionValue(action, view) {
+    if (action === 'retain' || action === 'apply' || action === 'cancel')
+        return '';
+    if (view.kind === 'idle' && view.reason === 'unavailable')
+        return '(unavailable)';
+    if (view.kind === 'idle' && view.reason === 'no_key')
+        return '(no key)';
+    if (action === 'test' && view.kind === 'testing')
+        return 'testing...';
+    return action === 'test' ? 'Enter or Ctrl+R' : 'Enter or Ctrl+F';
+}
+function actionRow(action, label, view) {
+    return { kind: 'action', action, label, value: actionValue(action, view) };
+}
+/** THE single source of the editor's rows - fields, actions, notes AND results. */
+export function editorRows(input) {
+    const { editor, retain, probe, target } = input;
+    const rows = EDITOR_FIELDS.map((field, at) => ({ kind: 'field', field,
+        label: EDITOR_LABELS[at], value: fieldValue(editor, field) }));
+    if (retain)
+        rows.push(actionRow('retain', 'Retain key for new endpoint', probe));
+    rows.push(actionRow('test', 'Test connection', probe), actionRow('discover', 'Discover models', probe), actionRow('apply', 'Apply to settings draft', probe), actionRow('cancel', 'Cancel editing', probe));
+    rows.push({ kind: 'note', muted: true,
+        label: `Target: ${editor.provider} ${profileEndpointSummary(editor.baseUrl)}` });
+    if (input.fastOnly) {
+        rows.push({ kind: 'note', muted: true,
+            label: 'Window applies when this profile is bound as Main.' });
+    }
+    const tone = probeTone(probe);
+    for (const line of probeLines(probe, target)) {
+        rows.push({ kind: 'result', label: line, tone });
+    }
+    return rows;
+}
+/** Rows the cursor can land on; index arithmetic now derives from the row model. */
+export function isFocusable(row) {
+    return row.kind === 'field' || row.kind === 'action';
+}
+/** The focusable rows, in order - the index space `useProfileScroll` follows. */
+export function focusableRows(rows) {
+    return rows.filter(isFocusable);
+}
+/** Result rows currently on screen, so the viewport can be widened to include them. */
+export function resultRowCount(rows) {
+    return rows.filter((row) => row.kind === 'result').length;
+}
+/** Longest id shown in one list row, inside the 40-column budget. */
+export const LIST_ID_CHARS = 28;
+/** A model's one-line name, bounded by `maxNameChars`. */
+export function clipName(name) {
+    const points = [...name];
+    return points.length <= PROBE_LIMITS.maxNameChars ? name
+        : `${points.slice(0, PROBE_LIMITS.maxNameChars - 3).join('')}...`;
+}

package/dist/ui/overlays/model-profile-state.d.ts

@@ -1,7 +1,7 @@
 import { type ModelProfile, type ModelProfilesConfig, type ModelRole } from '../../config/model-profiles.js';
 import type { ModelSettingsDraft } from '../../config/model-profile-store.js';
 import type { SubagentModelMode } from '../../team/model.js';
-export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'delete-confirm' | 'discard-confirm';
+export type ProfilePage = 'root' | 'picker' | 'manager' | 'editor' | 'models' | 'delete-confirm' | 'discard-confirm';
 /**
  * Which role a PROFILE PICKER page is choosing for.
  *
@@ -60,6 +60,14 @@ export type ModelProfileAction = {
     type: 'merge-editor';
 } | {
     type: 'cancel-editor';
+}
+/**
+ * The ONE write path for a discovered model (§6.3 / D-2 / D-3): only `model`
+ * changes - never the credential, never the context window, never the draft.
+ */
+ | {
+    type: 'choose-model';
+    model: string;
 } | {
     type: 'duplicate';
     id: string;

package/dist/ui/overlays/model-profile-state.js

@@ -168,6 +168,16 @@ export function modelProfileReducer(state, action) {
         case 'retain-key': return state.editor?.original.apiKey ? { ...state,
             editor: { ...state.editor, credentialMode: 'keep', apiKey: '' } } : state;
         case 'merge-editor': return mergeEditor(state);
+        case 'choose-model': {
+            // Legal ONLY from the list page (§7). `editor-field` would do the same thing,
+            // but routing the list page through the generic field action would also let a
+            // future `editField` side effect (key reset, endpoint flag) fire on a choice
+            // that never touched the endpoint.
+            if (!state.editor || state.page !== 'models')
+                return state;
+            return { ...state, page: 'editor', error: undefined,
+                editor: { ...state.editor, model: action.model } };
+        }
         case 'cancel-editor': return { ...state, editor: undefined, page: state.returnPage,
             error: undefined };
         case 'duplicate': {

package/dist/ui/overlays/use-model-probe.d.ts

@@ -0,0 +1,30 @@
+/**
+ * The probe task hook (model-profile-connection-test §6.2).
+ *
+ * IT LIVES IN `SettingsScreen`, ONCE, AND NOWHERE ELSE. The editor unmounts whenever
+ * the page changes (`SettingsScreen` renders it only for `page === 'editor'`), so a
+ * hook inside the editor would abort its own discovery the moment `Discover models`
+ * switched to the list page - the feature cancelling itself.
+ *
+ * TWO SLOTS, ONE IN FLIGHT. A test verdict and a discovered list answer different
+ * questions, so they are stored separately: opening the list must not erase a verdict
+ * the user still wants to read when they press Esc back (AC-27). Starting either task
+ * aborts whatever is running - one request at a time.
+ *
+ * `test()` AND `discover()` NEVER REJECT. The only callers are Ink input handlers,
+ * which have nowhere to await a `catch`; the hook folds every exception into an
+ * `unknown` failure so no frame can be left on `testing` forever.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import type { ModelProbe, ProbeTarget } from '../../agent/model-probe.js';
+import type { ProbeDiscoveryPhase, ProbeTestPhase } from './model-probe-view.js';
+export interface ModelProbeTasks {
+    test: ProbeTestPhase;
+    discovery: ProbeDiscoveryPhase;
+    busy: boolean;
+    startTest(target: ProbeTarget): void;
+    startDiscovery(target: ProbeTarget): void;
+    cancel(): void;
+}
+export declare function useModelProbe(probe?: ModelProbe): ModelProbeTasks;

package/dist/ui/overlays/use-model-probe.js

@@ -0,0 +1,109 @@
+/**
+ * The probe task hook (model-profile-connection-test §6.2).
+ *
+ * IT LIVES IN `SettingsScreen`, ONCE, AND NOWHERE ELSE. The editor unmounts whenever
+ * the page changes (`SettingsScreen` renders it only for `page === 'editor'`), so a
+ * hook inside the editor would abort its own discovery the moment `Discover models`
+ * switched to the list page - the feature cancelling itself.
+ *
+ * TWO SLOTS, ONE IN FLIGHT. A test verdict and a discovered list answer different
+ * questions, so they are stored separately: opening the list must not erase a verdict
+ * the user still wants to read when they press Esc back (AC-27). Starting either task
+ * aborts whatever is running - one request at a time.
+ *
+ * `test()` AND `discover()` NEVER REJECT. The only callers are Ink input handlers,
+ * which have nowhere to await a `catch`; the hook folds every exception into an
+ * `unknown` failure so no frame can be left on `testing` forever.
+ *
+ * ASCII ONLY (`ui/` is inside `glyphs.test.ts::inScope`).
+ */
+import { useCallback, useEffect, useRef, useState } from 'react';
+const TEST_FAILED_DETAIL = 'The connection test could not run.';
+const DISCOVERY_FAILED_DETAIL = 'The model list could not be fetched.';
+function unknownTest(targetId) {
+    return { ok: false, targetId, latencyMs: 0, kind: 'unknown', detail: TEST_FAILED_DETAIL };
+}
+function unknownDiscovery(connectionId) {
+    return { ok: false, connectionId, kind: 'unknown', detail: DISCOVERY_FAILED_DETAIL,
+        models: [], truncated: false, total: 0 };
+}
+/** Run one probe, guaranteeing the promise settles and no rejection escapes. */
+function settle(work, onValue, onFailure) {
+    let pending;
+    try {
+        pending = work();
+    }
+    catch {
+        onFailure();
+        return;
+    }
+    void pending.then(onValue, onFailure);
+}
+export function useModelProbe(probe) {
+    const [test, setTest] = useState({ phase: 'idle' });
+    const [discovery, setDiscovery] = useState({ phase: 'idle' });
+    const controller = useRef(null);
+    const inFlight = useRef(null);
+    const abortCurrent = useCallback(() => {
+        controller.current?.abort();
+        controller.current = null;
+        inFlight.current = null;
+    }, []);
+    useEffect(() => abortCurrent, [abortCurrent]);
+    const begin = useCallback((kind) => {
+        abortCurrent();
+        const next = new AbortController();
+        controller.current = next;
+        inFlight.current = kind;
+        return next;
+    }, [abortCurrent]);
+    /**
+     * Land one run's result and drop the in-flight refs with it.
+     *
+     * Clearing them here is what keeps `cancel()` honest: it is the ONLY caller of
+     * `abortCurrent`, and an Escape on a settled slot (a frame where `busy` is stale)
+     * must not erase a verdict the user is still reading.
+     */
+    const finish = useCallback((run, commit) => {
+        if (run.signal.aborted)
+            return;
+        controller.current = null;
+        inFlight.current = null;
+        commit();
+    }, []);
+    const startTest = useCallback((target) => {
+        if (!probe)
+            return;
+        const run = begin('test');
+        const targetId = probe.targetFingerprint(target);
+        setTest({ phase: 'testing', targetId });
+        settle(() => probe.test({ ...target, signal: run.signal }), (outcome) => {
+            finish(run, () => setTest({ phase: 'tested', outcome }));
+        }, () => {
+            finish(run, () => setTest({ phase: 'tested', outcome: unknownTest(targetId) }));
+        });
+    }, [probe, begin, finish]);
+    const startDiscovery = useCallback((target) => {
+        if (!probe)
+            return;
+        const run = begin('discovery');
+        const connectionId = probe.connectionFingerprint(target);
+        setDiscovery({ phase: 'discovering', connectionId });
+        settle(() => probe.discover({ ...target, signal: run.signal }), (outcome) => {
+            finish(run, () => setDiscovery({ phase: 'discovered', outcome }));
+        }, () => {
+            finish(run, () => setDiscovery({ phase: 'discovered',
+                outcome: unknownDiscovery(connectionId) }));
+        });
+    }, [probe, begin, finish]);
+    const cancel = useCallback(() => {
+        const kind = inFlight.current;
+        abortCurrent();
+        if (kind === 'test')
+            setTest({ phase: 'idle' });
+        if (kind === 'discovery')
+            setDiscovery({ phase: 'idle' });
+    }, [abortCurrent]);
+    const busy = test.phase === 'testing' || discovery.phase === 'discovering';
+    return { test, discovery, busy, startTest, startDiscovery, cancel };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aragon-agent/cli",
-  "version": "0.6.24",
+  "version": "0.6.25",
   "description": "AragonAgent CLI — a Claude-Code / Codex-style interactive terminal UI (TUI) on top of the @aragon-agent/core engine. Installable and runnable via npm / npx.",
   "license": "MIT",
   "author": "AragonAgent contributors",
@@ -56,7 +56,7 @@
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
-    "@aragon-agent/core": "^0.2.36",
+    "@aragon-agent/core": "^0.2.37",
     "chalk": "^5.6.2",
     "cli-highlight": "^2.0.0",
     "commander": "^12.1.0",