@addai/node 0.30.16-msp.4 → 0.30.16-msp.6

package/dist/capabilities.d.ts

@@ -84,10 +84,12 @@ interface CapabilitiesShape {
     /** 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.
-     *  jev is true on builds that can use Jev as the selector. */
+     *  jev is true on builds that can use Jev as the selector, codex on builds
+     *  that pick for Codex turns too. */
     model_selector?: {
         enabled: boolean;
         jev?: boolean;
+        codex?: 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', jev: true },
+        model_selector: { enabled: process.env.ADDAI_MSP !== '0', jev: true, codex: true },
         auto_update: (0, auto_update_1.autoUpdateState)(),
         machine: (0, machine_metrics_1.sampleMachine)(),
         claude: deco('claude', claude),

package/dist/claude-print.d.ts

@@ -14,7 +14,11 @@ export interface ClaudePrintInput {
     appendSystemPrompt?: string;
     /** Restrict to a specific set of tools (claude only). null/undefined = inherit. */
     allowedTools?: string[];
+    /** How long to wait for apps before the first model call. Unset = the CLI's default. */
+    mcpStartupWaitMs?: number;
 }
+/** The child's environment. The wait is only set when asked for, so everyone else keeps the CLI's default. */
+export declare function claudePrintEnv(mcpStartupWaitMs?: number, base?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 export type ClaudePrintInputBlock = {
     type: 'text';
     text: string;

package/dist/claude-print.js

@@ -5,6 +5,7 @@
 // our normalised RuntimeEvent shape, and resolves when the process exits.
 // No PTY needed — Claude detects non-TTY and runs headless.
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.claudePrintEnv = claudePrintEnv;
 exports.claudePrintInputMessage = claudePrintInputMessage;
 exports.blockDelta = blockDelta;
 exports.lineToEvents = lineToEvents;
@@ -14,6 +15,14 @@ const claude_binary_1 = require("./claude-binary");
 const win_1 = require("./win");
 const claude_system_prompt_1 = require("./claude-system-prompt");
 const prompt_transport_1 = require("./prompt-transport");
+/** The child's environment. The wait is only set when asked for, so everyone else keeps the CLI's default. */
+function claudePrintEnv(mcpStartupWaitMs, base = process.env) {
+    return {
+        ...base,
+        TERM: 'dumb',
+        ...(mcpStartupWaitMs != null ? { CLAUDE_CODE_MCP_STARTUP_WAIT_MS: String(mcpStartupWaitMs) } : {}),
+    };
+}
 /** Stream JSON reaches stdin only; files never become command-line arguments. */
 function claudePrintInputMessage(prompt, blocks) {
     if (!Array.isArray(blocks) || blocks.length < 1 || blocks.length > 12 || !blocks.every(b => b && (b.type === 'text' && typeof b.text === 'string' || ['image', 'document'].includes(b.type) && 'source' in b && b.source?.type === 'base64' && typeof b.source.data === 'string' && /^[A-Za-z0-9+/]*={0,2}$/.test(b.source.data)
@@ -204,7 +213,7 @@ function spawnClaudePrint(input) {
         const inv = (0, win_1.resolveCliInvocation)(bin, transport.args);
         proc = (0, child_process_1.spawn)(inv.file, inv.args, {
             cwd: input.workingDirectory,
-            env: { ...process.env, TERM: 'dumb' },
+            env: claudePrintEnv(input.mcpStartupWaitMs),
             stdio: (0, prompt_transport_1.stdioFor)(transport.stdin),
             // No console window. This is headless work on somebody's machine —
             // on Windows a spawn without this flashes a terminal every run.

package/dist/codex-models.d.ts

@@ -79,3 +79,5 @@ export declare function codexModelsFor(bin: string, key: string): CodexModelRepo
  * model is not in its list.
  */
 export declare function codexModelEfforts(model?: string | null, report?: CodexModelReport | null): string[] | null;
+/** False only when codex has listed its models and this isn't one of them. */
+export declare function codexModelListed(model: string, report?: CodexModelReport | null): boolean;

package/dist/codex-models.js

@@ -71,6 +71,7 @@ exports.probeCodexModels = probeCodexModels;
 exports.createCodexModelCache = createCodexModelCache;
 exports.codexModelsFor = codexModelsFor;
 exports.codexModelEfforts = codexModelEfforts;
+exports.codexModelListed = codexModelListed;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const os = __importStar(require("os"));
@@ -383,3 +384,7 @@ function codexModelEfforts(model, report = sharedCache.last()) {
     const entry = model ? report.catalog.find(e => e.id === model) : report.catalog.find(e => e.default);
     return entry?.efforts?.length ? entry.efforts : null;
 }
+/** False only when codex has listed its models and this isn't one of them. */
+function codexModelListed(model, report = sharedCache.last()) {
+    return !report || report.catalog.some(e => e.id === model);
+}

package/dist/model-selector.d.ts

@@ -1,5 +1,6 @@
 export declare const TIER_ORDER: readonly ["quick", "standard", "deep", "max"];
 export type TierName = typeof TIER_ORDER[number];
+export type MspAgent = 'claude' | 'codex';
 export interface TierSpec {
     model: string;
     effort: string;
@@ -29,6 +30,9 @@ export interface MspConfig {
         silence_minutes: number;
         backstop_hours: number;
     };
+    /** How long a Claude turn waits for its apps before the first model call.
+     *  At 0 they keep connecting in the background. null leaves the CLI's default. */
+    mcp_startup_wait_ms: number | null;
     /** A few sentences on how the entity talks, for the line. */
     voice: string;
 }
@@ -70,6 +74,7 @@ export interface MspDecision {
     /** Jev says it approves or restarts work, so it stays on the chat's tier. */
     go_ahead: boolean;
     max_run: MspConfig['max_run'];
+    mcp_startup_wait_ms: MspConfig['mcp_startup_wait_ms'];
     fan_out: boolean;
 }
 /**
@@ -77,7 +82,7 @@ export interface MspDecision {
  * the shape, but the node must not trust it: a typo in a tier must cost that
  * tier its override, not the turn.
  */
-export declare function parseConfig(raw: unknown): MspConfig | null;
+export declare function parseConfig(raw: unknown, agent?: MspAgent): MspConfig | null;
 /**
  * The person's own words for this turn. The chat dispatcher wraps the message
  * in a bracketed briefing ("[Direct message · … ]\n\n<message>"); the selector
@@ -186,6 +191,8 @@ export declare function decide(opts: {
     entityName: string;
     entityModel: string | null;
     entityEffort: string | null;
+    /** Which tiers this turn runs on. Claude's when not said. */
+    agent?: MspAgent;
     run?: SelectorRunner;
     /** Required for an entity on Jev; without it the turn falls back. */
     runJev?: JevRunner;

package/dist/model-selector.js

@@ -29,6 +29,12 @@
 // 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.
+//
+// Claude and Codex turns both come through here. The picking is the same; each
+// has its own models for the tiers (tiers and codex_tiers in the setting), so an
+// entity with both in its chain stays right on either. Claude as the selector
+// needs a Claude login on the node. On a Codex-only node Jev is what can pick,
+// and otherwise the turn falls back and runs as it would have.
 // 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;
@@ -87,6 +93,7 @@ const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const claude_binary_1 = require("./claude-binary");
 const config_1 = require("./config");
+const model_filter_1 = require("./model-filter");
 const win_1 = require("./win");
 exports.TIER_ORDER = ['quick', 'standard', 'deep', 'max'];
 const DEFAULT_CONFIG = {
@@ -105,8 +112,18 @@ const DEFAULT_CONFIG = {
     announce: 'always',
     overrides: { 'think hard': 'max', 'ultrathink': 'max', 'quick one': 'quick' },
     max_run: { silence_minutes: 15, backstop_hours: 6 },
+    mcp_startup_wait_ms: null,
     voice: '',
 };
+// Luna is codex's fast one, Terra its balanced one, Sol its coding one and Astra
+// its most capable. A tier naming a model the node's codex doesn't list runs on
+// the entity's own model instead (session-runner's applyModelSelection).
+const DEFAULT_CODEX_TIERS = {
+    quick: { model: 'gpt-6-luna', effort: 'low' },
+    standard: { model: 'gpt-6.1-terra', effort: 'medium' },
+    deep: { model: 'gpt-6.1-sol', effort: 'high' },
+    max: { model: 'gpt-6-astra', effort: 'max', fan_out: true },
+};
 const EFFORTS = new Set(['low', 'medium', 'high', 'xhigh', 'max']);
 const isTier = (t) => typeof t === 'string' && exports.TIER_ORDER.includes(t);
 const rank = (t) => exports.TIER_ORDER.indexOf(t);
@@ -117,18 +134,21 @@ const num = (v, lo, hi, dflt) => (typeof v === 'number' && Number.isFinite(v) ?
  * the shape, but the node must not trust it: a typo in a tier must cost that
  * tier its override, not the turn.
  */
-function parseConfig(raw) {
+function parseConfig(raw, agent = 'claude') {
     if (!raw || typeof raw !== 'object' || Array.isArray(raw))
         return null;
     const r = raw;
     if (r.enabled !== true)
         return null;
-    const tiers = { ...DEFAULT_CONFIG.tiers };
+    // The tiers this turn runs on. A Claude model in codex_tiers, or the other way
+    // round, costs that tier its override like any other typo.
+    const tiers = { ...(agent === 'codex' ? DEFAULT_CODEX_TIERS : DEFAULT_CONFIG.tiers) };
+    const rawTiers = agent === 'codex' ? r.codex_tiers : r.tiers;
     for (const t of exports.TIER_ORDER) {
-        const spec = r.tiers?.[t];
+        const spec = rawTiers?.[t];
         const model = str(spec?.model, 80);
         const effort = str(spec?.effort, 10);
-        if (model && /^(claude|sonnet|opus|haiku|fable)/i.test(model) && EFFORTS.has(effort)) {
+        if (model && (0, model_filter_1.modelForAgent)(agent, model) && EFFORTS.has(effort)) {
             tiers[t] = { model, effort, ...(spec?.fan_out === true ? { fan_out: true } : {}) };
         }
     }
@@ -166,6 +186,9 @@ function parseConfig(raw) {
             silence_minutes: num(r.max_run?.silence_minutes, 1, 120, DEFAULT_CONFIG.max_run.silence_minutes),
             backstop_hours: num(r.max_run?.backstop_hours, 0.25, 24, DEFAULT_CONFIG.max_run.backstop_hours),
         },
+        mcp_startup_wait_ms: typeof r.mcp_startup_wait_ms === 'number'
+            ? Math.round(num(r.mcp_startup_wait_ms, 0, 60_000, 0))
+            : null,
         voice: str(r.voice, 600),
     };
 }
@@ -280,6 +303,9 @@ const label = (model) => {
     for (const name of ['fable', 'opus', 'sonnet', 'haiku'])
         if (m.includes(name))
             return name[0].toUpperCase() + name.slice(1);
+    // gpt-6.1-sol reads GPT-6.1-Sol, as codex names it.
+    if (m.startsWith('gpt-'))
+        return model.split('-').map((p, i) => (i === 0 ? 'GPT' : p.charAt(0).toUpperCase() + p.slice(1))).join('-');
     return model;
 };
 const PLAIN_OPENER = {
@@ -493,7 +519,7 @@ function freshLast(last, now) {
  * a fallback decision, and the turn runs.
  */
 async function decide(opts) {
-    const cfg = parseConfig(opts.config);
+    const cfg = parseConfig(opts.config, opts.agent);
     if (!cfg)
         return null;
     const last = freshLast(opts.last, opts.now ?? Date.now());
@@ -525,6 +551,7 @@ async function decide(opts) {
             continues: false,
             go_ahead: false,
             max_run: cfg.max_run,
+            mcp_startup_wait_ms: cfg.mcp_startup_wait_ms,
             fan_out: t ? cfg.tiers[t].fan_out === true : false,
         };
     };
@@ -570,6 +597,7 @@ async function decide(opts) {
             continues,
             go_ahead: goAhead,
             max_run: cfg.max_run,
+            mcp_startup_wait_ms: cfg.mcp_startup_wait_ms,
             fan_out: cfg.tiers[s.tier].fan_out === true,
         };
         if (!shouldAnnounce(cfg, last, decision))
@@ -621,6 +649,7 @@ async function decide(opts) {
         continues: false,
         go_ahead: false,
         max_run: cfg.max_run,
+        mcp_startup_wait_ms: cfg.mcp_startup_wait_ms,
         fan_out: cfg.tiers[s.tier].fan_out === true,
     };
     if (!shouldAnnounce(cfg, last, decision))
@@ -631,7 +660,8 @@ async function decide(opts) {
 function mspApplies(req) {
     if (process.env.ADDAI_MSP === '0')
         return false;
-    if (req.agent !== 'claude' || req.mode !== 'print')
+    // Codex only has the one way to run. Claude's TUI runs can't change model here.
+    if (req.agent !== 'codex' && (req.agent !== 'claude' || req.mode !== 'print'))
         return false;
     return req.issued_via === 'chatflows' || req.issued_via === 'chat';
 }

package/dist/session-runner.d.ts

@@ -124,7 +124,7 @@ export interface RuntimeRequestRow {
     memoryV2Flagged?: boolean;
     /** Model Selector Protocol — NOT a DB column. Started by runRequest() as
      *  soon as the run is accepted, so the selector's second or so overlaps the
-     *  cwd/install/memory-pack setup; awaited by runClaudePrint() just before
+     *  cwd/install/memory-pack setup; awaited by applyModelSelection() just before
      *  the spawn. Resolves null for every entity without MSP switched on, and
      *  is undefined for runs it can't apply to. See model-selector.ts. */
     mspDecision?: Promise<MspDecision | null>;

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,
+            agent: req.agent === 'codex' ? 'codex' : 'claude',
             runJev: (0, model_selector_1.askJev)(token(), req.id),
         });
     }
@@ -1630,6 +1631,30 @@ function publishModelSelection(req, d, changed) {
         p_decision: { tier: d.tier, model: d.model, effort: d.effort },
     }).catch(err => console.error(`[msp] announce failed [reqId=${req.id}]: ${err.message}`));
 }
+/** This turn's model and effort, when MSP is on. Written onto req so a guardrail
+ *  retry turn stays on the same model. Call it just before the spawn. */
+async function applyModelSelection(req) {
+    const msp = req.mspDecision ? await req.mspDecision : null;
+    if (!msp)
+        return null;
+    // A ChatGPT login refuses a model codex doesn't list, which would fail the
+    // turn. The node's list can differ from the node the tiers were chosen on.
+    if (req.agent === 'codex' && msp.model && msp.model !== req.model && !(0, codex_models_1.codexModelListed)(msp.model)) {
+        console.log(`[msp] ${msp.model} is not on this node's codex; running the entity's own model [reqId=${req.id}]`);
+        msp.fallback_reason = msp.selector_error = `model_not_on_node: ${msp.model}`;
+        msp.fell_back = true;
+        msp.line = null;
+        msp.model = req.model;
+        msp.effort = req.effort;
+    }
+    const changed = (!!msp.model && msp.model !== req.model) || (!!msp.effort && msp.effort !== req.effort);
+    if (msp.model)
+        req.model = msp.model;
+    if (msp.effort)
+        req.effort = msp.effort;
+    publishModelSelection(req, msp, changed);
+    return msp;
+}
 // ── claude --print ─────────────────────────────────────────────────────────
 async function runClaudePrint(req, cwd, installed) {
     if (!req.prompt) {
@@ -1661,17 +1686,7 @@ async function runClaudePrint(req, cwd, installed) {
             abort.abort();
         }
     }
-    // Model Selector Protocol: this turn's model and effort, when it is on.
-    // Written onto req so a guardrail retry turn stays on the same model.
-    const msp = req.mspDecision ? await req.mspDecision : null;
-    if (msp) {
-        const changed = (!!msp.model && msp.model !== req.model) || (!!msp.effort && msp.effort !== req.effort);
-        if (msp.model)
-            req.model = msp.model;
-        if (msp.effort)
-            req.effort = msp.effort;
-        publishModelSelection(req, msp, changed);
-    }
+    const msp = await applyModelSelection(req);
     let handle;
     try {
         handle = (0, claude_print_1.spawnClaudePrint)({
@@ -1685,6 +1700,7 @@ async function runClaudePrint(req, cwd, installed) {
             resumeSessionId: req.resume_session_id ?? undefined,
             appendSystemPrompt: (0, time_context_1.appendTimeContext)(req.system_prompt),
             allowedTools: req.allowed_tools ?? undefined,
+            mcpStartupWaitMs: msp?.mcp_startup_wait_ms ?? undefined,
         });
     }
     catch (err) {
@@ -1811,6 +1827,7 @@ async function runCodex(req, cwd, installed) {
         void emit(req.id, 'session_dropped_missing_rollout', { sessionId: req.resume_session_id });
         req.resume_session_id = null;
     }
+    const msp = await applyModelSelection(req);
     let handle;
     try {
         const codexModel = (0, model_filter_1.modelForAgent)('codex', req.model);
@@ -1849,11 +1866,15 @@ async function runCodex(req, cwd, installed) {
     // call looks identical to a hang. Give it grok's leash: standard window
     // before any output (a wedged spawn/resume trips fast), 3x after activity
     // has been seen (silent tool work is expected, not a hang). Raw stdout/
-    // stderr bytes count as liveness via onActivity.
+    // stderr bytes count as liveness via onActivity. An MSP run can lengthen
+    // that leash with max_run.silence_minutes but not shorten it, because silence
+    // here can be a tool working. It is stopped rather than retried (below).
     const sawActivity = { current: false };
-    const hang = armHangWatchdog(req, lastError, () => handle.kill(), {
+    const silenced = { current: false };
+    const quietMs = () => Math.max(config_1.HANG_WATCHDOG_IDLE_MS * 3, (msp?.max_run.silence_minutes ?? 0) * 60_000);
+    const hang = armHangWatchdog(req, lastError, () => { silenced.current = true; handle.kill(); }, {
         sawActivity: () => sawActivity.current,
-        idleMsFn: () => (sawActivity.current ? config_1.HANG_WATCHDOG_IDLE_MS * 3 : config_1.HANG_WATCHDOG_IDLE_MS),
+        idleMsFn: () => (sawActivity.current ? quietMs() : config_1.HANG_WATCHDOG_IDLE_MS),
     });
     handle.onActivity(() => { sawActivity.current = true; hang.touch(); });
     handle.onEvent(ev => {
@@ -1869,7 +1890,7 @@ async function runCodex(req, cwd, installed) {
     });
     // Node-configured execution timeout (null/0 = unlimited). On timeout we
     // kill the agent; the completion below treats it as complete-with-partial.
-    const nodeTimeout = armNodeTimeout(req, () => handle.kill());
+    const nodeTimeout = armNodeTimeout(req, () => handle.kill(), msp ? msp.max_run.backstop_hours * 3600 : undefined);
     let exitCode;
     try {
         exitCode = await handle.done;
@@ -1889,6 +1910,14 @@ async function runCodex(req, cwd, installed) {
     nodeTimeout.clear();
     watcher.stop();
     hang.stop();
+    // An MSP run that worked and then went quiet ends with what it has, and says
+    // so, instead of being retried from the top. As in runClaudePrint.
+    const mspSilenced = !!msp && silenced.current && sawActivity.current;
+    if (mspSilenced) {
+        await emit(req.id, 'assistant_text', {
+            delta: `\n\n_I went quiet for ${Math.round(quietMs() / 60_000)} minutes, so I was stopped here._`,
+        });
+    }
     if (handle.threadId)
         await setStatus(req.id, { spawnedSessionId: handle.threadId });
     void emit(req.id, 'session_end', { reason: 'codex_exit', exitCode });
@@ -1896,7 +1925,7 @@ async function runCodex(req, cwd, installed) {
     if (currentStatus !== 'canceled') {
         // A timed-out run completes-with-partial: the node asked for a cap, not
         // a failure, so surface whatever the agent produced.
-        const cleanExit = exitCode === 0 || nodeTimeout.timedOut();
+        const cleanExit = exitCode === 0 || nodeTimeout.timedOut() || mspSilenced;
         await finalizeTerminal(req, {
             clean: cleanExit,
             errorCode: cleanExit ? undefined : (lastError.current?.code ?? `exit_${exitCode}`),
@@ -2305,8 +2334,8 @@ async function runRequest(req, entitybox) {
         return;
     }
     // Model Selector Protocol: start now, so the selector runs alongside the
-    // cwd/install/memory setup below instead of after it. Claude print chat
-    // turns only; whether it is on for this entity is the server's answer.
+    // cwd/install/memory setup below instead of after it. Claude print and Codex
+    // chat turns only; whether it is on for this entity is the server's answer.
     // Nothing in here may stop the run, so even the gate is guarded.
     try {
         if ((0, model_selector_1.mspApplies)(req))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@addai/node",
-  "version": "0.30.16-msp.4",
+  "version": "0.30.16-msp.6",
   "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": [