@alexeiled/pi-model-router 0.5.1 → 0.5.2

package/extensions/state.ts

@@ -8,10 +8,10 @@ import {
   parseCanonicalModelRef,
 } from './config';
 import type {
+  PersistedStateInput,
   RouterLastProfileState,
   RouterPersistedState,
   RouterPinByProfile,
-  RouterThinkingByProfile,
   RoutingDecision,
 } from './types';
 
@@ -128,23 +128,29 @@ export const isRouterPersistedState = (
   );
 };
 
-export const buildPersistedState = (
-  routerEnabled: boolean,
-  selectedProfile: string | undefined,
-  pinnedTierByProfile: RouterPinByProfile,
-  thinkingByProfile: RouterThinkingByProfile,
-  debugEnabled: boolean,
-  widgetEnabled: boolean,
-  debugHistory: RoutingDecision[],
-  lastDecision: RoutingDecision | undefined,
-  lastNonRouterModel: string | undefined,
-  accumulatedCost: number,
-): RouterPersistedState => {
+export const buildPersistedState = ({
+  routerEnabled,
+  selectedProfile,
+  pinnedTierByProfile,
+  thinkingByProfile,
+  debugEnabled,
+  widgetEnabled,
+  debugHistory,
+  lastDecision,
+  lastNonRouterModel,
+  accumulatedCost,
+}: PersistedStateInput): RouterPersistedState => {
+  const pinByProfile: RouterPinByProfile = {};
+  for (const [profile, tier] of Object.entries(pinnedTierByProfile)) {
+    if (tier) pinByProfile[profile] = tier;
+  }
   return structuredClone({
     enabled: routerEnabled,
     selectedProfile: selectedProfile ?? '',
-    pinTier: selectedProfile ? pinnedTierByProfile[selectedProfile] : undefined,
-    pinByProfile: { ...pinnedTierByProfile },
+    ...(selectedProfile && pinnedTierByProfile[selectedProfile]
+      ? { pinTier: pinnedTierByProfile[selectedProfile] }
+      : {}),
+    pinByProfile,
     thinkingByProfile: { ...thinkingByProfile },
     debugEnabled,
     widgetEnabled,

package/extensions/types.ts

@@ -10,49 +10,60 @@ export type RouterThinkingByProfile = Record<string, RouterThinkingByTier>;
 export interface RoutingRule {
   matches: string | string[];
   tier: RouterTier;
-  reason?: string;
+  reason?: string | undefined;
 }
 
 export interface ModelDefinition {
   model: string;
-  contextWindow?: number;
-  maxTokens?: number;
-  reasoning?: boolean;
-  thinkingLevels?: ThinkingLevel[];
+  contextWindow?: number | undefined;
+  maxTokens?: number | undefined;
+  reasoning?: boolean | undefined;
+  thinkingLevels?: ThinkingLevel[] | undefined;
 }
 
 export interface ClassifierConfig {
   model: string;
-  thinking?: ThinkingLevel;
+  thinking?: ThinkingLevel | undefined;
 }
 
 export interface RoutedTierConfig {
   model: string;
-  thinking?: ThinkingLevel;
-  fallbacks?: string[];
-  contextWindow?: number;
-  maxTokens?: number;
-  reasoning?: boolean;
-  thinkingLevels?: ThinkingLevel[];
-  resolvedContextWindow?: number;
-  resolvedMaxTokens?: number;
-  resolvedThinkingLevels?: ThinkingLevel[];
+  thinking?: ThinkingLevel | undefined;
+  fallbacks?: string[] | undefined;
+  contextWindow?: number | undefined;
+  maxTokens?: number | undefined;
+  reasoning?: boolean | undefined;
+  thinkingLevels?: ThinkingLevel[] | undefined;
+  resolvedContextWindow?: number | undefined;
+  resolvedMaxTokens?: number | undefined;
+  resolvedThinkingLevels?: ThinkingLevel[] | undefined;
 }
 
 export interface RouterProfile {
-  high?: RoutedTierConfig;
-  medium?: RoutedTierConfig;
-  low?: RoutedTierConfig;
+  high?: RoutedTierConfig | undefined;
+  medium?: RoutedTierConfig | undefined;
+  low?: RoutedTierConfig | undefined;
 }
 
 export interface RouterConfig {
-  debug?: boolean;
-  classifierModel?: ClassifierConfig;
-  phaseBias?: number;
-  maxSessionBudget?: number;
-  rules?: RoutingRule[];
+  debug?: boolean | undefined;
+  classifierModel?: ClassifierConfig | undefined;
+  phaseBias?: number | undefined;
+  maxSessionBudget?: number | undefined;
+  rules?: RoutingRule[] | undefined;
   profiles: Record<string, RouterProfile>;
-  models?: Record<string, ModelDefinition>;
+  models?: Record<string, ModelDefinition> | undefined;
+}
+
+export interface RouterStatusState {
+  routerEnabled: boolean;
+  selectedProfile: string | undefined;
+  pinnedTierByProfile: RouterPinByProfile;
+  lastDecision: RoutingDecision | undefined;
+  lastNonRouterModel: string | undefined;
+  accumulatedCost: number;
+  widgetEnabled: boolean;
+  currentConfig: RouterConfig;
 }
 
 export interface RoutingDecision {
@@ -65,10 +76,10 @@ export interface RoutingDecision {
   reasoning: string;
   thinking: ThinkingLevel;
   timestamp: number;
-  isClassifier?: boolean;
-  isFallback?: boolean;
-  isBudgetForced?: boolean;
-  isRuleMatched?: boolean;
+  isClassifier?: boolean | undefined;
+  isFallback?: boolean | undefined;
+  isBudgetForced?: boolean | undefined;
+  isRuleMatched?: boolean | undefined;
 }
 
 export interface RouterLastProfileState {
@@ -76,34 +87,51 @@ export interface RouterLastProfileState {
   timestamp: number;
 }
 
+export interface PersistedStateInput {
+  routerEnabled: boolean;
+  selectedProfile: string | undefined;
+  pinnedTierByProfile: RouterPinByProfile;
+  thinkingByProfile: RouterThinkingByProfile;
+  debugEnabled: boolean;
+  widgetEnabled: boolean;
+  debugHistory: RoutingDecision[];
+  lastDecision: RoutingDecision | undefined;
+  lastNonRouterModel: string | undefined;
+  accumulatedCost: number;
+}
+
 export interface RouterPersistedState {
   enabled: boolean;
   selectedProfile: string;
-  pinTier?: RouterTier;
-  pinByProfile?: RouterPinByProfile;
-  thinkingByProfile?: RouterThinkingByProfile;
-  debugEnabled?: boolean;
-  widgetEnabled?: boolean;
-  debugHistory?: RoutingDecision[];
-  lastPhase?: RouterPhase;
-  lastDecision?: RoutingDecision;
-  lastNonRouterModel?: string;
-  accumulatedCost?: number;
+  pinTier?: RouterTier | undefined;
+  pinByProfile?: RouterPinByProfile | undefined;
+  thinkingByProfile?: RouterThinkingByProfile | undefined;
+  debugEnabled?: boolean | undefined;
+  widgetEnabled?: boolean | undefined;
+  debugHistory?: RoutingDecision[] | undefined;
+  lastPhase?: RouterPhase | undefined;
+  lastDecision?: RoutingDecision | undefined;
+  lastNonRouterModel?: string | undefined;
+  accumulatedCost?: number | undefined;
   timestamp: number;
 }
 
+export interface RawRouterConfig {
+  debug?: unknown;
+  classifierModel?: unknown;
+  phaseBias?: unknown;
+  maxSessionBudget?: unknown;
+  rules?: unknown;
+  profiles?: unknown;
+  models?: unknown;
+}
+
 export interface ConfigLoadResult {
   config: RouterConfig;
   warnings: string[];
 }
 
 export interface ParsedConfigFile {
-  config: Partial<RouterConfig>;
+  config: RawRouterConfig;
   warnings: string[];
 }
-
-export interface CustomSessionEntry {
-  type: string;
-  customType?: string;
-  data?: unknown;
-}

package/extensions/ui.ts

@@ -1,17 +1,11 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type {
-  RouterConfig,
   RouterPinByProfile,
+  RouterStatusState,
   RouterThinkingByProfile,
   RoutingDecision,
 } from './types';
 
-const getEffectiveThinking = (
-  thinkingByProfile: RouterThinkingByProfile,
-  profileName: string,
-  decision: RoutingDecision,
-) => thinkingByProfile[profileName]?.[decision.tier] ?? decision.thinking;
-
 const getDecisionFlags = (decision: RoutingDecision): string[] => {
   const flags: string[] = [];
   if (decision.isFallback) flags.push('fallback');
@@ -53,16 +47,18 @@ export const formatModelRef = (ref: string | undefined): string => {
 
 export const updateStatus = (
   ctx: ExtensionContext,
-  routerEnabled: boolean,
-  selectedProfile: string | undefined,
-  pinnedTierByProfile: RouterPinByProfile,
-  thinkingByProfile: RouterThinkingByProfile,
-  lastDecision: RoutingDecision | undefined,
-  lastNonRouterModel: string | undefined,
-  accumulatedCost: number,
-  widgetEnabled: boolean,
-  currentConfig: RouterConfig,
+  state: RouterStatusState,
 ) => {
+  const {
+    routerEnabled,
+    selectedProfile,
+    pinnedTierByProfile,
+    lastDecision,
+    lastNonRouterModel,
+    accumulatedCost,
+    widgetEnabled,
+    currentConfig,
+  } = state;
   const activeRouterProfile = routerEnabled ? selectedProfile : undefined;
   const statusProfile = selectedProfile ?? 'none';
   const activePin = selectedProfile
@@ -77,12 +73,7 @@ export const updateStatus = (
 
     let statusText: string;
     if (lastDecision && matchesProfile && matchesPin) {
-      const effectiveThinking = getEffectiveThinking(
-        thinkingByProfile,
-        activeRouterProfile,
-        lastDecision,
-      );
-      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${effectiveThinking})`;
+      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`;
     } else {
       statusText = `router:${activeRouterProfile}${pinLabel} -> waiting`;
     }
@@ -106,16 +97,11 @@ export const updateStatus = (
         : ''),
   ];
   if (lastDecision && lastDecision.profile === statusProfile) {
-    const effectiveThinking = getEffectiveThinking(
-      thinkingByProfile,
-      statusProfile,
-      lastDecision,
-    );
     const flags = getDecisionFlags(lastDecision);
     const flagsStr = flags.length > 0 ? ` [${flags.join(',')}]` : '';
 
     widgetLines.push(
-      `Route: ${lastDecision.tier}${flagsStr} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${effectiveThinking})`,
+      `Route: ${lastDecision.tier}${flagsStr} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`,
       `Phase: ${lastDecision.phase}`,
     );
   } else if (!routerEnabled && lastNonRouterModel) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-model-router",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "type": "module",
   "files": [
     "extensions",
@@ -11,7 +11,7 @@
     "README.md",
     "CHANGELOG.md"
   ],
-  "description": "Smart per-turn model router for Pi that optimizes your AI budget and usage limits by dynamically switching LLM tiers based on task complexity, budget, and phase awareness.",
+  "description": "Independently maintained Pi model router with tiered routing, soft budget controls, classifier fallback, and custom-provider support.",
   "keywords": [
     "pi-package",
     "pi",
@@ -24,7 +24,7 @@
   "engines": {
     "node": ">=22.19.0"
   },
-  "packageManager": "npm@11.18.0",
+  "packageManager": "npm@12.0.2",
   "author": "Alexei Ledenev",
   "contributors": [
     "Ye Liu"
@@ -52,7 +52,7 @@
     "tsc": "tsc --noEmit",
     "build": "tsc",
     "prepublishOnly": "npm run check && npm test",
-    "test": "vitest run",
+    "test": "vitest run --pool=threads",
     "check": "biome check --error-on-warnings . && npm run tsc",
     "lint": "biome lint --error-on-warnings .",
     "lint:fix": "biome lint --write --error-on-warnings .",