@wrongstack/core 0.109.1 → 0.141.0

package/dist/models/index.d.ts

@@ -1,60 +1,164 @@
-export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-DU64QxQa.js';
-import { M as ModeStore, b as ModeConfig, a as Mode } from '../mode-ARA3HrkY.js';
-import { P as Provider, M as Message } from '../context-CNRYfhUv.js';
-import { M as MessageSelector, S as SelectorResult } from '../selector-C7wcdqMA.js';
-import '../models-registry-B6_KfS65.js';
+export { D as DefaultModelsRegistry, a as DefaultModelsRegistryOptions, c as classifyFamily } from '../models-registry-D90K9UnM.js';
+export { D as DefaultModeStore, L as LLMSelector, a as LLMSelectorOptions, M as ModeLoaderOptions, l as loadProjectModes, b as loadUserModes } from '../llm-selector-CP72f1lC.js';
+import { d as ModelMatrixEntry, P as ProviderConfig } from '../config-BaVThgnT.js';
+import '../mode-CZlO9iU1.js';
+import '../context-C7G_MtLV.js';
+import '../selector-4vDFZKt3.js';
 
-declare class DefaultModeStore implements ModeStore {
-    private activeModeId;
-    private modes;
-    private configDir;
-    constructor(config: ModeConfig);
-    getActiveMode(): Promise<Mode | null>;
-    setActiveMode(modeId: string | null): Promise<void>;
-    listModes(): Promise<Mode[]>;
-    getMode(modeId: string): Promise<Mode | null>;
-    addMode(mode: Mode): Promise<void>;
-    removeMode(modeId: string): Promise<void>;
-    private loadActiveMode;
-    private saveActiveMode;
-}
-interface ModeLoaderOptions {
-    projectModesDir?: string | undefined;
-    userModesDir?: string | undefined;
+/**
+ * Model Intelligence — knowledge base of model capabilities, strengths,
+ * and task-type suitability. Powers automatic agent → model routing.
+ *
+ * Each entry records:
+ *   - Known strengths (what this model family excels at)
+ *   - Known weaknesses (what it struggles with)
+ *   - Best-for task types (coding, planning, security, docs, etc.)
+ *   - Cost tier (budget / standard / premium)
+ *
+ * This is a curated dataset updated as new models release. Falls back
+ * gracefully for unknown models.
+ */
+interface ModelProfile {
+    /** Provider id (e.g. "anthropic", "openai"). */
+    provider: string;
+    /** Model id regex — matches partial ids (e.g. "claude-sonnet" matches "claude-sonnet-4-20250514"). */
+    pattern: RegExp;
+    /** Human-readable model family name. */
+    family: string;
+    /** What this model is particularly good at. */
+    strengths: string[];
+    /** Known limitations. */
+    weaknesses?: string[];
+    /** Task types this model is the best choice for. Ordered by preference. */
+    bestFor: TaskType[];
+    /** Task types to avoid with this model (use a different one). */
+    avoidFor?: TaskType[];
+    /** Approximate cost tier. */
+    costTier: 'budget' | 'standard' | 'premium';
+    /** Approximate speed tier (relative to other models). */
+    speedTier: 'fast' | 'normal' | 'slow';
+    /** Minimum recommended context window. */
+    minContext?: number;
 }
-declare function loadProjectModes(modesDir: string): Promise<Mode[]>;
-declare function loadUserModes(modesDir: string): Promise<Mode[]>;
+/** Task categories that map to agent roles. */
+type TaskType = 'coding' | 'planning' | 'security' | 'docs' | 'testing' | 'refactoring' | 'debugging' | 'data' | 'frontend' | 'backend' | 'review' | 'lightweight' | 'general';
+/** Known model profiles. Patterns are tried in order; first match wins. */
+declare const MODEL_PROFILES: ModelProfile[];
+/** Map task types to the agent roles that handle them. */
+declare const TASK_TO_ROLE: Record<TaskType, string[]>;
+/**
+ * Infer the most likely task type from a task description and target role.
+ * Uses keyword matching; falls back to the role's primary task type.
+ */
+declare function inferTaskType(description: string, role?: string): TaskType;
+/**
+ * Find the best matching model profile for a given provider + model id.
+ */
+declare function findModelProfile(provider: string, modelId: string): ModelProfile | undefined;
+/**
+ * Score a model for a given task type. Higher = better fit.
+ * Returns 0-100.
+ */
+declare function scoreModelForTask(profile: ModelProfile | undefined, taskType: TaskType): number;
 
-interface LLMSelectorOptions {
-    /** Provider used for the selector LLM call. Required. */
-    provider: Provider;
-    /** Model for the selector. Defaults to the provider's default model. */
-    model?: string | undefined;
-    /**
-     * Maximum tokens to keep in context (target budget).
-     * Selector will aim to keep total content below this.
-     */
-    maxContextTokens?: number | undefined;
-    /**
-     * Prompt instructing the selector how to behave.
-     * Should guide the LLM on importance tiers and output format.
-     */
-    systemPrompt?: string | undefined;
-}
 /**
- * LLM-powered message selector. Calls a sub-LLM to analyze the
- * message history and produce a keep/collapse plan — more surgical
- * than fixed-window rules.
+ * ModelRouter — intelligent model selection for subagent delegation.
+ *
+ * Combines:
+ *   1. User-configured model matrix (/setmodel overrides)
+ *   2. Model intelligence profiles (strengths/weaknesses per model family)
+ *   3. Provider availability (which models have API keys configured)
+ *   4. Per-model cost tracking
+ *
+ * Usage:
+ *   const router = new ModelRouter({ matrix, config, profiles: MODEL_PROFILES });
+ *   const pick = router.pickForTask('security-scanner', 'Audit the auth module');
+ *   // → { provider: 'anthropic', model: 'claude-sonnet-...', reason: 'best-for security' }
  */
-declare class LLMSelector implements MessageSelector {
-    private readonly provider;
-    private readonly model;
-    private readonly maxContextTokens;
-    private readonly systemPrompt;
-    constructor(opts: LLMSelectorOptions);
-    select(messages: Message[], maxToKeep: number): Promise<SelectorResult>;
-    private fallbackSelect;
-    private parseSelectorOutput;
+
+interface ModelIntelligenceEntry {
+    provider: string;
+    pattern: RegExp;
+    family: string;
+    strengths: string[];
+    weaknesses?: string[];
+    bestFor: string[];
+    avoidFor?: string[];
+    costTier: 'budget' | 'standard' | 'premium';
+    speedTier: 'fast' | 'normal' | 'slow';
+    minContext?: number;
+}
+interface RouterConfig {
+    /** User-configured model matrix (from /setmodel). */
+    matrix?: Record<string, ModelMatrixEntry> | undefined;
+    /** Provider configurations (to check API key availability). */
+    config: {
+        provider: string;
+        model: string;
+        providers?: Record<string, ProviderConfig>;
+    };
+    /** Known model intelligence profiles. */
+    profiles?: ModelIntelligenceEntry[] | undefined;
+}
+interface ModelPick {
+    provider: string;
+    model: string;
+    /** Why this model was chosen. */
+    reason: string;
+    /** Whether this came from the user's matrix (true) or auto-detected (false). */
+    fromMatrix: boolean;
+}
+interface RouterCosts {
+    /** Cumulative cost per provider/model key. */
+    byModel: Record<string, {
+        cost: number;
+        tokens: {
+            input: number;
+            output: number;
+        };
+        calls: number;
+    }>;
+    /** Grand total. */
+    totalCost: number;
+}
+declare class ModelRouter {
+    private profiles;
+    private matrix;
+    private config;
+    private costs;
+    constructor(opts: RouterConfig);
+    /** Look up the model matrix resolution for a role (role → phase → * → leader). */
+    private resolveMatrix;
+    /** Simplified phase lookup for common roles. */
+    private roleToPhase;
+    /**
+     * Pick the best model for a task.
+     *
+     * Priority:
+     *   1. User's /setmodel matrix entry for this role (explicit override)
+     *   2. Best-matching model from intelligence profiles
+     *   3. Leader model (fallback)
+     */
+    pickForTask(role: string, description: string): ModelPick;
+    /** Infer task category from description keywords + role. */
+    private inferCategory;
+    /** Find the best available model for a task category. */
+    private findBestModel;
+    /** Check if a provider has an API key configured. */
+    private hasKey;
+    /** Get the configured model list for a provider. */
+    private getProviderModels;
+    /** Record cost for a model. */
+    recordCost(provider: string, model: string, cost: number, tokens?: {
+        input: number;
+        output: number;
+    }): void;
+    /** Get cumulative costs. */
+    getCosts(): RouterCosts;
+    /** Reset cost tracking. */
+    resetCosts(): void;
+    /** List all available providers with their best model for each task category. */
+    suggestMatrix(): Record<string, ModelPick>;
 }
 
-export { DefaultModeStore, LLMSelector, type LLMSelectorOptions, type ModeLoaderOptions, loadProjectModes, loadUserModes };
+export { MODEL_PROFILES, type ModelIntelligenceEntry, type ModelPick, type ModelProfile, ModelRouter, type RouterConfig, type RouterCosts, TASK_TO_ROLE, type TaskType, findModelProfile, inferTaskType, scoreModelForTask };