ultimate-pi 0.18.1 → 0.19.0

package/vendor/pi-model-router/extensions/routing.ts

@@ -1,564 +0,0 @@
-import { streamSimple, type Context, type Message } from '@earendil-works/pi-ai';
-import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
-import type {
-  RouterTier,
-  RouterPhase,
-  RouterProfile,
-  RoutingDecision,
-  RoutingRule,
-  RouterThinkingByTier,
-  SessionLock,
-} from './types.js';
-import { parseCanonicalModelRef, isRouterTier } from './config.js';
-
-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--) {
-    const message = context.messages[i];
-    if (message.role === 'user') {
-      return extractTextFromContent(message.content).trim();
-    }
-  }
-  return '';
-};
-
-export const getFirstUserText = (context: Context): string => {
-  for (const message of context.messages) {
-    if (message.role === 'user') {
-      return extractTextFromContent(message.content).trim();
-    }
-  }
-  return '';
-};
-
-/** Context for one-shot session model lock: system prompt + first user message only. */
-export const buildSessionLockContext = (context: Context): Context => {
-  const firstUser = context.messages.find((message) => message.role === 'user');
-  const messages = firstUser ? [firstUser] : context.messages.slice(0, 1);
-  return { ...context, messages };
-};
-
-export const sessionLockToRoutingDecision = (
-  lock: SessionLock,
-  profile: RouterProfile,
-  thinkingOverrides?: RouterThinkingByTier,
-): RoutingDecision => {
-  const routed = profile[lock.tier];
-  const { provider, modelId } = parseCanonicalModelRef(lock.modelRef);
-  const baseThinking =
-    routed.thinking ??
-    (lock.tier === 'high' ? 'high' : lock.tier === 'low' ? 'low' : 'medium');
-  const effectiveThinking = thinkingOverrides?.[lock.tier] ?? baseThinking;
-  return {
-    profile: lock.profile,
-    tier: lock.tier,
-    phase: phaseForTier(lock.tier),
-    targetProvider: provider,
-    targetModelId: modelId,
-    targetLabel: lock.modelRef,
-    reasoning: lock.reasoning,
-    thinking: effectiveThinking,
-    timestamp: Date.now(),
-  };
-};
-
-export const routingDecisionToSessionLock = (
-  decision: RoutingDecision,
-): SessionLock => ({
-  profile: decision.profile,
-  tier: decision.tier,
-  modelRef: decision.targetLabel,
-  reasoning: decision.reasoning,
-});
-
-/** Text used to score initial session complexity (system prompt + first user message). */
-export const getSessionLockAnalysisText = (context: Context): string => {
-  const lockContext = buildSessionLockContext(context);
-  const system = (context.systemPrompt ?? '').trim();
-  const firstUser = getFirstUserText(lockContext);
-  if (system && firstUser) return `${system}\n\n${firstUser}`;
-  return system || firstUser || '';
-};
-
-/**
- * One-shot tier pick for session model lock (no prior-turn stickiness).
- */
-export const decideSessionLock = (
-  context: Context,
-  profileName: string,
-  profile: RouterProfile,
-  pinnedTier?: RouterTier,
-  thinkingOverrides?: RouterThinkingByTier,
-  phaseBias = 0.5,
-  rules?: RoutingRule[],
-): RoutingDecision => {
-  const analysisText = getSessionLockAnalysisText(context);
-  const synthetic: Context = {
-    systemPrompt: context.systemPrompt,
-    messages: analysisText
-      ? [{ role: 'user', content: analysisText, timestamp: Date.now() }]
-      : [],
-  };
-  return decideRouting(
-    synthetic,
-    profileName,
-    profile,
-    undefined,
-    pinnedTier,
-    thinkingOverrides,
-    phaseBias,
-    rules,
-    false,
-  );
-};
-
-/** Per-turn thinking tier merged onto a session-locked model decision. */
-export const applyThinkingToDecision = (
-  locked: RoutingDecision,
-  thinkingDecision: RoutingDecision,
-  profile: RouterProfile,
-  thinkingOverrides?: RouterThinkingByTier,
-): RoutingDecision => {
-  const tier = thinkingDecision.tier;
-  const routed = profile[tier];
-  const baseThinking =
-    routed.thinking ??
-    (tier === 'high' ? 'high' : tier === 'low' ? 'low' : 'medium');
-  const effectiveThinking = thinkingOverrides?.[tier] ?? baseThinking;
-
-  return {
-    profile: locked.profile,
-    tier,
-    phase: thinkingDecision.phase,
-    targetProvider: locked.targetProvider,
-    targetModelId: locked.targetModelId,
-    targetLabel: locked.targetLabel,
-    reasoning: `${locked.reasoning} | Thinking: ${thinkingDecision.reasoning}`,
-    thinking: effectiveThinking,
-    timestamp: Date.now(),
-    isClassifier: thinkingDecision.isClassifier,
-    isRuleMatched: thinkingDecision.isRuleMatched,
-    isBudgetForced: thinkingDecision.isBudgetForced,
-    isContextTriggered: thinkingDecision.isContextTriggered,
-  };
-};
-
-/** Harness subagents: tier from system prompt + optional first user line. */
-export const resolveTierFromPrompt = (
-  systemPrompt: string,
-  userText: string,
-  profileName: string,
-  profile: RouterProfile,
-  rules?: RoutingRule[],
-  phaseBias = 0.5,
-): RouterTier => {
-  const context: Context = {
-    systemPrompt,
-    messages: userText
-      ? [{ role: 'user', content: userText, timestamp: Date.now() }]
-      : [],
-  };
-  return decideSessionLock(
-    context,
-    profileName,
-    profile,
-    undefined,
-    undefined,
-    phaseBias,
-    rules,
-  ).tier;
-};
-
-export const getRecentConversationText = (
-  context: Context,
-  limit = 6,
-): string => {
-  return context.messages
-    .slice(-limit)
-    .map((message) => extractTextFromContent(message.content).trim())
-    .filter(Boolean)
-    .join('\n')
-    .toLowerCase();
-};
-
-export const countToolResults = (context: Context): number => {
-  return context.messages.filter((message) => message.role === 'toolResult')
-    .length;
-};
-
-export const countWords = (text: string): number => {
-  return text.split(/\s+/).filter(Boolean).length;
-};
-
-export const hasImageAttachment = (context: Context): boolean => {
-  return context.messages.some(
-    (message) =>
-      Array.isArray(message.content) &&
-      message.content.some((part) => part.type === 'image'),
-  );
-};
-
-export const containsAny = (text: string, keywords: string[]): boolean => {
-  return keywords.some((keyword) => text.includes(keyword));
-};
-
-export const phaseForTier = (tier: RouterTier): RouterPhase => {
-  if (tier === 'high') return 'planning';
-  if (tier === 'medium') return 'implementation';
-  return 'lightweight';
-};
-
-export const buildRoutingDecision = (
-  profileName: string,
-  profile: RouterProfile,
-  tier: RouterTier,
-  phase: RouterPhase,
-  reasoning: string,
-  thinkingOverrides?: RouterThinkingByTier,
-  isClassifier?: boolean,
-): RoutingDecision => {
-  const routed = profile[tier];
-  const { provider, modelId } = parseCanonicalModelRef(routed.model);
-  const baseThinking =
-    routed.thinking ??
-    (tier === 'high' ? 'high' : tier === 'low' ? 'low' : 'medium');
-  const effectiveThinking = thinkingOverrides?.[tier] ?? baseThinking;
-
-  return {
-    profile: profileName,
-    tier,
-    phase,
-    targetProvider: provider,
-    targetModelId: modelId,
-    targetLabel: routed.model,
-    reasoning,
-    thinking: effectiveThinking,
-    timestamp: Date.now(),
-    isClassifier,
-  };
-};
-
-export const decideRouting = (
-  context: Context,
-  profileName: string,
-  profile: RouterProfile,
-  previousDecision: RoutingDecision | undefined,
-  pinnedTier?: RouterTier,
-  thinkingOverrides?: RouterThinkingByTier,
-  phaseBias = 0.5,
-  rules?: RoutingRule[],
-  isBudgetExceeded = false,
-): RoutingDecision => {
-  const prompt = getLastUserText(context).toLowerCase();
-  const recentConversation = getRecentConversationText(context);
-  const toolResultCount = countToolResults(context);
-  const wordCount = countWords(prompt);
-  const multiLinePrompt = prompt.split('\n').length >= 4;
-
-  const explicitHighHints = [
-    'best',
-    'deep',
-    'deeply',
-    'carefully',
-    'thoroughly',
-    'robust',
-    'comprehensive',
-    'step by step',
-    'think hard',
-    'highest quality',
-  ];
-  const explicitLowHints = [
-    'fast',
-    'cheap',
-    'quick',
-    'quickly',
-    'brief',
-    'briefly',
-    'one sentence',
-    'one line',
-    'tiny',
-    'small',
-  ];
-  const planningKeywords = [
-    'plan',
-    'planning',
-    'architecture',
-    'architect',
-    'design',
-    'tradeoff',
-    'trade-off',
-    'research',
-    'investigate',
-    'root cause',
-    'analyze',
-    'analysis',
-    'migration',
-    'strategy',
-    'compare',
-    'options',
-    'approach',
-  ];
-  const summaryKeywords = [
-    'summarize',
-    'summary',
-    'changelog',
-    'rewrite',
-    'reformat',
-    'format',
-    'rename',
-    'explain briefly',
-    'recap',
-    'tl;dr',
-  ];
-  const implementationKeywords = [
-    'implement',
-    'code',
-    'fix',
-    'update',
-    'edit',
-    'write',
-    'refactor',
-    'add tests',
-    'patch',
-    'change',
-    'apply',
-    'continue',
-    'resume',
-    'make the changes',
-    'go ahead',
-  ];
-  const lookupKeywords = [
-    'where is',
-    'which file',
-    'show me',
-    'list',
-    'what files',
-    'find',
-    'grep',
-  ];
-
-  let phase: RouterPhase = previousDecision?.phase ?? 'implementation';
-  let tier: RouterTier = 'medium';
-  let reasoning = 'Defaulted to medium tier for general coding work.';
-  let isRuleMatched = false;
-
-  if (pinnedTier) {
-    phase = phaseForTier(pinnedTier);
-    tier = pinnedTier;
-    reasoning = `Pinned to ${pinnedTier} tier via /router-pin.`;
-  } else {
-    // Check custom rules first
-    if (rules) {
-      for (const rule of rules) {
-        const matches = Array.isArray(rule.matches)
-          ? rule.matches
-          : [rule.matches];
-        if (containsAny(prompt, matches)) {
-          tier = rule.tier;
-          phase = phaseForTier(tier);
-          reasoning =
-            rule.reason ??
-            `Matched custom routing rule for: ${matches.join(', ')}`;
-          isRuleMatched = true;
-          break;
-        }
-      }
-    }
-
-    if (!isRuleMatched) {
-      // Sticky phase adjustments
-      const highThreshold = Math.max(
-        40,
-        120 - (previousDecision?.phase === 'planning' ? phaseBias * 80 : 0),
-      );
-      const lowThreshold = Math.max(
-        4,
-        12 -
-          (previousDecision?.phase === 'implementation' ||
-          previousDecision?.phase === 'planning'
-            ? phaseBias * 8
-            : 0),
-      );
-
-      if (containsAny(prompt, explicitHighHints)) {
-        phase = 'planning';
-        tier = 'high';
-        reasoning =
-          'Detected an explicit request for deeper or higher-quality reasoning.';
-      } else if (containsAny(prompt, explicitLowHints)) {
-        phase = 'lightweight';
-        tier = 'low';
-        reasoning =
-          'Detected an explicit request for a faster or lighter response.';
-      } else if (containsAny(prompt, summaryKeywords)) {
-        phase = 'lightweight';
-        tier = 'low';
-        reasoning = 'Detected summary or lightweight transformation keywords.';
-      } else if (
-        containsAny(prompt, planningKeywords) ||
-        prompt.startsWith('why ') ||
-        wordCount >= highThreshold ||
-        multiLinePrompt
-      ) {
-        phase = 'planning';
-        tier = 'high';
-        reasoning =
-          previousDecision?.phase === 'planning'
-            ? 'Continued planning phase based on complexity or keywords.'
-            : 'Detected planning, broad analysis, or a high-complexity request.';
-      } else if (containsAny(prompt, implementationKeywords)) {
-        phase = 'implementation';
-        tier = 'medium';
-        reasoning =
-          'Detected implementation-oriented work with bounded execution scope.';
-      } else if (
-        containsAny(prompt, lookupKeywords) &&
-        wordCount <= 24 &&
-        toolResultCount === 0
-      ) {
-        phase = 'lightweight';
-        tier = 'low';
-        reasoning = 'Detected a short read-only lookup request.';
-      } else if (
-        previousDecision?.phase === 'planning' &&
-        toolResultCount === 0 &&
-        wordCount > lowThreshold
-      ) {
-        phase = 'planning';
-        tier = 'high';
-        reasoning =
-          'Kept the planning-phase bias because the conversation still looks exploratory.';
-      } else if (
-        toolResultCount > 0 ||
-        previousDecision?.phase === 'implementation' ||
-        recentConversation.includes('plan:')
-      ) {
-        phase = 'implementation';
-        tier = 'medium';
-        reasoning =
-          'Detected active implementation work from prior tools or recent plan execution context.';
-      } else if (wordCount <= lowThreshold) {
-        phase = 'lightweight';
-        tier = 'low';
-        reasoning = 'Detected a short bounded request.';
-      }
-    }
-  }
-
-  let isBudgetForced = false;
-  if (isBudgetExceeded && tier === 'high') {
-    tier = 'medium';
-    phase = 'implementation';
-    reasoning = `Budget exceeded. Downgraded from high to medium tier. (Original: ${reasoning})`;
-    isBudgetForced = true;
-  }
-
-  const decision = buildRoutingDecision(
-    profileName,
-    profile,
-    tier,
-    phase,
-    reasoning,
-    thinkingOverrides,
-    false,
-  );
-  decision.isRuleMatched = isRuleMatched;
-  decision.isBudgetForced = isBudgetForced;
-  return decision;
-};
-
-export const runClassifier = async (
-  classifierModelRef: string,
-  modelRegistry: ExtensionContext['modelRegistry'],
-  context: Context,
-  currentPhase?: RouterPhase,
-): Promise<{ tier: RouterTier; reasoning: string } | undefined> => {
-  try {
-    const { provider, modelId } = parseCanonicalModelRef(classifierModelRef);
-    const model = modelRegistry.find(provider, modelId);
-    if (!model) return undefined;
-
-    const auth = await modelRegistry.getApiKeyAndHeaders(model);
-    if (!auth.ok || !auth.apiKey) return undefined;
-    const apiKey = auth.apiKey;
-    const headers = auth.headers;
-
-    const promptText = getLastUserText(context);
-    const historyText = getRecentConversationText(context, 4);
-
-    const classifierPrompt = `You are a model router classifier. Your job is to categorize the user's latest request into one of three tiers: "high", "medium", or "low".
-
-Tiers:
-- high: Architecture, design, planning, tradeoff analysis, broad debugging, large refactors, codebase research.
-- medium: Implementation of a known plan, multi-file edits, normal coding work, focused debugging, tests/fixes.
-- low: Summaries, changelogs, formatting, quick explanations, small bounded transforms, simple read-only lookup.
-
-${currentPhase ? `Current conversation phase: ${currentPhase}\n` : ''}
-Recent history:
-${historyText}
-
-Latest user message:
-${promptText}
-
-Return your decision in exactly two lines:
-Tier: [high|medium|low]
-Reasoning: [one short sentence]
-
-${currentPhase === 'planning' ? 'Consider that the conversation is currently in a planning phase. Bias toward "high" unless the request is clearly a simple implementation or summary.' : ''}
-${currentPhase === 'implementation' ? 'Consider that the conversation is currently in an implementation phase. Bias toward "medium" unless the request is clearly planning or a simple summary.' : ''}`;
-
-    const classifierContext: Context = {
-      ...context,
-      messages: [{ role: 'user', content: classifierPrompt, timestamp: Date.now() }],
-    };
-
-    const stream = streamSimple(model, classifierContext, { apiKey, headers });
-    let fullText = '';
-    for await (const event of stream) {
-      if (
-        event.type === 'text_delta' &&
-        typeof (event as any).delta === 'string'
-      ) {
-        fullText += (event as any).delta;
-      }
-    }
-
-    const lines = fullText.trim().split('\n');
-    const tierLine = lines.find((l) => l.toLowerCase().startsWith('tier:'));
-    const reasoningLine = lines.find((l) =>
-      l.toLowerCase().startsWith('reasoning:'),
-    );
-
-    if (tierLine) {
-      const tierValue = tierLine.split(':')[1].trim().toLowerCase();
-      if (isRouterTier(tierValue)) {
-        return {
-          tier: tierValue,
-          reasoning: reasoningLine
-            ? reasoningLine.split(':')[1].trim()
-            : 'Classifier decision.',
-        };
-      }
-    }
-  } catch (error) {
-    // Ignore classifier errors and fall back to heuristics
-  }
-  return undefined;
-};

package/vendor/pi-model-router/extensions/state.ts

@@ -1,52 +0,0 @@
-import type {
-  RouterPinByProfile,
-  RouterThinkingByProfile,
-  RoutingDecision,
-  RouterPersistedState,
-  SessionLock,
-} from './types.js';
-
-export const isRouterPersistedState = (
-  value: unknown,
-): value is RouterPersistedState => {
-  if (typeof value !== 'object' || value === null) {
-    return false;
-  }
-  const v = value as any;
-  return (
-    typeof v.enabled === 'boolean' &&
-    typeof v.selectedProfile === 'string' &&
-    typeof v.timestamp === 'number'
-  );
-};
-
-export const buildPersistedState = (
-  routerEnabled: boolean,
-  selectedProfile: string,
-  pinnedTierByProfile: RouterPinByProfile,
-  thinkingByProfile: RouterThinkingByProfile,
-  debugEnabled: boolean,
-  widgetEnabled: boolean,
-  debugHistory: RoutingDecision[],
-  lastDecision: RoutingDecision | undefined,
-  lastNonRouterModel: string | undefined,
-  accumulatedCost: number,
-  sessionLock: SessionLock | undefined,
-): RouterPersistedState => {
-  return {
-    enabled: routerEnabled,
-    selectedProfile,
-    pinTier: pinnedTierByProfile[selectedProfile],
-    pinByProfile: { ...pinnedTierByProfile },
-    thinkingByProfile: { ...thinkingByProfile },
-    sessionLock,
-    debugEnabled,
-    widgetEnabled,
-    debugHistory,
-    lastPhase: lastDecision?.phase,
-    lastDecision,
-    lastNonRouterModel,
-    accumulatedCost,
-    timestamp: Date.now(),
-  };
-};

package/vendor/pi-model-router/extensions/types.ts

@@ -1,95 +0,0 @@
-import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
-
-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>;
-}
-
-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;
-}
-
-/** Fixed model for a router profile for the lifetime of a session (or until profile switch). */
-export interface SessionLock {
-  profile: string;
-  tier: RouterTier;
-  modelRef: string;
-  reasoning: string;
-}
-
-export interface RouterPersistedState {
-  enabled: boolean;
-  selectedProfile: string;
-  pinTier?: RouterTier;
-  pinByProfile?: RouterPinByProfile;
-  thinkingByProfile?: RouterThinkingByProfile;
-  sessionLock?: SessionLock;
-  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;
-}