@alexeiled/pi-model-router 0.5.1 → 0.6.0

package/extensions/commands.ts

@@ -6,12 +6,16 @@ import type {
 import type { AutocompleteItem } from '@earendil-works/pi-tui';
 import {
   getUnsupportedTiers,
+  isRouterPinValue,
+  isRouterTier,
+  isThinkingLevel,
   parseCanonicalModelRef,
   profileNames,
   ROUTER_PIN_VALUES,
   ROUTER_TIERS,
   THINKING_LEVELS,
 } from './config';
+import { preservesRouteCoverage } from './routing';
 import type {
   RouterConfig,
   RouterPinByProfile,
@@ -21,6 +25,7 @@ import type {
 } from './types';
 import {
   formatDecision,
+  formatDecisionSource,
   formatModelRef,
   formatPinSummary,
   formatThinkingSummary,
@@ -110,7 +115,7 @@ export const registerCommands = (
     args: string[],
   ): AutocompleteItem[] | null => {
     // thinking [tier] <level|auto>
-    const tierValues = [...ROUTER_TIERS];
+    const tierValues: RouterTier[] = [...ROUTER_TIERS];
     const levelValues = ['auto', ...THINKING_LEVELS];
 
     if (args.length <= 1) {
@@ -136,8 +141,8 @@ export const registerCommands = (
       ];
     }
 
-    if ((tierValues as string[]).includes(args[0])) {
-      const tier = args[0];
+    const tier = args[0];
+    if (isRouterTier(tier)) {
       const levelPrefix = args[1] ?? '';
       return levelValues
         .filter((v) => v.startsWith(levelPrefix))
@@ -168,7 +173,6 @@ export const registerCommands = (
       `Pins by profile: ${formatPinSummary(state.pinnedTierByProfile)}`,
       `Thinking overrides: ${formatThinkingSummary(state.thinkingByProfile)}`,
       `Widget: ${state.widgetEnabled ? 'on' : 'off'}`,
-      `Phase bias: ${state.currentConfig.phaseBias}`,
       `Session cost: $${state.accumulatedCost.toFixed(4)}` +
         (state.currentConfig.maxSessionBudget
           ? ` / $${state.currentConfig.maxSessionBudget.toFixed(2)}`
@@ -183,7 +187,9 @@ export const registerCommands = (
         `Last routed tier: ${state.lastDecision.tier}`,
         `Last phase: ${state.lastDecision.phase}`,
         `Last model: ${state.lastDecision.targetProvider}/${state.lastDecision.targetModelId} (${state.lastDecision.thinking})`,
-        `Reason: ${state.lastDecision.reasoning}`,
+        ...(formatDecisionSource(state.lastDecision)
+          ? [`Reason: ${formatDecisionSource(state.lastDecision)}`]
+          : []),
       );
     }
     if (state.lastConfigWarnings && state.lastConfigWarnings.length > 0) {
@@ -233,7 +239,7 @@ export const registerCommands = (
         [
           `Profile: ${currentProfile}`,
           `Pinned tier: ${state.pinnedTierByProfile[currentProfile] ?? 'auto'}`,
-          `Usage: /router pin <high|medium|low|auto>`,
+          `Usage: /router pin <high|medium|low|micro|auto>`,
         ].join('\n'),
         'info',
       );
@@ -242,13 +248,13 @@ export const registerCommands = (
     }
 
     if (args.length > 1) {
-      ctx.ui.notify('Usage: /router pin <high|medium|low|auto>', 'error');
+      ctx.ui.notify('Usage: /router pin <high|medium|low|micro|auto>', 'error');
       return;
     }
 
     const pinValue = args[0];
 
-    if (!ROUTER_PIN_VALUES.some((value) => value === pinValue)) {
+    if (!isRouterPinValue(pinValue)) {
       ctx.ui.notify(
         `Invalid router pin: ${pinValue}. Use one of: ${ROUTER_PIN_VALUES.join(', ')}`,
         'error',
@@ -256,7 +262,8 @@ export const registerCommands = (
       return;
     }
 
-    const nextTier = pinValue === 'auto' ? undefined : (pinValue as RouterTier);
+    const nextTier: RouterTier | undefined =
+      pinValue === 'auto' ? undefined : pinValue;
     if (nextTier) {
       state.pinnedTierByProfile[currentProfile] = nextTier;
     } else {
@@ -267,7 +274,7 @@ export const registerCommands = (
     ctx.ui.notify(
       nextTier
         ? `Router pinned to ${nextTier}`
-        : `Router pin cleared; heuristic routing restored`,
+        : `Router pin cleared; baseline routing restored`,
       'info',
     );
   };
@@ -303,28 +310,32 @@ export const registerCommands = (
     let tier: RouterTier | 'all' | undefined;
     let levelValue = '';
 
-    const tierValues = ['high', 'medium', 'low'];
     const levelValues = ['auto', ...THINKING_LEVELS];
 
     if (args.length === 1) {
-      levelValue = args[0];
+      const level = args[0];
+      if (!level) return;
+      levelValue = level;
       tier = 'all';
     } else if (args.length === 2) {
-      if (tierValues.includes(args[0]) || args[0] === 'all') {
-        tier = args[0] as RouterTier | 'all';
-        levelValue = args[1];
+      const requestedTier = args[0];
+      const requestedLevel = args[1];
+      if (!requestedTier || !requestedLevel) return;
+      if (isRouterTier(requestedTier) || requestedTier === 'all') {
+        tier = requestedTier === 'all' ? 'all' : requestedTier;
+        levelValue = requestedLevel;
       } else {
         ctx.ui.notify(
-          `Invalid tier: ${args[0]}. Use high, medium, or low.`,
+          `Invalid tier: ${args[0]}. Use high, medium, low, or micro.`,
           'error',
         );
         return;
       }
     }
 
-    if (tier !== 'all' && !tierValues.includes(tier as string)) {
+    if (tier !== 'all' && !tier) {
       ctx.ui.notify(
-        `Invalid tier: ${tier}. Use high, medium, or low.`,
+        `Invalid tier: ${tier}. Use high, medium, low, or micro.`,
         'error',
       );
       return;
@@ -338,14 +349,34 @@ export const registerCommands = (
     }
 
     const nextLevel =
-      levelValue === 'auto' ? undefined : (levelValue as ThinkingLevel);
-    state.thinkingByProfile[currentProfile] ??= {};
-    const overrides = state.thinkingByProfile[currentProfile];
-    const tiers = tier === 'all' ? ROUTER_TIERS : [tier as RouterTier];
+      levelValue === 'auto'
+        ? undefined
+        : isThinkingLevel(levelValue)
+          ? levelValue
+          : undefined;
+    const overrides = { ...state.thinkingByProfile[currentProfile] };
+    const tiers = tier === 'all' ? ROUTER_TIERS : [tier];
     for (const targetTier of tiers) {
       if (nextLevel) overrides[targetTier] = nextLevel;
       else delete overrides[targetTier];
     }
+    const activeProfile = state.currentConfig.profiles[currentProfile];
+    if (
+      nextLevel &&
+      activeProfile &&
+      preservesRouteCoverage(
+        activeProfile,
+        (provider, id) => ctx.modelRegistry.find(provider, id),
+        overrides,
+      ) === false
+    ) {
+      ctx.ui.notify(
+        `Router thinking unchanged: '${nextLevel}' leaves no eligible route.`,
+        'warning',
+      );
+      return;
+    }
+    state.thinkingByProfile[currentProfile] = overrides;
     if (Object.keys(overrides).length === 0) {
       delete state.thinkingByProfile[currentProfile];
     }
@@ -359,14 +390,13 @@ export const registerCommands = (
     }
     // Only warn when the level isn't supported by some tiers; skip for 'off' and 'auto'
     if (nextLevel && nextLevel !== 'off') {
-      const unsupported = getUnsupportedTiers(
-        state.currentConfig.profiles[currentProfile],
-        nextLevel,
-      );
+      const activeProfile = state.currentConfig.profiles[currentProfile];
+      if (!activeProfile) return;
+      const unsupported = getUnsupportedTiers(activeProfile, nextLevel);
       if (unsupported.length > 0) {
         ctx.ui.notify(
           `Router thinking (${tier}) set to ${nextLevel}. ` +
-            `${unsupported.join(', ')} tier${unsupported.length > 1 ? 's' : ''} may not support '${nextLevel}'.`,
+            `${unsupported.join(', ')} tier${unsupported.length > 1 ? 's' : ''} may not support '${nextLevel}' and will be skipped when unsupported.`,
           'warning',
         );
       }
@@ -412,19 +442,19 @@ export const registerCommands = (
 
   const handleFix = async (args: string[], ctx: ExtensionContext) => {
     if (args.length !== 1) {
-      ctx.ui.notify('Usage: /router fix <high|medium|low>', 'error');
+      ctx.ui.notify('Usage: /router fix <high|medium|low|micro>', 'error');
       return;
     }
     const tier = args[0]?.toLowerCase();
-    if (!ROUTER_TIERS.includes(tier as RouterTier)) {
-      ctx.ui.notify('Usage: /router fix <high|medium|low>', 'error');
+    if (!isRouterTier(tier)) {
+      ctx.ui.notify('Usage: /router fix <high|medium|low|micro>', 'error');
       return;
     }
     if (!state.lastDecision) {
       ctx.ui.notify('No recent routing decision to fix.', 'warning');
       return;
     }
-    state.pinnedTierByProfile[state.lastDecision.profile] = tier as RouterTier;
+    state.pinnedTierByProfile[state.lastDecision.profile] = tier;
     actions.persistState();
     actions.updateStatus(ctx);
     ctx.ui.notify(
@@ -515,10 +545,12 @@ export const registerCommands = (
       }
 
       if (parts.length === 1 && !hasTrailingSpace) {
-        return getSubcommandCompletions(parts[0]);
+        const subcommand = parts[0];
+        return subcommand ? getSubcommandCompletions(subcommand) : null;
       }
 
       const subcommand = parts[0];
+      if (!subcommand) return null;
       const subArgs = parts.slice(1);
       if (hasTrailingSpace && parts.length === 1) {
         subArgs.push('');
@@ -558,13 +590,13 @@ export const registerCommands = (
         }
         case 'fix': {
           const fixPrefix = subArgs[0] ?? '';
-          const items = ['high', 'medium', 'low']
-            .filter((t) => t.startsWith(fixPrefix.toLowerCase()))
-            .map((t) => ({
-              value: `fix ${t}`,
-              label: t,
-              description: `Correct decision and pin to ${t} tier`,
-            }));
+          const items = ROUTER_TIERS.filter((t) =>
+            t.startsWith(fixPrefix.toLowerCase()),
+          ).map((t) => ({
+            value: `fix ${t}`,
+            label: t,
+            description: `Correct decision and pin to ${t} tier`,
+          }));
           return items.length > 0 ? items : null;
         }
         case 'widget': {
@@ -597,6 +629,10 @@ export const registerCommands = (
       const parts = args?.trim().split(/\s+/) ?? [];
       const subcommand = parts[0];
       const subArgs = parts.slice(1);
+      if (!subcommand) {
+        await handleStatus(subArgs, ctx);
+        return;
+      }
 
       switch (subcommand) {
         case 'profile':
@@ -637,7 +673,7 @@ export const registerCommands = (
               'Router Subcommands:',
               '  status                      Show current status, profile, pin, cost, and last decision.',
               '  profile [name]              Switch to a profile (enables router if off). Lists available if no name.',
-              '  pin <tier|auto>             Force a tier (high|medium|low) or set to auto.',
+              '  pin <tier|auto>             Force a tier (high|medium|low|micro) or set to auto.',
               '  thinking [tier] <level>     Override thinking level (off|minimal|...|max|auto). Not all tier models may support every level.',
               '  disable                     Disable the router and restore the last used non-router model.',
               '  fix <tier>                  Correct the last routing decision and pin that tier for the current profile.',