@alexeiled/pi-model-router 0.5.1 → 0.5.2

package/CHANGELOG.md

@@ -1,5 +1,15 @@
 # Changelog
 
+## 0.5.2 — 2026-09-20
+
+- Fix context trimming so preserved system instructions count toward the actual token estimate.
+- Display the thinking level used by the completed route, not a pending profile override.
+- Separate classifier, context extraction and pure routing modules; share one runtime state adapter across provider and commands.
+- Validate raw configuration at the boundary and enable strict TypeScript indexing, optional-property and unused-code checks.
+- Add focused Biome async-safety, import-order, cycle and Node import rules.
+- Use Vitest worker threads for the small suite; remove arbitrary test sleeps and obvious test comments while preserving the full assertion set.
+- Align package metadata, architecture documentation and release instructions.
+
 ## 0.5.1 — 2026-09-20
 
 - Delegate generation and classification through Pi's native model registry instead of duplicating auth/dispatch logic. Cover keyless and headers-only auth, native providers and credential URLs with in-memory SDK integration tests.

package/README.md

@@ -63,13 +63,15 @@ npm run check
 npm test
 ```
 
-`npm run check` runs Biome lint, formatting and import-order checks, then the
-TypeScript compiler. Warnings fail the check. CI and releases use the same gate.
+`npm run check` runs Biome lint, formatting, import-order and async-safety checks, then
+TypeScript 7 with strict indexing, optional-property and unused-code checks. Warnings fail
+the check. CI and releases use the same gate.
 
 - `npm run format` formats TypeScript and root JSON files.
 - `npm run lint` checks lint rules; `npm run lint:fix` applies safe lint fixes.
 - `npx biome check --write .` also fixes formatting and import order.
 - `npm run tsc` runs only the type checker.
+- `npm test` uses Vitest worker threads; this keeps the small suite fast without weakening assertions.
 
 [Biome](https://biomejs.dev/) replaces Prettier and supplies linting in one pinned
 direct tooling dependency, without ESLint or formatter plugins. Type checking stays with

package/extensions/classifier.ts

@@ -0,0 +1,93 @@
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
+import type {
+  ThinkingLevel as AiThinkingLevel,
+  Context,
+} from '@earendil-works/pi-ai';
+import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { isRouterTier, parseCanonicalModelRef } from './config';
+import { extractTextFromContent, getRecentConversationText } from './context';
+import type { RouterPhase, RouterTier } from './types';
+
+const CLASSIFIER_TIMEOUT_MS = 10_000;
+const CLASSIFIER_MAX_TOKENS = 256;
+
+export const runClassifier = async (
+  classifierModelRef: string,
+  modelRegistry: ExtensionContext['modelRegistry'],
+  context: Context,
+  currentPhase?: RouterPhase,
+  thinking?: ThinkingLevel,
+  signal?: AbortSignal,
+): Promise<{ tier: RouterTier; reasoning: string } | undefined> => {
+  if (signal?.aborted) return undefined;
+  const { provider, modelId } = parseCanonicalModelRef(classifierModelRef);
+  if (provider === 'router') return undefined;
+  const model = modelRegistry.find(provider, modelId);
+  if (!model) return undefined;
+
+  const latestMessage = context.messages.at(-1);
+  const classifierContext: Context = {
+    messages: [
+      {
+        role: 'user',
+        content: [
+          {
+            type: 'text',
+            text: [
+              'Classify the coding task into exactly one tier: high, medium, or low.',
+              'Return exactly two lines:',
+              'Tier: <high|medium|low>',
+              'Reasoning: <short reason>',
+              `Current phase: ${currentPhase ?? 'unknown'}`,
+              `Recent conversation:\n${getRecentConversationText(context)}`,
+              `Latest request:\n${latestMessage ? extractTextFromContent(latestMessage.content) : ''}`,
+            ].join('\n'),
+          },
+        ],
+        timestamp: Date.now(),
+      },
+    ],
+  };
+  const timeout = AbortSignal.timeout(CLASSIFIER_TIMEOUT_MS);
+  const classifierSignal = signal
+    ? AbortSignal.any([signal, timeout])
+    : timeout;
+  const reasoning: AiThinkingLevel | undefined =
+    thinking && thinking !== 'off' ? thinking : undefined;
+  const stream = modelRegistry.streamSimple(model, classifierContext, {
+    signal: classifierSignal,
+    maxTokens: CLASSIFIER_MAX_TOKENS,
+    ...(reasoning ? { reasoning } : {}),
+  });
+
+  let fullText = '';
+  let completed = false;
+  for await (const event of stream) {
+    if (event.type === 'error') return undefined;
+    if (event.type === 'text_delta') fullText += event.delta;
+    if (event.type === 'done') {
+      completed = true;
+      fullText = extractTextFromContent(event.message.content);
+      break;
+    }
+  }
+  if (!completed) return undefined;
+
+  const tierLine = fullText
+    .split('\n')
+    .find((line) => line.toLowerCase().startsWith('tier:'));
+  const reasoningLine = fullText
+    .split('\n')
+    .find((line) => line.toLowerCase().startsWith('reasoning:'));
+  if (!tierLine || !reasoningLine) return undefined;
+
+  const tierValue = tierLine
+    .slice(tierLine.indexOf(':') + 1)
+    .trim()
+    .toLowerCase();
+  if (!isRouterTier(tierValue)) return undefined;
+  return {
+    tier: tierValue,
+    reasoning: reasoningLine.slice(reasoningLine.indexOf(':') + 1).trim(),
+  };
+};

package/extensions/commands.ts

@@ -6,6 +6,9 @@ import type {
 import type { AutocompleteItem } from '@earendil-works/pi-tui';
 import {
   getUnsupportedTiers,
+  isRouterPinValue,
+  isRouterTier,
+  isThinkingLevel,
   parseCanonicalModelRef,
   profileNames,
   ROUTER_PIN_VALUES,
@@ -110,7 +113,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 +139,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))
@@ -248,7 +251,7 @@ export const registerCommands = (
 
     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 +259,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 {
@@ -303,16 +307,20 @@ 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.`,
@@ -322,7 +330,7 @@ export const registerCommands = (
       }
     }
 
-    if (tier !== 'all' && !tierValues.includes(tier as string)) {
+    if (tier !== 'all' && !tier) {
       ctx.ui.notify(
         `Invalid tier: ${tier}. Use high, medium, or low.`,
         'error',
@@ -338,10 +346,17 @@ 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;
+    let overrides = state.thinkingByProfile[currentProfile];
+    if (!overrides) {
+      overrides = {};
+      state.thinkingByProfile[currentProfile] = overrides;
+    }
+    const tiers = tier === 'all' ? ROUTER_TIERS : [tier];
     for (const targetTier of tiers) {
       if (nextLevel) overrides[targetTier] = nextLevel;
       else delete overrides[targetTier];
@@ -359,10 +374,9 @@ 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}. ` +
@@ -416,7 +430,7 @@ export const registerCommands = (
       return;
     }
     const tier = args[0]?.toLowerCase();
-    if (!ROUTER_TIERS.includes(tier as RouterTier)) {
+    if (!isRouterTier(tier)) {
       ctx.ui.notify('Usage: /router fix <high|medium|low>', 'error');
       return;
     }
@@ -424,7 +438,7 @@ export const registerCommands = (
       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 +529,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('');
@@ -597,6 +613,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':

package/extensions/config.ts

@@ -9,6 +9,7 @@ import type {
   ConfigLoadResult,
   ModelDefinition,
   ParsedConfigFile,
+  RawRouterConfig,
   RoutedTierConfig,
   RouterConfig,
   RouterProfile,
@@ -19,7 +20,7 @@ import type {
 export const ROUTER_TIERS = ['high', 'medium', 'low'] as const;
 
 // Pi accepts this model capability at runtime, but older peer type releases omit it.
-export const MAX_THINKING_LEVEL = 'max' as ThinkingLevel;
+export const MAX_THINKING_LEVEL: ThinkingLevel = 'max';
 
 export const THINKING_LEVELS: readonly ThinkingLevel[] = [
   'off',
@@ -31,6 +32,9 @@ export const THINKING_LEVELS: readonly ThinkingLevel[] = [
   MAX_THINKING_LEVEL,
 ];
 export const ROUTER_PIN_VALUES = ['auto', 'high', 'medium', 'low'] as const;
+export type RouterPinValue = (typeof ROUTER_PIN_VALUES)[number];
+export const isRouterPinValue = (value: unknown): value is RouterPinValue =>
+  ROUTER_PIN_VALUES.some((candidate) => candidate === value);
 
 export const DEFAULT_THINKING_LEVELS: readonly ThinkingLevel[] = [
   'high',
@@ -44,7 +48,7 @@ export const isObjectRecord = (
   typeof value === 'object' && value !== null && !Array.isArray(value);
 
 export const isThinkingLevel = (value: unknown): value is ThinkingLevel =>
-  typeof value === 'string' && THINKING_LEVELS.includes(value as ThinkingLevel);
+  typeof value === 'string' && THINKING_LEVELS.some((level) => level === value);
 
 export const isRouterTier = (value: unknown): value is RouterTier =>
   value === 'high' || value === 'medium' || value === 'low';
@@ -55,14 +59,14 @@ export const parseConfigFile = (path: string): ParsedConfigFile => {
   }
 
   try {
-    const parsed = JSON.parse(readFileSync(path, 'utf-8')) as unknown;
+    const parsed: unknown = JSON.parse(readFileSync(path, 'utf-8'));
     if (!isObjectRecord(parsed)) {
       return {
         config: {},
         warnings: [`Ignored router config at ${path}: expected a JSON object.`],
       };
     }
-    return { config: parsed as Partial<RouterConfig>, warnings: [] };
+    return { config: parsed, warnings: [] };
   } catch (error) {
     return {
       config: {},
@@ -90,40 +94,42 @@ export const resolveModelRef = (
   return { canonicalRef: ref };
 };
 
-const mergeTier = (
-  existing?: RoutedTierConfig,
-  next?: Partial<RoutedTierConfig>,
-): RoutedTierConfig | undefined => {
-  if (!existing && !next) return undefined;
-  if (!next) return existing;
-  if (!existing) return next as RoutedTierConfig;
-  return { ...existing, ...next };
+const mergeRawValue = (existing: unknown, next: unknown): unknown => {
+  if (next === undefined) return existing;
+  if (isObjectRecord(existing) && isObjectRecord(next)) {
+    return { ...existing, ...next };
+  }
+  return next;
 };
 
 export const mergeConfig = (
-  base: RouterConfig,
-  override: Partial<RouterConfig>,
-): RouterConfig => {
-  const mergedProfiles: Record<string, RouterProfile> = { ...base.profiles };
-  for (const [name, profile] of Object.entries(
-    isObjectRecord(override.profiles) ? override.profiles : {},
-  )) {
-    if (!isObjectRecord(profile) || name === '__proto__') continue;
-    const existing = Object.hasOwn(mergedProfiles, name)
+  base: RawRouterConfig,
+  override: RawRouterConfig,
+): RawRouterConfig => {
+  const baseProfiles = isObjectRecord(base.profiles) ? base.profiles : {};
+  const overrideProfiles = isObjectRecord(override.profiles)
+    ? override.profiles
+    : {};
+  const mergedProfiles: Record<string, unknown> = { ...baseProfiles };
+  for (const [name, profile] of Object.entries(overrideProfiles)) {
+    if (name === '__proto__') continue;
+    if (!isObjectRecord(profile)) {
+      mergedProfiles[name] = profile;
+      continue;
+    }
+    const existing = isObjectRecord(mergedProfiles[name])
       ? mergedProfiles[name]
-      : undefined;
-    const nextProfile = profile as Partial<RouterProfile>;
+      : {};
     mergedProfiles[name] = {
-      high: mergeTier(existing?.high, nextProfile.high),
-      medium: mergeTier(existing?.medium, nextProfile.medium),
-      low: mergeTier(existing?.low, nextProfile.low),
+      high: mergeRawValue(existing.high, profile.high),
+      medium: mergeRawValue(existing.medium, profile.medium),
+      low: mergeRawValue(existing.low, profile.low),
     };
   }
 
-  const mergedModels: Record<string, ModelDefinition> = {
-    ...(base.models ?? {}),
-    ...(isObjectRecord(override.models) ? override.models : {}),
-  };
+  const baseModels = isObjectRecord(base.models) ? base.models : {};
+  const overrideModels = isObjectRecord(override.models) ? override.models : {};
+  const mergedModels = { ...baseModels, ...overrideModels };
 
   return {
     debug: override.debug ?? base.debug,
@@ -159,7 +165,7 @@ export const parseCanonicalModelRef = (
  * Validate and normalize the models map from config.
  */
 export const normalizeModelsMap = (
-  raw: Record<string, unknown> | undefined,
+  raw: unknown,
   warnings: string[],
 ): Record<string, ModelDefinition> => {
   const result: Record<string, ModelDefinition> = {};
@@ -321,8 +327,8 @@ export const normalizeTierConfig = (
   // Validate tier-level thinkingLevels array
   let tierThinkingLevels: ThinkingLevel[] | undefined;
   if (Array.isArray(value.thinkingLevels)) {
-    tierThinkingLevels = (value.thinkingLevels as unknown[]).filter(
-      (l): l is ThinkingLevel => isThinkingLevel(l),
+    tierThinkingLevels = value.thinkingLevels.filter((l): l is ThinkingLevel =>
+      isThinkingLevel(l),
     );
     if (tierThinkingLevels.length === 0) tierThinkingLevels = undefined;
   }
@@ -359,14 +365,11 @@ export const normalizeTierConfig = (
   };
 };
 
-export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
+export const normalizeConfig = (raw: RawRouterConfig): ConfigLoadResult => {
   const warnings: string[] = [];
 
   // Normalize models map first so aliases are available during tier normalization
-  const normalizedModels = normalizeModelsMap(
-    raw.models as Record<string, unknown> | undefined,
-    warnings,
-  );
+  const normalizedModels = normalizeModelsMap(raw.models, warnings);
   const hasModels = Object.keys(normalizedModels).length > 0;
 
   const normalizedProfiles: Record<string, RouterProfile> = {};
@@ -375,22 +378,23 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
     isObjectRecord(raw.profiles) ? raw.profiles : {},
   )) {
     if (name === '__proto__') continue;
+    const profileRecord = isObjectRecord(profile) ? profile : {};
     const high = normalizeTierConfig(
-      profile?.high,
+      profileRecord.high,
       name,
       'high',
       warnings,
       hasModels ? normalizedModels : undefined,
     );
     const medium = normalizeTierConfig(
-      profile?.medium,
+      profileRecord.medium,
       name,
       'medium',
       warnings,
       hasModels ? normalizedModels : undefined,
     );
     const low = normalizeTierConfig(
-      profile?.low,
+      profileRecord.low,
       name,
       'low',
       warnings,
@@ -446,7 +450,7 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
 
   // Resolve classifierModel — accepts string or { model, thinking } object
   let classifierModel: ClassifierConfig | undefined;
-  const rawClassifier = raw.classifierModel as unknown;
+  const rawClassifier = raw.classifierModel;
   if (typeof rawClassifier === 'string' && rawClassifier.trim()) {
     const resolved = resolveModelRef(
       rawClassifier.trim(),
@@ -510,7 +514,7 @@ export const loadRouterConfig = (cwd: string): ConfigLoadResult => {
   const projectPath = join(cwd, '.pi', 'model-router.json');
   const globalResult = parseConfigFile(globalPath);
   const projectResult = parseConfigFile(projectPath);
-  const baseConfig: RouterConfig = { profiles: {} };
+  const baseConfig: RawRouterConfig = { profiles: {} };
   const merged = mergeConfig(
     mergeConfig(baseConfig, globalResult.config),
     projectResult.config,
@@ -649,9 +653,8 @@ export const clampThinkingLevel = (
 
   const reqIdx = THINKING_LEVELS.indexOf(requested);
   for (let i = reqIdx; i >= 0; i--) {
-    if (supported.includes(THINKING_LEVELS[i])) {
-      return THINKING_LEVELS[i];
-    }
+    const level = THINKING_LEVELS[i];
+    if (level && supported.includes(level)) return level;
   }
 
   return 'off';

package/extensions/context.ts

@@ -0,0 +1,58 @@
+import type { Context, Message } from '@earendil-works/pi-ai';
+
+export const extractTextFromContent = (
+  content: string | Message['content'],
+): string => {
+  if (typeof content === 'string') return content;
+  return content
+    .map((part) => {
+      if (part.type === 'text') return part.text;
+      if (part.type === 'thinking') return part.thinking;
+      if (part.type === 'toolCall') {
+        return `${part.name} ${JSON.stringify(part.arguments)}`;
+      }
+      return '';
+    })
+    .filter(Boolean)
+    .join('\n');
+};
+
+export const getLastUserText = (context: Context): string => {
+  for (let i = context.messages.length - 1; i >= 0; i -= 1) {
+    const message = context.messages[i];
+    if (message?.role === 'user') {
+      return extractTextFromContent(message.content).trim();
+    }
+  }
+  return '';
+};
+
+export const getRecentConversationText = (
+  context: Context,
+  limit = 6,
+): string =>
+  context.messages
+    .slice(-limit)
+    .map((message) =>
+      message ? extractTextFromContent(message.content).trim() : '',
+    )
+    .filter(Boolean)
+    .join('\n')
+    .toLowerCase();
+
+export const countToolResults = (context: Context): number =>
+  context.messages.filter((message) => message?.role === 'toolResult').length;
+
+export const countWords = (text: string): number =>
+  text.split(/\s+/).filter(Boolean).length;
+
+export const hasImageAttachment = (context: Context): boolean =>
+  context.messages.some(
+    (message) =>
+      message &&
+      Array.isArray(message.content) &&
+      message.content.some((part) => part.type === 'image'),
+  );
+
+export const containsAny = (text: string, keywords: string[]): boolean =>
+  keywords.some((keyword) => text.includes(keyword));