@cruxy/cli 0.16.0 → 0.18.0

package/dist/routing/router.js

@@ -0,0 +1,84 @@
+import { MODEL_TIERS } from "../brand/voice.js";
+import { routingTierUnavailable } from "../errors/index.js";
+import { resolveModelId } from "./resolve.js";
+/**
+ * The tier a config resolves to when nothing else pins one down — mirrors the
+ * gateway's `auto` fallback (`AUTO_FALLBACK_TIER` in the SDK), so an unrouted
+ * cruxy session lands on exactly the tier it does today.
+ */
+export const DEFAULT_TIER = "vaani";
+/**
+ * The config-driven {@link Router}: maps a declared task class to a tier from
+ * `{ default, map }`, and fails loud when the resolved tier is not offered. It
+ * NEVER inspects prompt content — selection is purely `map[taskClass] ?? default`.
+ */
+export class ConfigRouter {
+    cfg;
+    offered;
+    /**
+     * @param cfg      the resolved routing table (default tier + per-task map)
+     * @param offered  the tiers this gateway/plan actually provides; a resolved
+     *                 tier outside this set fails loud. Defaults to all tiers — the
+     *                 seam a future entitlement check narrows (never a silent
+     *                 downgrade).
+     */
+    constructor(cfg, offered = MODEL_TIERS) {
+        this.cfg = cfg;
+        this.offered = new Set(offered);
+    }
+    select(taskClass) {
+        // Explicit override, else the default — an unmapped/unknown class is not an
+        // error, it just takes the default (never a crash, never the cheapest).
+        const tier = this.cfg.map[taskClass] ?? this.cfg.default;
+        // Fail loud: a configured tier the gateway does not offer is a usage error
+        // to fix, NOT a silent substitution to some other tier (a user who asked for
+        // mira reasoning must never be quietly handed kavi).
+        if (!this.offered.has(tier)) {
+            throw routingTierUnavailable(tier, taskClass, [...this.offered]);
+        }
+        return tier;
+    }
+}
+/**
+ * The base tier implied by the session's `model.model`: a real tier passes
+ * through; `auto` (and any non-tier value) falls back to {@link DEFAULT_TIER}.
+ * Used so that when a user has pinned a single tier, an opt-in routing table
+ * that omits `routing.default` still defaults to THEIR tier, not a fixed one.
+ */
+function baseTierFromModel(model) {
+    return MODEL_TIERS.includes(model)
+        ? model
+        : DEFAULT_TIER;
+}
+/**
+ * Build a router from resolved config, or `null` when routing should stay
+ * inert. Routing is:
+ *
+ * - a cruxy-gateway concept — tiers do not apply to BYO providers, so non-cruxy
+ *   providers get `null` (no override, their `model.model` is used unchanged);
+ * - opt-in — with no `routing.default` and an empty `routing.map`, this returns
+ *   `null` so behavior (and the wire body, and the state line) is byte-identical
+ *   to today. Multi-tier routing activates only once the user configures it.
+ */
+export function routerForConfig(config) {
+    if (config.model.provider !== "cruxy")
+        return null;
+    const { default: def, map } = config.routing;
+    const configured = def !== undefined || Object.keys(map).length > 0;
+    if (!configured)
+        return null;
+    return new ConfigRouter({
+        default: def ?? baseTierFromModel(config.model.model),
+        map,
+    });
+}
+/**
+ * Resolve a declared task class to `{ tier, model }`: the tier for honest
+ * surfacing (the U.4 state line), the wire model id for the request. The model
+ * id comes from the internal {@link resolveModelId} — callers never touch that
+ * mapping directly, so it stays the single source of truth.
+ */
+export function resolveTaskModel(router, taskClass) {
+    const tier = router.select(taskClass);
+    return { tier, model: resolveModelId(tier) };
+}

package/dist/routing/types.d.ts

@@ -0,0 +1,42 @@
+import { MODEL_TIERS } from "../brand/voice.js";
+/**
+ * Multi-model routing (C.30): route each unit of work to the right tier instead
+ * of running one model for everything. The caller DECLARES a {@link TaskClass}
+ * at the call site; a {@link Router} maps that class to a {@link Tier} via config
+ * — it never sniffs the prompt to guess difficulty. The tier→gateway model-id
+ * mapping is internal (see `resolve.ts`); only tier names ever appear in config,
+ * logs, errors, or the state line (the U.8 tier gag).
+ */
+/**
+ * The unit-of-work classes a caller can declare. Each is an explicit intent —
+ * NOT a difficulty the router infers. Unknown/unset resolves to the router's
+ * default tier, never a crash.
+ */
+export declare const TASK_CLASSES: readonly ["main-turn", "subagent", "plan", "commit-msg", "classify", "summarize"];
+export type TaskClass = (typeof TASK_CLASSES)[number];
+/** A routing tier — the ONLY model vocabulary the user ever sees (U.8). */
+export type Tier = (typeof MODEL_TIERS)[number];
+/**
+ * Selects a tier for a declared task class. Deliberately one method: the caller
+ * passes intent, the router returns a tier from its configured mapping. No
+ * prompt-content inspection, ever — difficulty detection is explicitly out of
+ * scope (a caller declares; the router does not guess).
+ */
+export interface Router {
+    /**
+     * Map a task class to its tier. Falls back to the configured default when the
+     * class has no explicit mapping; throws `CRUXY_E_ROUTING_TIER_UNAVAILABLE`
+     * (fail loud, never a silent substitution) when the resolved tier is not
+     * offered.
+     */
+    select(taskClass: TaskClass): Tier;
+}
+/**
+ * The declarative routing table: a `default` tier plus per-task overrides. Lives
+ * in config (`routing.default`, `routing.map`). An empty map means every class
+ * resolves to `default` — a single tier, no traffic splitting.
+ */
+export interface RoutingConfig {
+    default: Tier;
+    map: Partial<Record<TaskClass, Tier>>;
+}

package/dist/routing/types.js

@@ -0,0 +1,27 @@
+/**
+ * Multi-model routing (C.30): route each unit of work to the right tier instead
+ * of running one model for everything. The caller DECLARES a {@link TaskClass}
+ * at the call site; a {@link Router} maps that class to a {@link Tier} via config
+ * — it never sniffs the prompt to guess difficulty. The tier→gateway model-id
+ * mapping is internal (see `resolve.ts`); only tier names ever appear in config,
+ * logs, errors, or the state line (the U.8 tier gag).
+ */
+/**
+ * The unit-of-work classes a caller can declare. Each is an explicit intent —
+ * NOT a difficulty the router infers. Unknown/unset resolves to the router's
+ * default tier, never a crash.
+ */
+export const TASK_CLASSES = [
+    /** An interactive main-agent turn. */
+    "main-turn",
+    /** A spawned subagent task (C.14). */
+    "subagent",
+    /** Plan proposal / revision (C.31). */
+    "plan",
+    /** Commit / pull-request text generation. */
+    "commit-msg",
+    /** A cheap one-shot classification. */
+    "classify",
+    /** Context compaction / summarization. */
+    "summarize",
+];

package/dist/subagent/orchestrator.d.ts

@@ -2,6 +2,7 @@ import type { Provider } from "@cruxy/sdk";
 import type { ApprovalDecision } from "../approval/types.js";
 import type { CruxyConfig } from "../config/index.js";
 import type { StreamRenderer } from "../render/index.js";
+import type { Router } from "../routing/index.js";
 import type { ApproveAction, ToolContext, ToolRegistry } from "../tools/index.js";
 import type { SandboxService } from "../sandbox/index.js";
 import type { SubagentResult, SubagentSpec } from "./types.js";
@@ -15,6 +16,11 @@ import type { SubagentResult, SubagentSpec } from "./types.js";
 export interface SubagentOrchestratorDeps {
     provider: Provider;
     config: CruxyConfig;
+    /**
+     * Multi-model routing (C.30). When set, child runs route on their spec's task
+     * class (default `subagent`); omitted → the provider default (unchanged).
+     */
+    router?: Router;
     /** The parent's registry — the ceiling every child scope derives from. */
     parentRegistry: ToolRegistry;
     cwd: string;

package/dist/subagent/orchestrator.js

@@ -91,6 +91,8 @@ export class SubagentOrchestrator {
                 projectInstructions: deps.projectInstructions,
                 subagent: true,
                 budget,
+                router: deps.router,
+                taskClass: spec.taskClass ?? "subagent",
             });
         }
         catch (err) {

package/dist/subagent/types.d.ts

@@ -1,4 +1,5 @@
 import type { Usage } from "@cruxy/sdk";
+import type { TaskClass } from "../routing/index.js";
 /**
  * Types for subagent orchestration (C.14): the main agent delegates a bounded
  * subtask to a child agent that runs the SAME loop with its own fresh history,
@@ -35,6 +36,11 @@ export interface SubagentSpec {
      * spawn can narrow its budget, never raise it past the configured ceilings.
      */
     budget?: Partial<BudgetLimits>;
+    /**
+     * Routing task class for this spawn (C.30); defaults to `subagent`. A
+     * declaration at the spawn call site — not something the router guesses.
+     */
+    taskClass?: TaskClass;
 }
 /**
  * What the parent gets back — compact structured data, never the transcript.

package/dist/vcs/generate.d.ts

@@ -59,7 +59,9 @@ export declare function fillContent(input: GenerateInput): GeneratedContent;
  * rules, then normalize + redact. Resilient: if the model's reply isn't the
  * expected JSON, the first line becomes the subject and the rest the body.
  */
-export declare function generateWithLlm(provider: Provider, input: GenerateInput): Promise<GeneratedContent>;
+export declare function generateWithLlm(provider: Provider, input: GenerateInput, opts?: {
+    model?: string;
+}): Promise<GeneratedContent>;
 interface ParsedGenerated {
     branchName?: string;
     commitSubject?: string;

package/dist/vcs/generate.js

@@ -154,7 +154,7 @@ export function fillContent(input) {
  * rules, then normalize + redact. Resilient: if the model's reply isn't the
  * expected JSON, the first line becomes the subject and the rest the body.
  */
-export async function generateWithLlm(provider, input) {
+export async function generateWithLlm(provider, input, opts = {}) {
     const redactedDiff = redactSecrets(input.diff);
     const system = buildSystemPrompt(input);
     const user = buildUserPrompt({ ...input, diff: redactedDiff });
@@ -162,6 +162,9 @@ export async function generateWithLlm(provider, input) {
     for await (const ev of provider.stream({
         system,
         messages: [{ role: "user", content: user }],
+        // The commit-msg tier's wire model (C.30), resolved by the caller; omitted →
+        // the provider default.
+        ...(opts.model ? { model: opts.model } : {}),
     })) {
         if (ev.type === "text_delta")
             text += ev.text;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cruxy/cli",
-  "version": "0.16.0",
+  "version": "0.18.0",
   "description": "an agentic coding CLI",
   "type": "module",
   "bin": {
@@ -36,7 +36,7 @@
     "tinyglobby": "^0.2.10",
     "zod": "^3.23.8",
     "zod-to-json-schema": "^3.23.5",
-    "@cruxy/sdk": "0.1.0"
+    "@cruxy/sdk": "0.2.0"
   },
   "devDependencies": {
     "@types/better-sqlite3": "^7.6.13",