@alexeiled/pi-model-router 0.5.2 → 0.6.1

package/extensions/types.ts

@@ -1,18 +1,15 @@
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 
-export type RouterTier = 'high' | 'medium' | 'low';
+// Descending routing complexity; all tier iteration and ranking derives here.
+export const ROUTER_TIERS = ['high', 'medium', 'low', 'micro'] as const;
+export type RouterTier = (typeof ROUTER_TIERS)[number];
+export type ClassifierTier = RouterTier;
 export type RouterPin = RouterTier | 'auto';
 export type RouterPhase = 'planning' | 'implementation' | 'lightweight';
 export type RouterPinByProfile = Partial<Record<string, RouterTier>>;
 export type RouterThinkingByTier = Partial<Record<RouterTier, ThinkingLevel>>;
 export type RouterThinkingByProfile = Record<string, RouterThinkingByTier>;
 
-export interface RoutingRule {
-  matches: string | string[];
-  tier: RouterTier;
-  reason?: string | undefined;
-}
-
 export interface ModelDefinition {
   model: string;
   contextWindow?: number | undefined;
@@ -28,8 +25,12 @@ export interface ClassifierConfig {
 
 export interface RoutedTierConfig {
   model: string;
+  /** False for normalization defaults; omitted on legacy in-memory profiles. */
+  thinkingExplicit?: boolean | undefined;
   thinking?: ThinkingLevel | undefined;
   fallbacks?: string[] | undefined;
+  /** Canonical targets and exact alias metadata, in the same order as fallbacks. */
+  resolvedFallbacks?: ModelDefinition[] | undefined;
   contextWindow?: number | undefined;
   maxTokens?: number | undefined;
   reasoning?: boolean | undefined;
@@ -39,18 +40,35 @@ export interface RoutedTierConfig {
   resolvedThinkingLevels?: ThinkingLevel[] | undefined;
 }
 
+export interface JevConfig {
+  enabled: boolean;
+  apiKey: string;
+  endpoint: string;
+  model: string;
+  timeoutMs: number;
+  confidenceThreshold: number;
+  maxStateChars: number;
+  mode: 'advisory';
+}
+
+export interface JevProfileConfig {
+  enabled: boolean;
+}
+
 export interface RouterProfile {
+  baselineTier?: RouterTier | undefined;
+  jev?: JevProfileConfig | undefined;
   high?: RoutedTierConfig | undefined;
   medium?: RoutedTierConfig | undefined;
   low?: RoutedTierConfig | undefined;
+  micro?: RoutedTierConfig | undefined;
 }
 
 export interface RouterConfig {
+  jev?: JevConfig | undefined;
   debug?: boolean | undefined;
   classifierModel?: ClassifierConfig | undefined;
-  phaseBias?: number | undefined;
   maxSessionBudget?: number | undefined;
-  rules?: RoutingRule[] | undefined;
   profiles: Record<string, RouterProfile>;
   models?: Record<string, ModelDefinition> | undefined;
 }
@@ -63,9 +81,68 @@ export interface RouterStatusState {
   lastNonRouterModel: string | undefined;
   accumulatedCost: number;
   widgetEnabled: boolean;
-  currentConfig: RouterConfig;
+  maxSessionBudget: number | undefined;
+}
+
+export interface RoutePair {
+  tier: RouterTier;
+  model: string;
+  thinking: ThinkingLevel;
+}
+
+export interface JevRouteCandidate extends RoutePair {
+  id: string;
+}
+
+export interface JevDependencies {
+  fetch?: typeof fetch;
+  now?: () => number;
+}
+
+export interface JevRequest {
+  taskSummary: string;
+  candidates: readonly JevRouteCandidate[];
+  profile: JevProfileConfig | undefined;
+  /** Absolute monotonic deadline supplied by the routing orchestrator. */
+  routingDeadline: number;
+  signal?: AbortSignal | undefined;
 }
 
+/** Only allowlisted local identity and numeric diagnostics cross the adapter boundary. */
+export interface JevAdvice {
+  candidateId: string;
+  confidence: number;
+  latencyMs: number;
+}
+
+export const ROUTING_REASON_CODES = [
+  'baseline',
+  'pinned',
+  'continuation',
+  'classifier',
+  'jev',
+  'fallback',
+  'budget',
+  'legacy',
+] as const;
+export type RoutingReasonCode = (typeof ROUTING_REASON_CODES)[number];
+export const isRoutingReasonCode = (
+  value: unknown,
+): value is RoutingReasonCode =>
+  ROUTING_REASON_CODES.some((code) => code === value);
+export type RoutingErrorClass = 'advisor-unavailable' | 'deadline';
+export const ADVISOR_OUTCOMES = [
+  'none',
+  'bypassed',
+  'jev',
+  'jev-fallback',
+  'classifier',
+  'classifier-fallback',
+] as const;
+export type AdvisorOutcome = (typeof ADVISOR_OUTCOMES)[number];
+export const isAdvisorOutcome = (value: unknown): value is AdvisorOutcome =>
+  ADVISOR_OUTCOMES.some((outcome) => outcome === value);
+
 export interface RoutingDecision {
   profile: string;
   tier: RouterTier;
@@ -73,13 +150,15 @@ export interface RoutingDecision {
   targetProvider: string;
   targetModelId: string;
   targetLabel: string;
-  reasoning: string;
+  reasonCode: RoutingReasonCode;
+  routingLatencyMs?: number | undefined;
+  errorClass?: RoutingErrorClass | undefined;
+  advisor?: AdvisorOutcome | undefined;
   thinking: ThinkingLevel;
   timestamp: number;
   isClassifier?: boolean | undefined;
   isFallback?: boolean | undefined;
   isBudgetForced?: boolean | undefined;
-  isRuleMatched?: boolean | undefined;
 }
 
 export interface RouterLastProfileState {
@@ -117,6 +196,7 @@ export interface RouterPersistedState {
 }
 
 export interface RawRouterConfig {
+  jev?: unknown;
   debug?: unknown;
   classifierModel?: unknown;
   phaseBias?: unknown;

package/extensions/ui.ts

@@ -5,17 +5,67 @@ import type {
   RouterThinkingByProfile,
   RoutingDecision,
 } from './types';
+import { isAdvisorOutcome, isRoutingReasonCode } from './types';
 
 const getDecisionFlags = (decision: RoutingDecision): string[] => {
   const flags: string[] = [];
   if (decision.isFallback) flags.push('fallback');
   if (decision.isBudgetForced) flags.push('budget-limit');
-  if (decision.isRuleMatched) flags.push('rule');
   return flags;
 };
 
+export const formatDecisionSource = (decision: RoutingDecision): string =>
+  isRoutingReasonCode(decision.reasonCode) && decision.reasonCode !== 'legacy'
+    ? decision.reasonCode
+    : '';
+
+export const formatAdvisorLabel = (
+  decision: RoutingDecision,
+): string | undefined => {
+  if (!isAdvisorOutcome(decision.advisor)) return undefined;
+  switch (decision.advisor) {
+    case 'none':
+    case 'bypassed':
+      return undefined;
+    case 'jev':
+      return '🧭 Jev ✓';
+    case 'jev-fallback':
+      return '🧭 Jev ↪ base';
+    case 'classifier':
+      return '🧠 Classifier ✓';
+    case 'classifier-fallback':
+      return '🧠 Classifier ↪ base';
+    default:
+      return undefined;
+  }
+};
+
+export const formatAdvisorDetail = (
+  decision: RoutingDecision,
+): string | undefined => {
+  const label = formatAdvisorLabel(decision);
+  if (!label) return undefined;
+  const latency = Number.isFinite(decision.routingLatencyMs)
+    ? ` · ${Math.round(decision.routingLatencyMs ?? 0)}ms`
+    : '';
+  return `${label}${latency}`;
+};
+
+export const formatAdvisorFooter = (decision: RoutingDecision): string => {
+  if (
+    !decision.advisor ||
+    decision.advisor === 'none' ||
+    decision.advisor === 'bypassed'
+  )
+    return '';
+  const label = formatAdvisorLabel(decision);
+  return label ? ` · ${label}` : '';
+};
+
 export const formatDecision = (decision: RoutingDecision): string => {
-  return `${decision.profile}: ${decision.tier} -> ${decision.targetProvider}/${decision.targetModelId} [${decision.thinking}] (${decision.reasoning})`;
+  const source = formatDecisionSource(decision);
+  const advisor = formatAdvisorLabel(decision);
+  return `${decision.profile}: ${decision.tier} -> ${decision.targetProvider}/${decision.targetModelId} [${decision.thinking}]${source ? ` (${source})` : ''}${advisor ? ` [${advisor}]` : ''}`;
 };
 
 export const formatPinSummary = (
@@ -57,7 +107,7 @@ export const updateStatus = (
     lastNonRouterModel,
     accumulatedCost,
     widgetEnabled,
-    currentConfig,
+    maxSessionBudget,
   } = state;
   const activeRouterProfile = routerEnabled ? selectedProfile : undefined;
   const statusProfile = selectedProfile ?? 'none';
@@ -69,11 +119,11 @@ export const updateStatus = (
   if (activeRouterProfile) {
     const matchesProfile =
       lastDecision && lastDecision.profile === activeRouterProfile;
-    const matchesPin = activePin ? lastDecision?.tier === activePin : true;
+    const matchesPin = !activePin || lastDecision?.tier === activePin;
 
     let statusText: string;
     if (lastDecision && matchesProfile && matchesPin) {
-      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`;
+      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})${formatAdvisorFooter(lastDecision)}`;
     } else {
       statusText = `router:${activeRouterProfile}${pinLabel} -> waiting`;
     }
@@ -92,17 +142,18 @@ export const updateStatus = (
     `Profile: ${statusProfile}${activeRouterProfile ? ' (active)' : ''}`,
     `Pin: ${activePin ?? 'auto'}`,
     `Cost: $${accumulatedCost.toFixed(4)}` +
-      (currentConfig.maxSessionBudget
-        ? ` / $${currentConfig.maxSessionBudget.toFixed(2)}`
-        : ''),
+      (maxSessionBudget ? ` / $${maxSessionBudget.toFixed(2)}` : ''),
   ];
   if (lastDecision && lastDecision.profile === statusProfile) {
     const flags = getDecisionFlags(lastDecision);
     const flagsStr = flags.length > 0 ? ` [${flags.join(',')}]` : '';
+    const advisorDetail = formatAdvisorDetail(lastDecision);
 
     widgetLines.push(
       `Route: ${lastDecision.tier}${flagsStr} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${lastDecision.thinking})`,
       `Phase: ${lastDecision.phase}`,
+      `Source: ${formatDecisionSource(lastDecision) || 'unknown'}`,
+      ...(advisorDetail ? [advisorDetail] : []),
     );
   } else if (!routerEnabled && lastNonRouterModel) {
     widgetLines.push(`Fallback: ${lastNonRouterModel}`);

package/model-router.example.json

@@ -1,7 +1,16 @@
 {
   "debug": false,
+  "jev": {
+    "enabled": false,
+    "apiKey": "<rendered by chezmoi/1Password in user config only>",
+    "endpoint": "https://api.typesafe.ai/v1/systemone",
+    "model": "jev-1.13.0",
+    "timeoutMs": 750,
+    "confidenceThreshold": 0.65,
+    "maxStateChars": 12000,
+    "mode": "advisory"
+  },
   "classifierModel": "flash",
-  "phaseBias": 0.5,
   "maxSessionBudget": 1.0,
   "models": {
     "gpt-pro": {
@@ -25,30 +34,27 @@
       "contextWindow": 200000
     }
   },
-  "rules": [
-    {
-      "matches": ["deploy", "production", "release"],
-      "tier": "high",
-      "reason": "Safety check for production tasks"
-    },
-    { "matches": "changelog", "tier": "low" }
-  ],
   "profiles": {
     "auto": {
+      "baselineTier": "medium",
+      "jev": { "enabled": false },
       "high": {
         "model": "gpt-pro",
         "thinking": "high",
         "fallbacks": ["sonnet"]
       },
       "medium": { "model": "flash", "thinking": "medium" },
-      "low": { "model": "nano", "thinking": "low" }
+      "low": { "model": "nano", "thinking": "off" },
+      "micro": { "model": "nano", "thinking": "off" }
     },
     "cheap": {
+      "jev": { "enabled": false },
       "high": { "model": "flash", "thinking": "low" },
       "medium": { "model": "nano", "thinking": "off" },
       "low": { "model": "google/gemini-flash-lite-latest", "thinking": "off" }
     },
     "deep": {
+      "jev": { "enabled": false },
       "high": {
         "model": "openai/o1-preview",
         "thinking": "xhigh",
@@ -58,6 +64,7 @@
       "low": { "model": "flash", "thinking": "low" }
     },
     "anthropic": {
+      "jev": { "enabled": false },
       "high": {
         "model": "sonnet",
         "thinking": "high"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alexeiled/pi-model-router",
-  "version": "0.5.2",
+  "version": "0.6.1",
   "type": "module",
   "files": [
     "extensions",