@oar-sh/oar 0.9.24 → 0.9.26

package/server/claude-worker/sdk-message-normalizer.mjs

@@ -555,6 +555,11 @@ export function createSdkMessageNormalizer() {
         const thinking = state.thinking.get(index);
         if (thinking) {
           thinking.text = capThought(thinking.text + String(event?.delta?.thinking || ''));
+          // Gated as stream text: a delta can be one token, and every update
+          // carries the whole thought. Past the cap the text stops changing,
+          // so nothing more goes out until the block's final frame.
+          if (!shouldEmitStreamUpdate(thinking.text, thinking.lastEmittedText)) return actions;
+          thinking.lastEmittedText = thinking.text;
           actions.push({
             channel: 'thought',
             payload: {
@@ -715,7 +720,7 @@ export function createSdkMessageNormalizer() {
       const assistantError = lastAssistantError;
       lastAssistantError = '';
       const apiErrorStatus = Number(sdkMessage.api_error_status ?? NaN);
-      return [{
+      return [...flushOpenThoughts(), {
         channel: 'result',
         payload: {
           text: String(sdkMessage.result || '').trim(),
@@ -745,6 +750,29 @@ export function createSdkMessageNormalizer() {
     return [];
   }
 
+  // A thinking block the turn left open (aborted, failed) never gets its
+  // final frame: what the delta gating held back goes out with the result,
+  // so the stored thought ends with the last delta.
+  function flushOpenThoughts() {
+    const actions = [];
+    for (const state of threads.values()) {
+      for (const thinking of state.thinking.values()) {
+        if (!thinking.text.trim() || thinking.text === thinking.lastEmittedText) continue;
+        thinking.lastEmittedText = thinking.text;
+        actions.push({
+          channel: 'thought',
+          payload: {
+            reasoningId: thinking.reasoningId,
+            text: thinking.text,
+            done: false,
+            subagentRunId: subagentRunIdFor(state.key === 'main' ? null : state.key),
+          },
+        });
+      }
+    }
+    return actions;
+  }
+
   function finalStreamText() {
     return threadState(null).streamText;
   }

package/server/copilot-worker/copilot-prompt-context.mjs

@@ -25,6 +25,7 @@ import {
   applyPreviewInstructions,
   createPreviewInstructionsProvider,
 } from '../../shared/preview-instructions.mjs';
+import { applyMathInstructions } from '../../shared/math-instructions.mjs';
 import { applyMediaEmbedInstructions } from '../../shared/media-embed-instructions.mjs';
 import { buildModePrompt } from '../../shared/worker-runtime/prompt-context.mjs';
 import { loadRelayInstructionsFromFile } from '../../shared/worker-runtime/config-loader.mjs';
@@ -84,7 +85,7 @@ export function createCopilotPromptContextBuilder({
           .then(() => getPreviewInstructions({ conversationId: String(message?.conversationId || '') }))
           .catch(() => '')
         : '';
-      instructions = applyMediaEmbedInstructions(applyPreviewInstructions(toolInstructions, previewBlock));
+      instructions = applyMathInstructions(applyMediaEmbedInstructions(applyPreviewInstructions(toolInstructions, previewBlock)));
     }
     const prefix = buildModePrompt(relayMode, instructions, { includeInstructions });
     return {

package/server/copilot-worker/copilot-sdk-session-process.mjs

@@ -5005,10 +5005,12 @@ export function createCopilotSdkSessionRunner({
 
   /**
    * One image-model row (shared/worker-runtime/direct-openai-image.mjs). With
-   * an image operation the relay's execute route publishes the reply, the
-   * failure or the requeue itself; without one the shared helper publishes
-   * the reply, and a refusal by the provider is published here as the row's
-   * failure. Anything else requeues the row, as on the extension engine.
+   * an image operation the relay's execute route publishes the reply or the
+   * failure itself; without one the shared helper publishes the reply, and
+   * any failure of the request is published here as the row's failure, never
+   * requeued: the relay already retried it once, and a second run is billed
+   * again. Only an execute call that did not get through requeues the row
+   * (the route refuses to send an operation's request twice).
    */
   async function runDirectImageTurn(message) {
     const id = String(message.id || '');
@@ -5025,11 +5027,11 @@ export function createCopilotSdkSessionRunner({
       dbg('image turn', message.id, result.via, result.outcome);
     } catch (error) {
       if (isOpenAIImageTerminalError(error)) {
-        // A refusal by OpenAI, or a reply the relay could not process after
-        // OpenAI answered 2xx; the codes are the ones the relay's image
-        // operation uses for the same two cases.
-        const code = error.relayProcessing === true ? 'image-reply-unprocessed' : 'image-provider-rejected';
-        dbg(error.relayProcessing === true ? 'image reply not processed' : 'image turn refused by OpenAI', message.id, error.message);
+        // The relay's note and code (the ones its image operation uses for
+        // the same cases); an older relay names no code.
+        const code = error.imageCode
+          || (error.relayProcessing === true ? 'image-reply-unprocessed' : 'image-provider-rejected');
+        dbg('image turn failed', message.id, code, error.message);
         await publishResponse(message, {
           text: error.message,
           model: null,

package/server/cursor-worker/cursor-turn-runner.mjs

@@ -20,6 +20,7 @@ import {
   cursorSubagentRosterFingerprint,
 } from './cursor-subagent-roster.mjs';
 import { createAskUserBridge } from '../../shared/ask-user-bridge.mjs';
+import { renderMathInstructionBlock } from '../../shared/math-instructions.mjs';
 import { renderMediaEmbedInstructionBlock } from '../../shared/media-embed-instructions.mjs';
 import { EMPTY_TURN_COMPLETION_NOTE } from '../../shared/empty-turn-completion.mjs';
 import { resolveFallbackContextLimitTokens } from '../../shared/context-window-fallbacks.mjs';
@@ -586,7 +587,8 @@ export function createCursorTurnRunner({
       await ensureAgentHandle(message, model);
       const userMessage = buildUserMessageImpl(message);
       const modeNudge = cursorModeNudge(message.relayMode, lastNudgedRelayMode);
-      const mediaGuidance = mediaGuidanceSent ? '' : renderMediaEmbedInstructionBlock();
+      // The formula notation rides with it, for the same reason.
+      const mediaGuidance = mediaGuidanceSent ? '' : `${renderMediaEmbedInstructionBlock()}\n\n${renderMathInstructionBlock()}`;
       if (modeNudge || mediaGuidance) {
         userMessage.text = [mediaGuidance, modeNudge, userMessage.text].filter(Boolean).join('\n\n');
       }

package/server/cursor-worker/sdk-message-normalizer.mjs

@@ -170,6 +170,9 @@ export function createSdkMessageNormalizer() {
       deltaOwnsThinking = true;
       if (!openThought) openThought = { reasoningId: allocateThoughtId(), text: '' };
       openThought.text = capThought(openThought.text + String(update?.text || ''));
+      // Gated as stream text; the thought's close sends the whole text.
+      if (!shouldEmitStreamUpdate(openThought.text, openThought.lastEmittedText)) return actions;
+      openThought.lastEmittedText = openThought.text;
       actions.push({
         channel: 'thought',
         payload: {
@@ -201,6 +204,14 @@ export function createSdkMessageNormalizer() {
 
     if (type === 'turn-ended') {
       if (update?.usage && typeof update.usage === 'object') lastUsage = update.usage;
+      // A thought the turn left open: what the delta gating held back.
+      if (openThought?.text.trim() && openThought.text !== openThought.lastEmittedText) {
+        openThought.lastEmittedText = openThought.text;
+        actions.push({
+          channel: 'thought',
+          payload: { reasoningId: openThought.reasoningId, text: openThought.text, done: false, subagentRunId: null },
+        });
+      }
       return actions;
     }
 
@@ -231,6 +242,8 @@ export function createSdkMessageNormalizer() {
           state.openThought = { reasoningId: `cursor-thought-${runId}-${state.thoughtIndex++}`, text: '' };
         }
         state.openThought.text = capThought(state.openThought.text + String(nested.text || ''));
+        if (!shouldEmitStreamUpdate(state.openThought.text, state.openThought.lastEmittedText)) return actions;
+        state.openThought.lastEmittedText = state.openThought.text;
         actions.push({
           channel: 'thought',
           payload: {

package/server/db-schema.mjs

@@ -44,6 +44,8 @@ import { migrateConversationPlanOnly } from './migrations/0035-conversation-plan
 import { migrateTokenUsage } from './migrations/0036-token-usage.mjs';
 import { migrateRelayAsksQueueId } from './migrations/0037-relay-asks-queue-id.mjs';
 import { migrateTurnSeq } from './migrations/0038-turn-seq.mjs';
+import { migrateMediaIndex } from './migrations/0039-media-index.mjs';
+import { migrateImageSessionDefaults } from './migrations/0040-image-session-defaults.mjs';
 import { migrateImageConversationSchema } from './repositories/image-conversation-repository.mjs';
 
 // Mirrors DEFAULT_RELAY_MODE in server-runtime.mjs; used only by the one-time
@@ -1096,6 +1098,23 @@ try {
   console.warn(`[turn-seq] migration 0038 failed; retrying on next boot: ${error?.message || error}`);
 }
 
+// The media gallery index: tables, the two queue triggers on messages and a
+// one-time seed of the queue. The gallery works without it (empty), so a
+// failure is logged and retried next boot.
+try {
+  migrateMediaIndex(db);
+} catch (error) {
+  console.warn(`[media-index] migration 0039 failed; retrying on next boot: ${error?.message || error}`);
+}
+
+// An image session's own size/quality/count defaults. Image turns run on the
+// built-in defaults without it, so a failure is logged and retried next boot.
+try {
+  migrateImageSessionDefaults(db);
+} catch (error) {
+  console.warn(`[image-sessions] migration 0040 failed; retrying on next boot: ${error?.message || error}`);
+}
+
 const conversationColumns = db.prepare(`PRAGMA table_info(conversations)`).all().map((c) => c.name);
 if (!conversationColumns.includes('archived')) {
   db.exec(`ALTER TABLE conversations ADD COLUMN archived INTEGER NOT NULL DEFAULT 0`);

package/server/grok-worker/grok-turn-runner.mjs

@@ -10,6 +10,7 @@ import { extractGrokUsageFromPromptResult, normalizeGrokTurnUsage } from '../ser
 import { OAR_MCP_SERVER_NAME, buildOarMcpServerLaunch, isOarMcpServerDisabled } from '../mcp/oar-mcp-server.mjs';
 import { createPreviewInstructionsProvider } from '../../shared/preview-instructions.mjs';
 import { fetchRemoteRelayInflight } from '../../shared/remote-relay-tool-core.mjs';
+import { renderMathInstructionBlock } from '../../shared/math-instructions.mjs';
 import { renderMediaEmbedInstructionBlock } from '../../shared/media-embed-instructions.mjs';
 import { countPlanLikeLines } from '../../shared/plan-lines.mjs';
 import { PLAN_BOARD_ACTIONS } from '../../shared/plan-board-actions.mjs';
@@ -476,7 +477,8 @@ export function createGrokTurnRunner({
       : await Promise.resolve()
         .then(() => getPreviewInstructions?.({ conversationId: message.conversationId || sdkSessionId || '' }))
         .catch(() => '');
-    const mediaBlock = mediaInstructionsSent ? '' : renderMediaEmbedInstructionBlock();
+    // The formula notation rides with the media block, once per worker.
+    const mediaBlock = mediaInstructionsSent ? '' : `${renderMediaEmbedInstructionBlock()}\n\n${renderMathInstructionBlock()}`;
     const promptText = [previewBlock, mediaBlock, modeNudge, userText].filter(Boolean).join('\n\n');
     const pendingNudgedRelayMode = String(message.relayMode || 'agent').trim().toLowerCase();
 

package/server/grok-worker/sdk-message-normalizer.mjs

@@ -148,6 +148,9 @@ export function createSdkMessageNormalizer() {
         openThought = { reasoningId: allocateThoughtId(), text: '' };
       }
       openThought.text = capThought(openThought.text + chunk);
+      // Gated as stream text; the thought's close sends the whole text.
+      if (!shouldEmitStreamUpdate(openThought.text, openThought.lastEmittedText)) return actions;
+      openThought.lastEmittedText = openThought.text;
       actions.push({
         channel: 'thought',
         payload: {

package/server/migrations/0039-media-index.mjs

@@ -0,0 +1,167 @@
+'use strict';
+
+/**
+ * Migration: the media gallery index.
+ *
+ * `media_items`: one row per picture, video or attached file of a message
+ * (services/media-extract.mjs decides what counts). Rows go with their
+ * message or conversation (foreign keys, ON DELETE CASCADE). `message_ts`
+ * copies the message time so the gallery pages by an index.
+ *
+ * `media_index_queue`: the ids of messages to (re)index. Two triggers on
+ * `messages` put a row id here on insert and when a column the index reads
+ * changes; they never parse anything, so the write path pays one small
+ * insert. The indexer (services/media-index-service.mjs) drains the queue in
+ * batches. `seq` grows on every re-queue, so a drain only removes the queue
+ * row it actually indexed.
+ *
+ * `media_index_meta`: the extractor version the queue was seeded for. When
+ * it is missing (first run) or older than MEDIA_EXTRACTOR_VERSION, every
+ * message is queued once and the version is stored; later boots seed nothing.
+ *
+ * Not in SCHEMA_SQL (db-schema.mjs): the triggers name columns that older
+ * migrations add. The triggers are checked on every boot and re-created when
+ * missing or different, like the FTS triggers.
+ *
+ * Additive and idempotent. Rolling back: drop the triggers first, then the
+ * tables (a trigger left pointing at a dropped table breaks message inserts):
+ *   DROP TRIGGER IF EXISTS media_index_on_insert;
+ *   DROP TRIGGER IF EXISTS media_index_on_update;
+ *   DROP TABLE IF EXISTS media_index_queue; DROP TABLE IF EXISTS media_items;
+ *   DROP TABLE IF EXISTS media_index_meta;
+ *
+ * Usage: node server/migrations/0039-media-index.mjs [path/to/oar.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+import { cliDbPath } from '../services/database-file.mjs';
+import { MEDIA_EXTRACTOR_VERSION } from '../services/media-extract.mjs';
+
+export const MEDIA_INDEX_TRIGGERS = Object.freeze(['media_index_on_insert', 'media_index_on_update']);
+// Columns the index reads; a change to one re-queues the message.
+const WATCHED_COLUMNS = Object.freeze(['text', 'attachments', 'timestamp', 'role', 'kind', 'origin_json', 'conversation_id']);
+
+const QUEUE_UPSERT = `INSERT INTO media_index_queue (message_id, seq) VALUES (NEW.id, 0)
+    ON CONFLICT(message_id) DO UPDATE SET seq = seq + 1;`;
+
+function tableExists(db, name) {
+  return !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+}
+
+function columnsOf(db, table) {
+  return db.prepare(`PRAGMA table_info(${table})`).all().map((column) => column.name);
+}
+
+export function mediaIndexTriggerSql(messageColumns) {
+  const watched = WATCHED_COLUMNS.filter((column) => messageColumns.includes(column));
+  return {
+    media_index_on_insert: `CREATE TRIGGER media_index_on_insert AFTER INSERT ON messages BEGIN
+    ${QUEUE_UPSERT}
+  END`,
+    media_index_on_update: `CREATE TRIGGER media_index_on_update AFTER UPDATE OF ${watched.join(', ')} ON messages BEGIN
+    ${QUEUE_UPSERT}
+  END`,
+  };
+}
+
+export function migrateMediaIndex(db) {
+  if (!tableExists(db, 'messages') || !tableExists(db, 'conversations')) {
+    return { applied: false, tablesCreated: 0, triggersCreated: 0, seeded: 0 };
+  }
+  let tablesCreated = 0;
+  let triggersCreated = 0;
+  let seeded = 0;
+  const run = db.transaction(() => {
+    if (!tableExists(db, 'media_items')) {
+      db.exec(`
+        CREATE TABLE media_items (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          message_id TEXT NOT NULL REFERENCES messages(id) ON DELETE CASCADE,
+          conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+          ordinal INTEGER NOT NULL,
+          role TEXT NOT NULL,
+          sender TEXT NOT NULL,
+          origin TEXT NOT NULL,
+          locator_kind TEXT NOT NULL,
+          locator TEXT NOT NULL,
+          identity_key TEXT NOT NULL,
+          category TEXT NOT NULL,
+          media_kind TEXT NOT NULL,
+          mime TEXT,
+          name TEXT,
+          alt TEXT,
+          size_bytes INTEGER,
+          message_ts TEXT NOT NULL,
+          UNIQUE (message_id, ordinal)
+        );
+        CREATE INDEX idx_media_items_conv ON media_items(conversation_id, category, message_ts DESC, id DESC);
+        CREATE INDEX idx_media_items_all ON media_items(category, message_ts DESC, id DESC);
+        CREATE INDEX idx_media_items_identity ON media_items(identity_key);
+      `);
+      tablesCreated += 1;
+    }
+    if (!tableExists(db, 'media_index_queue')) {
+      db.exec(`
+        CREATE TABLE media_index_queue (
+          message_id TEXT PRIMARY KEY REFERENCES messages(id) ON DELETE CASCADE,
+          seq INTEGER NOT NULL DEFAULT 0
+        )
+      `);
+      tablesCreated += 1;
+    }
+    if (!tableExists(db, 'media_index_meta')) {
+      db.exec(`CREATE TABLE media_index_meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)`);
+      tablesCreated += 1;
+    }
+
+    const expected = mediaIndexTriggerSql(columnsOf(db, 'messages'));
+    for (const name of MEDIA_INDEX_TRIGGERS) {
+      const row = db.prepare(`SELECT sql FROM sqlite_master WHERE type = 'trigger' AND name = ?`).get(name);
+      if (row?.sql === expected[name]) continue;
+      if (row) db.exec(`DROP TRIGGER ${name}`);
+      db.exec(expected[name]);
+      triggersCreated += 1;
+    }
+
+    const version = db.prepare(`SELECT value FROM media_index_meta WHERE key = 'extractor_version'`).get()?.value;
+    if (String(version || '') !== String(MEDIA_EXTRACTOR_VERSION)) {
+      seeded = db.prepare(`
+        INSERT INTO media_index_queue (message_id, seq)
+        SELECT id, 0 FROM messages WHERE true
+        ON CONFLICT(message_id) DO UPDATE SET seq = seq + 1
+      `).run().changes;
+      db.prepare(`INSERT INTO media_index_meta (key, value) VALUES ('extractor_version', ?)
+        ON CONFLICT(key) DO UPDATE SET value = excluded.value`).run(String(MEDIA_EXTRACTOR_VERSION));
+    }
+  });
+  run();
+  return { applied: tablesCreated + triggersCreated + seeded > 0, tablesCreated, triggersCreated, seeded };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateMediaIndex(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  try {
+    const dbPath = cliDbPath(process.argv[2], new URL('..', import.meta.url));
+    const result = migrate(dbPath);
+    console.log(`Migration 0039 on ${dbPath}`);
+    console.log(result.applied
+      ? `  media index: tables created ${result.tablesCreated}, triggers created ${result.triggersCreated}, messages queued ${result.seeded}`
+      : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0039 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

package/server/migrations/0040-image-session-defaults.mjs

@@ -0,0 +1,93 @@
+'use strict';
+
+/**
+ * Migration: an image session's own defaults, and a turn's options.
+ *
+ * `image_sessions.defaults_json`: the size, quality, count, output format and
+ * background an image session's turns use unless a turn names its own
+ * (relay_tool update_session `image`, the conversation settings route).
+ * JSON as shared/openai-image-options.mjs validates it; NULL means none.
+ *
+ * `queue.image_options_json`: the options of one image turn as the send
+ * settled them, for a turn without an image operation (the worker sends them
+ * with its direct request). NULL for every other turn.
+ *
+ * The image tables are created by migrateImageConversationSchema
+ * (repositories/image-conversation-repository.mjs), which this migration
+ * calls first, additively, so a database whose tables are missing gets them
+ * before the column. A database without the queue table (no relay's) is
+ * left alone.
+ *
+ * Additive and idempotent. Safe to run on every boot. Rolling back needs no
+ * data change: older code ignores the column.
+ *
+ * Usage: node server/migrations/0040-image-session-defaults.mjs [path/to/oar.db]
+ */
+
+import { fileURLToPath } from 'url';
+import path from 'path';
+import process from 'process';
+import Database from 'better-sqlite3';
+import { cliDbPath } from '../services/database-file.mjs';
+import { migrateImageConversationSchema } from '../repositories/image-conversation-repository.mjs';
+
+export function hasImageSessionDefaultsColumn(db) {
+  try {
+    return db.prepare(`PRAGMA table_info(image_sessions)`).all().some((column) => column.name === 'defaults_json');
+  } catch {
+    return false;
+  }
+}
+
+function tableExists(db, name) {
+  return !!db.prepare(`SELECT name FROM sqlite_master WHERE type = 'table' AND name = ?`).get(name);
+}
+
+export function hasQueueImageOptionsColumn(db) {
+  try {
+    return db.prepare(`PRAGMA table_info(queue)`).all().some((column) => column.name === 'image_options_json');
+  } catch {
+    return false;
+  }
+}
+
+export function migrateImageSessionDefaults(db) {
+  // The image schema reads the queue; a database without one is no relay's.
+  if (!tableExists(db, 'queue')) return { applied: false, columnsAdded: 0 };
+  migrateImageConversationSchema(db);
+  let columnsAdded = 0;
+  if (!hasImageSessionDefaultsColumn(db)) {
+    db.exec(`ALTER TABLE image_sessions ADD COLUMN defaults_json TEXT`);
+    columnsAdded += 1;
+  }
+  if (!hasQueueImageOptionsColumn(db)) {
+    db.exec(`ALTER TABLE queue ADD COLUMN image_options_json TEXT`);
+    columnsAdded += 1;
+  }
+  return { applied: columnsAdded > 0, columnsAdded };
+}
+
+export function migrate(dbPath, options = {}) {
+  const db = new Database(dbPath, options);
+  try {
+    return migrateImageSessionDefaults(db);
+  } finally {
+    db.close();
+  }
+}
+
+const isMain = process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url);
+if (isMain) {
+  try {
+    // The given path, else the database in server/data (oar.db, else the
+    // name before 0.9.20); never a new one.
+    const dbPath = cliDbPath(process.argv[2], new URL('..', import.meta.url));
+    const result = migrate(dbPath);
+    console.log(`Migration 0040 on ${dbPath}`);
+    console.log(result.applied ? `  image session defaults, turn options: columns added ${result.columnsAdded}` : '  skipped: nothing to change');
+    process.exit(0);
+  } catch (err) {
+    console.error(`Migration 0040 failed: ${err?.message || err}`);
+    process.exit(1);
+  }
+}

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
@@ -543,6 +544,63 @@ export async function updateOpenAISettings({
   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');
 }

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()