@kylebrodeur/pi-model-router 0.1.2

package/extensions/types.ts

@@ -0,0 +1,148 @@
+import type { ThinkingLevel } from '@mariozechner/pi-agent-core';
+
+// ─── Feature Toggles (added by fork) ──────────────────────────────────────
+
+export type RouterFeature =
+  | 'ollamaSync'
+  | 'rateLimitFallback'
+  | 'perTurnRouting'
+  | 'intentClassifier'
+  | 'costBudgeting'
+  | 'phaseMemory'
+  | 'contextCompression'
+  | 'ledgerIntegration'
+  | 'agentBusIntegration';
+
+export interface FeatureToggles {
+  ollamaSync?: boolean;
+  rateLimitFallback?: boolean;
+  scopeShim?: boolean;
+  respectPiScope?: boolean;
+  perTurnRouting?: boolean;
+  intentClassifier?: boolean;
+  costBudgeting?: boolean;
+  phaseMemory?: boolean;
+  contextCompression?: boolean;
+  /**
+   * Log routing decisions to qmd-ledger if available.
+   * Progressive: detects pi-qmd-ledger at runtime.
+   */
+  ledgerIntegration?: boolean;
+  /**
+   * Publish model changes to pi-agent-bus MessageBus if available.
+   * Progressive: detects pi-agent-bus at runtime.
+   */
+  agentBusIntegration?: boolean;
+}
+
+export interface OllamaSyncConfig {
+  enabled?: boolean;
+  onStartup?: boolean;
+  onReload?: boolean;
+  addLaunchFlag?: boolean;
+  visionKeywords?: string[];
+  reasoningKeywords?: string[];
+  preferredFamilies?: string[];
+  defaultContextWindow?: number;
+  largeContextWindow?: number;
+}
+
+export interface RateLimitFallbackConfig {
+  enabled?: boolean;
+  shortDelayThreshold?: number;
+  autoFallback?: boolean;
+  autoRestore?: boolean;
+  restoreCheckInterval?: number;
+  fallbackSequence?: string[];
+}
+
+// ─── Original Router Types ─────────────────────────────────────────────────
+
+export type RouterTier = 'high' | 'medium' | 'low';
+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;
+}
+
+export interface RoutedTierConfig {
+  model: string;
+  thinking?: ThinkingLevel;
+  fallbacks?: string[];
+}
+
+export interface RouterProfile {
+  high: RoutedTierConfig;
+  medium: RoutedTierConfig;
+  low: RoutedTierConfig;
+}
+
+export interface RouterConfig {
+  defaultProfile?: string;
+  debug?: boolean;
+  classifierModel?: string;
+  phaseBias?: number;
+  largeContextThreshold?: number;
+  maxSessionBudget?: number;
+  rules?: RoutingRule[];
+  profiles: Record<string, RouterProfile>;
+  // ─── Feature toggles (added by fork) ──────────────────────────────
+  features?: FeatureToggles;
+  ollamaSync?: OllamaSyncConfig;
+  rateLimitFallback?: RateLimitFallbackConfig;
+}
+
+export interface RoutingDecision {
+  profile: string;
+  tier: RouterTier;
+  phase: RouterPhase;
+  targetProvider: string;
+  targetModelId: string;
+  targetLabel: string;
+  reasoning: string;
+  thinking: ThinkingLevel;
+  timestamp: number;
+  isClassifier?: boolean;
+  isFallback?: boolean;
+  isContextTriggered?: boolean;
+  isBudgetForced?: boolean;
+  isRuleMatched?: boolean;
+}
+
+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;
+  timestamp: number;
+}
+
+export interface ConfigLoadResult {
+  config: RouterConfig;
+  warnings: string[];
+}
+
+export interface ParsedConfigFile {
+  config: Partial<RouterConfig>;
+  warnings: string[];
+}
+
+export interface CustomSessionEntry {
+  type: string;
+  customType?: string;
+  data?: unknown;
+}

package/extensions/ui.ts

@@ -0,0 +1,130 @@
+import type { ExtensionContext } from '@mariozechner/pi-coding-agent';
+import type {
+  RoutingDecision,
+  RouterConfig,
+  RouterPinByProfile,
+  RouterThinkingByProfile,
+} 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');
+  if (decision.isContextTriggered) flags.push('context');
+  if (decision.isBudgetForced) flags.push('budget-limit');
+  if (decision.isRuleMatched) flags.push('rule');
+  return flags;
+};
+
+export const formatDecision = (decision: RoutingDecision): string => {
+  return `${decision.profile}: ${decision.tier} -> ${decision.targetProvider}/${decision.targetModelId} [${decision.thinking}] (${decision.reasoning})`;
+};
+
+export const formatPinSummary = (
+  pinnedTierByProfile: RouterPinByProfile,
+): string => {
+  const entries = Object.entries(pinnedTierByProfile)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([profile, tier]) => `${profile}:${tier}`);
+  return entries.length > 0 ? entries.join(', ') : 'none';
+};
+
+export const formatThinkingSummary = (
+  thinkingByProfile: RouterThinkingByProfile,
+): string => {
+  const entries = Object.entries(thinkingByProfile)
+    .sort(([a], [b]) => a.localeCompare(b))
+    .map(([profile, tierMap]) => {
+      const tiers = Object.entries(tierMap)
+        .sort(([a], [b]) => a.localeCompare(b))
+        .map(([tier, level]) => `${tier}:${level}`);
+      return `${profile}(${tiers.join(',')})`;
+    });
+  return entries.length > 0 ? entries.join(', ') : 'none';
+};
+
+export const formatModelRef = (ref: string | undefined): string => {
+  return ref ?? 'none';
+};
+
+export const updateStatus = (
+  ctx: ExtensionContext,
+  routerEnabled: boolean,
+  selectedProfile: string,
+  pinnedTierByProfile: RouterPinByProfile,
+  thinkingByProfile: RouterThinkingByProfile,
+  lastDecision: RoutingDecision | undefined,
+  lastNonRouterModel: string | undefined,
+  accumulatedCost: number,
+  widgetEnabled: boolean,
+  currentConfig: RouterConfig,
+) => {
+  const activeRouterProfile = routerEnabled ? selectedProfile : undefined;
+  const statusProfile = selectedProfile;
+  const activePin = pinnedTierByProfile[statusProfile];
+  const pinLabel = activePin ? ` [pin:${activePin}]` : '';
+
+  let statusText: string;
+  if (activeRouterProfile) {
+    const matchesProfile =
+      lastDecision && lastDecision.profile === activeRouterProfile;
+    const matchesPin = activePin ? lastDecision?.tier === activePin : true;
+
+    if (lastDecision && matchesProfile && matchesPin) {
+      const effectiveThinking = getEffectiveThinking(
+        thinkingByProfile,
+        activeRouterProfile,
+        lastDecision,
+      );
+      statusText = `router:${activeRouterProfile}${pinLabel} -> ${lastDecision.tier} -> ${lastDecision.targetProvider}/${lastDecision.targetModelId} (${effectiveThinking})`;
+    } else {
+      statusText = `router:${activeRouterProfile}${pinLabel} -> waiting`;
+    }
+  } else {
+    statusText = `router:off (${selectedProfile}${pinLabel}) -> ${formatModelRef(lastNonRouterModel)}`;
+  }
+  ctx.ui.setStatus('router', ctx.ui.theme.fg('dim', statusText));
+
+  if (!widgetEnabled) {
+    ctx.ui.setWidget('router', undefined);
+    return;
+  }
+
+  const widgetLines = [
+    `Router: ${routerEnabled ? 'enabled' : 'disabled'}`,
+    `Profile: ${statusProfile}${activeRouterProfile ? ' (active)' : ''}`,
+    `Pin: ${activePin ?? 'auto'}`,
+    `Cost: $${accumulatedCost.toFixed(4)}` +
+      (currentConfig.maxSessionBudget
+        ? ` / $${currentConfig.maxSessionBudget.toFixed(2)}`
+        : ''),
+  ];
+  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})`,
+      `Phase: ${lastDecision.phase}`,
+    );
+  } else if (!routerEnabled && lastNonRouterModel) {
+    widgetLines.push(`Fallback: ${lastNonRouterModel}`);
+  }
+  if (Object.keys(pinnedTierByProfile).length > 1) {
+    widgetLines.push(`Pins: ${formatPinSummary(pinnedTierByProfile)}`);
+  }
+  ctx.ui.setWidget(
+    'router',
+    widgetLines.map((line) => ctx.ui.theme.fg('dim', line)),
+  );
+};

package/model-router.agent-bus.json

@@ -0,0 +1,15 @@
+{
+  "comment": "Progressive Step 2: Router with ledger + agent-bus integration. Enables agent coordination for model selection.",
+  "features": {
+    "ollamaSync": true,
+    "rateLimitFallback": true,
+    "scopeShim": true,
+    "perTurnRouting": true,
+    "intentClassifier": false,
+    "costBudgeting": true,
+    "phaseMemory": true,
+    "contextCompression": true,
+    "ledgerIntegration": true,
+    "agentBusIntegration": true
+  }
+}

package/model-router.essential.json

@@ -0,0 +1,31 @@
+{
+  "comment": "Progressive Step 3: Essential config — all integrations enabled. Maximum interoperability with the Pi package ecosystem.",
+  "features": {
+    "ollamaSync": true,
+    "rateLimitFallback": true,
+    "scopeShim": true,
+    "perTurnRouting": true,
+    "intentClassifier": false,
+    "costBudgeting": true,
+    "phaseMemory": true,
+    "contextCompression": true,
+    "ledgerIntegration": true,
+    "agentBusIntegration": true
+  },
+  "ollamaSync": {
+    "enabled": true,
+    "onStartup": true,
+    "onReload": true
+  },
+  "rateLimitFallback": {
+    "enabled": true,
+    "shortDelayThreshold": 60,
+    "autoFallback": false,
+    "autoRestore": false,
+    "fallbackSequence": ["anthropic/claude-3-haiku-20240307", "ollama/*"]
+  },
+  "rules": [
+    { "matches": "ledger", "tier": "low", "reason": "Ledger operations are lightweight" },
+    { "matches": "agent-bus", "tier": "medium", "reason": "Agent coordination needs reliability" }
+  ]
+}

package/model-router.example.json

@@ -0,0 +1,70 @@
+{
+  "features": {
+    "ollamaSync": true,
+    "rateLimitFallback": true,
+    "scopeShim": true,
+    "perTurnRouting": true,
+    "intentClassifier": false,
+    "costBudgeting": true,
+    "phaseMemory": true,
+    "contextCompression": true
+  },
+  "ollamaSync": {
+    "enabled": true,
+    "onStartup": true,
+    "onReload": true
+  },
+  "rateLimitFallback": {
+    "enabled": true,
+    "shortDelayThreshold": 60,
+    "autoFallback": false,
+    "autoRestore": false,
+    "fallbackSequence": ["anthropic/claude-3-haiku-20240307", "ollama/*"]
+  },
+  "defaultProfile": "auto",
+  "debug": false,
+  "classifierModel": "google/gemini-flash-latest",
+  "phaseBias": 0.5,
+  "maxSessionBudget": 1.0,
+  "largeContextThreshold": 100000,
+  "rules": [
+    {
+      "matches": ["deploy", "production", "release"],
+      "tier": "high",
+      "reason": "Safety check for production tasks"
+    },
+    { "matches": "changelog", "tier": "low" }
+  ],
+  "profiles": {
+    "auto": {
+      "high": {
+        "model": "openai/gpt-5.4-pro",
+        "thinking": "high",
+        "fallbacks": ["anthropic/claude-3-5-sonnet-20241022"]
+      },
+      "medium": { "model": "google/gemini-flash-latest", "thinking": "medium" },
+      "low": { "model": "openai/gpt-5.4-nano", "thinking": "low" }
+    },
+    "cheap": {
+      "high": { "model": "google/gemini-flash-latest", "thinking": "low" },
+      "medium": { "model": "openai/gpt-5.4-nano", "thinking": "off" },
+      "low": { "model": "google/gemini-flash-lite-latest", "thinking": "off" }
+    },
+    "deep": {
+      "high": { "model": "openai/o1-preview", "thinking": "xhigh" },
+      "medium": { "model": "openai/gpt-5.4-pro", "thinking": "medium" },
+      "low": { "model": "google/gemini-flash-latest", "thinking": "low" }
+    },
+    "anthropic": {
+      "high": {
+        "model": "anthropic/claude-3-5-sonnet-20241022",
+        "thinking": "high"
+      },
+      "medium": {
+        "model": "anthropic/claude-3-5-sonnet-20241022",
+        "thinking": "medium"
+      },
+      "low": { "model": "anthropic/claude-3-haiku-20240307", "thinking": "low" }
+    }
+  }
+}

package/model-router.ledger.json

@@ -0,0 +1,15 @@
+{
+  "comment": "Progressive Step 1: Basic router with qmd-ledger integration. Enables logging routing decisions to ledger.",
+  "features": {
+    "ollamaSync": true,
+    "rateLimitFallback": true,
+    "scopeShim": true,
+    "perTurnRouting": true,
+    "intentClassifier": false,
+    "costBudgeting": true,
+    "phaseMemory": true,
+    "contextCompression": true,
+    "ledgerIntegration": true,
+    "agentBusIntegration": false
+  }
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "@kylebrodeur/pi-model-router",
+  "version": "0.1.2",
+  "type": "module",
+  "description": "Intelligent per-turn model router extension for the pi coding agent (Enhanced Fork)",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "model-router",
+    "llm",
+    "coding-agent",
+    "extension"
+  ],
+  "license": "MIT",
+  "author": "Kyle Brodeur <kylebrodeur@example.com> (https://github.com/kylebrodeur)",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kylebrodeur/pi-model-router.git"
+  },
+  "homepage": "https://github.com/kylebrodeur/pi-model-router#readme",
+  "bugs": {
+    "url": "https://github.com/kylebrodeur/pi-model-router/issues"
+  },
+  "files": [
+    "extensions/",
+    "docs/",
+    "model-router.example.json",
+    "model-router.ledger.json",
+    "model-router.agent-bus.json",
+    "model-router.essential.json",
+    "LICENSE",
+    "README.md",
+    "CHANGELOG.md",
+    "LEARNINGS.md",
+    "QUICKSTART.md",
+    "TESTING.md",
+    "CONTRIBUTING.md"
+  ],
+  "exports": {
+    ".": "./extensions/index.ts"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions/index.ts"
+    ]
+  },
+  "scripts": {
+    "tsc": "tsc --noEmit",
+    "build": "tsc",
+    "prepublishOnly": "npm run tsc"
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-agent-core": "*",
+    "@mariozechner/pi-ai": "*",
+    "@mariozechner/pi-coding-agent": ">=0.70.2",
+    "@mariozechner/pi-tui": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@mariozechner/pi-coding-agent": "^0.70.2",
+    "prettier": "^3.8.1",
+    "typescript": "^6.0.2"
+  }
+}