@addai/node 0.30.13 → 0.30.15

package/dist/auto-update.d.ts

@@ -103,6 +103,9 @@ type ProbeShape = Partial<Record<HarnessId, {
     available?: boolean;
 }>>;
 export interface AutoUpdateDeps {
+    /** Optional admission gate for direct sessions. Legacy callers keep the existing update path. */
+    quiesceDirect?: () => Promise<boolean>;
+    releaseDirect?: () => void;
     /** The daemon token — only used to derive this node's slot. */
     token: () => string | null;
     /** True while this node holds a child process for a live run. */

package/dist/auto-update.js

@@ -143,6 +143,21 @@ function installedHarnesses(probe) {
 /** One pass. Exported so `ainode` can be made to do it on demand later, and
  *  so a test can drive it without waiting an hour. */
 async function runOnce(d) {
+    if (!d.quiesceDirect || shouldRun({ enabled: d.enabled(), busy: d.isBusy(), breakerOpen: d.breakerOpen() })) {
+        return runUpdate(d);
+    }
+    if (!await d.quiesceDirect()) {
+        state = { ...state, last_result: 'skipped', skipped_reason: 'busy' };
+        return;
+    }
+    try {
+        await runUpdate(d);
+    }
+    finally {
+        d.releaseDirect?.();
+    }
+}
+async function runUpdate(d) {
     const skip = shouldRun({ enabled: d.enabled(), busy: d.isBusy(), breakerOpen: d.breakerOpen() });
     if (skip) {
         state = { ...state, last_checked_at: new Date().toISOString(), last_result: 'skipped', skipped_reason: skip };

package/dist/capabilities.d.ts

@@ -1,5 +1,7 @@
+import { entityboxFileCapabilities } from './entitybox-file-session';
 import type { EngineInfo } from './desktop/provider';
 import { type ClaudeModelEntry } from './claude-models';
+import { type CodexModelEntry } from './codex-models';
 import { type AutostartState } from './autostart';
 import { type AutoUpdateState } from './auto-update';
 import { type MachineSample } from './machine-metrics';
@@ -39,14 +41,15 @@ interface FlowsCapability {
     max_concurrent: number;
 }
 interface CapabilitiesShape {
+    entitybox?: {
+        files: NonNullable<ReturnType<typeof entityboxFileCapabilities>>;
+    };
     /** Version of @addai/node running. Lets the studio / CodeFlows
      *  UIs show "outdated daemon" hints and helps us debug field issues
      *  ("which version was this row produced by?"). */
     daemon_version?: string;
     claude: BinaryProbe & ClaudeModelFields;
-    codex: BinaryProbe & {
-        models?: string[];
-    };
+    codex: BinaryProbe & CodexModelFields;
     kimi: BinaryProbe & {
         models?: string[];
     };
@@ -91,6 +94,17 @@ interface ClaudeModelFields {
      *  fallback above — so a stale picker can be told apart from a live one. */
     models_source?: 'cli' | 'builtin';
 }
+interface CodexModelFields {
+    /** Asked of codex's app-server (codex-models.ts); empty until it answers.
+     *  There is no built-in list: a blank model — codex's own default — is the
+     *  one choice that always runs. */
+    models?: string[];
+    model_catalog?: CodexModelEntry[];
+    models_source?: 'cli' | 'builtin';
+    /** 'account' when the list is what this node's login can run, 'bundled'
+     *  when the login was left alone and it is what the CLI ships with. */
+    models_scope?: 'account' | 'bundled';
+}
 /** Codex's credential store: $CODEX_HOME (or ~/.codex) + /auth.json. */
 export declare function codexHome(): string;
 /**

package/dist/capabilities.js

@@ -42,12 +42,14 @@ exports.codexHome = codexHome;
 exports.codexAuthFromStore = codexAuthFromStore;
 exports.probeCapabilities = probeCapabilities;
 const engine_1 = require("./desktop/engine");
+const entitybox_file_session_1 = require("./entitybox-file-session");
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const os = __importStar(require("os"));
 const claude_binary_1 = require("./claude-binary");
 const claude_models_1 = require("./claude-models");
+const codex_models_1 = require("./codex-models");
 const kimi_binary_1 = require("./kimi-binary");
 const gemini_binary_1 = require("./gemini-binary");
 const grok_binary_1 = require("./grok-binary");
@@ -132,12 +134,6 @@ const CLAUDE_MODELS = [
     'claude-sonnet-4-6',
     'claude-haiku-4-5',
 ];
-const CODEX_MODELS = [
-    'gpt-5',
-    'gpt-5-mini',
-    'o4',
-    'o4-mini',
-];
 const KIMI_MODELS = [
     'kimi-k2-instruct',
     'kimi-k2-base',
@@ -257,7 +253,18 @@ async function probeCodex() {
     else {
         authShape = codexAuthFromStore(codexHome());
     }
-    return { available: true, version: ver.stdout, models: CODEX_MODELS, ...authShape };
+    // Asked once per binary and version, in the background; see codex-models.ts.
+    // Its efforts replace the registry's when it answers — they are per model,
+    // and newer codex takes xhigh and max.
+    const live = (0, codex_models_1.codexModelsFor)(bin, `${bin}|${ver.stdout}`);
+    return {
+        available: true,
+        version: ver.stdout,
+        models: live?.models ?? [],
+        ...(live ? { model_catalog: live.catalog, models_scope: live.scope, efforts: (0, codex_models_1.offeredEfforts)(live) } : {}),
+        models_source: live ? 'cli' : 'builtin',
+        ...authShape,
+    };
 }
 async function probeKimi() {
     const bin = (0, kimi_binary_1.findKimiBinary)();
@@ -487,7 +494,8 @@ async function probeCapabilities() {
     // login strategy) so Studio and the TUI render from one source of truth.
     const deco = (id, probe) => ({
         ...probe,
-        efforts: harness_registry_1.HARNESSES[id].efforts,
+        // A list the CLI gave itself (codex) beats the registry's.
+        efforts: probe.efforts?.length ? probe.efforts : harness_registry_1.HARNESSES[id].efforts,
         installable: (0, harness_registry_1.isInstallable)(id),
         login_strategy: harness_registry_1.HARNESSES[id].login.strategy,
         login_methods: [
@@ -495,7 +503,9 @@ async function probeCapabilities() {
             ...(harness_registry_1.HARNESSES[id].extraLogins ?? []).map(m => m.method),
         ],
     });
+    const fileCapability = (0, entitybox_file_session_1.entityboxFileCapabilities)(claude);
     return {
+        ...(fileCapability ? { entitybox: { files: fileCapability } } : {}),
         daemon_version: readDaemonVersion(),
         autostart: (0, autostart_1.status)(),
         container_engine: containerEngine,

package/dist/claude-models.d.ts

@@ -1,3 +1,4 @@
+import { type ModelProbeResult } from './model-cache';
 import { type CliInvocation } from './win';
 export interface ClaudeModelEntry {
     /** What goes to `--model`: an alias ('opus') or a full id. */
@@ -21,13 +22,7 @@ export interface ClaudeModelReport {
      *  the probe ever sees, so it is not reported as this node's default. */
     defaultModel?: string;
 }
-export type ProbeResult = {
-    ok: true;
-    report: ClaudeModelReport;
-} | {
-    ok: false;
-    reason: string;
-};
+export type ProbeResult = ModelProbeResult<ClaudeModelReport>;
 /**
  * Turn the `models` array of an initialize response into a report.
  *
@@ -67,13 +62,10 @@ export interface ModelCacheDeps {
     now: () => number;
     log: (line: string) => void;
 }
+/** Refreshed every 6h, retried 30 min after a failure — see model-cache.ts. */
 export declare function createClaudeModelCache(deps: ModelCacheDeps): {
-    /**
-     * The models for this binary state, or null to mean "use the built-in
-     * list". Never waits: a missing or stale answer is fetched in the
-     * background and arrives on a later call.
-     */
     get(bin: string, key: string): ClaudeModelReport | null;
+    last(): ClaudeModelReport | null;
 };
 /** What capabilities.ts reports for claude's models. */
 export declare function claudeModelsFor(bin: string, key: string): ClaudeModelReport | null;

package/dist/claude-models.js

@@ -77,9 +77,7 @@ exports.createClaudeModelCache = createClaudeModelCache;
 exports.claudeModelsFor = claudeModelsFor;
 const child_process_1 = require("child_process");
 const fs = __importStar(require("fs"));
-const os = __importStar(require("os"));
-const path = __importStar(require("path"));
-const paths_1 = require("./paths");
+const model_cache_1 = require("./model-cache");
 const win_1 = require("./win");
 // What a model id may look like before it is passed on: `claude-opus-5-5`,
 // `opus[1m]`, `claude-haiku-4-5-20251001`. Anything else is dropped rather
@@ -164,34 +162,6 @@ const CREDENTIAL_ENV = [
     'ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN', 'CLAUDE_CODE_OAUTH_TOKEN',
     'CLAUDE_CODE_OAUTH_REFRESH_TOKEN', 'CLAUDE_CONFIG_DIR',
 ];
-/** A throwaway folder that is both the probe's cwd and its CLAUDE_CONFIG_DIR,
- *  so no project's settings or CLAUDE.md are read and nothing the CLI writes
- *  lands in the real ~/.claude. Folders older than a day are swept — a
- *  probe's own cleanup can lose a race with Windows releasing the cwd. */
-function makeProbeDir() {
-    const root = path.join(paths_1.RUNTIME_HOME, 'model-probe');
-    try {
-        fs.mkdirSync(root, { recursive: true });
-        const cutoff = Date.now() - 24 * 60 * 60 * 1000;
-        for (const name of fs.readdirSync(root)) {
-            const p = path.join(root, name);
-            try {
-                if (fs.statSync(p).mtimeMs < cutoff)
-                    fs.rmSync(p, { recursive: true, force: true });
-            }
-            catch { /* next time */ }
-        }
-        return fs.mkdtempSync(path.join(root, 'p-'));
-    }
-    catch {
-        try {
-            return fs.mkdtempSync(path.join(os.tmpdir(), 'ainode-model-probe-'));
-        }
-        catch {
-            return null;
-        }
-    }
-}
 const PROBE_ARGS = [
     '--print', '--input-format', 'stream-json', '--output-format', 'stream-json', '--verbose',
     // No keychain reads (the macOS login), no hooks, no plugin sync, no
@@ -223,7 +193,10 @@ function probeClaudeModels(bin, opts = {}) {
             done({ ok: false, reason: err.message || String(err) });
             return;
         }
-        const dir = opts.dir ?? makeProbeDir();
+        // Both the probe's cwd and its CLAUDE_CONFIG_DIR, so no project's
+        // settings or CLAUDE.md are read and nothing the CLI writes lands in the
+        // real ~/.claude.
+        const dir = opts.dir ?? (0, model_cache_1.makeProbeDir)();
         if (!dir) {
             done({ ok: false, reason: 'no folder to probe from' });
             return;
@@ -337,63 +310,14 @@ function probeClaudeModels(bin, opts = {}) {
 }
 /** Tests only. */
 function __resetIsolationForTests() { isolationBroken = false; }
-/* ── the cache the heartbeat reads ─────────────────────────────────────── */
-/** Re-ask now and then even when nothing changed: the CLI's list can move
- *  without a CLI update. */
-const REFRESH_MS = 6 * 60 * 60 * 1000;
-const RETRY_AFTER_FAIL_MS = 30 * 60 * 1000;
+/** Refreshed every 6h, retried 30 min after a failure — see model-cache.ts. */
 function createClaudeModelCache(deps) {
-    let good = null;
-    let failed = null;
-    let inflight = null;
-    const start = (bin, key) => {
-        if (inflight)
-            return;
-        inflight = deps.probe(bin).then(result => {
-            if (result.ok) {
-                const changed = !good || good.report.models.join() !== result.report.models.join();
-                good = { key, report: result.report, at: deps.now() };
-                if (failed?.key === key)
-                    failed = null;
-                if (changed) {
-                    const head = result.report.catalog.filter(e => e.alias && e.resolved !== e.id)
-                        .map(e => `${e.id} → ${e.resolved}`).join(', ');
-                    deps.log(`[models] claude: ${result.report.models.length} models from the CLI${head ? ` (${head})` : ''}`);
-                }
-            }
-            else {
-                // An answer this exact binary already gave stays good: a refresh
-                // that fails is a reason to retry, not to forget it.
-                failed = { key, at: deps.now() };
-                const kept = good?.key === key;
-                deps.log(`[models] could not read claude's model list (${result.reason}) — ${kept ? 'keeping the last answer' : 'offering the built-in list'}; next try in ${RETRY_AFTER_FAIL_MS / 60000} min`);
-            }
-        }).catch(() => { failed = { key, at: deps.now() }; })
-            .finally(() => { inflight = null; });
-    };
-    return {
-        /**
-         * The models for this binary state, or null to mean "use the built-in
-         * list". Never waits: a missing or stale answer is fetched in the
-         * background and arrives on a later call.
-         */
-        get(bin, key) {
-            const now = deps.now();
-            const recentlyFailed = failed?.key === key && now - failed.at < RETRY_AFTER_FAIL_MS;
-            if (good?.key === key) {
-                if (now - good.at > REFRESH_MS && !recentlyFailed)
-                    start(bin, key);
-                return good.report;
-            }
-            if (!recentlyFailed)
-                start(bin, key);
-            // A new CLI version that has not answered yet: keep showing the last
-            // real list — closer to the truth than the constant, and it stops the
-            // pickers flickering to the built-in list across an upgrade. Once the
-            // new version has actually failed, the built-in list it is.
-            return failed?.key === key ? null : (good?.report ?? null);
-        },
-    };
+    return (0, model_cache_1.createModelCache)({
+        ...deps,
+        agent: 'claude',
+        describe: report => report.catalog.filter(e => e.alias && e.resolved !== e.id)
+            .map(e => `${e.id} → ${e.resolved}`).join(', '),
+    });
 }
 const sharedCache = createClaudeModelCache({
     probe: bin => probeClaudeModels(bin),

package/dist/claude-print.d.ts

@@ -2,6 +2,8 @@ import type { RuntimeEvent, RuntimePermissionMode, RuntimeEffortLevel } from './
 export interface ClaudePrintInput {
     workingDirectory: string;
     prompt: string;
+    /** Verified original file blocks for explicitly marked EntityBox chat. */
+    inputBlocks?: readonly ClaudePrintInputBlock[];
     permissionMode?: RuntimePermissionMode;
     effortLevel?: RuntimeEffortLevel;
     model?: string;
@@ -13,6 +15,19 @@ export interface ClaudePrintInput {
     /** Restrict to a specific set of tools (claude only). null/undefined = inherit. */
     allowedTools?: string[];
 }
+export type ClaudePrintInputBlock = {
+    type: 'text';
+    text: string;
+} | {
+    type: 'image' | 'document';
+    source: {
+        type: 'base64';
+        media_type: string;
+        data: string;
+    };
+};
+/** Stream JSON reaches stdin only; files never become command-line arguments. */
+export declare function claudePrintInputMessage(prompt: string, blocks: readonly ClaudePrintInputBlock[]): string;
 /**
  * The text to emit for one flushed block, given what came before.
  *

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.claudePrintInputMessage = claudePrintInputMessage;
 exports.blockDelta = blockDelta;
 exports.lineToEvents = lineToEvents;
 exports.spawnClaudePrint = spawnClaudePrint;
@@ -13,6 +14,16 @@ 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");
+/** 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)
+        && (b.type === 'document' ? b.source.media_type === 'application/pdf' : ['image/png', 'image/jpeg', 'image/webp', 'image/gif'].includes(b.source.media_type)))))
+        throw new Error('Invalid file input');
+    const message = JSON.stringify({ type: 'user', session_id: '', parent_tool_use_id: null, message: { role: 'user', content: [...blocks, { type: 'text', text: prompt }] } }) + '\n';
+    if (Buffer.byteLength(message) > 30 * 1024 * 1024)
+        throw new Error('File input is too large');
+    return message;
+}
 /**
  * The text to emit for one flushed block, given what came before.
  *
@@ -113,6 +124,7 @@ function lineToEvents(line, suppressText = false) {
     return [{ type: `claude:${type || 'unknown'}`, raw: line }];
 }
 function spawnClaudePrint(input) {
+    const inputMessage = input.inputBlocks ? claudePrintInputMessage(input.prompt, input.inputBlocks) : undefined;
     const bin = (0, claude_binary_1.findClaudeBinary)();
     // No claude on this runtime — fail THIS request cleanly rather than
     // spawning a bare 'claude' that ENOENTs and crashes the daemon. Both
@@ -138,6 +150,8 @@ function spawnClaudePrint(input) {
     ];
     if (partialStream)
         args.push('--include-partial-messages');
+    if (input.inputBlocks)
+        args.push('--input-format', 'stream-json');
     if (input.permissionMode === 'bypassPermissions') {
         args.push('--dangerously-skip-permissions');
     }
@@ -183,6 +197,8 @@ function spawnClaudePrint(input) {
     const isWindows = process.platform === 'win32';
     const sysPrompt = (0, claude_system_prompt_1.offloadLongSystemPrompt)(bin, args, isWindows, (0, claude_system_prompt_1.claudeSupportsPromptFile)(bin));
     const transport = (0, prompt_transport_1.offloadLongPrompt)(bin, sysPrompt.args, sysPrompt.args.length - 1, null, isWindows, true);
+    if (inputMessage !== undefined)
+        transport.stdin = inputMessage;
     let proc;
     try {
         const inv = (0, win_1.resolveCliInvocation)(bin, transport.args);

package/dist/codex-models.d.ts

@@ -0,0 +1,81 @@
+import { type ModelProbeResult } from './model-cache';
+import type { RuntimeEffortLevel } from './types';
+import { type CliInvocation } from './win';
+export interface CodexModelEntry {
+    /** What goes to `--model`. */
+    id: string;
+    /** Always `id` — codex has no aliases. Here so Studio reads both CLIs alike. */
+    resolved: string;
+    /** Codex's own label, e.g. 'GPT-6-Astra'. */
+    name: string;
+    alias: false;
+    /** Effort levels this model takes, in codex's spelling. */
+    efforts?: string[];
+    /** What a run with no model set gets. */
+    default?: true;
+}
+export interface CodexModelReport {
+    /** Plain ids, the default first — the shape `capabilities.codex.models`
+     *  has always had. */
+    models: string[];
+    catalog: CodexModelEntry[];
+    defaultModel?: string;
+    /** 'account': what this node's login can run. 'bundled': what the CLI
+     *  ships with, read without the login. */
+    scope: 'account' | 'bundled';
+}
+export type ProbeResult = ModelProbeResult<CodexModelReport>;
+/**
+ * Turn the `data` of a `model/list` answer into a report. Hidden models
+ * (codex's internal reviewers and the like) are left out. Returns null when
+ * nothing usable is in there.
+ */
+export declare function parseModelList(raw: unknown, scope: CodexModelReport['scope']): CodexModelReport | null;
+/** What a picker can offer: every level some listed model takes, in order. */
+export declare function offeredEfforts(report: CodexModelReport): RuntimeEffortLevel[];
+export type ProbeLogin = {
+    use: true;
+    file: string;
+} | {
+    use: false;
+    why: string;
+};
+/**
+ * May the probe use this login? Only if nothing about it can change while the
+ * probe runs: an API key never does, and a ChatGPT login only while its token
+ * is fresh. Never throws.
+ */
+export declare function loginForProbe(codexHome: string, now?: number): ProbeLogin;
+/**
+ * Ask one codex binary for its models. Never throws; resolves within
+ * `timeoutMs` however the CLI behaves, and leaves no process behind.
+ */
+export declare function probeCodexModels(bin: string, opts?: {
+    timeoutMs?: number;
+    /** Where the login lives. Runs link it from ~/.codex (writeCodexHome), so
+     *  the probe does too. */
+    codexHome?: string;
+    now?: number;
+    /** Tests only: run something else in place of the CLI. */
+    resolve?: (bin: string, args: string[]) => CliInvocation;
+    /** Tests only: where the throwaway CODEX_HOME goes. */
+    dir?: string;
+}): Promise<ProbeResult>;
+export interface CodexModelCacheDeps {
+    probe: (bin: string) => Promise<ProbeResult>;
+    now: () => number;
+    log: (line: string) => void;
+}
+/** Refreshed every 6h, retried 30 min after a failure — see model-cache.ts. */
+export declare function createCodexModelCache(deps: CodexModelCacheDeps): {
+    get(bin: string, key: string): CodexModelReport | null;
+    last(): CodexModelReport | null;
+};
+/** What capabilities.ts reports for codex's models. */
+export declare function codexModelsFor(bin: string, key: string): CodexModelReport | null;
+/**
+ * The effort levels a model takes, from the last list codex gave: the
+ * default model's when none is named. Null when codex never said, or the
+ * model is not in its list.
+ */
+export declare function codexModelEfforts(model?: string | null, report?: CodexModelReport | null): string[] | null;