omniharness-cli 0.1.84 → 0.1.86

package/dist/cli.js

@@ -7,6 +7,7 @@ import { ownVersion, runUpdate } from './update.js';
 import { readActiveCombo } from './config/settings.js';
 import { OmniRouteClient } from './config/omniRoute.js';
 import { doctor, helpText, models } from './doctor.js';
+import { debounceResizeEvents } from './ui/resizeDebounce.js';
 // A crash anywhere below would otherwise surface as a raw Node stack trace, or
 // as an unhandled rejection that terminates the process without saying why.
 // A CLI should fail with a sentence.
@@ -81,8 +82,12 @@ else {
         // The cost is that quitting no longer restores the pre-launch screen. For
         // a tool whose output you are meant to read back, that is the right trade.
         //
+        // Coalesce resize delivery before Ink's own internal listener ever sees
+        // it — see resizeDebounce.ts. Only meaningful for a real terminal; a
+        // non-TTY stdout never emits 'resize' and patching it would be inert.
+        const stdout = process.stdout.isTTY ? debounceResizeEvents(process.stdout, 80) : process.stdout;
         // The app owns Ctrl+C so idle quits but an in-flight run is cancelled first.
-        const { waitUntilExit } = render(_jsx(TerminalInterface, { engine: engine }), { exitOnCtrlC: false });
+        const { waitUntilExit } = render(_jsx(TerminalInterface, { engine: engine }), { stdout, exitOnCtrlC: false });
         await waitUntilExit();
     })();
 }

package/dist/config/omniRoute.js

@@ -145,17 +145,27 @@ export class OmniRouteClient {
     }
     /** List every model id the gateway exposes, including `auto/*` virtual combos and individual providers. */
     async listModels(signal) {
+        return (await this.listCatalog(signal)).map((entry) => entry.id);
+    }
+    /**
+     * The catalog with the context window each entry advertises. OmniRoute
+     * states `context_length` on providers' models, on `auto/*` engines and on
+     * combos alike; `max_input_tokens` stands in when an entry carries only that.
+     */
+    async listCatalog(signal) {
         const response = await this.requestWithRetry('/v1/models', { method: 'GET', signal });
         const payload = await response.json();
         const data = this.isRecord(payload) && Array.isArray(payload.data) ? payload.data : [];
-        const ids = [];
+        const entries = [];
         for (const entry of data) {
-            if (this.isRecord(entry) && typeof entry.id === 'string' && entry.id.trim() !== '')
-                ids.push(entry.id);
+            if (!this.isRecord(entry) || typeof entry.id !== 'string' || entry.id.trim() === '')
+                continue;
+            const window = this.positive(entry.context_length) ?? this.positive(entry.max_input_tokens);
+            entries.push(window !== undefined ? { id: entry.id, contextLength: window } : { id: entry.id });
         }
-        if (ids.length === 0)
+        if (entries.length === 0)
             throw new OmniRouteError(response.status, 'invalid models response');
-        return ids;
+        return entries;
     }
     /** Retry transient responses for idempotent metadata reads without touching chat/tool requests. */
     async requestWithRetry(path, init) {
@@ -431,6 +441,9 @@ export class OmniRouteClient {
         const provider = headers.get('x-omniroute-provider') ?? decision.provider;
         if (provider)
             fallback.activeProvider = provider;
+        const model = headers.get('x-omniroute-model');
+        if (model && model.trim() !== '')
+            fallback.model = model.trim();
         if (decision.strategy)
             fallback.strategy = decision.strategy;
         if (decision.latencyMs !== undefined)
@@ -485,6 +498,9 @@ export class OmniRouteClient {
     number(value) {
         return typeof value === 'number' && Number.isFinite(value) ? value : 0;
     }
+    positive(value) {
+        return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : undefined;
+    }
     safeParse(text) {
         try {
             return JSON.parse(text);

package/dist/ui/debounce.js

@@ -0,0 +1,18 @@
+export function debounce(fn, delayMs) {
+    let timer;
+    const debounced = ((...args) => {
+        if (timer)
+            clearTimeout(timer);
+        timer = setTimeout(() => {
+            timer = undefined;
+            fn(...args);
+        }, delayMs);
+    });
+    debounced.cancel = () => {
+        if (timer)
+            clearTimeout(timer);
+        timer = undefined;
+    };
+    return debounced;
+}
+//# sourceMappingURL=debounce.js.map

package/dist/ui/modelWindows.js

@@ -6,6 +6,12 @@
  * a model id (or the provider name OmniRoute reports) to a token budget;
  * `contextMeter` turns "tokens in" into a fill fraction and a zone the UI
  * colours (ok / warn / danger) using the playbook's 70 / 90 thresholds.
+ *
+ * The gateway's catalog is the first source: `/v1/models` states a
+ * `context_length` per entry, and `windowIndex` turns that into a lookup the
+ * meter consults before the substring table below. The table remains the
+ * answer for a model the catalog does not size, and when the catalog could
+ * not be read at all.
  */
 /** Known windows keyed by a substring of the model / provider id (longest match wins). */
 const WINDOWS = [
@@ -35,12 +41,52 @@ const WINDOWS = [
 ];
 /** Fallback window when nothing matches — conservative so the meter warns early rather than late. */
 export const DEFAULT_WINDOW = 128_000;
+/**
+ * Build the lookup from a catalog. Each entry is keyed by its full id and,
+ * when the id carries a provider prefix, by the bare model name after it —
+ * `X-OmniRoute-Model` reports the upstream name (`claude-sonnet-4-6`) while
+ * the catalog lists it under a prefix (`cc/claude-sonnet-4-6`). The first
+ * entry to claim a bare name keeps it, so a `dual`-mode mirror never
+ * contradicts its primary.
+ */
+export function windowIndex(entries) {
+    const index = new Map();
+    for (const entry of entries) {
+        const tokens = entry.contextLength;
+        if (tokens === undefined || !Number.isFinite(tokens) || tokens <= 0)
+            continue;
+        const id = entry.id.trim().toLowerCase();
+        if (id === '')
+            continue;
+        if (!index.has(id))
+            index.set(id, tokens);
+        const slash = id.indexOf('/');
+        if (slash > 0 && slash < id.length - 1) {
+            const bare = id.slice(slash + 1);
+            if (!index.has(bare))
+                index.set(bare, tokens);
+        }
+    }
+    return index;
+}
 /**
  * Resolve a context window for a model id and/or the provider OmniRoute
- * reported for the turn. Matching is case-insensitive substring; the longest
- * matching pattern wins so `gpt-4o-mini` beats `gpt-4o`.
+ * reported for the turn. A catalog `known` answers first, by the exact id and
+ * then by the bare name after a provider prefix. Otherwise matching is
+ * case-insensitive substring; the longest matching pattern wins so
+ * `gpt-4o-mini` beats `gpt-4o`.
  */
-export function windowFor(modelId, provider) {
+export function windowFor(modelId, provider, known) {
+    if (known && modelId) {
+        const id = modelId.trim().toLowerCase();
+        const exact = known.get(id);
+        if (exact !== undefined)
+            return exact;
+        const slash = id.indexOf('/');
+        const bare = slash > 0 ? known.get(id.slice(slash + 1)) : undefined;
+        if (bare !== undefined)
+            return bare;
+    }
     const haystack = `${modelId ?? ''} ${provider ?? ''}`.toLowerCase();
     let best;
     let bestLen = 0;
@@ -53,8 +99,8 @@ export function windowFor(modelId, provider) {
     return best ?? DEFAULT_WINDOW;
 }
 /** Build the meter. `used` below 0 clamps to 0; the fraction is capped at 1. */
-export function contextMeter(used, modelId, provider) {
-    const window = windowFor(modelId, provider);
+export function contextMeter(used, modelId, provider, known) {
+    const window = windowFor(modelId, provider, known);
     const safeUsed = Math.max(0, used);
     const fraction = Math.min(1, safeUsed / window);
     const zone = fraction >= 0.9 ? 'danger' : fraction >= 0.7 ? 'warn' : 'ok';

package/dist/ui/resizeDebounce.js

@@ -0,0 +1,52 @@
+import { debounce } from './debounce.js';
+/**
+ * Coalesce `resize` event delivery on a TTY stream so every listener — Ink's
+ * own internal one included — sees one event per burst instead of one per raw
+ * OS-level tick.
+ *
+ * Ink attaches its own `resize` listener directly to whatever stream is
+ * handed to `render()`, and on every single tick it recalculates its Yoga
+ * layout and writes a fresh frame — independent of anything application state
+ * does. That is not reachable by debouncing a `useState` call in a component:
+ * the redraw happens inside Ink regardless.
+ *
+ * A maximise or restore on Windows Terminal does not deliver one resize
+ * event. It animates through the transition and fires a burst of
+ * intermediate sizes a few milliseconds apart. Reacting to each one means
+ * Ink redraws against a size that is already stale by the time the escape
+ * sequences reach the terminal, and the frames land on top of one another
+ * instead of replacing one another — duplicated prompt boxes, fragments of an
+ * earlier frame still on screen once the window settles.
+ *
+ * The only place to fix that is before Ink's own listener ever sees the
+ * event — so this patches `.on` / `.off` for `resize` specifically, on the
+ * same stream object Ink and application code both subscribe to. `write`,
+ * `columns`, `rows`, `isTTY` and every other event pass through untouched.
+ */
+export function debounceResizeEvents(stream, delayMs) {
+    const realOn = stream.on.bind(stream);
+    const realOff = stream.off.bind(stream);
+    // Keyed on the caller's own listener, so .off(listener) still finds and
+    // cancels the right debounced wrapper — the caller never sees the wrapper.
+    const wrapped = new WeakMap();
+    stream.on = ((event, listener) => {
+        if (event !== 'resize')
+            return realOn(event, listener);
+        const debounced = debounce(listener, delayMs);
+        wrapped.set(listener, debounced);
+        return realOn(event, debounced);
+    });
+    stream.off = ((event, listener) => {
+        if (event !== 'resize')
+            return realOff(event, listener);
+        const debounced = wrapped.get(listener);
+        if (debounced) {
+            debounced.cancel();
+            wrapped.delete(listener);
+            return realOff(event, debounced);
+        }
+        return realOff(event, listener);
+    });
+    return stream;
+}
+//# sourceMappingURL=resizeDebounce.js.map

package/dist/ui/terminalInterface.js

@@ -12,7 +12,7 @@ import { capabilityLine, recentRows, shortenPath, twoColumn } from './home.js';
 import { conversationWidth, overflowCount, sidebarMode, SIDEBAR_WIDTH, todoRows, usageRows, clip as clipRow } from './sidebar.js';
 import { planViewport } from './viewport.js';
 import { statusMarker, toolHead } from './toolrow.js';
-import { contextMeter, meterBar } from './modelWindows.js';
+import { contextMeter, meterBar, windowIndex } from './modelWindows.js';
 import { BEL, SYNC_QUERY, isSyncOutputReply, osc9Notify, osc52Copy, shouldNudgeOnFinish, wrapSynchronizedOutput } from './termcaps.js';
 import { KITTY_POP, KITTY_PUSH, KITTY_QUERY, isEncodedKey, isKittyQueryResponse, parseRawKey } from './keys.js';
 import { ownVersion } from '../update.js';
@@ -271,6 +271,9 @@ export function TerminalInterface({ engine }) {
     const [pickerItems, setPickerItems] = useState([]);
     const [pickerIndex, setPickerIndex] = useState(0);
     const [pickerError, setPickerError] = useState();
+    // Context windows the catalog states, keyed by model id. Empty until the
+    // catalog has been read; the meter falls back to its own table meanwhile.
+    const [windows, setWindows] = useState(() => new Map());
     const [mode, setMode] = useState(engine.state.mode);
     const [permMode, setPermMode] = useState(engine.state.permissionMode ?? 'ask');
     const [approval, setApproval] = useState(null);
@@ -310,9 +313,20 @@ export function TerminalInterface({ engine }) {
             if (alive)
                 setRecentSessions(found);
         }).catch(() => { });
+        void Promise.resolve().then(() => engine.client.listCatalog()).then((catalog) => {
+            if (alive)
+                setWindows(windowIndex(catalog));
+        }).catch(() => { });
         return () => { alive = false; };
     }, []);
     useEffect(() => {
+        // The real fix for a resize storm (maximise/restore firing a burst of
+        // intermediate sizes) lives one layer down, in resizeDebounce.ts: it
+        // coalesces delivery of the raw 'resize' event on the stream itself,
+        // before Ink's own internal listener — which redraws unconditionally on
+        // every tick, independent of any component state — ever sees it. This
+        // handler can stay a plain listener because of that; by the time it
+        // fires, the event has already been coalesced upstream.
         const onResize = () => {
             setWidth(widthOf(stdout));
             setRows(rowsOf(stdout));
@@ -419,7 +433,7 @@ export function TerminalInterface({ engine }) {
             if (kittyTimer)
                 clearTimeout(kittyTimer);
             stdin?.off('data', onProbe);
-            stdout.off('resize', onResize);
+            stdout.off('resize', onResize); // resizeDebounce cancels the coalesced timer on .off itself
             const pendingApproval = approvalResolve.current;
             approvalResolve.current = null;
             pendingApproval?.({ approved: false });
@@ -434,7 +448,9 @@ export function TerminalInterface({ engine }) {
     const loadPicker = async () => {
         setPickerError(undefined);
         try {
-            const [accountCombos, modelIds] = await Promise.all([engine.client.listCombos(), engine.client.listModels()]);
+            const [accountCombos, catalog] = await Promise.all([engine.client.listCombos(), engine.client.listCatalog()]);
+            setWindows(windowIndex(catalog));
+            const modelIds = catalog.map((entry) => entry.id);
             const items = [];
             for (const combo of accountCombos) {
                 if (combo.name.trim() !== '' && !items.some((item) => item.id === combo.name)) {
@@ -984,7 +1000,9 @@ export function TerminalInterface({ engine }) {
     // The prompt tokens of the last completion, as the gateway counted them,
     // are the size of the context the next turn will carry.
     const contextTokens = metrics.usage?.contextTokens ?? 0;
-    const meter = contextMeter(contextTokens, engine.state.activeModel, metrics.fallback.activeProvider);
+    // Sized to the model that answered, when the gateway named one: an `auto/*`
+    // engine or a combo can land anywhere, and the window is that model's.
+    const meter = contextMeter(contextTokens, metrics.fallback.model ?? engine.state.activeModel, metrics.fallback.activeProvider, windows);
     const meterColor = meter.zone === 'danger' ? PALETTE.error : meter.zone === 'warn' ? PALETTE.warn : PALETTE.muted;
     const contextLabel = contextTokens > 0 ? `ctx ${meterBar(meter.fraction, 8)} ${Math.round(meter.fraction * 100)}%` : '';
     const compression = metrics.compression.inputTokens > 0 ? `${Math.round((1 - metrics.compression.ratio) * 100)}% ${metrics.compression.strategy.toUpperCase()}` : '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omniharness-cli",
-  "version": "0.1.84",
+  "version": "0.1.86",
   "description": "OmniHarness — local-first agent orchestration harness for OmniRoute.",
   "license": "MIT",
   "type": "module",