@giovannijecha/jecode 0.1.8 → 0.2.0

package/dist/provider-commands.js

@@ -1,16 +1,17 @@
-// Provider, model, and setup command flows.
+// Provider and model command flows.
 import { heading } from "./tui/picker.js";
 import { PROVIDERS } from "./providers/index.js";
 import { readSettings } from "./settings.js";
-import { askForKey } from "./credential-commands.js";
+import { authenticationNeed, ensureProviderAuthentication, } from "./credential-commands.js";
 import { providerFailure } from "./provider-errors.js";
+import { providerLabel } from "./provider-label.js";
 /**
  * The provider menu.
  *
  * Every provider is offered, including the ones that cannot run: the reason
  * one is unusable — the variable it wants, by name — is worth more on screen
  * than the row would be worth hidden. A blocked choice opens the same masked
- * credential flow used by setup and settings, and cancellation leaves the old choice.
+ * credential flow used by settings, and cancellation leaves the old choice.
  */
 export async function providersCommand(session, host, behavior = {}) {
     const choose = chooser(host);
@@ -34,32 +35,22 @@ export async function providersCommand(session, host, behavior = {}) {
     // Picking the provider already in use is not a no-op when it cannot run:
     // it is how the user asks to fix the reason it cannot.
     if (chosen.id === session.provider.id) {
-        const blocked = chosen.blocked();
-        if (blocked !== undefined) {
-            if (!isCredentialBlocker(chosen, blocked)) {
-                host.emit({ kind: "notice", text: blocked, tone: "error" });
-                return false;
-            }
-            await askForKey(chosen.keyVar, host, session.palette);
-            if (chosen.blocked() !== undefined)
-                return false;
-        }
-        return true;
+        if (!(await ensureProviderAuthentication(chosen, session, host)))
+            return false;
+        return session.model === ""
+            ? modelsCommand(session, host, { announce: false, save: behavior.save })
+            : true;
     }
     // A provider that cannot run is worth one offer to fix it, here, rather
     // than a note telling the user to leave and export something.
     const blocked = chosen.blocked();
     if (blocked !== undefined) {
-        if (!isCredentialBlocker(chosen, blocked)) {
-            host.emit({ kind: "notice", text: blocked, tone: "error" });
-            return false;
-        }
-        await askForKey(chosen.keyVar, host, session.palette);
+        await ensureProviderAuthentication(chosen, session, host);
         const still = chosen.blocked();
         if (still !== undefined) {
             host.emit({
                 kind: "notice",
-                text: `${providerName(chosen.id)} still needs an API key · provider unchanged`,
+                text: `${providerLabel(chosen.id)} still needs ${authenticationNeed(chosen)} · provider unchanged`,
                 tone: "warn",
             });
             return false;
@@ -77,6 +68,13 @@ export async function providersCommand(session, host, behavior = {}) {
     session.model = readSettings().models?.[chosen.id] ?? chosen.defaultModel;
     session.config.providerId = chosen.id;
     session.config.model = session.model;
+    if (session.model === "" && !(await modelsCommand(session, host, { announce: false, save: false }))) {
+        session.provider = before.provider;
+        session.model = before.model;
+        session.config.providerId = before.providerId;
+        session.config.model = before.configModel;
+        return false;
+    }
     if (behavior.save !== false) {
         const saved = readSettings();
         const models = { ...saved.models };
@@ -93,7 +91,7 @@ export async function providersCommand(session, host, behavior = {}) {
     if (behavior.announce !== false) {
         host.emit({
             kind: "notice",
-            text: session.model === "" ? `${chosen.id} — pick a model with /models` : `${chosen.id} · ${session.model}`,
+            text: session.model === "" ? `provider · ${chosen.id} · pick a model` : `provider · ${chosen.id}`,
             tone: "info",
         });
     }
@@ -111,16 +109,12 @@ export async function modelsCommand(session, host, behavior = {}) {
     // to pick a model, and "go and export a variable" is not an answer.
     const blocked = provider.blocked();
     if (blocked !== undefined) {
-        if (!isCredentialBlocker(provider, blocked)) {
-            host.emit({ kind: "notice", text: blocked, tone: "error" });
-            return false;
-        }
-        await askForKey(provider.keyVar, host, session.palette);
+        await ensureProviderAuthentication(provider, session, host);
         const still = provider.blocked();
         if (still !== undefined) {
             host.emit({
                 kind: "notice",
-                text: `${providerName(provider.id)} still needs an API key`,
+                text: `${providerLabel(provider.id)} still needs ${authenticationNeed(provider)}`,
                 tone: "warn",
             });
             return false;
@@ -171,38 +165,10 @@ export async function modelsCommand(session, host, behavior = {}) {
         }
     }
     if (behavior.announce !== false) {
-        host.emit({ kind: "notice", text: `${provider.id} · ${chosen}`, tone: "info" });
+        host.emit({ kind: "notice", text: `model · ${chosen}`, tone: "info" });
     }
     return true;
 }
-/** Make the provider selected by flags/environment usable without leaving the TUI. */
-export async function setupCommand(session, host) {
-    const blocked = session.provider.blocked();
-    if (blocked !== undefined) {
-        if (!isCredentialBlocker(session.provider, blocked)) {
-            host.emit({ kind: "notice", text: blocked, tone: "error" });
-            return;
-        }
-        const accepted = await askForKey(session.provider.keyVar, host, session.palette);
-        if (!accepted || session.provider.blocked() !== undefined) {
-            host.emit({
-                kind: "notice",
-                text: `${providerName(session.provider.id)} still needs an API key · /setup`,
-                tone: "warn",
-            });
-            return;
-        }
-    }
-    if (session.model === "") {
-        await modelsCommand(session, host);
-        return;
-    }
-    host.emit({
-        kind: "notice",
-        text: `${session.provider.id} · ${session.model} · ${session.provider.location?.() ?? "cloud"} · ready`,
-        tone: "info",
-    });
-}
 /** The way to put a menu up, or nothing — and the reason, already said. */
 function chooser(host) {
     if (host.choose === undefined) {
@@ -210,12 +176,6 @@ function chooser(host) {
     }
     return host.choose;
 }
-function providerName(id) {
-    return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
-}
-function isCredentialBlocker(provider, blocked) {
-    return blocked.startsWith(`${provider.keyVar} `);
-}
 async function saveDefaults(host, patch) {
     if (host.saveSettings === undefined)
         return true;

package/dist/provider-label.js

@@ -0,0 +1,10 @@
+// Stable human-facing names for provider identifiers.
+export function providerLabel(id) {
+    switch (id) {
+        case "anthropic": return "Anthropic";
+        case "openai": return "OpenAI";
+        case "openai-codex": return "OpenAI Codex";
+        case "ollama": return "Ollama";
+        default: return id === "" ? "Provider" : `${id[0]?.toUpperCase() ?? ""}${id.slice(1)}`;
+    }
+}

package/dist/providers/anthropic.js

@@ -27,7 +27,7 @@ export const anthropic = {
     // Sonnet is the default because it is the one that can be left running.
     // Opus via `--model claude-opus-5`, Haiku via `--model claude-haiku-4-5`.
     defaultModel: "claude-sonnet-5",
-    keyVar: KEY,
+    auth: { kind: "api-key", keyVar: KEY },
     blocked() {
         return apiKey() === undefined ? `${KEY} is not set` : undefined;
     },

package/dist/providers/index.js

@@ -1,7 +1,8 @@
 import { anthropic } from "./anthropic.js";
 import { openai } from "./openai.js";
+import { openaiCodex } from "./openai-codex.js";
 import { configureOllama, ollama } from "./ollama.js";
-export const PROVIDERS = [anthropic, openai, ollama];
+export const PROVIDERS = [anthropic, openai, openaiCodex, ollama];
 export function providerNames() {
     return PROVIDERS.map((provider) => provider.id);
 }

package/dist/providers/ollama.js

@@ -25,7 +25,7 @@ export function ollamaConnection() {
 export const ollama = {
     id: "ollama",
     defaultModel: "",
-    keyVar: KEY,
+    auth: { kind: "api-key", keyVar: KEY },
     // The only provider whose key is conditional: a daemon on this machine is
     // reached over loopback and asks for nothing, so demanding a key there
     // would be an invented requirement.

package/dist/providers/openai-codex.js

@@ -0,0 +1,114 @@
+// ChatGPT-backed Codex Responses, kept separate from the OpenAI API provider.
+import { randomUUID } from "node:crypto";
+import { openAICodexAccount } from "../accounts.js";
+import { openAIAuthorization } from "../openai-account.js";
+import { applicationVersion } from "../version.js";
+import { getJson, postSse } from "./http.js";
+import { assembleOpenAI } from "./openai-stream.js";
+import { fromWireResponse, stopNotice, toWireItems, toWireTool, } from "./openai-wire.js";
+const ID = "openai-codex";
+const BASE = "https://chatgpt.com/backend-api/codex";
+// Jecode's product version is unrelated to the Codex protocol gate. OpenAI's
+// own catalogue updater uses this sentinel to request the complete current
+// manifest; Jecode then keeps only entries explicitly visible in that manifest.
+const CATALOG_COMPATIBILITY_VERSION = "99.99.99";
+const SESSION_ID = randomUUID();
+const MAX_CATALOG_ITEMS = 4_000;
+const MAX_MODELS = 1_000;
+const MAX_MODEL_CHARS = 256;
+export const openaiCodex = {
+    id: ID,
+    defaultModel: "",
+    auth: { kind: "oauth", account: ID, label: "ChatGPT" },
+    blocked() {
+        return openAICodexAccount() === undefined ? "ChatGPT account is not connected" : undefined;
+    },
+    location: () => "cloud",
+    async models(signal, onStatus) {
+        return withAuthorization(async (authorization) => {
+            const body = await getJson(`${BASE}/models?client_version=${CATALOG_COMPATIBILITY_VERSION}`, headers(authorization, randomUUID()), signal, onStatus);
+            return modelIds(body);
+        }, signal, onStatus);
+    },
+    async send(req) {
+        return withAuthorization(async (authorization) => {
+            const events = await postSse(`${BASE}/responses`, {
+                ...headers(authorization, randomUUID()),
+                "openai-beta": "responses=experimental",
+            }, {
+                model: req.model,
+                store: false,
+                stream: true,
+                instructions: req.system,
+                input: req.messages.flatMap((message) => toWireItems(message, ID)),
+                tools: req.tools.map(toWireTool),
+                tool_choice: "auto",
+                parallel_tool_calls: true,
+                reasoning: { effort: req.effort, summary: "auto" },
+                text: { verbosity: "low" },
+                include: ["reasoning.encrypted_content"],
+                prompt_cache_key: SESSION_ID,
+            }, 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, ID);
+        }, req.signal, req.onStatus);
+    },
+};
+async function withAuthorization(operation, signal, onStatus) {
+    let authorization = await openAIAuthorization(undefined, signal, onStatus);
+    try {
+        return await operation(authorization);
+    }
+    catch (error) {
+        if (statusOf(error) !== 401)
+            throw error;
+        authorization = await openAIAuthorization(authorization.accessToken, signal, onStatus);
+        return operation(authorization);
+    }
+}
+function headers(authorization, requestId) {
+    const version = applicationVersion();
+    return {
+        authorization: `Bearer ${authorization.accessToken}`,
+        "chatgpt-account-id": authorization.accountId,
+        originator: "jecode",
+        "user-agent": `jecode/${version} (${process.platform}; ${process.arch})`,
+        "session-id": SESSION_ID,
+        "x-client-request-id": requestId,
+    };
+}
+function modelIds(value) {
+    const source = record(value) && Array.isArray(value["models"]) ? value["models"] : undefined;
+    if (source === undefined)
+        throw new Error("OpenAI Codex did not return a model list");
+    const seen = new Set();
+    return source
+        .slice(0, MAX_CATALOG_ITEMS)
+        .flatMap((entry) => {
+        if (!record(entry))
+            return [];
+        const id = entry["slug"];
+        if (typeof id !== "string" ||
+            id === "" ||
+            id.length > MAX_MODEL_CHARS ||
+            entry["visibility"] !== "list" ||
+            seen.has(id))
+            return [];
+        seen.add(id);
+        return [{ id, priority: typeof entry["priority"] === "number" ? entry["priority"] : 0 }];
+    })
+        .sort((left, right) => left.priority - right.priority)
+        .slice(0, MAX_MODELS)
+        .map((entry) => entry.id);
+}
+function statusOf(error) {
+    return typeof error === "object" && error !== null && "status" in error
+        ? error.status
+        : undefined;
+}
+function record(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/providers/openai-stream.js

@@ -1,12 +1,11 @@
 // 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.
+// Unlike Anthropic, a standard Responses stream ends with the whole finished
+// response in `response.completed`. The ChatGPT Codex backend can instead send
+// an empty final `output` after complete `response.output_item.done` events, so
+// those streamed items remain the fallback when the final envelope is empty.
 export async function assembleOpenAI(events, onStream) {
     const items = [];
-    let completed;
     let refusal = false;
     for await (const raw of events) {
         const event = raw;
@@ -29,11 +28,10 @@ export async function assembleOpenAI(events, onStream) {
                 if (event.item !== undefined)
                     items.push(event.item);
                 break;
+            case "response.done":
             case "response.completed":
             case "response.incomplete":
-                if (event.response !== undefined)
-                    completed = event.response;
-                break;
+                return reconcileOutput(event.response, items);
             case "response.failed": {
                 const response = event.response;
                 throw new Error(`openai stream error: ${response?.error?.message ?? "unspecified"}`);
@@ -44,5 +42,11 @@ export async function assembleOpenAI(events, onStream) {
                 break;
         }
     }
-    return completed ?? { output: items };
+    return { output: items };
+}
+function reconcileOutput(completed, items) {
+    if (completed === undefined)
+        return { output: items };
+    const finalCount = Array.isArray(completed.output) ? completed.output.length : 0;
+    return items.length > finalCount ? { ...completed, output: items } : completed;
 }

package/dist/providers/openai-wire.js

@@ -14,8 +14,8 @@ export function toWireTool(tool) {
         parameters: tool.input,
     };
 }
-export function toWireItems(message) {
-    if (message.rawFrom === "openai" && Array.isArray(message.raw)) {
+export function toWireItems(message, providerId = "openai") {
+    if (message.rawFrom === providerId && Array.isArray(message.raw)) {
         return message.raw;
     }
     const items = [];
@@ -50,7 +50,7 @@ export function stopNotice(data) {
         ? "[truncated: hit max_output_tokens — raise --max-tokens]"
         : `[incomplete: ${reason}]`;
 }
-export function fromWireResponse(data) {
+export function fromWireResponse(data, providerId = "openai") {
     const raw = Array.isArray(data.output) ? data.output : [];
     const content = [];
     for (const entry of raw) {
@@ -81,7 +81,7 @@ export function fromWireResponse(data) {
     const notice = stopNotice(data);
     if (notice !== undefined)
         content.push({ kind: "text", text: notice });
-    return { role: "assistant", content, raw, rawFrom: "openai", usage: normalizeUsage(data) };
+    return { role: "assistant", content, raw, rawFrom: providerId, usage: normalizeUsage(data) };
 }
 function normalizeUsage(data) {
     const usage = data.usage;

package/dist/providers/openai.js

@@ -23,7 +23,7 @@ const NON_TEXT_MODE = /(?:^|[-_])(audio|realtime|transcribe|tts)(?:[-_]|$)/;
 export const openai = {
     id: "openai",
     defaultModel: "gpt-5",
-    keyVar: KEY,
+    auth: { kind: "api-key", keyVar: KEY },
     blocked() {
         return apiKey() === undefined ? `${KEY} is not set` : undefined;
     },
@@ -41,7 +41,7 @@ export const openai = {
         const events = await postSse(ENDPOINT, headers(key), {
             model: req.model,
             instructions: req.system,
-            input: req.messages.flatMap(toWireItems),
+            input: req.messages.flatMap((message) => toWireItems(message)),
             tools: req.tools.map(toWireTool),
             max_output_tokens: req.maxTokens,
             reasoning: { effort: normalizeEffort(req.effort), summary: "auto" },

package/dist/providers/sse.js

@@ -76,6 +76,6 @@ function parseData(chunk) {
         return JSON.parse(data);
     }
     catch {
-        return undefined;
+        throw new Error("SSE event contained invalid JSON");
     }
 }

package/dist/settings-command.js

@@ -25,7 +25,7 @@ export async function settingsCommand(session, host) {
         if (index === undefined)
             return;
         const action = items[index]?.action;
-        if (action === undefined || action === "close")
+        if (action === undefined)
             return;
         selected = index;
         switch (action) {
@@ -75,14 +75,21 @@ function settingsItems(values) {
                 }]),
         { 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) } },
+        ...(values.maxTokens === undefined
+            ? []
+            : [{
+                    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" } },
+        {
+            action: "credentials",
+            option: { label: "authentication", hint: "manage API keys and accounts" },
+        },
     ];
 }
 function settingsValues(session) {
@@ -91,7 +98,7 @@ function settingsValues(session) {
         model: session.model,
         ...(session.provider.id === "ollama" ? { ollamaConnection: ollamaConnectionHint() } : {}),
         effort: session.config.effort,
-        maxTokens: session.config.maxTokens,
+        ...(session.provider.id === "openai-codex" ? {} : { maxTokens: session.config.maxTokens }),
         maxSteps: session.config.maxSteps,
         reducedMotion: session.config.reducedMotion,
     };
@@ -187,7 +194,7 @@ async function persist(host, patch) {
         return true;
     }
     catch (error) {
-        host.emit({ kind: "notice", text: `could not save settings: ${error.message}`, tone: "error" });
+        host.emit({ kind: "notice", text: `could not save settings · ${error.message}`, tone: "error" });
         return false;
     }
 }

package/dist/tools/shell.js

@@ -8,7 +8,7 @@ const MAX_OUTPUT_CHARS = 30_000;
 export const runCommand = {
     name: "run_command",
     description: "Run a shell command starting in the workspace root and return its combined stdout " +
-        "and stderr. The shell is not a filesystem sandbox, so every call requires approval. Output is " +
+        "and stderr. The shell is not a filesystem sandbox, so calls ask for approval by default. Output is " +
         "truncated past 30000 characters.",
     dangerous: true,
     input: {

package/dist/transcript.js

@@ -25,9 +25,6 @@ export function transcriptMarkdown(blocks) {
             case "notice":
                 out.push(`> ${block.tone.toUpperCase()}: ${safeMultiline(block.text).replaceAll("\n", "\n> ")}`, "");
                 break;
-            case "list":
-                out.push(...block.items.map((item) => safeInline(item.text)), "");
-                break;
         }
     }
     while (out[out.length - 1] === "")

package/dist/tui/app-workflows.js

@@ -4,24 +4,33 @@ import { runTurn } from "../controller.js";
 import { updateSettings } from "../settings.js";
 import { saveTranscript } from "../transcript-export.js";
 import { recordUsage } from "../usage.js";
-import { answerAt, scopeFor } from "./approve.js";
+import { answerAt } from "./approve.js";
+import { cancel as cancelOpen } from "./overlay.js";
 import { controllerOptions, turnFailure } from "./session-view.js";
 import { transcribe } from "./turn.js";
 const WAITING = "Waiting";
 export function appWorkflows(options) {
-    const { session, state, allowed, feedback } = options;
+    const { session, state, permissions, feedback } = options;
     async function command(text) {
         const activity = options.startActivity("command", `Running ${text.split(/\s+/)[0]}`);
         if (activity === undefined)
             return;
         try {
             const outcome = await handleCommand(text, session, {
-                emit: options.commandOutput,
+                emit: options.commandNotice,
                 signal: activity.control.signal,
+                showHelp: () => new Promise((resolve) => {
+                    state.open = { help: true, settle: resolve };
+                    options.render();
+                }),
                 choose: (picker) => new Promise((resolve) => {
                     state.open = { picker, settle: resolve };
                     options.render();
                 }),
+                dismiss: () => {
+                    state.open = state.open === undefined ? undefined : cancelOpen(state.open);
+                    options.render();
+                },
                 type: (field) => new Promise((resolve) => {
                     state.open = { field, settle: resolve };
                     options.render();
@@ -33,19 +42,13 @@ export function appWorkflows(options) {
                 reset: () => {
                     state.blocks.splice(0);
                     state.past.length = 0;
-                    allowed.clear();
+                    permissions.reset();
                     state.scroll = 0;
                     state.follow = true;
                     state.unseen = 0;
                     state.lastMaxScroll = 0;
                 },
-                permissions: () => [...allowed].map(([key, label]) => ({ key, label })),
-                revokePermission: (key) => {
-                    if (key === undefined)
-                        allowed.clear();
-                    else
-                        allowed.delete(key);
-                },
+                permissions,
                 exportTranscript: () => saveTranscript(options.transcriptRoot, state.blocks),
                 saveSettings: async (patch) => {
                     await updateSettings(patch);
@@ -76,11 +79,8 @@ export function appWorkflows(options) {
             emit: options.emit,
             render: options.render,
             palette: session.palette,
-            approved: (call) => session.config.autoApprove || allowed.has(scopeFor(call).key),
-            remember: (call) => {
-                const scope = scopeFor(call);
-                allowed.set(scope.key, scope.summary);
-            },
+            approved: (call) => permissions.approved(call),
+            remember: (call) => permissions.remember(call),
             ask: (prompt, settle) => {
                 state.open = { picker: prompt, settle: (index) => settle(answerAt(index)) };
                 options.render();
@@ -92,7 +92,7 @@ export function appWorkflows(options) {
         });
         let finishReason;
         try {
-            await runTurn(session.history, controllerOptions(session), events, activity.control.signal);
+            await runTurn(session.history, controllerOptions(session, permissions.availableTools()), events, activity.control.signal);
         }
         catch (error) {
             const interrupted = activity.control.signal.aborted;

package/dist/tui/app.js

@@ -18,6 +18,7 @@ import { transcriptRenderer } from "./transcript-view.js";
 import { appState } from "./app-state.js";
 import { appInput } from "./app-input.js";
 import { appWorkflows } from "./app-workflows.js";
+import { sessionPermissions } from "../permissions.js";
 const FRAME_MS = 16;
 const SPIN_MS = 80;
 /** How long a lone escape waits to prove it is not the start of a sequence. */
@@ -29,9 +30,7 @@ export async function runApp(session, transcriptRoot, environment = {}) {
     const transcript = transcriptRenderer();
     const workspace = await workspaceLabel(session.config.root);
     const state = appState();
-    // Tools the user said "always" to. It lives for the window and dies with it:
-    // a permission granted once, in one conversation, is not a setting.
-    const allowed = new Map();
+    const permissions = sessionPermissions(session.tools, session.config.autoApprove);
     let closed;
     let frameTimer;
     let spinTimer;
@@ -100,12 +99,8 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         else
             state.unseen++;
     };
-    const commandOutput = (block) => {
-        const next = commandFeedback(block);
-        if (next === undefined)
-            emit(block);
-        else
-            feedback.show(next);
+    const commandNotice = (notice) => {
+        feedback.show(commandFeedback(notice));
     };
     const scrollBy = (amount) => {
         state.scroll = Math.max(0, state.scroll + amount);
@@ -177,10 +172,10 @@ export async function runApp(session, transcriptRoot, environment = {}) {
         session,
         transcriptRoot,
         state,
-        allowed,
+        permissions,
         feedback,
         emit,
-        commandOutput,
+        commandNotice,
         render,
         refreshSettings: () => {
             terminal.setReducedMotion(session.config.reducedMotion);