@oar-sh/oar 0.9.23 → 0.9.25

package/server/public/app/agent-sdk-ui.js

@@ -0,0 +1,349 @@
+// Agent SDK rows inside Settings: the Claude Agent SDK in the Claude, Claude
+// API and DeepSeek tabs, the Cursor SDK in the Cursor tab, and the Windows
+// helper (koffi, the relay's own lock check) under General.
+//
+// The relay installs these on demand from pins it ships (agent-sdk-store.mjs),
+// so a row is mostly a window on the store: its state, the pinned and the
+// installed version, the live npm log, the last error and the next automatic
+// retry, and the one button that state calls for. Nothing here composes a
+// command; the request carries an SDK id and the relay looks it up.
+//
+// Every visible state comes from the `agent_sdk_state` broadcast (the same
+// payload as GET /api/agent-sdks/status), so an install survives closing the
+// modal or being started by a first chat or another device. Rendering reads
+// the latest payload and never assumes a local step sequence; the log is
+// redrawn from the whole buffer whenever `logSeq` moves.
+//
+// The markup holds only empty mounts (`data-agent-sdk="<id>"`); this module
+// draws the row into each. One SDK can have several mounts (Claude's), so the
+// parts are found by `data-part`, not by id. The log is host process output:
+// it goes in with textContent, and the little that goes through innerHTML is
+// static and escaped with escHtml anyway.
+
+import { escHtml } from './store.js';
+import { cancelAgentSdkInstall, getAgentSdkStatus, startAgentSdkInstall } from './api-client.js';
+import { updateProviderReadinessInputs } from './provider-readiness.mjs';
+
+export const AGENT_SDK_IDS = Object.freeze(['claude', 'cursor', 'koffi']);
+const STATES = Object.freeze(['missing', 'installing', 'ready', 'error', 'unsupported']);
+const ACTIONS = Object.freeze(['install', 'retry', 'reinstall', 'cancel']);
+const ACTION_LABELS = Object.freeze({ install: 'Install', retry: 'Retry', reinstall: 'Reinstall', cancel: 'Cancel' });
+// Until the first payload names them.
+const DEFAULT_LABELS = Object.freeze({ claude: 'Claude Agent SDK', cursor: 'Cursor SDK', koffi: 'Windows helper' });
+const STATE_WORDS = Object.freeze({
+  missing: 'Not installed',
+  installing: 'Installing…',
+  ready: 'Installed',
+  error: 'Install failed',
+  unsupported: 'Not available on this platform',
+});
+const LOG_WORDS = Object.freeze({ installing: 'Running', ready: 'Finished', error: 'Failed' });
+
+let sdkState = { root: null, host: null, sdks: {} };
+let loadFailed = false;
+// A request the relay refused before any broadcast, on the row that sent it;
+// the SDK's next transition clears it.
+let localErrors = {};
+const requestsInFlight = new Set();
+// One-shot per failed install: its log opens once, and a later redraw of the
+// same payload does not fight the user closing it.
+const expandedFailures = new Map();
+let statusRefresh = null;
+
+function normalizeId(raw) {
+  const value = String(raw || '').trim().toLowerCase();
+  return AGENT_SDK_IDS.includes(value) ? value : '';
+}
+
+function normalizeState(raw) {
+  const value = String(raw || '').trim().toLowerCase();
+  return STATES.includes(value) ? value : 'missing';
+}
+
+function labelOf(id, status) {
+  return String(status?.label || '').trim() || DEFAULT_LABELS[id] || id;
+}
+
+/** The Windows helper only where it can exist; the SDK rows always. */
+export function isAgentSdkRowShown(id, snapshot) {
+  if (normalizeId(id) !== 'koffi') return true;
+  const status = snapshot?.sdks?.koffi;
+  if (!status || typeof status !== 'object') return false;
+  if (status.support) return status.support !== 'no';
+  return snapshot?.host?.platform === 'win32';
+}
+
+/** "Installed · pinned 0.3.1 · installed 0.3.1", with whose install it waits for. */
+export function agentSdkStatusText(status) {
+  if (!status || typeof status !== 'object') return 'Checking…';
+  const state = normalizeState(status.state);
+  const heldBy = Number(status.heldBy) || 0;
+  const parts = [state === 'installing' && heldBy
+    ? `Installing by another OAR process (pid ${heldBy})…`
+    : STATE_WORDS[state]];
+  const pinned = String(status.pinned || '').trim();
+  const installed = String(status.installed || '').trim();
+  if (pinned) parts.push(`pinned ${pinned}`);
+  if (installed) parts.push(`installed ${installed}`);
+  else if (state !== 'unsupported') parts.push('none installed');
+  return parts.join(' · ');
+}
+
+export function agentSdkStatusState(status) {
+  if (!status || typeof status !== 'object') return 'pending';
+  const state = normalizeState(status.state);
+  if (state === 'ready') return 'active';
+  if (state === 'error' && status.kind !== 'cancelled') return 'error';
+  if (state === 'installing') return 'pending';
+  return 'unconfigured';
+}
+
+function formatRetryTime(iso) {
+  const at = new Date(iso);
+  if (Number.isNaN(at.getTime())) return '';
+  try {
+    return at.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' });
+  } catch {
+    return at.toISOString().slice(11, 16);
+  }
+}
+
+/** The line under the row: the error, the next automatic retry. */
+export function agentSdkNoteText(status) {
+  if (!status || typeof status !== 'object') return '';
+  const state = normalizeState(status.state);
+  const parts = [];
+  // "Not available" is the whole story already in the status line.
+  const error = String(status.error || '').trim();
+  if (error && state === 'error') parts.push(error);
+  if (status.retryAt && state === 'error') {
+    const time = formatRetryTime(status.retryAt);
+    if (time) parts.push(`Next automatic retry at ${time}.`);
+  }
+  return parts.join(' ');
+}
+
+/** The buttons a row offers, in order. */
+export function agentSdkActions(status, { reinstall = true } = {}) {
+  if (!status || typeof status !== 'object') return [];
+  switch (normalizeState(status.state)) {
+    case 'missing': return ['install'];
+    case 'installing': return ['cancel'];
+    case 'error': return ['retry'];
+    case 'ready': return reinstall ? ['reinstall'] : [];
+    default: return [];
+  }
+}
+
+export function agentSdkLogSummary(status) {
+  const word = status?.kind === 'cancelled' ? 'Cancelled' : (LOG_WORDS[normalizeState(status?.state)] || 'Install');
+  return `${word} · install log`;
+}
+
+function part(mount, name) {
+  return mount.querySelector(`[data-part="${name}"]`);
+}
+
+function setHidden(element, hidden) {
+  if (element) element.hidden = !!hidden;
+}
+
+function mountSkeleton(mount, id) {
+  if (mount.dataset.agentSdkMounted === '1') return;
+  mount.dataset.agentSdkMounted = '1';
+  const buttons = ACTIONS.map((action) => (
+    `<button type="button" class="summary-btn" data-action="${escHtml(action)}" hidden>${escHtml(ACTION_LABELS[action])}</button>`
+  )).join('');
+  mount.innerHTML = `
+    <div class="settings-row" style="margin-bottom: 0;">
+      <span class="cli-install-label" data-part="label">${escHtml(DEFAULT_LABELS[id])}</span>
+      <div class="settings-help settings-provider-status" data-part="status" style="flex: 1 1 auto;">Checking…</div>
+      <div class="settings-inline-actions">${buttons}</div>
+    </div>
+    <div class="settings-help settings-provider-status settings-gap-xs" data-part="note" hidden></div>
+    <details class="cli-install-log" data-part="log-details" hidden>
+      <summary data-part="log-summary">Install log</summary>
+      <pre data-part="log"></pre>
+    </details>
+  `;
+  for (const button of mount.querySelectorAll('button[data-action]')) {
+    button.addEventListener('click', () => { void runAgentSdkAction(id, button.dataset.action); });
+  }
+}
+
+function renderMount(mount, { expandFailure = false } = {}) {
+  const id = normalizeId(mount.dataset.agentSdk);
+  if (!id) return;
+  mountSkeleton(mount, id);
+  const status = sdkState.sdks?.[id] || null;
+  const shown = isAgentSdkRowShown(id, sdkState);
+  setHidden(mount, !shown);
+  if (!shown) return;
+
+  const label = part(mount, 'label');
+  if (label) label.textContent = labelOf(id, status);
+
+  const statusLine = part(mount, 'status');
+  if (statusLine) {
+    // The same words as the store's error, which the note shows already.
+    const localError = localErrors[id] && localErrors[id] !== String(status?.error || '').trim() ? localErrors[id] : '';
+    statusLine.textContent = localError
+      || (!status && loadFailed ? 'Unable to load the SDK status.' : agentSdkStatusText(status));
+    statusLine.dataset.state = localError || (!status && loadFailed) ? 'error' : agentSdkStatusState(status);
+  }
+
+  // The Windows helper has nothing to reinstall: its state and a Retry.
+  const offered = agentSdkActions(status, { reinstall: id !== 'koffi' });
+  const busy = requestsInFlight.has(id);
+  for (const button of mount.querySelectorAll('button[data-action]')) {
+    const action = button.dataset.action;
+    setHidden(button, !offered.includes(action));
+    // canInstall is false while spawns are off or the folder is unusable;
+    // Cancel needs nothing but the install it stops.
+    button.disabled = busy || (action !== 'cancel' && status?.canInstall === false);
+  }
+
+  const note = part(mount, 'note');
+  const noteText = agentSdkNoteText(status);
+  if (note) {
+    note.textContent = noteText;
+    note.dataset.state = noteText && status?.kind !== 'cancelled' ? 'error' : '';
+  }
+  setHidden(note, !noteText);
+
+  const details = part(mount, 'log-details');
+  const log = String(status?.log || '');
+  const showLog = !!status && (normalizeState(status.state) === 'installing' || log.length > 0);
+  setHidden(details, !showLog);
+  const summary = part(mount, 'log-summary');
+  if (summary && status) summary.textContent = agentSdkLogSummary(status);
+  const logBox = part(mount, 'log');
+  // Keyed on the install, not on logSeq alone: a new install starts with an
+  // empty buffer.
+  const logKey = `${status?.startedAt || ''}|${status?.logSeq || 0}`;
+  if (logBox && showLog && mount.dataset.logKey !== logKey) {
+    logBox.textContent = log;
+    logBox.scrollTop = logBox.scrollHeight;
+    mount.dataset.logKey = logKey;
+  }
+  if (details && showLog && expandFailure) details.open = true;
+}
+
+export function renderAgentSdkRows() {
+  if (typeof document === 'undefined') return;
+  const expand = new Set();
+  for (const id of AGENT_SDK_IDS) {
+    const status = sdkState.sdks?.[id];
+    if (!status || normalizeState(status.state) !== 'error' || !status.log) continue;
+    const signature = `${status.startedAt || ''}|${status.finishedAt || ''}`;
+    if (expandedFailures.get(id) === signature) continue;
+    expandedFailures.set(id, signature);
+    if (status.kind !== 'cancelled') expand.add(id);
+  }
+  for (const mount of document.querySelectorAll('[data-agent-sdk]')) {
+    renderMount(mount, { expandFailure: expand.has(normalizeId(mount.dataset.agentSdk)) });
+  }
+}
+
+// A broadcast can outrun the HTTP response that started it. Within one
+// install (same startedAt) logSeq only grows, so an older snapshot never
+// regresses the log or the state.
+function isStaleStatus(current, incoming) {
+  if (!current || !incoming) return false;
+  if (current.startedAt && incoming.startedAt && incoming.startedAt < current.startedAt) return true;
+  if (!current.startedAt || current.startedAt !== incoming.startedAt) return false;
+  const currentSeq = Number(current.logSeq || 0);
+  const incomingSeq = Number(incoming.logSeq || 0);
+  if (incomingSeq < currentSeq) return true;
+  // Equal: a settled install is not reopened by the slower answer that
+  // snapshotted its start.
+  return incomingSeq === currentSeq
+    && normalizeState(current.state) !== 'installing'
+    && normalizeState(incoming.state) === 'installing';
+}
+
+/**
+ * Single entry point for every payload (GET, POST answers, the broadcast).
+ * It also feeds provider readiness, so a failed SDK shows up wherever that is
+ * asked.
+ */
+export function applyAgentSdkState(payload) {
+  if (!payload || typeof payload !== 'object' || !payload.sdks || typeof payload.sdks !== 'object') {
+    renderAgentSdkRows();
+    return sdkState;
+  }
+  const sdks = { ...sdkState.sdks };
+  for (const id of AGENT_SDK_IDS) {
+    const incoming = payload.sdks[id];
+    if (!incoming || typeof incoming !== 'object' || isStaleStatus(sdks[id], incoming)) continue;
+    const before = sdks[id];
+    if (!before || before.state !== incoming.state || before.startedAt !== incoming.startedAt) delete localErrors[id];
+    sdks[id] = incoming;
+  }
+  sdkState = {
+    root: typeof payload.root === 'string' ? payload.root : sdkState.root,
+    host: payload.host && typeof payload.host === 'object' ? payload.host : sdkState.host,
+    sdks,
+  };
+  loadFailed = false;
+  updateProviderReadinessInputs({ agentSdks: sdkState });
+  renderAgentSdkRows();
+  return sdkState;
+}
+
+export function getAgentSdkState() {
+  return sdkState;
+}
+
+/** Reads the rows; a second caller joins the read in flight. */
+export function refreshAgentSdkRows() {
+  if (statusRefresh) return statusRefresh;
+  const promise = (async () => {
+    try {
+      const payload = await getAgentSdkStatus();
+      if (!payload) {
+        loadFailed = true;
+        renderAgentSdkRows();
+        return null;
+      }
+      return applyAgentSdkState(payload);
+    } finally {
+      if (statusRefresh === promise) statusRefresh = null;
+    }
+  })();
+  statusRefresh = promise;
+  return promise;
+}
+
+/** Install, Retry, Reinstall or Cancel, from a row's button. */
+export async function runAgentSdkAction(sdk, action) {
+  const id = normalizeId(sdk);
+  const wanted = ACTIONS.includes(action) ? action : '';
+  if (!id || !wanted || requestsInFlight.has(id)) return;
+  requestsInFlight.add(id);
+  delete localErrors[id];
+  renderAgentSdkRows();
+  try {
+    const payload = wanted === 'cancel'
+      ? await cancelAgentSdkInstall(id)
+      : await startAgentSdkInstall(id, { reinstall: wanted === 'reinstall' });
+    applyAgentSdkState(payload);
+  } catch (error) {
+    localErrors = { ...localErrors, [id]: String(error?.message || 'The SDK request failed.') };
+    // The refusal carried the rows, but as a throw: read them again.
+    await refreshAgentSdkRows().catch(() => {});
+  } finally {
+    requestsInFlight.delete(id);
+    renderAgentSdkRows();
+  }
+}
+
+/** Tests only. */
+export function resetAgentSdkUiForTests() {
+  sdkState = { root: null, host: null, sdks: {} };
+  loadFailed = false;
+  localErrors = {};
+  requestsInFlight.clear();
+  expandedFailures.clear();
+  statusRefresh = null;
+}

package/server/public/app/api-client.js

@@ -1,5 +1,6 @@
 import { BASE, TOKEN, CLIENT_ID, IS_SHARE_PREVIEW, SHARE_PREVIEW_CONVERSATION_ID, SHARED_CONVERSATION_TOKEN, authHeaders, updateWorkspaceRootHints, applyContextUsageBar, readContextUsageRatio, currentConvId, conversations, setCliOnline, setCloudflaredTunnelState, setActiveRuntimeSessionCount, setRuntimeSessionBindingCount, setContextIndicatorMode, setServerPlatform, setUpdateState } from './store.js';
 import { liveActivityCap } from './live-activity-cap.mjs';
+import { OPENAI_IMAGE_PRESETS_PATH, OPENAI_IMAGE_SETTINGS_FIELDS, OPENAI_IMAGE_USAGE_PATH } from './openai-image-spend.mjs';
 
 // fetch() has no default timeout. Without one, a request issued while the app is
 // being backgrounded can hang indefinitely on a half-open mobile connection and
@@ -331,6 +332,8 @@ export async function updateClaudeSettings({
   enabled = undefined,
   model = undefined,
   enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
   attributionMode = undefined,
   backgroundCommandLimitMinutes = undefined,
 } = {}) {
@@ -338,6 +341,8 @@ export async function updateClaudeSettings({
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+  if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
   if (typeof attributionMode === 'string' && attributionMode.trim()) payload.attributionMode = attributionMode.trim();
   if (Number.isFinite(backgroundCommandLimitMinutes)) payload.backgroundCommandLimitMinutes = backgroundCommandLimitMinutes;
   return settingsRequest('/api/settings/claude', payload, 'Failed to update Claude settings');
@@ -393,6 +398,25 @@ export async function cancelCliInstall() {
   return settingsRequest('/api/cli/install/cancel', null, 'Failed to cancel the CLI install');
 }
 
+// Agent SDKs the relay installs on demand. As for the CLIs, the body carries
+// only an SDK id, which the relay looks up in its own table.
+export async function getAgentSdkStatus() {
+  return apiFetch('/api/agent-sdks/status');
+}
+
+export async function startAgentSdkInstall(sdk, { reinstall = false } = {}) {
+  return settingsRequest(
+    '/api/agent-sdks/install',
+    { sdk: String(sdk || ''), reinstall: reinstall === true },
+    'Failed to start the SDK install',
+  );
+}
+
+// Stops a running install, and dismisses a failure otherwise.
+export async function cancelAgentSdkInstall(sdk) {
+  return settingsRequest('/api/agent-sdks/install/cancel', { sdk: String(sdk || '') }, 'Failed to cancel the SDK install');
+}
+
 // Grok account auth (Sign in / Sign out). One route shorter than Claude's: the
 // device code rides in the authorize URL and the CLI polls x.ai itself, so
 // nothing is ever pasted back through the relay.
@@ -424,11 +448,15 @@ export async function updateGrokSettings({
   enabled = undefined,
   model = undefined,
   enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
 } = {}) {
   const payload = {};
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+  if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
   return settingsRequest('/api/settings/grok', payload, 'Failed to update Grok settings');
 }
 
@@ -493,21 +521,86 @@ export async function loadClaudeCloudBranches(repo) {
 
 export async function updateOpenAISettings({
   apiKey = '',
-  model = 'gpt-4o',
+  model = undefined,
   baseUrl = undefined,
   enabled = undefined,
+  enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
   remove = false,
 } = {}) {
   const payload = {
     apiKey: String(apiKey || '').trim(),
-    model: String(model || '').trim() || 'gpt-4o',
     remove: remove === true,
   };
+  // Every Settings call names the model; the Select Models save does not, and
+  // must not reset the default model to gpt-4o.
+  if (model !== undefined) payload.model = String(model || '').trim() || 'gpt-4o';
   if (typeof baseUrl === 'string') payload.baseUrl = String(baseUrl).trim();
   if (typeof enabled === 'boolean') payload.enabled = enabled;
+  if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+  if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
   return settingsRequest('/api/settings/openai', payload, 'Failed to update OpenAI settings');
 }
 
+/**
+ * The daily image cap and today's override (POST /api/settings/openai with
+ * only these fields). Throws with the relay's words: a paired relay's
+ * request is refused (403).
+ */
+export async function updateOpenAIImageSpendSettings({ imageDailyCapUsd = undefined, allowImagesToday = undefined } = {}) {
+  const payload = {};
+  if (imageDailyCapUsd !== undefined) payload[OPENAI_IMAGE_SETTINGS_FIELDS.dailyCapUsd] = Number(imageDailyCapUsd);
+  if (typeof allowImagesToday === 'boolean') payload[OPENAI_IMAGE_SETTINGS_FIELDS.allowToday] = allowImagesToday;
+  return settingsRequest('/api/settings/openai', payload, 'Failed to update the image cap');
+}
+
+/** Today's image spend; with a conversation, that chat's cost too. Null on any failure. */
+export async function loadOpenAIImageUsage({ conversationId = '' } = {}) {
+  const id = String(conversationId || '').trim();
+  return quietGet(id ? `${OPENAI_IMAGE_USAGE_PATH}?conversationId=${encodeURIComponent(id)}` : OPENAI_IMAGE_USAGE_PATH);
+}
+
+// The presets routes: the relay's `error` and `code` ride on the thrown Error.
+async function imagePresetsRequest(method, path, body = null) {
+  if (!networkRequestsEnabled) return null;
+  let response;
+  try {
+    response = await fetch(`${BASE}${path}`, {
+      signal: requestTimeoutSignal(),
+      method,
+      headers: { 'Content-Type': 'application/json', ...authHeaders() },
+      ...(body ? { body: JSON.stringify(body) } : {}),
+    });
+  } catch (error) {
+    noteFetchFailure(path, error);
+    throw Object.assign(new Error(`The relay could not be reached (${readableServerError(toErrorMessage(error))}).`), { status: 0, code: null });
+  }
+  noteFetchSuccess();
+  const result = await response.json().catch(() => null);
+  if (!response.ok) {
+    throw Object.assign(
+      new Error(readableServerError(result?.error || '') || `The relay answered HTTP ${response.status}.`),
+      { status: response.status, code: result?.code || null },
+    );
+  }
+  return result;
+}
+
+/** `{ presets }` (built-ins and own), or null when the relay has none to give. */
+export async function loadOpenAIImagePresets() {
+  return quietGet(OPENAI_IMAGE_PRESETS_PATH);
+}
+
+export async function saveOpenAIImagePreset(preset, { replace = false } = {}) {
+  return imagePresetsRequest('PUT', OPENAI_IMAGE_PRESETS_PATH, { preset, ...(replace ? { replace: true } : {}) });
+}
+
+export async function deleteOpenAIImagePreset(name) {
+  return imagePresetsRequest('DELETE', `${OPENAI_IMAGE_PRESETS_PATH}/${encodeURIComponent(String(name || ''))}`);
+}
+
 export async function loadCursorSettings() {
   return apiFetch('/api/settings/cursor');
 }
@@ -517,6 +610,8 @@ export async function updateCursorSettings({
   model = undefined,
   enabled = undefined,
   enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
   remove = false,
 } = {}) {
   const payload = {
@@ -528,6 +623,8 @@ export async function updateCursorSettings({
   if (typeof model === 'string' && model.trim()) payload.model = model.trim();
   if (typeof enabled === 'boolean') payload.enabled = enabled;
   if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+  if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+  if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
   return settingsRequest('/api/settings/cursor', payload, 'Failed to update Cursor settings');
 }
 
@@ -546,6 +643,8 @@ export async function updateDeepSeekSettings({
   model = undefined,
   enabled = undefined,
   enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
   baseUrl = undefined,
   attribution = undefined,
   monthlyBudget = undefined,
@@ -563,6 +662,8 @@ export async function updateDeepSeekSettings({
     if (typeof model === 'string' && model.trim()) payload.model = model.trim();
     if (typeof enabled === 'boolean') payload.enabled = enabled;
     if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+    if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+    if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
     if (baseUrl === null || typeof baseUrl === 'string') payload.baseUrl = baseUrl === null ? null : String(baseUrl).trim();
     if (typeof attribution === 'string' && attribution.trim()) payload.attribution = attribution.trim();
     if (monthlyBudget === null || (typeof monthlyBudget === 'number' && Number.isFinite(monthlyBudget))) payload.monthlyBudget = monthlyBudget;
@@ -590,6 +691,8 @@ export async function updateClaudeApiSettings({
   model = undefined,
   enabled = undefined,
   enabledModels = undefined,
+  shownModels = undefined,
+  autoEnableNew = undefined,
   monthlyCapUsd = undefined,
   remove = false,
 } = {}) {
@@ -602,6 +705,8 @@ export async function updateClaudeApiSettings({
     if (typeof model === 'string' && model.trim()) payload.model = model.trim();
     if (typeof enabled === 'boolean') payload.enabled = enabled;
     if (Array.isArray(enabledModels)) payload.enabledModels = enabledModels;
+    if (Array.isArray(shownModels)) payload.shownModels = shownModels;
+    if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
     if (monthlyCapUsd === null || (typeof monthlyCapUsd === 'number' && Number.isFinite(monthlyCapUsd))) payload.monthlyCapUsd = monthlyCapUsd;
   }
   return settingsRequest('/api/settings/claude-api', payload, 'Failed to update Claude API settings');
@@ -940,14 +1045,50 @@ export async function refreshModelVariantCatalog() {
   return apiFetch('/api/model-variants/refresh', { method: 'POST' });
 }
 
-export async function saveEnabledModelVariants(enabledVariantIds = []) {
+/**
+ * Copilot's selection and its "Turn new models on automatically". A null
+ * list leaves the selection alone (only the switch changes): an empty one is
+ * refused, at least one variant stays on. `shownVariantIds` names the rows
+ * the save could see: the relay turns only those on or off.
+ */
+export async function saveEnabledModelVariants(enabledVariantIds = [], { autoEnableNew = undefined, shownVariantIds = undefined } = {}) {
+  const payload = {};
+  if (enabledVariantIds !== null) {
+    payload.enabledVariantIds = Array.isArray(enabledVariantIds)
+      ? enabledVariantIds.map((value) => String(value || '').trim()).filter(Boolean)
+      : [];
+  }
+  if (Array.isArray(shownVariantIds)) {
+    payload.shownVariantIds = shownVariantIds.map((value) => String(value || '').trim()).filter(Boolean);
+  }
+  if (typeof autoEnableNew === 'boolean') payload.autoEnableNew = autoEnableNew;
   return apiFetch('/api/model-variants', {
     method: 'PATCH',
-    body: JSON.stringify({
-      enabledVariantIds: Array.isArray(enabledVariantIds)
-        ? enabledVariantIds.map((value) => String(value || '').trim()).filter(Boolean)
-        : [],
-    }),
+    body: JSON.stringify(payload),
+  });
+}
+
+// Opening Select Models clears every provider's "New" tags and the menu dot;
+// answers `{ ok, unseenNewModelCount }`.
+export async function markModelsSeen() {
+  return apiFetch('/api/model-variants/seen', { method: 'POST' });
+}
+
+// Settings › General › Models: the background check for new models. A failed
+// read throws with the relay's reason, which the section shows.
+export async function loadModelRefreshSettings() {
+  return apiFetchOrThrow('/api/model-refresh-settings');
+}
+
+/** Any of `{ auto, intervalHours, excluded }`; a refused value throws with the relay's reason. */
+export async function updateModelRefreshSettings(patch = {}) {
+  const payload = {};
+  if (typeof patch.auto === 'boolean') payload.auto = patch.auto;
+  if (patch.intervalHours !== undefined) payload.intervalHours = Number(patch.intervalHours);
+  if (Array.isArray(patch.excluded)) payload.excluded = patch.excluded.map((value) => String(value || '').trim()).filter(Boolean);
+  return apiFetchOrThrow('/api/model-refresh-settings', {
+    method: 'POST',
+    body: JSON.stringify(payload),
   });
 }
 

package/server/public/app/ask-user-view.js

@@ -131,7 +131,8 @@ export async function loadRelayQuestions(conversationId) {
   // after a link the relay did not know: its notice keeps the screen empty
   // until the reader opens something.
   const readingAView = document.body?.classList?.contains('inbox-view-active')
-    || document.body?.classList?.contains('status-view-active');
+    || document.body?.classList?.contains('status-view-active')
+    || document.body?.classList?.contains('media-view-active');
   if (!conversationId && pending.length && !readingAView && !isConversationAutoOpenHeld()) {
     const latest = pending
       .slice()