@north-light/crouter 0.3.161 → 0.3.162

package/dist/core/config.js

@@ -2,6 +2,7 @@ import { mkdirSync, rmSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { isDeepStrictEqual } from 'node:util';
 import { CONFIG_FILE, STATE_FILE, CONDENSED_HISTORY_MODES, defaultScopeConfig, defaultScopeState, defaultModelLaddersConfig, defaultKindsConfig, defaultRemoteCanvasConfig } from '../types.js';
+import { emitEvent } from './events/emit.js';
 import { atomicWriteJson, readJsonIfExists, writeJson, ensureDir } from './fs-utils.js';
 import { scopeRoot, requireScopeRoot, findProjectScopeRoots } from './scope.js';
 import { profileRoot } from './profiles/manifest.js';
@@ -172,6 +173,83 @@ function mergeModelLadders(raw, base = defaultModelLaddersConfig()) {
     }
     return out;
 }
+function validStrength(value) {
+    return value === 'ultra' || value === 'strong' || value === 'medium' || value === 'light';
+}
+/** Validate and overlay route entries. Invalid declarations are loud but local:
+ * a typo must not prevent unrelated launch configuration from resolving. */
+function mergeModelRoutes(raw, base = {}) {
+    const out = { ...base };
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return out;
+    for (const [routeId, value] of Object.entries(raw)) {
+        const patch = value;
+        const invalid = (rule) => { emitEvent({ level: 'warn', event: 'config.model_routes.invalid', fields: { route_id: routeId, rule } }); };
+        if (!patch || typeof patch !== 'object' || Array.isArray(patch)) {
+            invalid('route must be an object');
+            continue;
+        }
+        const route = { ...out[routeId], ...patch, models: { ...out[routeId]?.models, ...patch.models } };
+        if (typeof route.family !== 'string' || route.family.trim() === '') {
+            invalid('family must be a non-empty string');
+            continue;
+        }
+        if (typeof route.credentialSource !== 'string' || route.credentialSource.trim() === '') {
+            invalid('credentialSource must be a non-empty string');
+            continue;
+        }
+        if (typeof route.providerId !== 'string' || route.providerId.trim() === '') {
+            invalid('providerId must be a non-empty string');
+            continue;
+        }
+        if (!route.models || typeof route.models !== 'object' || Array.isArray(route.models)) {
+            invalid('models must be an object');
+            continue;
+        }
+        const models = {};
+        let rule;
+        for (const [strength, spec] of Object.entries(route.models)) {
+            if (!validStrength(strength)) {
+                rule = `models.${strength} is not a model strength`;
+                break;
+            }
+            if (typeof spec !== 'string' || spec.trim() === '') {
+                rule = `models.${strength} must be a non-empty provider/id ref`;
+                break;
+            }
+            const slash = spec.indexOf('/');
+            if (slash <= 0 || slash === spec.length - 1) {
+                rule = `models.${strength} must be provider/id`;
+                break;
+            }
+            if (spec.slice(0, slash) !== route.providerId) {
+                rule = `models.${strength} provider prefix must equal providerId`;
+                break;
+            }
+            models[strength] = spec;
+        }
+        if (rule !== undefined) {
+            invalid(rule);
+            continue;
+        }
+        out[routeId] = { family: route.family, credentialSource: route.credentialSource, providerId: route.providerId, models };
+    }
+    return out;
+}
+function mergeModelRouting(raw, base) {
+    if (raw === undefined)
+        return base;
+    if (raw === null || typeof raw !== 'object' || Array.isArray(raw))
+        return base;
+    const value = raw;
+    const strings = (items) => Array.isArray(items) && items.every((item) => typeof item === 'string' && item.trim() !== '') ? [...items] : undefined;
+    const strengths = Array.isArray(value.strengthFallback) && value.strengthFallback.every((item) => validStrength(item)) ? [...value.strengthFallback] : undefined;
+    return {
+        ...(strings(value.credentialSourceOrder) !== undefined ? { credentialSourceOrder: strings(value.credentialSourceOrder) } : {}),
+        ...(strings(value.familyOrder) !== undefined ? { familyOrder: strings(value.familyOrder) } : {}),
+        ...(strengths !== undefined ? { strengthFallback: strengths } : {}),
+    };
+}
 /** True when `pattern` (a `spawnEnv.allow` entry) matches EVERY possible env
  *  var name — a bare `*`, or any run of nothing but `*` characters (`**`,
  *  `***`, …). This is the one glob shape that reopens the inherit-all hole
@@ -362,10 +440,12 @@ function mergeConfig(partial) {
     const fold_finished_tools = typeof partial.fold_finished_tools === 'boolean' ? partial.fold_finished_tools : defaults.fold_finished_tools;
     const keybindings = normalizeKeybindings(partial.keybindings);
     const modelLadders = mergeModelLadders(partial.modelLadders);
+    const modelRoutes = mergeModelRoutes(partial.modelRoutes);
+    const modelRouting = mergeModelRouting(partial.modelRouting, undefined);
     const kinds = mergeKinds(partial.kinds);
     const remoteCanvas = mergeRemoteCanvas(partial.remoteCanvas);
     const spawnEnv = mergeSpawnEnv(partial.spawnEnv, defaults.spawnEnv?.allow);
-    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, fold_finished_tools, keybindings, modelLadders, kinds, remoteCanvas, spawnEnv };
+    return { schema_version, marketplaces, plugins, configuredClis, auto_update, max_panes_per_window, brokerThresholds, completion_bell, live_cycles, condensed_history, fold_finished_tools, keybindings, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), kinds, remoteCanvas, spawnEnv };
 }
 /** Raw (un-defaulted) partial config for one scope, or null if the scope has
  *  no root or no config.json. Used by `readMergedLaunchConfig` to layer
@@ -450,18 +530,24 @@ export function readMergedLaunchConfig(targetCwd = process.cwd(), targetProfileI
     const projectRawsFarthestFirst = readRawProjectScopeConfigs(targetCwd, targetProfileId);
     let kinds = mergeKinds(userRaw?.kinds, defaults.kinds);
     let modelLadders = mergeModelLadders(userRaw?.modelLadders, defaults.modelLadders);
+    let modelRoutes = mergeModelRoutes(userRaw?.modelRoutes);
+    let modelRouting = mergeModelRouting(userRaw?.modelRouting, undefined);
     let spawnEnv = mergeSpawnEnv(userRaw?.spawnEnv, defaults.spawnEnv?.allow);
     if (profileRaw !== null) {
         kinds = mergeKinds(profileRaw.kinds, kinds);
         modelLadders = mergeModelLadders(profileRaw.modelLadders, modelLadders);
+        modelRoutes = mergeModelRoutes(profileRaw.modelRoutes, modelRoutes);
+        modelRouting = mergeModelRouting(profileRaw.modelRouting, modelRouting);
         spawnEnv = mergeSpawnEnv(profileRaw.spawnEnv, spawnEnv.allow);
     }
     for (const raw of projectRawsFarthestFirst) {
         kinds = mergeKinds(raw.kinds, kinds);
         modelLadders = mergeModelLadders(raw.modelLadders, modelLadders);
+        modelRoutes = mergeModelRoutes(raw.modelRoutes, modelRoutes);
+        modelRouting = mergeModelRouting(raw.modelRouting, modelRouting);
         spawnEnv = mergeSpawnEnv(raw.spawnEnv, spawnEnv.allow);
     }
-    return { kinds, modelLadders, spawnEnv };
+    return { kinds, modelLadders, ...(Object.keys(modelRoutes).length > 0 ? { modelRoutes } : {}), ...(modelRouting !== undefined ? { modelRouting } : {}), spawnEnv };
 }
 /** The effective `KindConfig` for one full kind string (top-level, e.g.
  *  `developer`, or sub-kind, e.g. `plan/reviewers/security`), across

package/dist/core/model-routes.d.ts

@@ -0,0 +1,37 @@
+import type { ModelStrength } from '../types.js';
+export type ModelRequest = {
+    kind: 'logical';
+    family: string;
+    strength: ModelStrength;
+    spec: string;
+} | {
+    kind: 'concrete';
+    spec: string;
+} | {
+    kind: 'exact';
+    spec: string;
+};
+export type RoutedCandidate = {
+    routeId: string;
+    credentialSource: string;
+    family: string;
+    strength: ModelStrength;
+    providerId: string;
+    modelId: string;
+    thinkingLevel?: string;
+    rank: number;
+};
+export type RouteAvailability = {
+    authenticated: boolean;
+    coolingUntil?: number;
+    registered: boolean;
+};
+export interface ModelRegistryLike {
+    find(providerId: string, modelId: string): unknown;
+    hasConfiguredAuth(model: unknown): boolean;
+}
+/** Expand config-derived route order only. Availability never affects rank. */
+export declare function expandModelCandidates(request: ModelRequest, cwd?: string, profileId?: string | null): RoutedCandidate[];
+/** Probe the common availability facts consumed unchanged by resolveProviderCandidates. */
+export declare function probeRouteAvailability(candidate: RoutedCandidate, registry: ModelRegistryLike, now?: number): RouteAvailability;
+export declare function modelRequestFromConfig(model: string | undefined, modelIntent: string | undefined, exact: boolean): ModelRequest | undefined;

package/dist/core/model-routes.js

@@ -0,0 +1,140 @@
+import { readMergedLaunchConfig } from './config.js';
+import { isManagedProvider, readRotationConfig, readSubscriptionPool } from './subscription-state.js';
+const STRENGTHS = ['ultra', 'strong', 'medium', 'light'];
+const THINKING_SUFFIXES = new Set(['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max']);
+function parseSpec(spec) {
+    const slash = spec.indexOf('/');
+    if (slash <= 0 || slash === spec.length - 1)
+        return undefined;
+    const providerId = spec.slice(0, slash);
+    const rawId = spec.slice(slash + 1);
+    const colon = rawId.lastIndexOf(':');
+    const suffix = colon > 0 ? rawId.slice(colon + 1).toLowerCase() : undefined;
+    return {
+        providerId,
+        modelId: suffix !== undefined && THINKING_SUFFIXES.has(suffix) ? rawId.slice(0, colon) : rawId,
+        ...(suffix !== undefined && THINKING_SUFFIXES.has(suffix) && suffix !== 'off' ? { thinkingLevel: suffix } : {}),
+    };
+}
+function synthesizeRoutes(ladders) {
+    const route = (family) => {
+        const providerId = ladders[family].strong.slice(0, ladders[family].strong.indexOf('/'));
+        return { family, credentialSource: 'default', providerId, models: ladders[family] };
+    };
+    return { anthropic: route('anthropic'), openai: route('openai') };
+}
+function ordered(first, rest) {
+    return [first, ...rest.filter((item) => item !== first)];
+}
+function strengths(requested, configured) {
+    return ordered(requested, configured).filter((value, index, all) => all.indexOf(value) === index);
+}
+/** Expand config-derived route order only. Availability never affects rank. */
+export function expandModelCandidates(request, cwd, profileId) {
+    const cfg = readMergedLaunchConfig(cwd, profileId ?? null);
+    const routes = cfg.modelRoutes && Object.keys(cfg.modelRoutes).length > 0 ? cfg.modelRoutes : synthesizeRoutes(cfg.modelLadders);
+    const routeEntries = Object.entries(routes);
+    const fallback = cfg.modelRouting?.strengthFallback ?? [readRotationConfig().defaultFallbackStrength ?? 'strong'];
+    const declarationFamilies = routeEntries.map(([, route]) => route.family).filter((value, index, all) => all.indexOf(value) === index);
+    const declarationSources = routeEntries.map(([, route]) => route.credentialSource).filter((value, index, all) => all.indexOf(value) === index);
+    if (request.kind === 'exact') {
+        const parsed = parseSpec(request.spec);
+        return parsed ? [{ routeId: 'exact', credentialSource: 'exact', family: parsed.providerId, strength: 'strong', ...parsed, rank: 0 }] : [];
+    }
+    const concrete = request.kind === 'concrete' ? parseSpec(request.spec) : undefined;
+    const logical = request.kind === 'logical' ? request : undefined;
+    const matchesConcrete = (spec, exactThinking) => {
+        const parsed = parseSpec(spec);
+        return parsed !== undefined
+            && concrete !== undefined
+            && parsed.providerId === concrete.providerId
+            && parsed.modelId === concrete.modelId
+            && (!exactThinking || parsed.thinkingLevel === concrete.thinkingLevel);
+    };
+    const concreteRoute = concrete === undefined ? undefined : routeEntries.find(([, route]) => Object.values(route.models).some((spec) => matchesConcrete(spec, false)));
+    const requestedStrength = logical?.strength ?? (() => {
+        if (!concrete)
+            return 'strong';
+        // Mirrors the former ladder back-map: preserve a precise thinking-level
+        // match, then map a drifting/omitted suffix to the weakest same-model cell.
+        for (const exactThinking of [true, false]) {
+            for (const strength of exactThinking ? STRENGTHS : [...STRENGTHS].reverse()) {
+                if (routeEntries.some(([, route]) => {
+                    const spec = route.models[strength];
+                    return spec !== undefined && matchesConcrete(spec, exactThinking);
+                }))
+                    return strength;
+            }
+        }
+        return 'strong';
+    })();
+    const requestedFamily = logical?.family ?? concreteRoute?.[1].family ?? concrete?.providerId ?? 'anthropic';
+    const sourceOrder = concrete ? declarationSources : (cfg.modelRouting?.credentialSourceOrder ?? declarationSources);
+    const familyOrder = concrete ? [requestedFamily] : (cfg.modelRouting?.familyOrder ?? declarationFamilies);
+    const emitted = [];
+    const seen = new Set();
+    const append = (routeId, route, strength, spec) => {
+        const parsed = parseSpec(spec);
+        if (!parsed)
+            return;
+        if (concrete && parsed.modelId !== concrete.modelId)
+            return;
+        const key = `${parsed.providerId}/${parsed.modelId}:${parsed.thinkingLevel ?? ''}`;
+        if (seen.has(key))
+            return;
+        seen.add(key);
+        emitted.push({ routeId, credentialSource: route.credentialSource, family: route.family, strength, ...parsed, rank: emitted.length });
+    };
+    // Concrete requests retain their exact model/provider first even if a route has
+    // not been authored for it; declared routes then offer that identical model in
+    // other credential sources only.
+    if (concrete) {
+        const [routeId, route] = concreteRoute ?? [
+            'concrete',
+            { family: requestedFamily, credentialSource: 'default', providerId: concrete.providerId, models: { [requestedStrength]: request.spec } },
+        ];
+        append(routeId, route, requestedStrength, request.spec);
+    }
+    for (const credentialSource of sourceOrder) {
+        for (const strength of concrete ? [requestedStrength] : strengths(requestedStrength, fallback)) {
+            for (const family of ordered(requestedFamily, familyOrder)) {
+                for (const [routeId, route] of routeEntries) {
+                    if (route.credentialSource !== credentialSource || route.family !== family)
+                        continue;
+                    const spec = route.models[strength];
+                    if (spec)
+                        append(routeId, route, strength, spec);
+                }
+            }
+        }
+    }
+    return emitted.map((candidate, rank) => ({ ...candidate, rank }));
+}
+/** Probe the common availability facts consumed unchanged by resolveProviderCandidates. */
+export function probeRouteAvailability(candidate, registry, now = Date.now()) {
+    const model = registry.find(candidate.providerId, candidate.modelId);
+    if (model === undefined)
+        return { registered: false, authenticated: false };
+    if (!isManagedProvider(candidate.providerId))
+        return { registered: true, authenticated: registry.hasConfiguredAuth(model) };
+    const pool = readSubscriptionPool(candidate.providerId).filter((entry) => entry.authFailure === undefined);
+    const cooling = pool.length > 0 && pool.every((entry) => (entry.rateLimitedUntil || 0) > now);
+    return {
+        registered: true,
+        authenticated: pool.length > 0,
+        ...(cooling ? { coolingUntil: Math.min(...pool.map((entry) => entry.rateLimitedUntil || 0)) } : {}),
+    };
+}
+export function modelRequestFromConfig(model, modelIntent, exact) {
+    if (!model)
+        return undefined;
+    if (exact)
+        return { kind: 'exact', spec: model };
+    if (modelIntent) {
+        const slash = modelIntent.indexOf('/');
+        const strength = slash > 0 ? modelIntent.slice(slash + 1) : '';
+        if (STRENGTHS.includes(strength))
+            return { kind: 'logical', family: modelIntent.slice(0, slash), strength: strength, spec: model };
+    }
+    return { kind: 'concrete', spec: model };
+}

package/dist/core/runtime/broker.d.ts

@@ -3,7 +3,6 @@ import { type AgentSessionRuntime, type AgentSessionServices, type CreateAgentSe
 import { type ImageContent } from '@earendil-works/pi-ai';
 import { type BrokerSdkConfig } from './launch.js';
 import { type BrokerEngine } from './broker-sdk.js';
-import { type ManagedProviderRotationPolicyControl } from './managed-provider-cooling.js';
 import { type KnownStreamWaitControl } from './stream-watchdog.js';
 import { FrameDecoder, type BrokerSnapshot, type BrokerToClient, type ClientRole, type RpcExtensionUIRequest, type RpcExtensionUIResponse } from './broker-protocol.js';
 /**
@@ -231,9 +230,6 @@ export interface BrokerDialogDeps {
     /** Broadcast a non-blocking display frame (setStatus/setWidget/setTitle) to ALL
      *  viewers — the relay path for pi's fire-and-forget extension-UI surface. */
     broadcast: (frame: BrokerToClient) => void;
-    /** Live provider-fallback policy. This is a callback because an explicit
-     *  set_model updates the running broker's pin state without a revive. */
-    providerRotationPolicy?: ManagedProviderRotationPolicyControl;
     /** Optional broker-owned control for a deliberate, deadline-bounded provider
      *  wait: pause the dead-stream watchdog while the provider extension sleeps to
      *  a known finite future deadline, returning a release fn that resumes it. Put