mouaif 0.3.0

package/src/messages.js

@@ -0,0 +1,238 @@
+'use strict';
+// Messages — per-chat transcript.
+//
+// Each chat (identified by its project directory + chat id) owns a
+// transcript of user / assistant / system / tool messages. Messages are
+// persisted in the app-level SQLite store (~/.mouaif/store.sqlite) via
+// src/chatdb.js. The legacy file backend (`.mouaif.messages.<chatId>.json`)
+// was removed; opt-in commit history is available through the per-chat
+// trace-to-file export (docs/decisions.md §5).
+//
+// Schema (per message):
+//   { role, content, ts, attachments?, reasoning?, usage?, cost?,
+//     streamingMs?, modelId?, toolCallId?, name?, args?, ok?, phase? }
+const path = require('path');
+const toolFeedback = require('./toolFeedback.js');
+const CHAT_ID_RE = /^[a-f0-9]{8}$/i;
+function assertChatId(chatId) {
+if (!chatId || typeof chatId !== 'string' || !CHAT_ID_RE.test(chatId)) {
+const e = new Error('chatId must be an 8-character hexadecimal id');
+e.code = 'EBADINPUT';
+throw e;
+}
+return chatId;
+}
+function messagesFilePath(projectDir, chatId) {
+if (!projectDir || typeof projectDir !== 'string') {
+throw new TypeError('projectDir must be a non-empty string');
+}
+assertChatId(chatId);
+return path.join(projectDir, '.mouaif.messages.' + chatId + '.json');
+}
+const VALID_ROLES = new Set(['user', 'assistant', 'system', 'tool']);
+const MAX_IMAGE_ATTACHMENTS = 8;
+const MAX_IMAGE_DATA_URL_CHARS = 12 * 1024 * 1024;
+function normalizeAttachments(list) {
+if (!Array.isArray(list)) return [];
+const out = [];
+for (const a of list) {
+if (!a || typeof a !== 'object') continue;
+if (a.type !== 'image') continue;
+const mimeType = typeof a.mimeType === 'string' ? a.mimeType : '';
+const dataUrl = typeof a.dataUrl === 'string' ? a.dataUrl : '';
+if (!/^image\/(png|jpe?g|webp|gif)$/i.test(mimeType)) continue;
+if (!dataUrl.startsWith('data:' + mimeType + ';base64,')) continue;
+if (dataUrl.length > MAX_IMAGE_DATA_URL_CHARS) continue;
+const item = { type: 'image', mimeType, dataUrl };
+if (typeof a.name === 'string' && a.name) item.name = a.name.slice(0, 160);
+out.push(item);
+if (out.length >= MAX_IMAGE_ATTACHMENTS) break;
+}
+return out;
+}
+function normalizeMessage(m) {
+if (!m || typeof m !== 'object') return null;
+if (!VALID_ROLES.has(m.role)) return null;
+if (typeof m.content !== 'string') return null;
+const out = {
+role: m.role,
+content: m.content,
+ts: typeof m.ts === 'string' ? m.ts : new Date().toISOString()
+};
+// Preserve a previously-assigned seq (appended rows carry one).
+if (typeof m.seq === 'number' && Number.isFinite(m.seq)) out.seq = m.seq;
+if (m.role === 'user') {
+const attachments = normalizeAttachments(m.attachments);
+if (attachments.length) out.attachments = attachments;
+}
+if (m.role === 'assistant') {
+if (typeof m.reasoning === 'string') out.reasoning = m.reasoning;
+if (m.usage && typeof m.usage === 'object') out.usage = m.usage;
+if (m.cost && typeof m.cost === 'object') out.cost = m.cost;
+if (typeof m.streamingMs === 'number') out.streamingMs = m.streamingMs;
+if (typeof m.modelId === 'string') out.modelId = m.modelId;
+}
+if (m.role === 'tool') {
+if (typeof m.toolCallId === 'string') out.toolCallId = m.toolCallId;
+if (typeof m.name === 'string') out.name = m.name;
+if (m.args && typeof m.args === 'object') out.args = m.args;
+if (typeof m.ok === 'boolean') out.ok = m.ok;
+if (typeof m.phase === 'string') out.phase = m.phase;
+}
+return out;
+}
+function getChatDb() {
+return require('./chatdb.js');
+}
+// ---- Public surface -------------------------------------------------------
+function listMessages(projectDir, chatId) {
+return getChatDb().listMessages(projectDir, chatId);
+}
+function listMessagesWindow(projectDir, chatId, opts) {
+return getChatDb().listMessagesWindow(projectDir, chatId, opts);
+}
+function getMessageCount(projectDir, chatId) {
+return getChatDb().getMessageCount(projectDir, chatId);
+}
+function projectMessageCounts(projectDir, chatIds) {
+return getChatDb().projectMessageCounts(projectDir, chatIds);
+}
+function getMessage(projectDir, chatId, index) {
+if (typeof index !== 'number' || index < 0) return null;
+return listMessages(projectDir, chatId)[index] || null;
+}
+// messageCursor(projectDir, chatId) -> { nextSeq }
+//
+// Cheap append-only recovery cursor for a chat transcript. `nextSeq` is
+// the first persisted row the client may not have yet; if the client
+// already knows the same value, there is no tail to fetch. This keeps
+// streaming recovery keyed on stable message seq instead of a fuzzy
+// count/timestamp revision marker.
+function messageCursor(projectDir, chatId) {
+return getChatDb().messageCursorDb(projectDir, chatId);
+}
+function appendMessage(projectDir, chatId, msg) {
+if (!msg || typeof msg !== 'object') {
+throw new TypeError('msg must be an object');
+}
+if (!VALID_ROLES.has(msg.role)) {
+throw new TypeError('msg.role must be one of user | assistant | system | tool');
+}
+if (typeof msg.content !== 'string') {
+throw new TypeError('msg.content must be a string');
+}
+const normalized = normalizeMessage(msg);
+if (!normalized) {
+throw new TypeError('msg could not be normalized');
+}
+return getChatDb().appendMessage(projectDir, chatId, normalized);
+}
+function replaceMessages(projectDir, chatId, list) {
+if (!Array.isArray(list)) throw new TypeError('list must be an array');
+const out = [];
+for (const m of list) {
+const n = normalizeMessage(m);
+if (n) out.push(n);
+}
+return getChatDb().replaceMessages(projectDir, chatId, out);
+}
+function clearMessages(projectDir, chatId) {
+return getChatDb().clearMessages(projectDir, chatId);
+}
+// addChatCost(projectDir, chatId, amount) -> { total, known, currency, knownCount } | null
+//
+// Attribute a priced run that is not a chat turn to a chat's persisted total
+// (dictation — see docs/features/dictation.md). No message row is written: the
+// run produced a draft, not a turn, and the chat and project totals are the
+// only places it belongs.
+function addChatCost(projectDir, chatId, amount) {
+return getChatDb().addChatCost(projectDir, chatId, amount);
+}
+// ---- Reconstruct upstream history (unchanged) -----------------------------
+function reconstructUpstreamHistory(list, contentForMessage, options) {
+const source = Array.isArray(list) ? list : [];
+const contentOf = typeof contentForMessage === 'function'
+? contentForMessage
+: (m) => m && m.content;
+const includeTools = !options || options.includeTools !== false;
+const toolFeedbackMaxBytes = options && options.toolFeedbackMaxBytes;
+const toolOutput = options && options.toolOutput;
+const out = [];
+const usedIds = new Set();
+let pairNumber = 0;
+for (let i = 0; i < source.length; i++) {
+const m = source[i];
+if (!m || typeof m !== 'object') continue;
+if (m.role === 'tool') {
+if (!includeTools) continue;
+if (m.phase !== 'call') continue;
+const result = source[i + 1];
+if (!result || result.role !== 'tool' || result.phase !== 'result') continue;
+const callId = typeof m.toolCallId === 'string' ? m.toolCallId : '';
+const resultId = typeof result.toolCallId === 'string' ? result.toolCallId : '';
+if (callId !== resultId) continue;
+pairNumber++;
+let wireId = callId;
+if (!/^[A-Za-z0-9_-]{1,40}$/.test(wireId) || usedIds.has(wireId)) {
+wireId = 'call_history_' + pairNumber.toString(36);
+}
+while (usedIds.has(wireId)) {
+pairNumber++;
+wireId = 'call_history_' + pairNumber.toString(36);
+}
+usedIds.add(wireId);
+let args = '{}';
+try { args = JSON.stringify(m.args || {}); } catch { /* keep empty object */ }
+const name = m.name || result.name || 'tool';
+const storedContent = typeof result.content === 'string' ? result.content : JSON.stringify(result.content || {});
+let storedResult = null;
+try { storedResult = JSON.parse(storedContent); } catch { /* plain-text result */ }
+// During the live tool loop, explanatory text and tool_calls share
+// one assistant message. Persistence keeps the text as a separate UI
+// segment immediately before the call card; merge that segment back
+// on replay so resumed chats serialize the same provider-cache prefix.
+const previous = out[out.length - 1];
+const mergePreviousAssistant = previous && previous.role === 'assistant'
+&& !previous.tool_calls && typeof previous.content === 'string' && previous.content.trim();
+if (mergePreviousAssistant) out.pop();
+out.push({
+role: 'assistant',
+content: mergePreviousAssistant ? previous.content : null,
+tool_calls: [{ id: wireId, type: 'function', function: { name, arguments: args } }]
+});
+out.push({
+role: 'tool', tool_call_id: wireId, name,
+content: toolFeedback.compactToolFeedback({
+name, content: storedContent, result: storedResult, maxBytes: toolFeedbackMaxBytes, toolOutput
+})
+});
+i++;
+continue;
+}
+const content = contentOf(m);
+if (m.role === 'assistant' && (content == null || (typeof content === 'string' && !content.trim()))) {
+continue;
+}
+out.push({ role: m.role, content });
+}
+return out;
+}
+module.exports = {
+VALID_ROLES,
+CHAT_ID_RE,
+normalizeAttachments,
+normalizeMessage,
+assertChatId,
+messagesFilePath,
+listMessages,
+listMessagesWindow,
+getMessage,
+getMessageCount,
+projectMessageCounts,
+messageCursor,
+appendMessage,
+replaceMessages,
+clearMessages,
+addChatCost,
+reconstructUpstreamHistory
+};

package/src/modelList.js

@@ -0,0 +1,137 @@
+'use strict';
+
+// The per-provider live model list, shared by the two endpoints that need it.
+//
+// `/api/ai/models/live` (the chat picker's refresh) and
+// `/api/ai/transcribe/models` (the Dictate tab) ask the same question of the
+// same upstream — "what models does this provider offer right now?" — and an
+// hour-long cache keyed by provider + credential hash already existed for the
+// first. Dictation needs a *filtered* slice of the same answer, so the fetch
+// and the cache moved here rather than being duplicated.
+//
+// Errors are typed and propagated; callers decide what a failure means.
+// `/api/ai/models/live` maps them onto 4xx/5xx statuses, while the dictation
+// catalog treats a provider that cannot answer as "no extra models" — one
+// unreachable provider must not empty the whole picker.
+
+const { ai, credentialForProvider, hashShort, modelListCacheKey, MODEL_LIST_CACHE, MODEL_LIST_TTL_MS, MODEL_LIST_TIMEOUT_MS } = require('./server-shared.js');
+
+// liveModelsFor(provider, opts) -> { models, fetchedAt, cached }
+//
+// opts.force — bypass the cache (the chat picker's explicit refresh).
+//
+// opts.purpose — which slice of the provider's catalog to read:
+//   'chat'          (default) the list the model picker offers;
+//   'transcription' the speech-to-text slice, read through the provider's
+//                   `listTranscriptionModels` adapter when it has one
+//                   (OpenRouter's /models is sliced by output modality and
+//                   defaults to `text`, so none of its 21 speech-to-text
+//                   models are in the chat list at all), and otherwise the
+//                   chat list, for the caller to filter;
+//   'image'         the image-generation slice, read through the provider's
+//                   `listImageModels` adapter when it has one (OpenRouter's
+//                   /images/models, and Gemini's /v1beta/models filtered to
+//                   the Imagen rows). A provider without a separate slice
+//                   returns its chat list, for the caller to filter.
+//
+// The slices live under different cache keys. They are different upstream
+// questions, and answering one with the other is exactly how dictation came
+// to offer chat models that /audio/transcriptions rejects — and how the
+// image picker came to offer only the eleven chat models that happen to
+// report an image modality.
+//
+// `cached` reports whether the returned list came from the in-memory cache,
+// which the HTTP layer echoes to the client; it must reflect the actual hit,
+// not merely that no bypass was requested.
+//
+// Typed errors: `EUNKNOWN_PROVIDER`, `ENO_APIKEY`, `EUNREACHABLE`, `EUPSTREAM`
+// (with `.status`), `ETIMEOUT`. The http-server maps them the same way it
+// always did.
+async function liveModelsFor(provider, opts) {
+  if (!provider || !ai.ENDPOINTS[provider]) {
+    const e = new Error('unknown provider');
+    e.code = 'EUNKNOWN_PROVIDER';
+    throw e;
+  }
+  const purpose = opts && opts.purpose === 'transcription' ? 'transcription'
+    : (opts && opts.purpose === 'image' ? 'image' : 'chat');
+  let cred = null;
+  try { cred = credentialForProvider(provider); }
+  catch { /* the adapter surfaces ENO_APIKEY when a credential is required */ }
+
+  // Keyed by provider + credential hash + slice so rotating a key cannot serve
+  // the previous account's list, and so the two slices cannot cross over.
+  const cacheKey = modelListCacheKey(provider, cred ? hashShort(cred) : '-', purpose);
+  const now = Date.now();
+  if (opts && opts.force) MODEL_LIST_CACHE.delete(cacheKey);
+  const cached = MODEL_LIST_CACHE.get(cacheKey);
+  if (cached && (now - cached.fetchedAt) < MODEL_LIST_TTL_MS) {
+    return { models: cached.models, fetchedAt: cached.fetchedAt, cached: true };
+  }
+
+  // Bound the call so a slow upstream cannot hang the request.
+  const ac = new AbortController();
+  let timedOut = false;
+  const timer = setTimeout(() => { timedOut = true; ac.abort(); }, MODEL_LIST_TIMEOUT_MS);
+  try {
+    // A provider with a separate catalogue answers this slice; every other
+    // provider returns null here and the chat list is filtered by the caller
+    // instead.
+    const sliced = purpose === 'transcription'
+    ? await ai.listTranscriptionModels(provider, cred || null, ac.signal)
+    : (purpose === 'image' ? await ai.listImageModels(provider, cred || null, ac.signal) : null);
+    const models = sliced || await ai.listModels(provider, cred || null, ac.signal);
+    clearTimeout(timer);
+    // Discard the late result: the caller already saw the timeout.
+    if (timedOut) {
+      const e = new Error('Timed out after ' + Math.round(MODEL_LIST_TIMEOUT_MS / 1000) + 's waiting for ' + provider + ' upstream');
+      e.code = 'ETIMEOUT';
+      e.status = 504;
+      throw e;
+    }
+    const fetchedAt = Date.now();
+    MODEL_LIST_CACHE.set(cacheKey, { models, fetchedAt });
+    return { models, fetchedAt, cached: false };
+  } catch (err) {
+    clearTimeout(timer);
+    if (timedOut || (err && err.code === 'ETIMEOUT')) {
+      const e = new Error('Timed out after ' + Math.round(MODEL_LIST_TIMEOUT_MS / 1000) + 's waiting for ' + provider + ' upstream');
+      e.code = 'ETIMEOUT';
+      e.status = 504;
+      throw e;
+    }
+    throw err;
+  }
+}
+
+// liveModelsForMany(providers, opts) -> { list, failures }
+//
+// Best-effort across providers, for the dictation catalog: a provider that
+// cannot answer contributes nothing and is reported in `failures` instead of
+// failing the whole request. Rows are tagged with their provider so a caller
+// that merges several catalogs can tell them apart.
+async function liveModelsForMany(providers, opts) {
+  const list = [];
+  const failures = [];
+  const results = await Promise.all((Array.isArray(providers) ? providers : []).map(async (provider) => {
+    try {
+      const result = await liveModelsFor(provider, opts);
+      return { provider, models: result.models };
+    } catch (e) {
+      return { provider, error: e };
+    }
+  }));
+  for (const result of results) {
+    if (result.error) {
+      failures.push({ provider: result.provider, code: result.error.code || 'EUPSTREAM', error: result.error.message || String(result.error) });
+      continue;
+    }
+    for (const m of (result.models || [])) {
+      if (!m || !m.id) continue;
+      list.push(Object.assign({}, m, { provider: result.provider }));
+    }
+  }
+  return { list, failures };
+}
+
+module.exports = { liveModelsFor, liveModelsForMany };

package/src/notifications.js

@@ -0,0 +1,52 @@
+'use strict';
+// App-level browser notification preferences.
+//
+// The persisted `notifications` object has grown over time. Older stores
+// held five booleans (progress/completion/errors and
+// askUser/toolAuthorization); the current shape is a flat set of named
+// channels. This module is the single server-side normalizer so every
+// sender (chat streaming, access sign-in) agrees on the defaults.
+//
+// Kept in sync with normalizePreferences() in
+// frontend/src/components/SettingsNotifications.jsx.
+const DEFAULT_NOTIFICATION_PREFS = Object.freeze({
+// One replaceable ASCII status per chat: progress, completion, errors.
+status: true,
+// Questions and tool-authorization requests (the "attention" slot).
+authorization: true,
+// Answer/allow/deny directly from the notification when supported.
+quickActions: true,
+// A sign-in to this server (password or passkey). On by default: a new
+// sign-in is exactly the event a user wants to know about, and it can be
+// turned off from Settings → Notifications.
+login: true
+});
+
+// resolveNotificationPrefs(saved) — collapse the persisted settings into
+// the current key shape. New stores hold these keys directly; older
+// stores only had the legacy five booleans, which are derived here.
+function resolveNotificationPrefs(saved) {
+const prefs = saved || {};
+return {
+status: prefs.status !== undefined
+? prefs.status === true
+: prefs.progress !== false && prefs.completion !== false && prefs.errors !== false,
+authorization: prefs.authorization !== undefined
+? prefs.authorization === true
+: prefs.askUser !== false && prefs.toolAuthorization !== false,
+quickActions: prefs.quickActions !== false,
+login: prefs.login !== undefined ? prefs.login === true : DEFAULT_NOTIFICATION_PREFS.login
+};
+}
+
+// notificationEnabled(saved, key) — resolve + read one channel in a single
+// step for callers that only care about a boolean gate.
+function notificationEnabled(saved, key) {
+return resolveNotificationPrefs(saved)[key] === true;
+}
+
+module.exports = {
+DEFAULT_NOTIFICATION_PREFS,
+resolveNotificationPrefs,
+notificationEnabled
+};