dsh-auto-model-routing 0.4.1 → 0.5.0

package/lib/index.js

@@ -3,48 +3,43 @@ import { SettingsStore } from './settings.js';
 import { settingsHost } from './settings-host.js';
 import { homedir } from 'node:os';
 import { FileStateStore, RoutingState } from './state.js';
-import { Router } from './router.js';
-import { endpoint, labelEndpoint } from './endpoints.js';
+import { endpoint, labelEndpoint, observeEndpoint } from './endpoints.js';
 import { FeedbackBook } from './feedback.js';
-import { JudgementBook } from './judgements.js';
-import { userInput } from './input.js';
-import { JevClient, rubricVersion } from './jev.js';
+import { JevClient } from './jev.js';
 import { routeSubagentTool } from './subagent-tool.js';
-import { buildState, previousTurn } from './context.js';
 import { policyHost } from './policy-host.js';
 import { PolicyStore } from './policy-store.js';
+import { currentMainSelection, mainSupported } from './support.js';
+import { createRegistry, registry as builtin } from './strategies/index.js';
 export const name = 'dsh-auto-model-routing';
+/** Child decision records. The historical directory name is kept on purpose: records are not migrated. */
+export const CHILD_DECISIONS_DIR = 'state/auto-model-routing/policy-v2';
 export const inject = ['llm', 'agents', 'tools'];
-const knownEfforts = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 export function apply(ctx, config = {}) {
     const home = config.home ?? process.env.DSH_HOME ?? resolve(homedir(), '.dsh');
+    const registry = config.strategies ? createRegistry(config.strategies) : builtin;
     const settings = new SettingsStore(resolve(home, 'plugins/dsh-auto-model-routing/config.json'));
-    const hostSettings = settingsHost(ctx, settings);
+    const hostSettings = settingsHost(ctx, settings, registry);
     const jev = new JevClient({ get: hostSettings.credential }, config.jevBase, config.jevTimeoutMs ?? (() => settings.read().settings.jevTimeoutMs), config.jevBase ? undefined : () => settings.read().settings.decisionService);
     const stateFiles = new FileStateStore(resolve(home, 'state/auto-model-routing/sessions'));
     const state = new RoutingState(stateFiles);
-    const book = new JudgementBook(resolve(home, 'state/auto-model-routing/judgements.jsonl'));
-    const router = new Router(state, (sessionId, turn, tier, model, effort) => {
-        const line = { sessionId, turn, tier, ...(effort ? { effort } : {}), model, rubricVersion };
-        book.judged(line);
-        // Recording is best effort: a failed append never touches the request or the mode.
-        try {
-            book.append(line);
-        }
-        catch (error) {
-            ctx.logger.warn(`auto-model-routing: could not record the judgement: ${String(error)}`);
-        }
-    }, () => settings.read().settings);
     const feedback = new FeedbackBook(resolve(home, 'state/auto-model-routing/allocation-feedback.jsonl'));
-    const policy = policyHost(ctx, { feedback, jev, state, store: new PolicyStore(resolve(home, 'state/auto-model-routing/policy-v2')), settings: () => settings.read().settings, catalog: () => hostSettings.catalog(true) });
+    // Official writer is available only while the session controller is mounted.
+    let selectModel;
+    const policy = policyHost(ctx, { feedback, jev, state, selectModel: async (request) => { if (!selectModel)
+            throw new Error('session controller is unavailable'); await selectModel(request); }, store: new PolicyStore(resolve(home, CHILD_DECISIONS_DIR), registry), settings: () => settings.read().settings, catalog: () => hostSettings.catalog(), registry });
     const toastOn = () => settings.read().settings.decisionToast;
-    ctx.effect(() => ctx.tools.register(routeSubagentTool(jev, { agents: ctx.agents, state, readSettings: () => settings.read().settings, catalog: hostSettings.catalog, judged: (sessionId, value) => router.judged(sessionId, value) })));
+    ctx.effect(() => ctx.tools.register(routeSubagentTool(jev, { agents: ctx.agents, state, readSettings: () => settings.read().settings, catalog: hostSettings.catalog, registry })));
     ctx.on('agent/created', ({ agent, source }) => {
         // Factory resume announces `resume`; a nonzero initial seed also excludes restored/forked histories.
         if (source !== 'startup' || agent.session.header.origin === 'subagent' || agent.session.firstLiveSeq !== 0 || agent.session.header.isSeeded || agent.session.snapshotEvents().some(event => event.type === 'session/end-seed') || stateFiles.get(agent.id))
             return;
-        if (settings.read().settings.defaultMode === 'AUTO')
-            state.setMode(agent.id, 'AUTO');
+        if (settings.read().settings.defaultMode !== 'AUTO')
+            return;
+        // A new session whose default main model is outside AUTO's registered families starts in MANUAL.
+        if (!mainSupported(currentMainSelection(ctx, agent), registry))
+            return;
+        state.setMode(agent.id, 'AUTO');
         return undefined;
     });
     // Agent is the WeakMap identity; origin stays on the immutable session header.
@@ -57,69 +52,12 @@ export function apply(ctx, config = {}) {
         }
         return value;
     };
-    ctx.on('agent/pre-step', async (payload, next) => {
-        const decision = await next();
-        // Judge only steps that actually enter, using the messages that enter (a rejected step sends nothing).
-        if (settings.read().settings.policy === 'policy-v2' || payload.step !== 1 || decision.kind !== 'enter')
-            return decision;
-        const agent = ref(payload.agent);
-        if (agent.origin !== 'subagent' && userInput(decision.messages).userTurn)
-            book.userTurn(agent.id, payload.turn);
-        const job = router.begin(agent, payload.turn, decision.messages);
-        if (!job)
-            return decision;
-        // History before this turn's messages enter: the previous user message and assistant reply.
-        const prior = previousTurn(payload.agent.session.deriveMessages());
-        const result = await jev.judge(buildState({ previous: job.previous, prevUser: prior.user, prevAssistant: prior.assistant, text: job.text }), payload.signal);
-        if (result.kind === 'ok') {
-            const { kind: _, tier, ...measure } = result;
-            router.resolve(agent, payload.turn, tier, measure);
-        }
-        else if (result.kind === 'failed')
-            router.fail(agent, payload.turn, result.category);
-        else
-            router.cancel(agent, payload.turn);
-        return decision;
-    });
-    // Reply → user turn, for the reply-bar tier button (memory only; empty after a restart).
-    ctx.on('session/event', (session, event) => {
-        if (event.type !== 'assistant/message')
-            return;
-        const data = event.data;
-        book.assistant(session.id, data.message.id, data.turn);
-    });
-    // Official selection writer, set while the session controller is available.
-    let selectModel;
-    const inflight = new Map();
-    ctx.on('agent/request', async (payload, next) => {
-        const config = await next();
-        if (settings.read().settings.policy === 'policy-v2' || payload.agent.session.header.origin === 'subagent')
-            return config;
-        const model = router.needsModelInfo(ref(payload.agent)) ? await ctx.llm.resolveModelInfo(config.provider, config.model, payload.signal) : undefined;
-        const efforts = (model?.reasoning?.efforts ?? []).map(effort => effort.id).filter(id => knownEfforts.has(id));
-        const catalog = model && settings.read().settings.mainEfforts ? await hostSettings.catalog() : undefined;
-        const routed = router.request(ref(payload.agent), payload.turn, config, efforts, catalog);
-        // AUTO moved the effort away from the official selection: make that selection (and the picker) carry it.
-        // `config` is the official selection for this request, so a user pick made since the last sync is caught too.
-        // Not awaited and never fatal; `inflight` only stops repeat calls before the first one lands.
-        if (selectModel && routed.reasoningEffort && routed.reasoningEffort !== config.reasoningEffort) {
-            const key = `${routed.provider}\0${routed.model}\0${routed.reasoningEffort}`;
-            if (inflight.get(payload.agent.id) !== key) {
-                inflight.set(payload.agent.id, key);
-                selectModel({ sessionId: payload.agent.id, provider: routed.provider, model: routed.model, reasoningEffort: routed.reasoningEffort })
-                    .catch(error => ctx.logger.warn(`auto-model-routing: could not sync the model selection: ${String(error)}`))
-                    .finally(() => { if (inflight.get(payload.agent.id) === key)
-                    inflight.delete(payload.agent.id); });
-            }
-        }
-        return routed;
-    }, { prepend: true });
     ctx.inject(['sessionController'], child => {
         selectModel = request => child.sessionController.selectModel(request);
         child.effect(() => () => { selectModel = undefined; });
     });
     ctx.inject(['connection', 'sessionController'], child => {
-        for (const operation of ['state', 'setMode', 'label', 'settings', 'saveSettings', 'setKey', 'testDecision', 'childRouting']) {
+        for (const operation of ['state', 'setMode', 'label', 'observe', 'settings', 'saveSettings', 'setKey', 'testDecision', 'childRouting']) {
             child.effect(() => child.connection.fetch.register({
                 path: `/api/auto-model-routing.${operation}`,
                 methods: ['POST'], requestBody: 'buffered',
@@ -139,25 +77,52 @@ export function apply(ctx, config = {}) {
                         const result = await child.sessionController.resolveAgent(id);
                         return 'agent' in result ? ref(result.agent) : undefined;
                     };
+                    const resolveSessionAgent = async (id) => {
+                        const result = await child.sessionController.resolveAgent(id);
+                        return 'agent' in result ? result.agent : undefined;
+                    };
                     const payload = enveloped ? wire.payload : body;
+                    let manualDecision;
                     if (operation === 'setMode' && typeof payload?.sessionId === 'string') {
                         const id = payload.sessionId;
                         const mode = payload.mode;
-                        if ((mode === 'AUTO' || mode === 'MANUAL') && state.read(id).mode !== mode && await resolveAgent(id))
+                        if ((mode === 'AUTO' || mode === 'MANUAL') && state.read(id).mode !== mode && await resolveAgent(id)) {
+                            const decisionId = policy.appliedDecision(id);
+                            if (mode === 'MANUAL' && decisionId !== undefined)
+                                manualDecision = { sessionId: id, decisionId };
                             policy.invalidate(id);
+                        }
                     }
                     const response = operation === 'childRouting'
                         ? (typeof payload?.sessionId === 'string'
-                            ? Response.json(policy.status(payload.sessionId) ?? { status: 'unsupported', reason: '没有已绑定的 policy-v2 决策' })
+                            ? Response.json(policy.status(payload.sessionId) ?? { status: 'unsupported', reason: '没有已绑定的子任务决策' })
                             : Response.json({ error: 'invalid request' }, { status: 400 }))
                         : operation === 'settings' || operation === 'saveSettings' || operation === 'setKey' || operation === 'testDecision'
                             ? await hostSettings.endpoint(operation, payload)
-                            : operation === 'label' ? await labelEndpoint(payload, resolveAgent, book, feedback) : await endpoint(operation, payload, resolveAgent, router, state, toastOn);
-                    if ((operation === 'state' || operation === 'setMode') && response.ok && settings.read().settings.policy === 'policy-v2') {
+                            : operation === 'observe' ? await observeEndpoint(payload, resolveAgent, feedback, () => ctx.logger.warn('auto-model-routing: could not record exposure'))
+                                : operation === 'label' ? await labelEndpoint(payload, resolveAgent, feedback) : await endpoint(operation, payload, resolveAgent, state);
+                    if (manualDecision && response.ok) {
+                        try {
+                            feedback.fact(manualDecision.sessionId, manualDecision.decisionId, 'manual-switch');
+                        }
+                        catch {
+                            ctx.logger.warn('auto-model-routing: could not record MANUAL switch');
+                        }
+                    }
+                    if ((operation === 'state' || operation === 'setMode') && response.ok) {
+                        const sessionId = payload.sessionId;
+                        const agent = await resolveSessionAgent(sessionId).catch(() => undefined);
+                        const selection = agent ? currentMainSelection(ctx, agent) : undefined;
+                        const supported = mainSupported(selection, registry);
+                        // Leaving AUTO is persisted: a pick outside the registered families must not keep judging turns.
+                        if (!supported && state.read(sessionId).mode === 'AUTO') {
+                            state.setMode(sessionId, 'MANUAL');
+                            policy.invalidate(sessionId);
+                        }
                         const value = await response.json();
-                        const main = policy.mainStatus(payload.sessionId);
-                        const { decision: _legacyDecision, effort: _legacyEffort, reason: _legacyReason, history: _legacyHistory, ...base } = value;
-                        const result = { ...base, history: [], policy: 'policy-v2', ...main };
+                        const main = policy.mainStatus(sessionId);
+                        const { previous: _previous, ...persisted } = value;
+                        const result = { ...persisted, mode: state.read(sessionId).mode, ...main, ...(toastOn() ? { decisionToast: true } : {}), autoSupport: { supported, ...(selection ? { provider: selection.provider, model: selection.model } : {}) } };
                         return Response.json(enveloped ? { type: 'server-response', rpcId: wire.rpcId, result: { ok: true, value: result } } : result);
                     }
                     if (!enveloped)

package/lib/jev.d.ts

@@ -8,7 +8,6 @@ export interface PolicyMeasure {
     capabilityConfidence?: number;
     capabilityProbabilities?: Record<string, number>;
 }
-import { type Tier } from './effort.js';
 export type Depth = 'lower' | 'baseline' | 'higher';
 export type Capability = 'bounded' | 'analytical' | 'frontier';
 export type PolicyResult = ({
@@ -21,22 +20,8 @@ export type PolicyResult = ({
 } | {
     kind: 'cancelled';
 };
-export declare const policyVersion: string;
 import type { JevCategory } from './hints.js';
 export { CATEGORY_HINTS, type JevCategory } from './hints.js';
-export type Distribution = Partial<Record<Tier, number>>;
-export type JevResult = {
-    kind: 'ok';
-    tier: Tier;
-    confidence?: number;
-    probabilities?: Distribution;
-    ms: number;
-} | {
-    kind: 'failed';
-    category: JevCategory;
-} | {
-    kind: 'cancelled';
-};
 export interface CredentialSource {
     get(name: string): {
         value: string;
@@ -44,32 +29,35 @@ export interface CredentialSource {
         value: string;
     } | undefined>;
 }
-/** Shared by the main session and `route_subagent`; only `state` differs (design D4). Single source: rubric.json. */
-export declare const TIER_QUESTIONS: {
-    tier: {
+/** The only rule file: main and child questions are taken from it verbatim. */
+export declare const QUESTIONS: {
+    capability: {
+        type: string;
+        instructions: string;
+        criteria: {
+            bounded: string;
+            analytical: string;
+            frontier: string;
+            insufficient_context: string;
+        };
+    };
+    depth: {
         type: string;
         instructions: string;
         criteria: {
-            simple: string;
-            standard: string;
-            complex: string;
-            escalated: string;
+            lower: string;
+            baseline: string;
+            higher: string;
         };
     };
 };
-/** Content hash of the rubric, stored with each judgement so labels can be compared per rubric. */
-export declare const rubricVersion: string;
-/** One tier up (`escalated` stays): the only tier arithmetic in code; it never reads message text. */
-export declare function tierAbove(tier: Tier): Tier;
 export declare class JevClient {
     private readonly env;
     private readonly timeoutMs;
     private readonly service?;
     readonly url: string;
     constructor(env: CredentialSource, base?: string, timeoutMs?: number | (() => number), service?: (() => DecisionConfig | undefined) | undefined);
-    /** One request, no retry. Never throws; never returns the body or the key. */
-    /** `state` is assembled and redacted by the caller (`buildState`). */
-    judge(state: string, signal: AbortSignal): Promise<JevResult>;
+    /** One request, no retry. Never throws; never returns the body or the key. `state` comes from `buildState`. */
     judgePolicy(state: string, signal: AbortSignal, scope: 'main' | 'child', dimensions?: 'both' | 'capability' | 'depth'): Promise<PolicyResult>;
     private decide;
 }

package/lib/jev.js

@@ -1,19 +1,11 @@
-import { createHash } from 'node:crypto';
 import { resolveDecisionService } from './decision-service.js';
 const probability = (value) => typeof value === 'number' && Number.isFinite(value) && value >= 0 && value <= 1;
 const distribution = (value) => Object.fromEntries(Object.entries(value ?? {}).filter(([, v]) => probability(v)));
-import { tiers } from './effort.js';
-import rubric from './rubric.json' with { type: 'json' };
-import policyQuestions from './policy-v2-rubric.json' with { type: 'json' };
-export const policyVersion = `policy-v2-${createHash('sha256').update(JSON.stringify(policyQuestions)).digest('hex').slice(0, 8)}`;
+import policyQuestions from './rubric.json' with { type: 'json' };
 export { CATEGORY_HINTS } from './hints.js';
 const MAX_BODY = 64 * 1024;
-/** Shared by the main session and `route_subagent`; only `state` differs (design D4). Single source: rubric.json. */
-export const TIER_QUESTIONS = rubric;
-/** Content hash of the rubric, stored with each judgement so labels can be compared per rubric. */
-export const rubricVersion = createHash('sha256').update(JSON.stringify(TIER_QUESTIONS)).digest('hex').slice(0, 8);
-/** One tier up (`escalated` stays): the only tier arithmetic in code; it never reads message text. */
-export function tierAbove(tier) { return tiers[Math.min(tiers.indexOf(tier) + 1, tiers.length - 1)]; }
+/** The only rule file: main and child questions are taken from it verbatim. */
+export const QUESTIONS = policyQuestions;
 function byStatus(status) {
     if (status === 402)
         return 'insufficient-credits';
@@ -32,33 +24,13 @@ export class JevClient {
     timeoutMs;
     service;
     url;
-    constructor(env, base = 'https://openrouter.ai', timeoutMs = 3000, service) {
+    constructor(env, base = 'https://openrouter.ai', timeoutMs = 5000, service) {
         this.env = env;
         this.timeoutMs = timeoutMs;
         this.service = service;
         this.url = `${base}/api/alpha/decisions`;
     }
-    /** One request, no retry. Never throws; never returns the body or the key. */
-    /** `state` is assembled and redacted by the caller (`buildState`). */
-    async judge(state, signal) {
-        const result = await this.decide(state, signal, TIER_QUESTIONS);
-        if (result.kind !== 'ok')
-            return result;
-        const answer = result.answers?.tier;
-        const choice = answer?.choice;
-        if (!tiers.includes(choice))
-            return { kind: 'failed', category: 'invalid-response' };
-        const unit = (v) => typeof v === 'number' && v >= 0 && v <= 1;
-        const probabilities = {};
-        for (const t of tiers) {
-            const v = answer?.probabilities?.[t];
-            if (unit(v))
-                probabilities[t] = v;
-        }
-        return { kind: 'ok', tier: choice, ms: result.ms,
-            ...(unit(answer?.confidence) ? { confidence: answer.confidence } : {}),
-            ...(Object.keys(probabilities).length ? { probabilities } : {}) };
-    }
+    /** One request, no retry. Never throws; never returns the body or the key. `state` comes from `buildState`. */
     async judgePolicy(state, signal, scope, dimensions = 'both') {
         const questions = scope === 'main' || dimensions === 'depth' ? { depth: policyQuestions.depth }
             : dimensions === 'capability' ? { capability: policyQuestions.capability } : policyQuestions;
@@ -82,7 +54,7 @@ export class JevClient {
             return { kind: 'cancelled' };
         const configuredTimeout = typeof this.timeoutMs === 'function' ? this.timeoutMs() : this.timeoutMs;
         // Settings callbacks use the public range; numeric constructor overrides remain available to tests.
-        const timeout = typeof this.timeoutMs === 'function' && (!Number.isInteger(configuredTimeout) || configuredTimeout < 1000 || configuredTimeout > 4500) ? 3000 : configuredTimeout;
+        const timeout = typeof this.timeoutMs === 'function' && (!Number.isInteger(configuredTimeout) || configuredTimeout < 1000 || configuredTimeout > 8000) ? 5000 : configuredTimeout;
         const deadline = AbortSignal.timeout(timeout);
         const started = performance.now();
         try {

package/lib/policy-host.d.ts

@@ -1,33 +1,39 @@
 import type { FeedbackBook } from './feedback.js';
 import type { Context } from '@deepseek-ai/cordis';
 import type { JevClient, Depth } from './jev.js';
+import { type Registry } from './strategies/index.js';
 import { PolicyStore, type ChildDecision } from './policy-store.js';
 import type { RoutingState } from './state.js';
 import type { RoutingCatalog, Settings } from './settings-contract.js';
 export declare function policyHost(ctx: Context, deps: {
+    selectModel: (request: {
+        sessionId: string;
+        provider: string;
+        model: string;
+        reasoningEffort: string;
+    }) => Promise<unknown>;
     feedback: FeedbackBook;
     jev: JevClient;
     state: RoutingState;
     store: PolicyStore;
     settings: () => Settings;
     catalog: () => Promise<RoutingCatalog>;
+    registry?: Registry;
 }): {
+    appliedDecision: (id: string) => number | undefined;
     invalidate: (id: string) => void;
     status: (id: string) => {
-        version: 1;
         childId: string;
         parentId: string;
         rootId: string;
-        policyVersion: string;
-        mappingVersion: string;
         status: "failed" | "recommended" | "unsupported" | "needs-context" | "applied";
         path: "ordinary" | "fork" | "teammate";
         explicit: {
-            provider: "claude" | "codex" | "dsh-magpie-connect";
+            provider: string;
             model?: string | undefined;
             reasoningEffort?: string | undefined;
         };
-        family?: "claude" | "codex" | undefined;
+        family?: string | undefined;
         decision?: {
             id: number;
             source: "main" | "subagent";
@@ -47,12 +53,12 @@ export declare function policyHost(ctx: Context, deps: {
             capabilityProbabilities?: Record<string, number> | undefined;
         } | undefined;
         route?: {
-            provider: "claude" | "codex" | "dsh-magpie-connect";
+            provider: string;
             model: string;
             reasoningEffort: "low" | "medium" | "high" | "xhigh";
         } | undefined;
         actual?: {
-            provider: "claude" | "codex" | "dsh-magpie-connect";
+            provider: string;
             model: string;
             reasoningEffort: "low" | "medium" | "high" | "xhigh";
         } | undefined;
@@ -60,7 +66,6 @@ export declare function policyHost(ctx: Context, deps: {
     } | undefined;
     mainStatus: (id: string) => {
         decision?: NonNullable<ChildDecision["decision"]>;
-        policyVersion?: string;
         depth?: Depth;
         effort?: string;
         reason?: string;