@alexeiled/pi-model-router 0.5.1 → 0.6.0

package/extensions/config.ts

@@ -7,19 +7,22 @@ import { DEFAULT_CONTEXT_WINDOW, DEFAULT_MAX_TOKENS } from './constants';
 import type {
   ClassifierConfig,
   ConfigLoadResult,
+  JevConfig,
   ModelDefinition,
   ParsedConfigFile,
+  RawRouterConfig,
   RoutedTierConfig,
   RouterConfig,
   RouterProfile,
   RouterTier,
-  RoutingRule,
 } from './types';
 
-export const ROUTER_TIERS = ['high', 'medium', 'low'] as const;
+import { ROUTER_TIERS } from './types';
+
+export { ROUTER_TIERS } from './types';
 
 // 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',
@@ -30,7 +33,10 @@ export const THINKING_LEVELS: readonly ThinkingLevel[] = [
   'xhigh',
   MAX_THINKING_LEVEL,
 ];
-export const ROUTER_PIN_VALUES = ['auto', 'high', 'medium', 'low'] as const;
+export const ROUTER_PIN_VALUES = ['auto', ...ROUTER_TIERS] 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,10 +50,10 @@ 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';
+  ROUTER_TIERS.some((tier) => tier === value);
 
 export const parseConfigFile = (path: string): ParsedConfigFile => {
   if (!existsSync(path)) {
@@ -55,20 +61,19 @@ 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: [] };
-  } catch (error) {
+    return { config: parsed, warnings: [] };
+  } catch {
+    // JSON parse errors can include source snippets containing credentials.
     return {
       config: {},
-      warnings: [
-        `Failed to parse router config at ${path}: ${error instanceof Error ? error.message : String(error)}`,
-      ],
+      warnings: [`Failed to parse router config at ${path}.`],
     };
   }
 };
@@ -90,42 +95,48 @@ 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),
+      baselineTier: mergeRawValue(existing.baselineTier, profile.baselineTier),
+      high: mergeRawValue(existing.high, profile.high),
+      medium: mergeRawValue(existing.medium, profile.medium),
+      low: mergeRawValue(existing.low, profile.low),
+      micro: mergeRawValue(existing.micro, profile.micro),
+      jev: mergeRawValue(existing.jev, profile.jev),
     };
   }
 
-  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 {
+    jev: mergeRawValue(base.jev, override.jev),
     debug: override.debug ?? base.debug,
     classifierModel: override.classifierModel ?? base.classifierModel,
     phaseBias: override.phaseBias ?? base.phaseBias,
@@ -141,16 +152,12 @@ export const parseCanonicalModelRef = (
 ): { provider: string; modelId: string } => {
   const slashIndex = value.indexOf('/');
   if (slashIndex === -1) {
-    throw new Error(
-      `Invalid model reference "${value}". Expected "provider/model".`,
-    );
+    throw new Error('Invalid model reference. Expected "provider/model".');
   }
   const provider = value.slice(0, slashIndex).trim();
   const modelId = value.slice(slashIndex + 1).trim();
   if (!provider || !modelId) {
-    throw new Error(
-      `Invalid model reference "${value}". Expected "provider/model".`,
-    );
+    throw new Error('Invalid model reference. Expected "provider/model".');
   }
   return { provider, modelId };
 };
@@ -159,7 +166,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> = {};
@@ -174,7 +181,7 @@ export const normalizeModelsMap = (
       continue;
     }
 
-    const model = typeof entry.model === 'string' ? entry.model.trim() : '';
+    let model = typeof entry.model === 'string' ? entry.model.trim() : '';
     if (!model) {
       warnings.push(
         `Model definition "${alias}" is missing the "model" field. Skipped.`,
@@ -183,10 +190,11 @@ export const normalizeModelsMap = (
     }
 
     try {
-      parseCanonicalModelRef(model);
-    } catch (error) {
+      const { provider, modelId } = parseCanonicalModelRef(model);
+      model = `${provider}/${modelId}`;
+    } catch {
       warnings.push(
-        `Model definition "${alias}": ${error instanceof Error ? error.message : String(error)}`,
+        `Model definition "${alias}" has an invalid model reference. Skipped.`,
       );
       continue;
     }
@@ -259,23 +267,31 @@ export const normalizeTierConfig = (
   const aliasDefinition = resolved.definition;
   let parsedModel: string;
   try {
-    parseCanonicalModelRef(resolved.canonicalRef);
-    parsedModel = resolved.canonicalRef;
-  } catch (error) {
+    const { provider, modelId } = parseCanonicalModelRef(resolved.canonicalRef);
+    parsedModel = `${provider}/${modelId}`;
+  } catch {
     warnings.push(
-      `Profile "${profileName}" ${tier} tier: ${error instanceof Error ? error.message : String(error)} Tier disabled.`,
+      `Profile "${profileName}" ${tier} tier has an invalid model reference. Tier disabled.`,
     );
     return undefined;
   }
 
-  const thinking = isThinkingLevel(value.thinking) ? value.thinking : 'medium';
+  const tierReasoning =
+    typeof value.reasoning === 'boolean' ? value.reasoning : undefined;
+  const effectiveReasoning = tierReasoning ?? aliasDefinition?.reasoning;
+  const defaultThinking =
+    tier === 'micro' || effectiveReasoning === false ? 'off' : 'medium';
+  const thinking = isThinkingLevel(value.thinking)
+    ? value.thinking
+    : defaultThinking;
   if (value.thinking !== undefined && !isThinkingLevel(value.thinking)) {
     warnings.push(
-      `Profile "${profileName}" ${tier} tier has invalid thinking level. Defaulting to medium.`,
+      `Profile "${profileName}" ${tier} tier has invalid thinking level. Defaulting to ${defaultThinking}.`,
     );
   }
 
   let fallbacks: string[] | undefined;
+  const resolvedFallbacks: ModelDefinition[] = [];
   if (Array.isArray(value.fallbacks)) {
     fallbacks = [];
     for (const f of value.fallbacks) {
@@ -283,11 +299,15 @@ export const normalizeTierConfig = (
         // Resolve aliases in fallbacks too
         const resolvedFallback = resolveModelRef(f, models);
         try {
-          parseCanonicalModelRef(resolvedFallback.canonicalRef);
-          fallbacks.push(resolvedFallback.canonicalRef);
-        } catch (error) {
+          const { provider, modelId } = parseCanonicalModelRef(
+            resolvedFallback.canonicalRef,
+          );
+          const model = `${provider}/${modelId}`;
+          fallbacks.push(model);
+          resolvedFallbacks.push({ ...resolvedFallback.definition, model });
+        } catch {
           warnings.push(
-            `Invalid fallback model "${f}" in profile "${profileName}" ${tier} tier: ${error instanceof Error ? error.message : String(error)}`,
+            `Invalid fallback model in profile "${profileName}" ${tier} tier. Ignored.`,
           );
         }
       }
@@ -312,17 +332,12 @@ export const normalizeTierConfig = (
   const resolvedMaxTokens =
     tierMaxTokens ?? aliasDefinition?.maxTokens ?? DEFAULT_MAX_TOKENS;
 
-  // Resolve reasoning: tier config > alias > undefined (assumed true)
-  const tierReasoning =
-    typeof value.reasoning === 'boolean' ? value.reasoning : undefined;
-  const effectiveReasoning = tierReasoning ?? aliasDefinition?.reasoning;
-
   // Resolve thinkingLevels: tier config > alias > default
   // 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;
   }
@@ -347,11 +362,13 @@ export const normalizeTierConfig = (
 
   return {
     model: parsedModel,
+    thinkingExplicit: isThinkingLevel(value.thinking),
     thinking,
     fallbacks,
+    resolvedFallbacks,
     contextWindow: tierContextWindow,
     maxTokens: tierMaxTokens,
-    reasoning: tierReasoning,
+    reasoning: effectiveReasoning,
     thinkingLevels: tierThinkingLevels,
     resolvedContextWindow,
     resolvedMaxTokens,
@@ -359,14 +376,113 @@ export const normalizeTierConfig = (
   };
 };
 
-export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
+export const DEFAULT_JEV_CONFIG = {
+  endpoint: 'https://api.typesafe.ai/v1/systemone',
+  model: 'jev-1.13.0',
+  timeoutMs: 750,
+  confidenceThreshold: 0.65,
+  maxStateChars: 12000,
+  mode: 'advisory',
+} as const;
+
+export const isJevEndpoint = (value: unknown): value is string => {
+  if (typeof value !== 'string') return false;
+  try {
+    const url = new URL(value);
+    return (
+      url.protocol === 'https:' &&
+      !url.username &&
+      !url.password &&
+      !url.search &&
+      !url.hash
+    );
+  } catch {
+    return false;
+  }
+};
+
+export const normalizeJevConfig = (
+  raw: unknown,
+  warnings: string[],
+): JevConfig | undefined => {
+  if (raw === undefined) return undefined;
+  const invalid = (): undefined => {
+    warnings.push('Ignored invalid Jev configuration.');
+    return undefined;
+  };
+  if (!isObjectRecord(raw)) return invalid();
+  const value: Record<string, unknown> = { ...DEFAULT_JEV_CONFIG, ...raw };
+  if (
+    (value.enabled !== undefined && typeof value.enabled !== 'boolean') ||
+    !isJevEndpoint(value.endpoint) ||
+    typeof value.model !== 'string' ||
+    !/^[a-zA-Z0-9._-]{1,128}$/.test(value.model) ||
+    typeof value.timeoutMs !== 'number' ||
+    !Number.isFinite(value.timeoutMs) ||
+    value.timeoutMs <= 0 ||
+    value.timeoutMs > 1500 ||
+    typeof value.confidenceThreshold !== 'number' ||
+    !Number.isFinite(value.confidenceThreshold) ||
+    value.confidenceThreshold < 0 ||
+    value.confidenceThreshold > 1 ||
+    typeof value.maxStateChars !== 'number' ||
+    !Number.isInteger(value.maxStateChars) ||
+    value.maxStateChars < 1 ||
+    value.maxStateChars > 12000 ||
+    value.mode !== 'advisory' ||
+    (value.apiKey !== undefined &&
+      (typeof value.apiKey !== 'string' || /[\r\n]/.test(value.apiKey)))
+  )
+    return invalid();
+  if (value.timeoutMs > 750)
+    warnings.push(
+      'Jev timeoutMs clamped to the effective 750 ms provider cap.',
+    );
+  const apiKey = typeof value.apiKey === 'string' ? value.apiKey.trim() : '';
+  if (value.enabled === true && !apiKey) {
+    warnings.push('Jev disabled: missing user-config API key.');
+  }
+  return {
+    enabled: value.enabled === true && apiKey.length > 0,
+    apiKey,
+    endpoint: value.endpoint,
+    model: value.model,
+    timeoutMs: Math.min(value.timeoutMs, 750),
+    confidenceThreshold: value.confidenceThreshold,
+    maxStateChars: value.maxStateChars,
+    mode: 'advisory',
+  };
+};
+
+// Remove every project Jev setting before merging with user-owned credentials.
+export const stripProjectJevConfig = (
+  raw: RawRouterConfig,
+  warnings: string[],
+): RawRouterConfig => {
+  const { jev: ignored, ...project } = raw;
+  let found = ignored !== undefined;
+  if (isObjectRecord(project.profiles)) {
+    project.profiles = Object.fromEntries(
+      Object.entries(project.profiles).map(([name, profile]) => {
+        if (!isObjectRecord(profile)) return [name, profile];
+        const { jev, ...tiers } = profile;
+        if (jev !== undefined) found = true;
+        return [name, tiers];
+      }),
+    );
+  }
+  if (found)
+    warnings.push(
+      'Ignored project Jev settings: configure Jev only in user config.',
+    );
+  return project;
+};
+
+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,78 +491,83 @@ 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,
       hasModels ? normalizedModels : undefined,
     );
 
-    if (!high && !medium && !low) {
+    const micro = normalizeTierConfig(
+      profileRecord.micro,
+      name,
+      'micro',
+      warnings,
+      hasModels ? normalizedModels : undefined,
+    );
+
+    if (!high && !medium && !low && !micro) {
       warnings.push(`Profile "${name}" has no valid tiers. Skipped.`);
       continue;
     }
 
-    normalizedProfiles[name] = { high, medium, low };
+    let baselineTier: RouterTier | undefined;
+    if (profileRecord.baselineTier !== undefined) {
+      const candidate = profileRecord.baselineTier;
+      const normalizedTier = isRouterTier(candidate)
+        ? { high, medium, low, micro }[candidate]
+        : undefined;
+      if (isRouterTier(candidate) && normalizedTier) {
+        baselineTier = candidate;
+      } else {
+        warnings.push(
+          `Profile "${name}" baselineTier must name a configured tier. Ignored.`,
+        );
+      }
+    }
+
+    const jev = isObjectRecord(profileRecord.jev)
+      ? { enabled: profileRecord.jev.enabled === true }
+      : undefined;
+    normalizedProfiles[name] = {
+      ...(baselineTier ? { baselineTier } : {}),
+      high,
+      medium,
+      low,
+      micro,
+      jev,
+    };
   }
 
-  const phaseBias =
-    typeof raw.phaseBias === 'number'
-      ? Math.max(0, Math.min(1, raw.phaseBias))
-      : 0.5;
+  if (raw.phaseBias !== undefined)
+    warnings.push('Deprecated router config field "phaseBias" ignored.');
+  if (raw.rules !== undefined)
+    warnings.push('Deprecated router config field "rules" ignored.');
 
   const maxSessionBudget =
     typeof raw.maxSessionBudget === 'number' && raw.maxSessionBudget > 0
       ? raw.maxSessionBudget
       : undefined;
 
-  const rules: RoutingRule[] = [];
-  if (Array.isArray(raw.rules)) {
-    for (const rule of raw.rules) {
-      if (isObjectRecord(rule)) {
-        const matches = rule.matches;
-        const tier = rule.tier;
-        if (
-          ((typeof matches === 'string' && matches.trim().length > 0) ||
-            (Array.isArray(matches) &&
-              matches.length > 0 &&
-              matches.every(
-                (m) => typeof m === 'string' && m.trim().length > 0,
-              ))) &&
-          isRouterTier(tier)
-        ) {
-          rules.push({
-            matches,
-            tier,
-            reason: typeof rule.reason === 'string' ? rule.reason : undefined,
-          });
-        } else {
-          warnings.push(
-            `Ignored invalid routing rule: ${JSON.stringify(rule)}`,
-          );
-        }
-      }
-    }
-  }
-
   // 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(),
@@ -455,10 +576,8 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
     try {
       parseCanonicalModelRef(resolved.canonicalRef);
       classifierModel = { model: resolved.canonicalRef };
-    } catch (error) {
-      warnings.push(
-        `Invalid classifierModel: ${error instanceof Error ? error.message : String(error)}`,
-      );
+    } catch {
+      warnings.push('Invalid classifierModel model reference. Ignored.');
     }
   } else if (isObjectRecord(rawClassifier)) {
     const modelRef =
@@ -475,14 +594,12 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
           : undefined;
         if (rawClassifier.thinking !== undefined && !thinking) {
           warnings.push(
-            `classifierModel has invalid thinking level "${String(rawClassifier.thinking)}". Ignored.`,
+            'classifierModel has an invalid thinking level. Ignored.',
           );
         }
         classifierModel = { model: resolved.canonicalRef, thinking };
-      } catch (error) {
-        warnings.push(
-          `Invalid classifierModel: ${error instanceof Error ? error.message : String(error)}`,
-        );
+      } catch {
+        warnings.push('Invalid classifierModel model reference. Ignored.');
       }
     } else {
       warnings.push(
@@ -493,11 +610,10 @@ export const normalizeConfig = (raw: RouterConfig): ConfigLoadResult => {
 
   return {
     config: {
+      jev: normalizeJevConfig(raw.jev, warnings),
       debug: typeof raw.debug === 'boolean' ? raw.debug : false,
       classifierModel,
-      phaseBias,
       maxSessionBudget,
-      rules: rules.length > 0 ? rules : undefined,
       profiles: normalizedProfiles,
       models: hasModels ? normalizedModels : undefined,
     },
@@ -510,10 +626,10 @@ 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,
+    stripProjectJevConfig(projectResult.config, projectResult.warnings),
   );
   const normalized = normalizeConfig(merged);
   return {
@@ -634,25 +750,3 @@ export const getUnsupportedTiers = (
   }
   return unsupported;
 };
-
-/**
- * Clamps a requested thinking level to the highest supported level
- * in the provided array of supported levels.
- */
-export const clampThinkingLevel = (
-  requested: ThinkingLevel,
-  supported: ThinkingLevel[] | undefined,
-): ThinkingLevel => {
-  if (requested === 'off' || !supported || supported.length === 0) {
-    return 'off';
-  }
-
-  const reqIdx = THINKING_LEVELS.indexOf(requested);
-  for (let i = reqIdx; i >= 0; i--) {
-    if (supported.includes(THINKING_LEVELS[i])) {
-      return THINKING_LEVELS[i];
-    }
-  }
-
-  return 'off';
-};