@addai/node 0.30.16-msp.1 → 0.30.16-msp.3

package/dist/capabilities.d.ts

@@ -83,9 +83,11 @@ interface CapabilitiesShape {
     auto_update?: AutoUpdateState;
     /** Present when this build has the Model Selector Protocol, so Studio can
      *  say which nodes would ignore an entity's selector setting instead of
-     *  guessing from a version number. enabled is false under ADDAI_MSP=0. */
+     *  guessing from a version number. enabled is false under ADDAI_MSP=0.
+     *  jev is true on builds that can use Jev as the selector. */
     model_selector?: {
         enabled: boolean;
+        jev?: boolean;
     };
 }
 /** What the heartbeat says about claude's models. `models` keeps its old

package/dist/capabilities.js

@@ -510,7 +510,7 @@ async function probeCapabilities() {
         autostart: (0, autostart_1.status)(),
         container_engine: containerEngine,
         flows: await probeFlows(),
-        model_selector: { enabled: process.env.ADDAI_MSP !== '0' },
+        model_selector: { enabled: process.env.ADDAI_MSP !== '0', jev: true },
         auto_update: (0, auto_update_1.autoUpdateState)(),
         machine: (0, machine_metrics_1.sampleMachine)(),
         claude: deco('claude', claude),

package/dist/model-selector.d.ts

@@ -12,6 +12,10 @@ export interface MspConfig {
         model: string;
         effort: string;
         timeout_ms: number;
+        /** 'jev' needs a credential_id; without one the selector stays on Claude. */
+        provider: 'claude' | 'jev';
+        /** The Vault item holding the TypeSafe key. The server reads it, never the node. */
+        credential_id: string | null;
     };
     tiers: Record<TierName, TierSpec>;
     floor: TierName;
@@ -34,6 +38,8 @@ export interface MspLast {
     model?: string | null;
     effort?: string | null;
     light_streak?: number | null;
+    /** When it was decided, added by the server. */
+    at?: string | null;
 }
 export interface MspDecision {
     /** null when the turn fell back to the entity's own model. */
@@ -56,6 +62,13 @@ export interface MspDecision {
     selector_error: string | null;
     selector_ms: number | null;
     selector_input_tokens: number | null;
+    selector_provider: MspConfig['selector']['provider'];
+    /** How sure Jev was of its pick, 0 to 1. Null for Claude, which doesn't say. */
+    confidence: number | null;
+    /** Jev says this message leans on earlier chat it can't see. */
+    continues: boolean;
+    /** Jev says it approves or restarts work, so it stays on the chat's tier. */
+    go_ahead: boolean;
     max_run: MspConfig['max_run'];
     fan_out: boolean;
 }
@@ -132,6 +145,35 @@ export type SelectorRunner = (call: SelectorCall) => Promise<SelectorResult>;
 /** argv for the bare selector. The message itself goes down stdin. */
 export declare function selectorArgs(call: Pick<SelectorCall, 'model' | 'effort' | 'systemPrompt'>): string[];
 export declare const spawnSelector: SelectorRunner;
+export interface JevCall {
+    message: string;
+    current: TierName | null;
+}
+export interface JevResult {
+    ok: boolean;
+    tier: TierName | null;
+    confidence: number | null;
+    continues: boolean;
+    goAhead: boolean;
+    ms: number;
+    inputTokens: number | null;
+    error: string | null;
+}
+export type JevRunner = (call: JevCall) => Promise<JevResult>;
+/** Asks the server, which holds the key. Never rejects. */
+export declare const askJev: (token: string, requestId: string) => JevRunner;
+export declare const JEV_CONFIDENCE_FLOOR = 0.6;
+/**
+ * Jev only sees one message, so it mustn't mean a weak model. "yes do that" reads
+ * as quick and can be the go-ahead for an hour's work, so a go-ahead can't go
+ * lighter than where the chat already is. A follow-up question, or a pick Jev is
+ * unsure of, needs less: at least standard. settle() keeps a heavy model for its
+ * cache, so only the effort comes down. Holding max effort for "and the fix for
+ * number one?" took 3 minutes where medium took 15 s.
+ */
+export declare function steadyJevPick(pick: TierName, confidence: number | null, current: TierName | null, continues?: boolean, goAhead?: boolean): TierName;
+/** The last decision, unless it is too old to be worth staying steady for. */
+export declare function freshLast(last: MspLast | null | undefined, now: number): MspLast | null;
 /**
  * The whole decision for one turn. Never throws: every failure comes back as
  * a fallback decision, and the turn runs.
@@ -145,6 +187,9 @@ export declare function decide(opts: {
     entityModel: string | null;
     entityEffort: string | null;
     run?: SelectorRunner;
+    /** Required for an entity on Jev; without it the turn falls back. */
+    runJev?: JevRunner;
+    now?: number;
 }): Promise<MspDecision | null>;
 /** Is MSP worth asking about for this request at all? Cheap, no I/O. */
 export declare function mspApplies(req: {

package/dist/model-selector.js

@@ -22,6 +22,13 @@
 // The selector runs bare, because its whole budget is about a second: no MCP
 // servers, no tools, no slash commands, no session file, its own system prompt
 // in place of Claude Code's, and an empty folder so no CLAUDE.md is found.
+//
+// An entity can use TypeSafe's Jev instead (selector.provider 'jev'). Jev only
+// sorts: it returns a tier and how sure it is, never words, so the line is the
+// plain one and it can't be talked into saying something odd. The key stays on
+// the server: the node asks the entity-msp-select edge function, which reads
+// the entity's chosen Vault key. Only the new message goes, never the chat, and
+// a message with override words isn't sent at all.
 // Plan: addai-entity-studio docs/model-selector-protocol-plan.md.
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
     if (k2 === undefined) k2 = k;
@@ -57,7 +64,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.spawnSelector = exports.TIER_ORDER = void 0;
+exports.JEV_CONFIDENCE_FLOOR = exports.askJev = exports.spawnSelector = exports.TIER_ORDER = void 0;
 exports.parseConfig = parseConfig;
 exports.messageFromPrompt = messageFromPrompt;
 exports.recentLines = recentLines;
@@ -70,6 +77,8 @@ exports.plainLine = plainLine;
 exports.selectorSystemPrompt = selectorSystemPrompt;
 exports.selectorUserPrompt = selectorUserPrompt;
 exports.selectorArgs = selectorArgs;
+exports.steadyJevPick = steadyJevPick;
+exports.freshLast = freshLast;
 exports.decide = decide;
 exports.mspApplies = mspApplies;
 const child_process_1 = require("child_process");
@@ -77,12 +86,13 @@ const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const claude_binary_1 = require("./claude-binary");
+const config_1 = require("./config");
 const win_1 = require("./win");
 exports.TIER_ORDER = ['quick', 'standard', 'deep', 'max'];
 const DEFAULT_CONFIG = {
     enabled: false,
     // Picks take 2-3 s on a node (most of it the CLI starting); 6 s leaves room.
-    selector: { model: 'claude-haiku-5-5', effort: 'low', timeout_ms: 6000 },
+    selector: { model: 'claude-haiku-5-5', effort: 'low', timeout_ms: 6000, provider: 'claude', credential_id: null },
     tiers: {
         quick: { model: 'claude-haiku-5-5', effort: 'low' },
         standard: { model: 'claude-sonnet-5-5', effort: 'medium' },
@@ -136,12 +146,15 @@ function parseConfig(raw) {
     const sel = r.selector ?? {};
     const selModel = str(sel.model, 80);
     const selEffort = str(sel.effort, 10);
+    const credentialId = str(sel.credential_id, 64) || null;
     return {
         enabled: true,
         selector: {
             model: selModel && /^(claude|haiku|sonnet)/i.test(selModel) ? selModel : DEFAULT_CONFIG.selector.model,
             effort: EFFORTS.has(selEffort) ? selEffort : DEFAULT_CONFIG.selector.effort,
             timeout_ms: num(sel.timeout_ms, 500, 15_000, DEFAULT_CONFIG.selector.timeout_ms),
+            provider: sel.provider === 'jev' && credentialId ? 'jev' : 'claude',
+            credential_id: credentialId,
         },
         tiers,
         floor,
@@ -303,7 +316,7 @@ function selectorSystemPrompt(cfg, entityName) {
 }
 function selectorUserPrompt(opts) {
     return [
-        `Current tier: ${opts.current ?? 'none yet (first message of this chat)'}`,
+        `Current tier: ${opts.current ?? 'none (first message of this chat, or it has been quiet for a while)'}`,
         opts.forced ? `The person asked for the ${opts.forced} tier in words. Pick ${opts.forced}.` : '',
         opts.recent.length ? `\nRecent chat, oldest first:\n${opts.recent.join('\n')}` : '',
         '\nNew message:',
@@ -407,7 +420,73 @@ const spawnSelector = (call) => new Promise((resolve) => {
     catch { /* same */ }
 });
 exports.spawnSelector = spawnSelector;
+// The whole trip takes about 0.4 s, or 2 s when the edge function starts cold,
+// and setup takes about 2 s anyway. A little over the function's own 2 s limit
+// on Jev, so its answer arrives rather than being cut off just before it.
+const JEV_TIMEOUT_MS = 3000;
+/** Asks the server, which holds the key. Never rejects. */
+const askJev = (token, requestId) => async (call) => {
+    const started = Date.now();
+    const failed = (error) => ({ ok: false, tier: null, confidence: null, continues: false, goAhead: false, ms: Date.now() - started, inputTokens: null, error });
+    try {
+        const res = await fetch(`${config_1.SUPABASE_URL}/functions/v1/entity-msp-select`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json', apikey: config_1.SUPABASE_ANON_KEY, authorization: `Bearer ${config_1.SUPABASE_ANON_KEY}` },
+            body: JSON.stringify({ token, requestId, message: call.message, current: call.current }),
+            signal: AbortSignal.timeout(JEV_TIMEOUT_MS),
+        });
+        if (!res.ok)
+            return failed(`http_${res.status}`);
+        const out = await res.json();
+        if (out.ok !== true || !isTier(out.tier))
+            return failed(str(out.error, 80) || 'jev_bad_answer');
+        return {
+            ok: true,
+            tier: out.tier,
+            confidence: typeof out.confidence === 'number' ? out.confidence : null,
+            continues: out.continues === true,
+            goAhead: out.go_ahead === true,
+            ms: Date.now() - started,
+            inputTokens: typeof out.input_tokens === 'number' ? out.input_tokens : null,
+            error: null,
+        };
+    }
+    catch (err) {
+        const name = err.name;
+        return failed(name === 'TimeoutError' || name === 'AbortError' ? 'timeout' : `fetch: ${err.message}`);
+    }
+};
+exports.askJev = askJev;
+// TypeSafe's own guidance for acting on an answer automatically.
+exports.JEV_CONFIDENCE_FLOOR = 0.6;
+/**
+ * Jev only sees one message, so it mustn't mean a weak model. "yes do that" reads
+ * as quick and can be the go-ahead for an hour's work, so a go-ahead can't go
+ * lighter than where the chat already is. A follow-up question, or a pick Jev is
+ * unsure of, needs less: at least standard. settle() keeps a heavy model for its
+ * cache, so only the effort comes down. Holding max effort for "and the fix for
+ * number one?" took 3 minutes where medium took 15 s.
+ */
+function steadyJevPick(pick, confidence, current, continues = false, goAhead = false) {
+    const atLeast = (least) => (rank(pick) < rank(least) ? least : pick);
+    if (goAhead)
+        return atLeast(current && rank(current) > rank('standard') ? current : 'standard');
+    if (continues || (confidence !== null && confidence < exports.JEV_CONFIDENCE_FLOOR))
+        return atLeast('standard');
+    return pick;
+}
 // ── one turn ─────────────────────────────────────────────────────────────────
+// How long the prompt cache lives, and so how long holding a heavy model for it
+// is worth anything. Past this a light message would pay to rewrite the cache on
+// the heavy model for nothing, so the chat starts fresh.
+const CACHE_TTL_MS = 60 * 60 * 1000;
+/** The last decision, unless it is too old to be worth staying steady for. */
+function freshLast(last, now) {
+    if (!last || typeof last !== 'object')
+        return null;
+    const at = typeof last.at === 'string' ? Date.parse(last.at) : NaN;
+    return Number.isFinite(at) && now - at > CACHE_TTL_MS ? null : last;
+}
 /**
  * The whole decision for one turn. Never throws: every failure comes back as
  * a fallback decision, and the turn runs.
@@ -416,10 +495,11 @@ async function decide(opts) {
     const cfg = parseConfig(opts.config);
     if (!cfg)
         return null;
-    const last = opts.last && typeof opts.last === 'object' ? opts.last : null;
+    const last = freshLast(opts.last, opts.now ?? Date.now());
     const current = last && isTier(last.tier) ? last.tier : null;
     const message = messageFromPrompt(opts.prompt);
     const forced = overrideFor(message, cfg.overrides);
+    const provider = cfg.selector.provider;
     const fallback = (reason, ms, tokens) => {
         // This chat's last tier if it had one; otherwise exactly what the entity
         // would have run without MSP.
@@ -439,10 +519,62 @@ async function decide(opts) {
             selector_error: reason,
             selector_ms: ms,
             selector_input_tokens: tokens,
+            selector_provider: provider,
+            confidence: null,
+            continues: false,
+            go_ahead: false,
             max_run: cfg.max_run,
             fan_out: t ? cfg.tiers[t].fan_out === true : false,
         };
     };
+    if (provider === 'jev') {
+        // The person said which tier, so the message has no reason to leave the node.
+        let jev = null;
+        if (!forced) {
+            if (!opts.runJev)
+                return fallback('jev_unavailable', null, null);
+            try {
+                jev = await opts.runJev({ message, current });
+            }
+            catch (err) {
+                jev = { ok: false, tier: null, confidence: null, continues: false, goAhead: false, ms: 0, inputTokens: null, error: `runner: ${err.message}` };
+            }
+            if (!jev.ok || !jev.tier)
+                return fallback(jev.error ?? 'jev_bad_answer', jev.ms, jev.inputTokens);
+        }
+        const continues = jev?.continues === true;
+        const goAhead = jev?.goAhead === true;
+        const picked = forced ?? steadyJevPick(jev.tier, jev.confidence, current, continues, goAhead);
+        const s = settle(cfg, last, picked, forced ? 'override' : 'selector');
+        const sure = jev?.confidence;
+        const decision = {
+            tier: s.tier,
+            model: s.model,
+            effort: s.effort,
+            picked: clampTier(picked, cfg.floor, cfg.ceiling),
+            source: forced ? 'override' : 'selector',
+            why: forced
+                ? 'asked for in the message'
+                : `Jev${typeof sure === 'number' ? `, ${Math.round(sure * 100)}% sure` : ''}${goAhead ? ', a go-ahead' : continues ? ', follows on from earlier' : ''}`,
+            line: plainLine(cfg, s.tier),
+            light_streak: s.light_streak,
+            effort_only: s.effort_only,
+            fell_back: false,
+            fallback_reason: null,
+            selector_error: null,
+            selector_ms: jev?.ms ?? null,
+            selector_input_tokens: jev?.inputTokens ?? null,
+            selector_provider: 'jev',
+            confidence: jev?.confidence ?? null,
+            continues,
+            go_ahead: goAhead,
+            max_run: cfg.max_run,
+            fan_out: cfg.tiers[s.tier].fan_out === true,
+        };
+        if (!shouldAnnounce(cfg, last, decision))
+            decision.line = null;
+        return decision;
+    }
     let result;
     try {
         result = await (opts.run ?? exports.spawnSelector)({
@@ -483,6 +615,10 @@ async function decide(opts) {
         selector_error: parsed ? null : (result.error ?? 'unparseable_reply'),
         selector_ms: result.ms,
         selector_input_tokens: result.inputTokens,
+        selector_provider: 'claude',
+        confidence: null,
+        continues: false,
+        go_ahead: false,
         max_run: cfg.max_run,
         fan_out: cfg.tiers[s.tier].fan_out === true,
     };

package/dist/session-runner.js

@@ -1600,6 +1600,7 @@ async function startModelSelection(req) {
             entityName: setting.entity_name || 'the assistant',
             entityModel: req.model,
             entityEffort: req.effort,
+            runJev: (0, model_selector_1.askJev)(token(), req.id),
         });
     }
     catch (err) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.30.16-msp.1",
+  "version": "0.30.16-msp.3",
   "description": "Daemon that pairs a machine with your +Ai account and runs Claude / Codex / Kimi / Gemini agents on its behalf. Reachable via Supabase from Vault, Entity Studio, or any other +Ai surface.",
   "license": "MIT",
   "keywords": [