@giovannijecha/jecode 0.1.5-rc.2

package/dist/providers/openai-stream.js

@@ -0,0 +1,48 @@
+// Reassembling an OpenAI Responses reply from its event stream.
+//
+// Unlike Anthropic, this stream ends with the whole finished response in
+// `response.completed`, so there is nothing to rebuild: the deltas drive the
+// display, and the final event is taken as authoritative. Items collected
+// along the way are only a fallback for a stream that ends without it.
+export async function assembleOpenAI(events, onStream) {
+    const items = [];
+    let completed;
+    let refusal = false;
+    for await (const raw of events) {
+        const event = raw;
+        switch (event.type) {
+            case "response.output_text.delta":
+                if (typeof event.delta === "string")
+                    onStream?.({ kind: "text", text: event.delta });
+                break;
+            case "response.refusal.delta":
+                if (typeof event.delta === "string") {
+                    onStream?.({ kind: "text", text: `${refusal ? "" : "[refused] "}${event.delta}` });
+                    refusal = true;
+                }
+                break;
+            case "response.reasoning_summary_text.delta":
+                if (typeof event.delta === "string")
+                    onStream?.({ kind: "thinking", text: event.delta });
+                break;
+            case "response.output_item.done":
+                if (event.item !== undefined)
+                    items.push(event.item);
+                break;
+            case "response.completed":
+            case "response.incomplete":
+                if (event.response !== undefined)
+                    completed = event.response;
+                break;
+            case "response.failed": {
+                const response = event.response;
+                throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
+            }
+            case "error":
+                throw new Error(`openai stream error: ${event.error?.message ?? event.message ?? "unspecified"}`);
+            default:
+                break;
+        }
+    }
+    return completed ?? { output: items };
+}

package/dist/providers/openai-wire.js

@@ -0,0 +1,112 @@
+// Translation between the normalized vocabulary and the OpenAI Responses wire
+// shape: a flat `input` list where tool calls and their outputs are top-level
+// items keyed by `call_id`, rather than blocks nested inside a message.
+// The Responses API has no `xhigh`; collapse it onto the nearest level rather
+// than passing through a value it will reject.
+export function normalizeEffort(effort) {
+    return effort === "xhigh" || effort === "max" ? "high" : effort;
+}
+export function toWireTool(tool) {
+    return {
+        type: "function",
+        name: tool.name,
+        description: tool.description,
+        parameters: tool.input,
+    };
+}
+export function toWireItems(message) {
+    if (message.rawFrom === "openai" && Array.isArray(message.raw)) {
+        return message.raw;
+    }
+    const items = [];
+    const texts = [];
+    for (const block of message.content) {
+        if (block.kind === "text") {
+            texts.push(block.text);
+        }
+        else if (block.kind === "tool_call") {
+            items.push({
+                type: "function_call",
+                call_id: block.id,
+                name: block.name,
+                arguments: JSON.stringify(block.input),
+            });
+        }
+        else {
+            items.push({ type: "function_call_output", call_id: block.id, output: block.output });
+        }
+    }
+    if (texts.length > 0) {
+        const type = message.role === "assistant" ? "output_text" : "input_text";
+        items.unshift({ role: message.role, content: [{ type, text: texts.join("\n") }] });
+    }
+    return items;
+}
+export function stopNotice(data) {
+    const reason = data.incomplete_details?.reason;
+    if (reason === undefined)
+        return undefined;
+    return reason === "max_output_tokens"
+        ? "[truncated: hit max_output_tokens — raise --max-tokens]"
+        : `[incomplete: ${reason}]`;
+}
+export function fromWireResponse(data) {
+    const raw = Array.isArray(data.output) ? data.output : [];
+    const content = [];
+    for (const entry of raw) {
+        const item = entry;
+        if (item.type === "message" && Array.isArray(item.content)) {
+            for (const part of item.content) {
+                const piece = part;
+                if (piece.type === "output_text" && typeof piece.text === "string") {
+                    content.push({ kind: "text", text: piece.text });
+                }
+                else if (piece.type === "refusal" && typeof piece.refusal === "string") {
+                    content.push({ kind: "text", text: `[refused] ${piece.refusal}` });
+                }
+            }
+        }
+        else if (item.type === "function_call" &&
+            typeof item.call_id === "string" &&
+            typeof item.name === "string") {
+            content.push({
+                kind: "tool_call",
+                id: item.call_id,
+                name: item.name,
+                input: parseArguments(item.arguments),
+            });
+        }
+        // reasoning items and anything future: carried in `raw` only.
+    }
+    const notice = stopNotice(data);
+    if (notice !== undefined)
+        content.push({ kind: "text", text: notice });
+    return { role: "assistant", content, raw, rawFrom: "openai", usage: normalizeUsage(data) };
+}
+function normalizeUsage(data) {
+    const usage = data.usage;
+    if (usage === undefined || usage === null)
+        return undefined;
+    return {
+        inputTokens: usage.input_tokens ?? 0,
+        outputTokens: usage.output_tokens ?? 0,
+        cachedInputTokens: usage.input_tokens_details?.cached_tokens ?? 0,
+        cacheWriteInputTokens: usage.input_tokens_details?.cache_write_tokens ?? 0,
+        reasoningTokens: usage.output_tokens_details?.reasoning_tokens ?? 0,
+    };
+}
+// Arguments arrive as a JSON string and models vary in how they escape it, so
+// this always goes through a real parse — never string matching.
+function parseArguments(text) {
+    if (text === undefined || text === "")
+        return {};
+    try {
+        const parsed = JSON.parse(text);
+        return typeof parsed === "object" && parsed !== null
+            ? parsed
+            : {};
+    }
+    catch {
+        return {};
+    }
+}

package/dist/providers/openai.js

@@ -0,0 +1,70 @@
+// OpenAI Responses API, spoken directly.
+//
+// Responses wire contract verified against the official API reference on
+// 2026-08-29. Keep final response events authoritative over display deltas.
+import { postSse } from "./http.js";
+import { listModels } from "./catalog.js";
+import { keyFor } from "../credentials.js";
+import { assembleOpenAI } from "./openai-stream.js";
+import { fromWireResponse, normalizeEffort, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+const ENDPOINT = "https://api.openai.com/v1/responses";
+const MODELS = "https://api.openai.com/v1/models";
+const KEY = "OPENAI_API_KEY";
+/**
+ * What this account can reach that is not a chat model.
+ *
+ * The list is an exclusion rather than an allow-list on purpose: an unknown
+ * `gpt-`something is far more likely to be a model worth offering than one
+ * worth hiding, and an allow-list would quietly bury every family shipped
+ * after this line was written.
+ */
+const NOT_CHAT = /^(text-|tts-|whisper|dall-e|sora|gpt-image|omni-moderation|davinci|babbage)/;
+const NON_TEXT_MODE = /(?:^|[-_])(audio|realtime|transcribe|tts)(?:[-_]|$)/;
+export const openai = {
+    id: "openai",
+    defaultModel: "gpt-5",
+    keyVar: KEY,
+    blocked() {
+        return apiKey() === undefined ? `${KEY} is not set` : undefined;
+    },
+    // The endpoint answers in no order worth keeping, so descending puts the
+    // highest-numbered family — usually the newest — at the top of the menu.
+    async models(signal, onStatus) {
+        const ids = await listModels(MODELS, headers(requireKey()), signal, onStatus);
+        return ids
+            .filter((id) => !NOT_CHAT.test(id) && !NON_TEXT_MODE.test(id))
+            .sort((a, b) => b.localeCompare(a));
+    },
+    location: () => "cloud",
+    async send(req) {
+        const key = requireKey();
+        const events = await postSse(ENDPOINT, headers(key), {
+            model: req.model,
+            instructions: req.system,
+            input: req.messages.flatMap(toWireItems),
+            tools: req.tools.map(toWireTool),
+            max_output_tokens: req.maxTokens,
+            reasoning: { effort: normalizeEffort(req.effort), summary: "auto" },
+            store: false,
+            include: ["reasoning.encrypted_content"],
+            stream: true,
+        }, req.signal, req.onStatus);
+        const data = await assembleOpenAI(events, req.onStream);
+        const notice = stopNotice(data);
+        if (notice !== undefined)
+            req.onStream?.({ kind: "text", text: `\n${notice}` });
+        return fromWireResponse(data);
+    },
+};
+function apiKey() {
+    return keyFor(KEY);
+}
+function requireKey() {
+    const key = apiKey();
+    if (key === undefined)
+        throw new Error(`${KEY} is not set`);
+    return key;
+}
+function headers(key) {
+    return { authorization: `Bearer ${key}` };
+}

package/dist/providers/sse.js

@@ -0,0 +1,81 @@
+// Server-sent events, read off a fetch response body.
+//
+// The format is small: `field: value` lines, a blank line ends an event. Only
+// `data` matters here — both providers put the event discriminator inside the
+// JSON payload, so the `event:` line is redundant and skipped.
+import { addBounded, MAX_SSE_EVENT_CHARS, MAX_SSE_STREAM_CHARS, } from "./stream-limits.js";
+export async function* readSseJson(body) {
+    const reader = body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    let finished = false;
+    let total = 0;
+    const append = (text) => {
+        total = addBounded(total, text.length, MAX_SSE_STREAM_CHARS, "SSE stream");
+        buffer += text;
+    };
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            append(decoder.decode(value, { stream: true }));
+            for (;;) {
+                const boundary = findBoundary(buffer);
+                if (boundary === undefined)
+                    break;
+                assertEventSize(boundary.start);
+                const chunk = buffer.slice(0, boundary.start);
+                buffer = buffer.slice(boundary.end);
+                const payload = parseData(chunk);
+                if (payload !== undefined)
+                    yield payload;
+            }
+            assertEventSize(buffer.length);
+        }
+        // A stream that ends without a trailing blank line still owes us its last
+        // event.
+        append(decoder.decode());
+        assertEventSize(buffer.length);
+        const payload = parseData(buffer);
+        if (payload !== undefined)
+            yield payload;
+        finished = true;
+    }
+    finally {
+        if (!finished)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+}
+function assertEventSize(length) {
+    if (length > MAX_SSE_EVENT_CHARS) {
+        throw new Error(`SSE event exceeded ${MAX_SSE_EVENT_CHARS} characters`);
+    }
+}
+// Handles both LF and CRLF framing without normalising the buffer first — a
+// normalising pass would have to cope with a \r\n split across two chunks.
+function findBoundary(buffer) {
+    const lf = buffer.indexOf("\n\n");
+    const crlf = buffer.indexOf("\r\n\r\n");
+    if (lf === -1 && crlf === -1)
+        return undefined;
+    if (crlf !== -1 && (lf === -1 || crlf < lf))
+        return { start: crlf, end: crlf + 4 };
+    return { start: lf, end: lf + 2 };
+}
+function parseData(chunk) {
+    const data = chunk
+        .split(/\r?\n/)
+        .filter((line) => line.startsWith("data:"))
+        .map((line) => line.slice("data:".length).trimStart())
+        .join("\n");
+    if (data === "" || data === "[DONE]")
+        return undefined;
+    try {
+        return JSON.parse(data);
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/providers/stream-limits.js

@@ -0,0 +1,11 @@
+// Response streams are remote input. Bound the pieces that otherwise grow
+// independently of the request's output-token setting.
+export const MAX_SSE_EVENT_CHARS = 1_000_000;
+export const MAX_SSE_STREAM_CHARS = 4_000_000;
+export const MAX_TOOL_ARGUMENT_CHARS = 1_000_000;
+export function addBounded(total, added, maximum, label) {
+    if (added > maximum - total) {
+        throw new Error(`${label} exceeded ${maximum} characters`);
+    }
+    return total + added;
+}

package/dist/session.js

@@ -0,0 +1,3 @@
+// What one run holds. Its own module so the app and the slash commands can
+// both depend on the shape without depending on each other.
+export {};

package/dist/settings-command.js

@@ -0,0 +1,202 @@
+// The persistent settings hub. Every interaction uses the shared dock picker
+// and field contracts; this module owns choices and persistence, not drawing.
+import { modelsCommand, providersCommand } from "./provider-commands.js";
+import { credentialsCommand } from "./credential-commands.js";
+import { EFFORTS, readSettings, settingsLabel, updateSettings } from "./settings.js";
+import { ollamaConnectionHint, ollamaConnectionSetting, } from "./ollama-settings-command.js";
+import { of } from "./tui/editor.js";
+import { heading } from "./tui/picker.js";
+/** A focused path to the same saved reasoning default exposed by /settings. */
+export async function effortCommand(session, host) {
+    const value = await effortSetting(session, host);
+    if (value === undefined)
+        return;
+    host.emit({ kind: "notice", text: `effort · ${value}`, tone: "info" });
+}
+export async function settingsCommand(session, host) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return;
+    let selected = 0;
+    while (true) {
+        const values = settingsValues(session);
+        const items = settingsItems(values);
+        const index = await choose(settingsPicker(values, session.palette, selected));
+        if (index === undefined)
+            return;
+        const action = items[index]?.action;
+        if (action === undefined || action === "close")
+            return;
+        selected = index;
+        switch (action) {
+            case "provider":
+                await providerSetting(session, host);
+                break;
+            case "ollamaConnection":
+                await ollamaConnectionSetting(session, host, (patch) => persist(host, patch));
+                break;
+            case "model":
+                await modelSetting(session, host);
+                break;
+            case "effort":
+                await effortSetting(session, host);
+                break;
+            case "maxTokens":
+                await numberSetting(session, host, "maxTokens", "max output tokens");
+                break;
+            case "maxSteps":
+                await numberSetting(session, host, "maxSteps", "max tool steps");
+                break;
+            case "reducedMotion":
+                await motionSetting(session, host);
+                break;
+            case "credentials":
+                await credentialsCommand(session, host);
+                break;
+        }
+    }
+}
+export function settingsPicker(values, pal, index = 0, store = settingsLabel()) {
+    return {
+        title: heading("settings", store, pal),
+        right: "↑↓ enter · esc close",
+        footer: "Changes apply now · flags and environment win at launch",
+        options: settingsItems(values).map((item) => item.option),
+        index,
+    };
+}
+function settingsItems(values) {
+    return [
+        { action: "provider", option: { label: "provider", hint: values.provider } },
+        ...(values.ollamaConnection === undefined
+            ? []
+            : [{
+                    action: "ollamaConnection",
+                    option: { label: "ollama connection", hint: values.ollamaConnection },
+                }]),
+        { action: "model", option: { label: "model", hint: values.model || "choose a model" } },
+        { action: "effort", option: { label: "effort", hint: values.effort } },
+        { action: "maxTokens", option: { label: "max output tokens", hint: String(values.maxTokens) } },
+        { action: "maxSteps", option: { label: "max tool steps", hint: String(values.maxSteps) } },
+        {
+            action: "reducedMotion",
+            option: { label: "reduced motion", hint: values.reducedMotion ? "on" : "off" },
+        },
+        { action: "credentials", option: { label: "credentials", hint: "manage API keys" } },
+        { action: "close", option: { label: "close" } },
+    ];
+}
+function settingsValues(session) {
+    return {
+        provider: session.provider.id,
+        model: session.model,
+        ...(session.provider.id === "ollama" ? { ollamaConnection: ollamaConnectionHint() } : {}),
+        effort: session.config.effort,
+        maxTokens: session.config.maxTokens,
+        maxSteps: session.config.maxSteps,
+        reducedMotion: session.config.reducedMotion,
+    };
+}
+async function providerSetting(session, host) {
+    const before = {
+        provider: session.provider,
+        model: session.model,
+        providerId: session.config.providerId,
+        configModel: session.config.model,
+    };
+    if (!(await providersCommand(session, host, { announce: false, save: false })))
+        return;
+    const current = readSettings();
+    const models = { ...current.models };
+    if (session.model !== "")
+        models[session.provider.id] = session.model;
+    if (await persist(host, { provider: session.provider.id, models }))
+        return;
+    session.provider = before.provider;
+    session.model = before.model;
+    session.config.providerId = before.providerId;
+    session.config.model = before.configModel;
+}
+async function modelSetting(session, host) {
+    const before = { model: session.model, configModel: session.config.model };
+    if (!(await modelsCommand(session, host, { announce: false, save: false })))
+        return;
+    const current = readSettings();
+    const models = { ...current.models, [session.provider.id]: session.model };
+    if (await persist(host, { models }))
+        return;
+    session.model = before.model;
+    session.config.model = before.configModel;
+}
+async function effortSetting(session, host) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return;
+    const current = session.config.effort;
+    const index = await choose({
+        title: heading("effort", "saved default", session.palette),
+        right: "↑↓ enter · esc back",
+        options: EFFORTS.map((value) => ({ label: value })),
+        index: Math.max(0, EFFORTS.findIndex((value) => value === current)),
+    });
+    const value = index === undefined ? undefined : EFFORTS[index];
+    if (value === undefined || !(await persist(host, { effort: value })))
+        return;
+    session.config.effort = value;
+    return value;
+}
+async function motionSetting(session, host) {
+    const choose = chooser(host);
+    if (choose === undefined)
+        return;
+    const values = [false, true];
+    const index = await choose({
+        title: heading("reduced motion", "saved default", session.palette),
+        right: "↑↓ enter · esc back",
+        options: values.map((value) => ({ label: value ? "on" : "off" })),
+        index: session.config.reducedMotion ? 1 : 0,
+    });
+    const value = index === undefined ? undefined : values[index];
+    if (value === undefined || !(await persist(host, { reducedMotion: value })))
+        return;
+    session.config.reducedMotion = value;
+    host.refreshSettings?.();
+}
+async function numberSetting(session, host, name, label) {
+    if (host.type === undefined)
+        return;
+    const field = {
+        title: heading(label, "positive integer", session.palette),
+        right: "enter save · esc back",
+        editor: of(String(session.config[name])),
+        secret: false,
+        note: "Applies to the next model turn.",
+    };
+    const text = await host.type(field);
+    if (text === undefined)
+        return;
+    const value = Number(text);
+    if (!Number.isSafeInteger(value) || value <= 0) {
+        host.emit({ kind: "notice", text: `${label} must be a positive integer`, tone: "error" });
+        return;
+    }
+    if (!(await persist(host, { [name]: value })))
+        return;
+    session.config[name] = value;
+}
+async function persist(host, patch) {
+    try {
+        await updateSettings(patch);
+        return true;
+    }
+    catch (error) {
+        host.emit({ kind: "notice", text: `could not save settings: ${error.message}`, tone: "error" });
+        return false;
+    }
+}
+function chooser(host) {
+    if (host.choose === undefined) {
+        host.emit({ kind: "notice", text: "that command needs the screen", tone: "warn" });
+    }
+    return host.choose;
+}

package/dist/settings.js

@@ -0,0 +1,98 @@
+// Persistent, non-secret defaults for interactive and batch sessions.
+import { readFileSync } from "node:fs";
+import { chmod, mkdir } from "node:fs/promises";
+import * as path from "node:path";
+import { atomicWrite } from "./atomic.js";
+import { providerNames } from "./providers/index.js";
+import { parseOllamaEndpoint } from "./providers/ollama-endpoint.js";
+import { userDataLabel, userDataPath } from "./user-data.js";
+export const EFFORTS = ["low", "medium", "high", "xhigh", "max"];
+let saved;
+export function readSettings() {
+    if (saved === undefined)
+        saved = readStore();
+    return copy(saved);
+}
+export async function updateSettings(patch) {
+    const next = normalize({ ...readSettings(), ...patch });
+    const file = settingsPath();
+    const directory = path.dirname(file);
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+    if (process.platform !== "win32")
+        await chmod(directory, 0o700);
+    await atomicWrite(file, `${JSON.stringify(next, null, 2)}\n`, { mode: 0o600 });
+    saved = next;
+    return file;
+}
+export function settingsPath() {
+    return userDataPath("settings.json");
+}
+export function settingsLabel() {
+    return userDataLabel("settings.json");
+}
+/** Forget the cached read so tests and explicit reloads see the disk again. */
+export function reloadSettings() {
+    saved = undefined;
+}
+function readStore() {
+    try {
+        return normalize(JSON.parse(readFileSync(settingsPath(), "utf8")));
+    }
+    catch {
+        // Missing, unreadable, and malformed stores all fall back safely. A bad
+        // preference must never prevent the agent from starting.
+        return {};
+    }
+}
+function normalize(value) {
+    if (!record(value))
+        return {};
+    const providers = providerNames();
+    const provider = member(value["provider"], providers);
+    const models = modelsOf(value["models"], providers);
+    const ollamaHost = endpoint(value["ollamaHost"]);
+    const effort = member(value["effort"], EFFORTS);
+    const reducedMotion = typeof value["reducedMotion"] === "boolean" ? value["reducedMotion"] : undefined;
+    const maxTokens = positiveInteger(value["maxTokens"]);
+    const maxSteps = positiveInteger(value["maxSteps"]);
+    return {
+        ...(provider === undefined ? {} : { provider }),
+        ...(models === undefined ? {} : { models }),
+        ...(ollamaHost === undefined ? {} : { ollamaHost }),
+        ...(effort === undefined ? {} : { effort }),
+        ...(reducedMotion === undefined ? {} : { reducedMotion }),
+        ...(maxTokens === undefined ? {} : { maxTokens }),
+        ...(maxSteps === undefined ? {} : { maxSteps }),
+    };
+}
+function modelsOf(value, providers) {
+    if (!record(value))
+        return undefined;
+    const models = Object.fromEntries(Object.entries(value).filter((entry) => providers.includes(entry[0]) && typeof entry[1] === "string" && entry[1].trim() !== ""));
+    return Object.keys(models).length === 0 ? undefined : models;
+}
+function member(value, values) {
+    return typeof value === "string" && values.includes(value) ? value : undefined;
+}
+function endpoint(value) {
+    if (typeof value !== "string")
+        return undefined;
+    try {
+        return parseOllamaEndpoint(value).baseUrl;
+    }
+    catch {
+        return undefined;
+    }
+}
+function positiveInteger(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0 ? value : undefined;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function copy(value) {
+    return {
+        ...value,
+        ...(value.models === undefined ? {} : { models: { ...value.models } }),
+    };
+}

package/dist/start.js

@@ -0,0 +1,47 @@
+// Application bootstrap: resolve one session, then choose its terminal surface.
+import * as path from "node:path";
+import { runBatch } from "./batch.js";
+import { showCliInfo } from "./cli-info.js";
+import { loadConfig } from "./config.js";
+import { systemPrompt } from "./prompt.js";
+import { configureProviders, selectProvider } from "./providers/index.js";
+import { builtinTools } from "./tools/index.js";
+import { configureColor } from "./ui/render.js";
+import { STEEL } from "./ui/theme.js";
+import { emptyUsage } from "./usage.js";
+import { runApp } from "./tui/app.js";
+import { interactive } from "./tui/screen.js";
+export async function start(args = process.argv.slice(2), environment = {}) {
+    const applicationRoot = environment.applicationRoot ?? path.resolve(import.meta.dirname, "..");
+    const transcriptRoot = environment.transcriptRoot ?? process.cwd();
+    const write = environment.write ?? ((text) => process.stdout.write(text));
+    if (await showCliInfo(args, applicationRoot, write))
+        return;
+    const config = loadConfig(args);
+    configureProviders(config);
+    const provider = selectProvider(config.providerId);
+    const hasScreen = environment.interactive?.() ?? interactive();
+    // A provider whose catalogue is not fixed has no sensible default model.
+    // The TUI can ask; a pipe cannot, so batch mode still requires one up front.
+    const model = config.model === "" ? provider.defaultModel : config.model;
+    if (model === "" && !hasScreen) {
+        throw new Error(`${provider.id} has no default model — pass --model <id> (or set JECODE_MODEL)`);
+    }
+    configureColor(hasScreen);
+    const session = {
+        config,
+        provider,
+        model,
+        palette: STEEL,
+        tools: builtinTools(),
+        system: systemPrompt(config),
+        history: [],
+        usage: emptyUsage(),
+    };
+    if (hasScreen) {
+        await (environment.runInteractive ?? runApp)(session, transcriptRoot);
+    }
+    else {
+        await (environment.runNonInteractive ?? runBatch)(session);
+    }
+}