muonroi-cli 1.4.0 → 1.5.0

package/src/council/leader.ts

@@ -1,281 +0,0 @@
-import { getModelByTier, getModelInfo, getModelsForProvider } from "../models/registry.js";
-import { loadKeyForProvider } from "../providers/keychain.js";
-import { detectProviderForModel } from "../providers/runtime.js";
-import type { ProviderId } from "../providers/types.js";
-import { getRoleModel, getRoleModels, isProviderDisabled, type ModelRole } from "../utils/settings.js";
-
-const TIER_RANK: Record<string, number> = { fast: 1, balanced: 2, premium: 3 };
-
-function tierOf(modelId: string): "fast" | "balanced" | "premium" | undefined {
-  const info = getModelInfo(modelId);
-  return info?.tier;
-}
-
-// ─── Cost-aware sub-task routing ────────────────────────────────────────────
-
-/**
- * Council sub-tasks that can be downshifted to a cheaper tier.
- * Maps each task to the LOWEST tier acceptable for that work; the resolver
- * picks the highest-quality reachable model that is still ≤ this tier.
- *
- * Keep this table in one place — it's the policy. Anything not listed here
- * MUST keep using the leader model (final synthesis, debate planning).
- */
-export type CouncilSubTask =
-  | "research_need" // 1-line JSON classifier
-  | "evaluate_round" // JSON criteria status; needs decent judgement
-  | "round_summary" // summarize 6 exchanges
-  | "clarify_questions" // generate 3-5 questions
-  | "spec_synthesis" // merge Q&A into ClarifiedSpec
-  | "readiness_judge" // self-judge whether clarification is sufficient to debate
-  | "effort_estimate" // batch story-point estimation for BacklogItems (P6)
-  | "sprint_goal" // batch sprint goal generation for SprintPlan (P7)
-  | "reporter_qa" // free-form Q&A from Discord reporter (P8)
-  | "maintain_design" // P15 Mode C — single LLM design plan for maintenance task
-  | "maintain_review" // P15 Mode C — single LLM review agent after edit
-  | "pr_body"; // P16 Mode C — generate PR body from diff + task context (fast tier)
-
-const SUB_TASK_TIER: Record<CouncilSubTask, "fast" | "balanced"> = {
-  research_need: "fast",
-  evaluate_round: "balanced",
-  round_summary: "fast",
-  clarify_questions: "balanced",
-  spec_synthesis: "balanced",
-  readiness_judge: "balanced",
-  effort_estimate: "fast",
-  sprint_goal: "fast",
-  reporter_qa: "fast",
-  maintain_design: "balanced",
-  maintain_review: "fast",
-  pr_body: "fast",
-};
-
-/**
- * Pick a cheaper model for a council sub-task on the leader's provider,
- * with fallback to the leader model itself when no cheaper model is
- * reachable / cataloged.
- *
- * Hard rule (matches resolveLeaderModelDetailed): never cross providers.
- * The leader's provider already has a key loaded, so this is zero-cost
- * to reach.
- *
- * Returns the leader model unchanged when:
- *   - cost-aware mode is disabled
- *   - leader is already at or below the target tier
- *   - no cataloged model on the leader's provider matches the target tier
- */
-export function pickCouncilTaskModel(task: CouncilSubTask, leaderModelId: string, costAware: boolean): string {
-  if (!costAware) return leaderModelId;
-
-  const targetTier = SUB_TASK_TIER[task];
-  const leaderTier = tierOf(leaderModelId);
-
-  // Already at or below target — no benefit from switching.
-  if (leaderTier && TIER_RANK[leaderTier] <= TIER_RANK[targetTier]) {
-    return leaderModelId;
-  }
-
-  let leaderProvider: string;
-  try {
-    leaderProvider = detectProviderForModel(leaderModelId);
-  } catch {
-    return leaderModelId;
-  }
-  const candidate = getModelByTier(targetTier, leaderProvider);
-
-  // Only accept a candidate that's on the same provider as the leader.
-  // getModelByTier may fall back to "any provider" — reject that to avoid
-  // billing surprises and silent key-misses.
-  if (candidate && candidate.provider === leaderProvider) {
-    return candidate.id;
-  }
-  return leaderModelId;
-}
-
-export interface LeaderResolution {
-  modelId: string;
-  /** Set when configured leader was auto-promoted to a higher tier. */
-  promotedFrom?: { modelId: string; tier?: string };
-  /** Set when no configured leader existed and one was picked by tier. */
-  defaulted?: boolean;
-}
-
-/**
- * Resolve the leader model with quality-aware promotion.
- *
- * Hard rule: stay within the SESSION model's provider — don't switch providers
- * (different billing, surprise cost). We only upgrade tier within the same
- * provider that the user is already running.
- *
- * Priority:
- *   1. Find the highest-tier reachable model from the session provider's
- *      catalog (registry + any configured role-models on that provider).
- *   2. If a configured `roleModels.leader` exists AND is on the session
- *      provider, use it unless a strictly higher-tier model exists on the
- *      same provider — then auto-promote with a note.
- *   3. If configured leader is on a DIFFERENT provider, ignore it and pick
- *      from the session provider.
- *   4. Fall back to the session model itself.
- */
-export async function resolveLeaderModelDetailed(sessionModelId: string): Promise<LeaderResolution> {
-  const sessionProviderId = detectProviderForModel(sessionModelId);
-  const configured = getRoleModel("leader");
-  const configuredProvider = configured ? detectProviderForModel(configured) : undefined;
-  const configuredTier = configured ? tierOf(configured) : undefined;
-
-  const sessionDisabled = isProviderDisabled(sessionProviderId as ProviderId);
-  const sessionReachable =
-    !sessionDisabled &&
-    (await loadKeyForProvider(sessionProviderId)
-      .then(() => true)
-      .catch(() => false));
-  if (!sessionReachable) {
-    return { modelId: configured ?? sessionModelId };
-  }
-
-  // Build candidate set ON THE SESSION PROVIDER ONLY.
-  const candidates = new Map<string, "fast" | "balanced" | "premium">();
-  for (const m of getModelsForProvider(sessionProviderId)) {
-    if (m.tier) candidates.set(m.id, m.tier);
-  }
-  // Include any configured role-models that happen to be on session provider.
-  for (const id of Object.values(getRoleModels())) {
-    if (!id) continue;
-    if (detectProviderForModel(id) !== sessionProviderId) continue;
-    const t = tierOf(id);
-    if (t) candidates.set(id, t);
-  }
-  const sessionTier = tierOf(sessionModelId);
-  if (sessionTier) candidates.set(sessionModelId, sessionTier);
-
-  let best: { id: string; tier: "fast" | "balanced" | "premium" } | undefined;
-  for (const [id, tier] of candidates) {
-    if (!best || TIER_RANK[tier] > TIER_RANK[best.tier]) {
-      best = { id, tier };
-    }
-  }
-
-  // Configured leader on the same provider → respect it unless we can promote.
-  if (configured && configuredProvider === sessionProviderId) {
-    if (!best || !configuredTier || TIER_RANK[best.tier] <= TIER_RANK[configuredTier]) {
-      return { modelId: configured };
-    }
-    return {
-      modelId: best.id,
-      promotedFrom: { modelId: configured, tier: configuredTier },
-    };
-  }
-
-  // Configured leader on different provider — ignore and pick from session provider.
-  if (configured && configuredProvider !== sessionProviderId && best) {
-    return {
-      modelId: best.id,
-      promotedFrom: { modelId: configured, tier: configuredTier },
-    };
-  }
-
-  // No usable configured leader — use the session model itself. We intentionally
-  // do NOT silently promote to the highest-tier model on the provider: the
-  // user's account/key may not have access to that tier (e.g. SiliconFlow Pro),
-  // which would cause 401s on every leader call. Tier-upgrade is a deliberate
-  // choice — opt in by setting roleModels.leader in config.
-  return { modelId: sessionModelId, defaulted: true };
-}
-
-/** Back-compat sync wrapper. Returns the modelId only; no reachability check. */
-export function resolveLeaderModel(sessionModelId: string): string {
-  const configured = getRoleModel("leader");
-  if (configured) return configured;
-  // See resolveLeaderModelDetailed for why we no longer silently upgrade to
-  // the premium tier on the session provider (user may not have access).
-  return sessionModelId;
-}
-
-export function hasMultiProviderConfig(roleModels: Partial<Record<ModelRole, string>>): boolean {
-  const providers = new Set<string>();
-  for (const modelId of Object.values(roleModels)) {
-    if (modelId) providers.add(detectProviderForModel(modelId));
-  }
-  return providers.size >= 2;
-}
-
-export async function resolveParticipants(
-  sessionModelId: string,
-  preferMultiProvider: boolean,
-): Promise<Array<{ role: ModelRole; model: string }>> {
-  const ALL_ROLES: ModelRole[] = ["implement", "verify", "research"];
-  const candidates: Array<{ role: ModelRole; model: string }> = [];
-  const configuredRoleModels = getRoleModels();
-  const hasExplicit = hasMultiProviderConfig(configuredRoleModels);
-
-  if (hasExplicit && preferMultiProvider) {
-    for (const role of ALL_ROLES) {
-      const modelId = getRoleModel(role);
-      if (!modelId) continue;
-      const provider = detectProviderForModel(modelId);
-      if (isProviderDisabled(provider as ProviderId)) continue;
-      const canReach = await loadKeyForProvider(provider)
-        .then(() => true)
-        .catch(() => false);
-      if (canReach) candidates.push({ role, model: modelId });
-    }
-    if (candidates.length >= 2) return candidates;
-  }
-
-  const mainProviderId = detectProviderForModel(sessionModelId);
-  // Skip same-provider resolution if the provider is disabled
-  if (!isProviderDisabled(mainProviderId as ProviderId)) {
-    const sameCandidates = await resolveSameProviderCandidates(mainProviderId, sessionModelId, ALL_ROLES);
-    if (sameCandidates.length >= 2) return sameCandidates;
-  }
-
-  const providerDisabled = isProviderDisabled(detectProviderForModel(sessionModelId) as ProviderId);
-  const canReach =
-    !providerDisabled &&
-    (await loadKeyForProvider(detectProviderForModel(sessionModelId))
-      .then(() => true)
-      .catch(() => false));
-  if (canReach) {
-    return ALL_ROLES.map((role) => ({ role, model: sessionModelId }));
-  }
-
-  return [];
-}
-
-async function resolveSameProviderCandidates(
-  providerId: ProviderId,
-  sessionModelId: string,
-  roles: ModelRole[],
-): Promise<Array<{ role: ModelRole; model: string }>> {
-  if (isProviderDisabled(providerId)) return [];
-  const canReach = await loadKeyForProvider(providerId)
-    .then(() => true)
-    .catch(() => false);
-  if (!canReach) return [];
-
-  const providerModels = getModelsForProvider(providerId);
-  if (providerModels.length === 0) {
-    return roles.map((role) => ({ role, model: sessionModelId }));
-  }
-
-  const tierPreference: Record<string, Array<"fast" | "balanced" | "premium">> = {
-    implement: ["balanced", "premium", "fast"],
-    verify: ["premium", "balanced", "fast"],
-    research: ["fast", "balanced", "premium"],
-  };
-
-  const usedModels = new Set<string>();
-  const candidates: Array<{ role: ModelRole; model: string }> = [];
-
-  for (const role of roles) {
-    const prefs = tierPreference[role] ?? ["balanced", "fast", "premium"];
-    let picked = providerModels.find((m) => prefs.some((t) => m.tier === t) && !usedModels.has(m.id));
-    if (!picked) picked = providerModels.find((m) => !usedModels.has(m.id));
-    if (!picked) picked = providerModels[0];
-
-    candidates.push({ role, model: picked.id });
-    usedModels.add(picked.id);
-  }
-
-  return candidates;
-}