More things - 2

app-docs.md

@@ -0,0 +1,106 @@
+# InferencePort App Documentation
+
+This document gives the assistant a structured reference for the public web interface, the main settings surfaces, account and media flows, and the current privacy and terms policies. Use the section list tool first, then read only the section that answers the user’s question.
+
+## Pages
+
+- `index.html` is the main app experience. It includes the chat workspace, bottom composer, welcome screen, sidebar, media panel, settings access, authentication entry points, and share-import banner.
+- `admin.html` is a separate administrator page and is not part of the normal end-user workflow.
+- `privacy.html` explains what data the app collects, how it is used, and what the user can expect from storage and third-party services.
+- `terms.html` explains acceptable use, prohibited use, account expectations, and service disclaimers.
+
+## Chat Workspace
+
+- The welcome view is the landing state before a session has visible history. It exposes the centered input for starting a chat.
+- The chat view shows the active conversation, message variants, tool calls, generated media, and message actions like copy, edit, regenerate, and continue.
+- The main composer supports plain text, markdown-style input, attachments, tool toggles, and prompt editing.
+- User message editing creates a new version of the prompt. Follow-up turns continue from the active branch instead of the original branch.
+- Assistant responses can have multiple versions. Users can switch between versions, regenerate a reply, or continue generating from the selected assistant message when appropriate.
+
+## Sidebar And Media Library
+
+- The sidebar contains the chat session list, deleted chat access, media library access, settings access, and account shortcuts.
+- The media library shows folders and saved files, including text documents, rich text documents, images, video, audio, and assistant-generated assets.
+- Signed-in users can upload files, create folders, create notes, rename items, move items, edit text documents, restore trashed items, and permanently delete files.
+- Signed-out or guest users are restricted to download and delete behavior in the media area. Upload and creation actions require sign-in.
+- The three-dot item menu exposes contextual actions like download, rename, move, trash, restore, and delete forever depending on item state and the user’s authentication status.
+
+## Settings And Account
+
+- The Chat settings tab controls theme and tool toggles for web search, image generation, video generation, and audio generation.
+- The Chat settings tab also shows tool usage progress bars, including the free-plan daily web search limit and other tool quotas returned by the usage service.
+- The Personalization tab lets signed-in users edit a private system prompt that is stored for their account and sent before chats.
+- The Memories tab lets users save, edit, and delete persistent short memories that can influence future chats.
+- The Account tab lets signed-in users edit usernames, review the active subscription plan, inspect current device sessions, revoke other sessions, open billing, and delete the account.
+
+## Modals
+
+- Auth modal: sign in, sign up, or continue with supported OAuth providers.
+- Confirm modal: generic confirmation for destructive or sensitive actions.
+- Text prompt modal: used for naming files or folders, entering URLs, and other short-form prompts.
+- Image modal: full-size image preview.
+- Device session modal: details for a logged-in device session with revoke controls.
+- File viewer modal: view or edit attached text files from messages.
+- Tool call modal: shows details of tool arguments and results from assistant tool usage.
+- Media picker modal: choose saved media items to attach into a draft.
+- Folder picker modal: choose a destination folder when moving library items.
+
+## Tool Limits And Credits
+
+- Usage data is fetched from `https://sharktide-lightning.hf.space/usage`.
+- The app shows quota progress when that endpoint returns usage metrics such as daily chat credits, image generations, video generations, audio generations, and free-plan web searches.
+- Free accounts have a local limit of 15 web searches per day inside the app. When the limit is reached, the web search tool should explain that the user has hit the daily free-plan search cap and suggest waiting for reset or upgrading.
+
+## Data Collection
+
+When a user visits the site, the app may collect or process:
+
+- Basic connection metadata such as IP address, browser user agent, and timestamps for security, session tracking, rate limiting, and device session management.
+- Turnstile verification state to confirm the visitor is human before using protected routes or WebSocket actions.
+- Authentication tokens and account identifiers when a user signs in.
+- Chat content, uploaded media, saved memories, settings, personalization prompts, and device session records when those features are used.
+- Usage and subscription information returned by the billing and quota services.
+- Temporary guest identifiers and client identifiers stored in local storage so guest sessions and per-device usage can work.
+
+The app should not claim zero collection. It stores and processes the data needed to provide chats, uploads, settings synchronization, abuse prevention, and billing-aware limits.
+
+## Privacy Policy
+
+InferencePort uses data to operate the service, store chats and media, apply user settings, enforce limits, detect abuse, and support account management. If a user signs in, account-linked data can be synchronized across devices. If a user stays signed out, temporary identifiers may still be stored locally so guest sessions and limits continue to work.
+
+Uploaded files, chat messages, saved memories, and personalization prompts may be stored on the service so the product can retrieve them later. Generated assets may also be stored so they can be re-opened or downloaded. Third-party services may process requests for authentication, verification, billing, quota tracking, web search, and model execution.
+
+The privacy policy should explain that:
+
+- Users should avoid submitting highly sensitive personal data unless they understand the risks.
+- The service may log operational metadata for debugging, billing, moderation, and abuse prevention.
+- Third-party providers may receive request data needed to fulfill product features.
+- Users can delete chats, media, memories, or accounts through the interface, but operational backups or logs may persist briefly where required for reliability or security.
+- No guarantee of absolute security should be stated.
+
+## Terms Of Service
+
+Ethical, legal use is permitted. Users may use the service for ordinary personal, educational, creative, and business tasks so long as their use is lawful and does not harm others or the service.
+
+The terms should make clear that users must not:
+
+- Use the service to break the law, violate contracts, infringe intellectual property, or bypass security controls.
+- Upload or distribute malware, credential theft content, destructive payloads, or instructions intended for abuse.
+- Harass, exploit, impersonate, defraud, stalk, or intentionally harm other people.
+- Attempt to overload, disrupt, scrape, reverse engineer, or misuse the service infrastructure beyond normal permitted use.
+- Use the service to generate or automate clearly illegal activity.
+
+The terms should also explain that:
+
+- Users are responsible for the content they submit and the actions they take using the service.
+- Service availability, quotas, model behavior, and features can change over time.
+- The service may suspend access for abusive, unlawful, or dangerous use.
+- Outputs can be wrong, incomplete, or unsafe and should be reviewed before relying on them.
+- InferencePort AI disclaims responsibility for losses or damages resulting from misuse of the service or from users choosing to run risky content.
+
+## Troubleshooting
+
+- If uploads are disabled, check whether the user is signed in.
+- If web search stops working, check the daily free-plan search limit.
+- If a message edit seems to branch incorrectly, make sure the current selected message version is the one the user expects before sending the next follow-up.
+- If a response shows a retry button, the assistant request or tool flow failed before completion and can usually be retried directly from the conversation.

server/appDocs.js

@@ -0,0 +1,65 @@
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const DOCS_PATH = path.resolve(__dirname, '..', 'app-docs.md');
+
+let cachedSections = [];
+let cachedMtimeMs = 0;
+
+function slugify(text) {
+  return String(text || '')
+    .toLowerCase()
+    .replace(/[^a-z0-9]+/g, '-')
+    .replace(/^-+|-+$/g, '');
+}
+
+async function loadSections() {
+  const stats = await fs.stat(DOCS_PATH);
+  if (cachedSections.length && cachedMtimeMs === stats.mtimeMs) return cachedSections;
+
+  const raw = await fs.readFile(DOCS_PATH, 'utf8');
+  const parts = raw.split(/^##\s+/m);
+  const first = parts.shift() || '';
+  const sections = [];
+
+  const overview = first.replace(/^#.*$/m, '').trim();
+  if (overview) {
+    sections.push({
+      id: 'overview',
+      title: 'Overview',
+      content: overview,
+    });
+  }
+
+  parts.forEach((part) => {
+    const lines = part.split('\n');
+    const title = (lines.shift() || '').trim();
+    const content = lines.join('\n').trim();
+    if (!title || !content) return;
+    sections.push({
+      id: slugify(title),
+      title,
+      content,
+    });
+  });
+
+  cachedSections = sections;
+  cachedMtimeMs = stats.mtimeMs;
+  return sections;
+}
+
+export async function listAppDocSections() {
+  const sections = await loadSections();
+  return sections.map(({ id, title }) => ({ id, title }));
+}
+
+export async function readAppDocSection(sectionId) {
+  const target = String(sectionId || '').trim().toLowerCase();
+  if (!target) return null;
+  const sections = await loadSections();
+  return sections.find((section) =>
+    section.id === target || section.title.toLowerCase() === target
+  ) || null;
+}

server/auth.js

@@ -93,13 +93,25 @@ export async function getTierConfig() {
   } catch { return null; }
 }
 
-export async function getUsageInfo(accessToken) {
+export async function getUsageInfo(accessToken, clientId = '') {
   try {
     const h = { Accept: 'application/json' };
     if (accessToken) h.Authorization = `Bearer ${accessToken}`;
+    if (clientId) h['X-Client-ID'] = clientId;
     const r = await fetch('https://sharktide-lightning.hf.space/usage', { headers: h });
-    return r.ok ? r.json() : null;
-  } catch { return null; }
+    const payload = r.ok ? await r.json() : null;
+    console.log('[Usage API]', JSON.stringify({
+      ok: r.ok,
+      status: r.status,
+      clientId: clientId || null,
+      hasAuth: !!accessToken,
+      payload,
+    }));
+    return payload;
+  } catch (err) {
+    console.error('[Usage API] request failed:', err.message);
+    return null;
+  }
 }
 
 function defaultSettings() {

server/chatStream.js

@@ -9,6 +9,8 @@ import { encoding_for_model } from "tiktoken";
 import { mediaStore } from "./mediaStore.js";
 import { memoryStore } from "./memoryStore.js";
 import { systemPromptStore } from "./systemPromptStore.js";
+import { consumeWebSearchUsage } from "./webSearchUsageStore.js";
+import { listAppDocSections, readAppDocSection } from "./appDocs.js";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
 const WORKER_PATH = path.join(__dirname, "searchWorker.js");
@@ -1234,6 +1236,7 @@ export async function streamChat({
   sessionName = "",
   accessToken,
   clientId,
+  webSearchLimit = null,
   onToken = () => {},
   onDone = () => {},
   onError = () => {},
@@ -1271,6 +1274,7 @@ export async function streamChat({
     const allToolCalls = [];
     const draftState = { text: "" };
     const responseEdits = [];
+    const responseSegments = [];
 
     while (!finished && agentStep < MAX_AGENT_STEPS) {
       const effectiveMessages = buildModelMessages(baseMessages, workingMessages, sessionId);
@@ -1288,11 +1292,20 @@ export async function streamChat({
         abortSignal
       );
 
+      if (stepText) {
+        responseSegments.push({ type: "text", text: stepText });
+      }
       assistantText += stepText;
       draftState.text = assistantText;
 
       if (toolCalls.length > 0) {
         allToolCalls.push(...toolCalls);
+        responseSegments.push(
+          ...toolCalls.map((call) => ({
+            type: "tool_call",
+            callId: call.id,
+          }))
+        );
         workingMessages.push({
           role: "assistant",
           content: stepText || "",
@@ -1306,6 +1319,7 @@ export async function streamChat({
           owner,
           accessToken,
           clientId,
+          webSearchLimit,
           abortSignal,
           draftState,
           onToolCall,
@@ -1349,6 +1363,7 @@ export async function streamChat({
       );
 
       if (finalStepText) {
+        responseSegments.push({ type: "text", text: finalStepText });
         assistantText += finalStepText;
         draftState.text = assistantText;
         workingMessages.push({ role: "assistant", content: finalStepText });
@@ -1363,7 +1378,7 @@ export async function streamChat({
     const sessionName = extractSessionName(assistantText);
 
     if (typeof onDone === "function") {
-      onDone(assistantText, allToolCalls, false, sessionName, responseEdits);
+      onDone(assistantText, allToolCalls, false, sessionName, responseEdits, responseSegments);
     }
 
     clearPromptState(sessionId);
@@ -1474,6 +1489,31 @@ function buildToolList(tools) {
       parameters: { type: "object", properties: { note: { type: "string" } }, required: ["note"] }
     }
   });
+  list.push({
+    type: "function",
+    function: {
+      name: "list_app_doc_sections",
+      description: "List the available sections of the app documentation so you can choose one relevant section to read.",
+      parameters: {
+        type: "object",
+        properties: {},
+      },
+    },
+  });
+  list.push({
+    type: "function",
+    function: {
+      name: "read_app_doc_section",
+      description: "Read one specific app documentation section by section id or exact section title.",
+      parameters: {
+        type: "object",
+        properties: {
+          section_id: { type: "string", description: "The section id or exact title from list_app_doc_sections." },
+        },
+        required: ["section_id"],
+      },
+    },
+  });
   list.push({
     type: "function",
     function: {
@@ -1684,6 +1724,7 @@ async function processToolCalls({
   owner,
   accessToken,
   clientId,
+  webSearchLimit,
   abortSignal,
   draftState,
   onToolCall,
@@ -1793,6 +1834,18 @@ async function processToolCalls({
         result = "Note stored for the rest of this response.";
       }
 
+      else if (toolName === "list_app_doc_sections") {
+        const sections = await listAppDocSections();
+        result = JSON.stringify(sections, null, 2);
+      }
+
+      else if (toolName === "read_app_doc_section") {
+        const section = await readAppDocSection(args.section_id);
+        result = section
+          ? [`Section: ${section.title}`, `Section ID: ${section.id}`, "", section.content].join("\n")
+          : `Documentation section "${args.section_id}" was not found.`;
+      }
+
       else if (toolName === "list_memories") {
         const memories = owner ? await memoryStore.list(owner) : [];
         result = JSON.stringify(memories, null, 2);
@@ -1840,7 +1893,16 @@ async function processToolCalls({
       }
 
       else if (toolName === "ollama_search") {
-        result = await gradioSearch(args.query);
+        if (webSearchLimit?.key && Number.isFinite(webSearchLimit.limit)) {
+          const usage = await consumeWebSearchUsage(webSearchLimit.key, webSearchLimit.limit);
+          if (!usage.allowed) {
+            result = `Web search limit reached for today. Free accounts can use ${usage.limit} web searches per day. Try again on ${usage.window} after the daily reset or upgrade to a paid plan.`;
+          } else {
+            result = await gradioSearch(args.query);
+          }
+        } else {
+          result = await gradioSearch(args.query);
+        }
       }
 
       else if (toolName === "read_web_page") {

server/index.js

@@ -250,6 +250,12 @@ async function requireRequestOwner(req, res) {
   return resolved;
 }
 
+function requireSignedInMediaOwner(resolved, res, message = 'Sign in to upload files.') {
+  if (resolved?.owner?.type === 'user') return true;
+  res.status(403).json({ error: 'media:auth_required', message });
+  return false;
+}
+
 app.get('/health', (_req,res) => res.json({ok:true}));
 
 app.get('/api/share/:token', async (req,res) => {
@@ -285,6 +291,7 @@ app.get('/api/media', async (req, res) => {
 app.post('/api/media/upload', express.raw({ type: () => true, limit: '100mb' }), async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to upload files.')) return;
   try {
     const name = decodeURIComponent(String(req.headers['x-file-name'] || 'upload.bin'));
     const mimeType = String(req.headers['x-mime-type'] || 'application/octet-stream');
@@ -319,6 +326,7 @@ app.post('/api/media/upload', express.raw({ type: () => true, limit: '100mb' }),
 app.post('/api/media/folders', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to create folders.')) return;
   try {
     const item = await mediaStore.createFolder(resolved.owner, {
       name: req.body?.name || 'New Folder',
@@ -335,6 +343,7 @@ app.post('/api/media/folders', async (req, res) => {
 app.post('/api/media/documents', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to create documents.')) return;
   try {
     const richText = !!req.body?.richText;
     const content = String(req.body?.content || '');
@@ -364,6 +373,7 @@ app.post('/api/media/documents', async (req, res) => {
 app.post('/api/media/move', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to move files.')) return;
   try {
     const items = await mediaStore.move(resolved.owner, req.body?.ids || [], req.body?.parentId || null);
     const usage = await mediaStore.getUsage(resolved.owner);
@@ -390,6 +400,7 @@ app.post('/api/media/trash', async (req, res) => {
 app.post('/api/media/restore', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to restore files.')) return;
   try {
     const items = await mediaStore.restore(resolved.owner, req.body?.ids || []);
     const usage = await mediaStore.getUsage(resolved.owner);
@@ -429,6 +440,7 @@ app.get('/api/media/:id/text', async (req, res) => {
 app.put('/api/media/:id/text', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to edit files.')) return;
   try {
     const buffer = Buffer.from(String(req.body?.content || ''), 'utf8');
     if (buffer.byteLength > MAX_TEXT_UPLOAD_BYTES) {
@@ -453,6 +465,23 @@ app.put('/api/media/:id/text', async (req, res) => {
   }
 });
 
+app.post('/api/media/:id/rename', async (req, res) => {
+  const resolved = await requireRequestOwner(req, res);
+  if (!resolved) return;
+  if (!requireSignedInMediaOwner(resolved, res, 'Sign in to rename files.')) return;
+  try {
+    const name = String(req.body?.name || '').trim();
+    if (!name) return res.status(400).json({ error: 'media:name_required', message: 'A file name is required.' });
+    const item = await mediaStore.rename(resolved.owner, req.params.id, name);
+    if (!item) return res.status(404).json({ error: 'media:not_found' });
+    const usage = await mediaStore.getUsage(resolved.owner);
+    res.json({ item, usage });
+  } catch (err) {
+    console.error('media rename error', err);
+    res.status(500).json({ error: 'media:rename_failed', message: err.message || 'Rename failed' });
+  }
+});
+
 app.get('/api/media/:id/content', async (req, res) => {
   const resolved = await requireRequestOwner(req, res);
   if (!resolved) return;

server/mediaStore.js

@@ -402,6 +402,17 @@ export const mediaStore = {
     return sanitizeEntry(entry);
   },
 
+  async rename(owner, id, name) {
+    ensureOwner(owner);
+    await ensureLoaded();
+    const entry = getEntry(id);
+    if (!entry || !canAccess(entry, owner)) return null;
+    entry.name = normalizeName(name, entry.name || 'Untitled');
+    entry.updatedAt = nowIso();
+    await saveIndex();
+    return sanitizeEntry(entry);
+  },
+
   async move(owner, ids, parentId = null) {
     ensureOwner(owner);
     await ensureLoaded();

server/webSearchUsageStore.js

@@ -0,0 +1,91 @@
+import fs from 'fs/promises';
+import path from 'path';
+
+const DATA_DIR = '/data';
+const STORE_FILE = path.join(DATA_DIR, 'web-search-usage.json');
+const APP_TIMEZONE = process.env.APP_TIMEZONE || 'America/New_York';
+
+let state = { days: {} };
+let loaded = false;
+let saveChain = Promise.resolve();
+
+function todayKey() {
+  return new Intl.DateTimeFormat('en-CA', {
+    timeZone: APP_TIMEZONE,
+    year: 'numeric',
+    month: '2-digit',
+    day: '2-digit',
+  }).format(new Date());
+}
+
+function pruneDays() {
+  const keepKey = todayKey();
+  state.days = Object.fromEntries(
+    Object.entries(state.days || {}).filter(([key]) => key === keepKey)
+  );
+}
+
+async function ensureLoaded() {
+  if (loaded) return;
+  loaded = true;
+  try {
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    const raw = await fs.readFile(STORE_FILE, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed && typeof parsed === 'object') state = parsed;
+  } catch {}
+  pruneDays();
+}
+
+function saveState() {
+  saveChain = saveChain.then(async () => {
+    pruneDays();
+    await fs.mkdir(DATA_DIR, { recursive: true });
+    await fs.writeFile(STORE_FILE, JSON.stringify(state, null, 2), 'utf8');
+  }).catch((err) => {
+    console.error('Failed to persist web search usage:', err);
+  });
+  return saveChain;
+}
+
+function getCounterRecord(key) {
+  const day = todayKey();
+  if (!state.days[day]) state.days[day] = {};
+  if (!state.days[day][key]) state.days[day][key] = 0;
+  return {
+    day,
+    used: state.days[day][key],
+    set(nextValue) {
+      state.days[day][key] = nextValue;
+    },
+  };
+}
+
+export async function getWebSearchUsage(key, limit = 15) {
+  await ensureLoaded();
+  const record = getCounterRecord(key);
+  return {
+    limit,
+    used: record.used,
+    remaining: Math.max(0, limit - record.used),
+    window: record.day,
+    period: 'daily',
+  };
+}
+
+export async function consumeWebSearchUsage(key, limit = 15) {
+  await ensureLoaded();
+  const record = getCounterRecord(key);
+  if (record.used >= limit) {
+    return {
+      allowed: false,
+      ...(await getWebSearchUsage(key, limit)),
+    };
+  }
+  record.set(record.used + 1);
+  await saveState();
+  return {
+    allowed: true,
+    ...(await getWebSearchUsage(key, limit)),
+  };
+}

server/wsHandler.js

@@ -14,6 +14,7 @@ import { mediaStore } from './mediaStore.js';
 import { memoryStore } from './memoryStore.js';
 import { chatTrashStore } from './chatTrashStore.js';
 import { systemPromptStore } from './systemPromptStore.js';
+import { getWebSearchUsage } from './webSearchUsageStore.js';
 import crypto from 'crypto';
 import path from 'path';
 
@@ -45,9 +46,36 @@ import path from 'path';
  */
 
 const activeStreams = new Map();
+const VERSION_META_FIELDS = ['toolCalls', 'responseEdits', 'responseSegments', 'error'];
+const CONTINUE_ASSISTANT_PROMPT =
+  'Continue your previous response exactly where it left off. Do not restart, summarize, or repeat the opening. Preserve the same formatting and only add the missing continuation.';
+const FREE_WEB_SEARCH_LIMIT = 15;
 
 initGuestRequestLimiter().catch(err => console.error('Failed to initialize guest request limiter:', err));
 
+function usageOwnerKey(client, clientId = '') {
+  if (client?.userId) return `user:${client.userId}`;
+  return `guest:${clientId || client?.tempId || 'anonymous'}`;
+}
+
+function isFreeSearchPlan(client, usageInfo) {
+  if (!client?.userId) return true;
+  const planKey = usageInfo?.plan_key || usageInfo?.planKey || null;
+  return planKey === 'free';
+}
+
+async function buildUsagePayload(client, clientId = '') {
+  const usageInfo = await getUsageInfo(client?.accessToken, clientId);
+  const webSearchDaily = await getWebSearchUsage(usageOwnerKey(client, clientId), FREE_WEB_SEARCH_LIMIT);
+  return {
+    ...(usageInfo || {}),
+    usage: {
+      ...(usageInfo?.usage || {}),
+      webSearchDaily,
+    },
+  };
+}
+
 export async function handleWsMessage(ws, msg, wsClients) {
   const client = wsClients.get(ws); if (!client) return;
   // Require turnstile verification for most message types
@@ -296,6 +324,11 @@ const handlers = {
       });
     }
 
+    const usagePayload = await buildUsagePayload(client, msg.clientId || '');
+    const webSearchLimit = isFreeSearchPlan(client, usagePayload)
+      ? { key: usageOwnerKey(client, msg.clientId || ''), limit: FREE_WEB_SEARCH_LIMIT }
+      : null;
+
     await streamChat({
       sessionId,
       model: session.model,
@@ -304,6 +337,7 @@ const handlers = {
       tools: tools || {},
       accessToken: client.accessToken,
       clientId: msg.clientId,
+      webSearchLimit,
       owner,
       sessionName: session.name,
       abortSignal: abort.signal,
@@ -321,7 +355,7 @@ const handlers = {
         responseEditsCollected.push(edit);
         safeSend(ws, { type: 'chat:draftEdited', edit, text: draftText, sessionId });
       },
-      async onDone(text, toolCalls, aborted, sessionNameFromTag, responseEdits = []) {
+      async onDone(text, toolCalls, aborted, sessionNameFromTag, responseEdits = [], responseSegments = []) {
         activeStreams.delete(ws);
         const finalText = text || fullText;
 
@@ -339,6 +373,7 @@ const handlers = {
         });
         const asstEntry = buildEntry('assistant', finalText, mergedCalls, {
           responseEdits: [...responseEditsCollected, ...responseEdits],
+          responseSegments,
         });
 
         const mediaEntries = assetsCollected.map((asset) =>
@@ -362,8 +397,8 @@ const handlers = {
         }
         if (generatedFiles.length) safeSend(ws, { type: 'media:changed' });
 
-        // Rebuild tree structure with new messages appended
-        let newRootMessage = rootMessage ? validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage))) : null;
+        // Rebuild tree structure with new messages appended to the active branch leaf.
+        let newRootMessage = rootMessage ? cloneAndRepairTree(rootMessage) : null;
 
         if (!newRootMessage) {
           // First message in session - must have user entry
@@ -371,16 +406,12 @@ const handlers = {
           newRootMessage = userEntry;
           newRootMessage.versions[0].tail = [{ ...asstEntry }, ...mediaEntries];
         } else {
-          // Append to current tail
-          const currentVerIdx = newRootMessage.currentVersionIdx ?? 0;
-          let currentTail = newRootMessage.versions[currentVerIdx].tail || [];
-          currentTail = JSON.parse(JSON.stringify(currentTail));
-          if (userEntry) {
-            currentTail.push(userEntry);
-          }
-          currentTail.push(asstEntry);
-          currentTail.push(...mediaEntries);
-          newRootMessage.versions[currentVerIdx].tail = currentTail;
+          const appendedEntries = [
+            ...(userEntry ? [userEntry] : []),
+            asstEntry,
+            ...mediaEntries,
+          ];
+          appendEntriesToActiveLeaf(newRootMessage, appendedEntries);
         }
 
         const newHistory = [newRootMessage];
@@ -426,7 +457,7 @@ const handlers = {
     }
     
     // Find the target message in the tree and add new version
-    const newRoot = validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+    const newRoot = cloneAndRepairTree(rootMessage);
     const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
       // Add new version with EMPTY tail (no responses yet for this edited version)
       msgInTree.versions.push({
@@ -474,7 +505,7 @@ const handlers = {
     if (!targetMsg || !targetMsg.versions || versionIdx >= targetMsg.versions.length) return;
     
     // Find and update the message in tree, switching to specified version
-    const newRoot = validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+    const newRoot = cloneAndRepairTree(rootMessage);
     const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
       msgInTree.currentVersionIdx = versionIdx;
       msgInTree.content = msgInTree.versions[versionIdx].content;
@@ -494,6 +525,164 @@ const handlers = {
     safeSend(ws, { type: 'chat:versionSelected', sessionId, messageId: targetMsg.id, messageIndex, history: extractFlatHistory(newRoot) });
   },
 
+  'chat:assistantAction': async (ws, msg, client) => {
+    const { sessionId, messageIndex } = msg;
+    const action = msg.action === 'continue' ? 'continue' : 'regenerate';
+    const session = client.userId
+      ? sessionStore.getUserSession(client.userId, sessionId)
+      : sessionStore.getTempSession(client.tempId, sessionId);
+    if (!session) return safeSend(ws, { type: 'error', message: 'Session not found' });
+
+    const rootMessage = session.history?.[0];
+    if (!rootMessage) return safeSend(ws, { type: 'error', message: 'No history' });
+
+    const flatHistory = extractFlatHistory(rootMessage);
+    const targetMsg = flatHistory[messageIndex];
+    if (!targetMsg || targetMsg.role !== 'assistant') {
+      return safeSend(ws, { type: 'error', message: 'Assistant message not found' });
+    }
+
+    if (activeStreams.has(ws)) activeStreams.get(ws).abort();
+    const abort = new AbortController();
+    activeStreams.set(ws, abort);
+
+    const owner = getClientOwner(client);
+    const historyBeforeTarget = flatHistory.slice(0, messageIndex);
+    const baseAssistantText = stripSessionTagText(targetMsg.content || '');
+    const actionHistory = action === 'continue'
+      ? [...historyBeforeTarget, { role: 'assistant', content: baseAssistantText }]
+      : historyBeforeTarget;
+    const actionUserMessage = action === 'continue' ? CONTINUE_ASSISTANT_PROMPT : null;
+
+    safeSend(ws, {
+      type: 'chat:start',
+      sessionId,
+      streamKind: 'assistantAction',
+      action,
+      messageIndex,
+      prefillText: action === 'continue' ? baseAssistantText : '',
+    });
+
+    let fullText = '';
+    const assetsCollected = [];
+    const toolCallsCollected = [];
+    const responseEditsCollected = [];
+    const usagePayload = await buildUsagePayload(client, msg.clientId || '');
+    const webSearchLimit = isFreeSearchPlan(client, usagePayload)
+      ? { key: usageOwnerKey(client, msg.clientId || ''), limit: FREE_WEB_SEARCH_LIMIT }
+      : null;
+
+    await streamChat({
+      sessionId,
+      model: session.model,
+      history: actionHistory,
+      userMessage: actionUserMessage,
+      tools: msg.tools || {},
+      accessToken: client.accessToken,
+      clientId: msg.clientId,
+      webSearchLimit,
+      owner,
+      sessionName: session.name,
+      abortSignal: abort.signal,
+      onToken(t) {
+        fullText += t;
+        safeSend(ws, { type: 'chat:token', token: t, sessionId });
+      },
+      onToolCall(call) {
+        safeSend(ws, { type: 'chat:toolCall', call, sessionId });
+        if (call.state === 'resolved' || call.state === 'canceled') toolCallsCollected.push(call);
+      },
+      onNewAsset(asset) {
+        safeSend(ws, { type: 'chat:asset', asset, sessionId });
+        assetsCollected.push(asset);
+        safeSend(ws, { type: 'media:changed' });
+      },
+      onDraftEdit(edit, draftText) {
+        responseEditsCollected.push(edit);
+        safeSend(ws, { type: 'chat:draftEdited', edit, text: draftText, sessionId });
+      },
+      async onDone(text, toolCalls, aborted, sessionNameFromTag, responseEdits = [], responseSegments = []) {
+        activeStreams.delete(ws);
+        if (aborted) {
+          return safeSend(ws, { type: 'chat:aborted', sessionId });
+        }
+
+        const rawAssistantText = text || fullText;
+        const resolvedMap = new Map(toolCallsCollected.map((call) => [call.id, call]));
+        const mergedCalls = (toolCalls || []).map((call) => {
+          const resolved = resolvedMap.get(call.id) || {};
+          return { ...call, state: resolved.state || 'resolved', result: resolved.result };
+        });
+
+        let finalText = rawAssistantText;
+        let finalSegments = responseSegments;
+
+        if (action === 'continue') {
+          const { continuationText, overlapLength } = stripContinuationOverlap(baseAssistantText, rawAssistantText);
+          finalText = baseAssistantText + continuationText;
+          finalSegments = [
+            ...(baseAssistantText ? [{ type: 'text', text: baseAssistantText }] : []),
+            ...trimLeadingTextFromSegments(responseSegments, overlapLength),
+          ];
+        }
+
+        const mediaEntries = assetsCollected.map((asset) =>
+          buildMediaEntry(asset.role, {
+            assetId: asset.id,
+            mimeType: asset.mimeType,
+            name: asset.name,
+          })
+        );
+
+        const generatedFiles = extractAssistantGeneratedFiles(finalText);
+        for (const file of generatedFiles) {
+          await mediaStore.storeBuffer(owner, {
+            name: file.name,
+            mimeType: file.mimeType,
+            buffer: file.buffer,
+            sessionId,
+            source: 'assistant_generated',
+            kind: file.kind,
+          }).catch((err) => console.error('Failed to store generated text asset:', err));
+        }
+        if (generatedFiles.length) safeSend(ws, { type: 'media:changed' });
+
+        const newRoot = cloneAndRepairTree(rootMessage);
+        const found = findAndUpdateMessage(newRoot, targetMsg.id, (msgInTree) => {
+          const nextVersion = buildVersionRecord(finalText, {
+            tail: mediaEntries,
+            toolCalls: mergedCalls,
+            responseEdits: [...responseEditsCollected, ...responseEdits],
+            responseSegments: finalSegments,
+          });
+          applyVersionToMessage(msgInTree, nextVersion);
+        });
+        if (!found) {
+          return safeSend(ws, { type: 'error', message: 'Assistant branch could not be updated' });
+        }
+
+        let newName = session.name;
+        if (sessionNameFromTag) {
+          newName = sessionNameFromTag;
+        }
+
+        const newHistory = [newRoot];
+        if (client.userId) {
+          await sessionStore.updateUserSession(client.userId, client.accessToken, sessionId, { history: newHistory, name: newName });
+        } else {
+          sessionStore.updateTempSession(client.tempId, sessionId, { history: newHistory, name: newName });
+        }
+
+        safeSend(ws, { type: 'chat:done', sessionId, name: newName, history: extractFlatHistory(newRoot) });
+      },
+      onError(err) {
+        activeStreams.delete(ws);
+        console.error('assistant action streamChat error:', err);
+        safeSend(ws, { type: 'chat:error', error: String(err), sessionId });
+      },
+    });
+  },
+
   'settings:get': async (ws, msg, client) => {
     const s = client.userId
       ? await getUserSettings(client.userId, client.accessToken)
@@ -580,7 +769,7 @@ const handlers = {
     const subInfo = await getSubscriptionInfo(c.accessToken);
     safeSend(ws, { type: 'account:subscription', info: subInfo });
   },
-  'account:getUsage':        async (ws, msg, c) => { safeSend(ws, { type: 'account:usage', usage: await getUsageInfo(c.accessToken) }); },
+  'account:getUsage':        async (ws, msg, c) => { safeSend(ws, { type: 'account:usage', usage: await buildUsagePayload(c, msg.clientId || '') }); },
   'account:getTierConfig':   async (ws)          => { safeSend(ws, { type: 'account:tierConfig', config: await getTierConfig() }); },
   'account:getSessions':     (ws, msg, c)         => { if (!c.userId) return; safeSend(ws, { type: 'account:deviceSessions', sessions: deviceSessionStore.getForUser(c.userId), currentToken: c.deviceToken }); },
   'account:revokeSession':   (ws, msg, c, wsClients) => {
@@ -662,15 +851,30 @@ function buildEntry(role, content, toolCalls = [], extraFields = {}) {
     result: c.result,
   }));
   const validContent = (content === undefined || content === null) ? '' : content;
+  const versionMeta = {};
+  const topLevelExtraFields = { ...extraFields };
+  VERSION_META_FIELDS.forEach((key) => {
+    if (key in topLevelExtraFields) {
+      versionMeta[key] = topLevelExtraFields[key];
+      delete topLevelExtraFields[key];
+    }
+  });
   return { 
     id: generateMessageId(),
     role, 
     content: validContent, 
     timestamp: Date.now(),
-    versions: [{ content: validContent, tail: [], timestamp: Date.now() }], 
+    versions: [{
+      content: validContent,
+      tail: [],
+      timestamp: Date.now(),
+      ...(normalizedCalls.length ? { toolCalls: normalizedCalls } : {}),
+      ...versionMeta,
+    }],
     currentVersionIdx: 0,
     ...(normalizedCalls.length ? { toolCalls: normalizedCalls } : {}),
-    ...extraFields,
+    ...versionMeta,
+    ...topLevelExtraFields,
   };
 }
 
@@ -685,6 +889,82 @@ function buildMediaEntry(role, content) {
   };
 }
 
+function buildVersionRecord(content, extraFields = {}) {
+  const validContent = content === undefined || content === null ? '' : content;
+  const version = {
+    content: validContent,
+    tail: Array.isArray(extraFields.tail) ? extraFields.tail : [],
+    timestamp: Date.now(),
+  };
+  VERSION_META_FIELDS.forEach((key) => {
+    if (extraFields[key] !== undefined && extraFields[key] !== null) {
+      version[key] = extraFields[key];
+    }
+  });
+  return version;
+}
+
+function applyVersionToMessage(message, versionRecord) {
+  if (!message?.versions || !Array.isArray(message.versions)) {
+    message.versions = [];
+  }
+  message.versions.push(versionRecord);
+  message.currentVersionIdx = message.versions.length - 1;
+  syncMessageFromActiveVersion(message);
+  return message;
+}
+
+function stripSessionTagText(content) {
+  return typeof content === 'string'
+    ? content.replace(/<session_name>[\s\S]*?<\/session_name>/gi, '').trim()
+    : content;
+}
+
+function stripContinuationOverlap(baseText = '', generatedText = '') {
+  const base = String(baseText || '');
+  const generated = String(generatedText || '');
+  if (!base) return { continuationText: generated, overlapLength: 0 };
+  if (!generated) return { continuationText: '', overlapLength: 0 };
+  if (generated.startsWith(base)) {
+    return { continuationText: generated.slice(base.length), overlapLength: base.length };
+  }
+
+  const maxWindow = Math.min(base.length, generated.length, 400);
+  for (let size = maxWindow; size > 0; size--) {
+    if (base.slice(-size) === generated.slice(0, size)) {
+      return { continuationText: generated.slice(size), overlapLength: size };
+    }
+  }
+
+  return { continuationText: generated, overlapLength: 0 };
+}
+
+function trimLeadingTextFromSegments(segments = [], overlapLength = 0) {
+  let remaining = Math.max(0, overlapLength);
+  const trimmedSegments = [];
+
+  for (const segment of segments || []) {
+    if (!segment || segment.type !== 'text' || remaining <= 0) {
+      trimmedSegments.push(segment);
+      continue;
+    }
+
+    const text = String(segment.text || '');
+    if (remaining >= text.length) {
+      remaining -= text.length;
+      continue;
+    }
+
+    trimmedSegments.push({
+      ...segment,
+      text: text.slice(remaining),
+    });
+    remaining = 0;
+  }
+
+  return trimmedSegments.filter((segment) => segment && (segment.type !== 'text' || segment.text));
+}
+
 function extractAssistantGeneratedFiles(text) {
   if (!text || typeof text !== 'string') return [];
   const files = [];
@@ -746,6 +1026,70 @@ function validateAndRepairTree(rootMessage) {
   return rootMessage;
 }
 
+function cloneAndRepairTree(rootMessage) {
+  return validateAndRepairTree(JSON.parse(JSON.stringify(rootMessage)));
+}
+
+function getActiveVersion(message) {
+  if (!message) return null;
+  const versions = Array.isArray(message.versions) ? message.versions : [];
+  if (!versions.length) {
+    message.versions = [{ content: message.content ?? '', tail: [], timestamp: Date.now() }];
+    message.currentVersionIdx = 0;
+    return message.versions[0];
+  }
+  const currentVersionIdx = Number.isInteger(message.currentVersionIdx)
+    ? Math.max(0, Math.min(message.currentVersionIdx, versions.length - 1))
+    : 0;
+  message.currentVersionIdx = currentVersionIdx;
+  if (!Array.isArray(message.versions[currentVersionIdx].tail)) {
+    message.versions[currentVersionIdx].tail = [];
+  }
+  if (message.versions[currentVersionIdx].content === undefined || message.versions[currentVersionIdx].content === null) {
+    message.versions[currentVersionIdx].content = message.content ?? '';
+  }
+  return message.versions[currentVersionIdx];
+}
+
+function cloneVersionMetaValue(value) {
+  if (value === undefined) return undefined;
+  return JSON.parse(JSON.stringify(value));
+}
+
+function syncMessageFromActiveVersion(message) {
+  if (!message) return message;
+  const currentVersion = getActiveVersion(message);
+  if (!currentVersion) return message;
+  message.content = currentVersion.content ?? message.content ?? '';
+  VERSION_META_FIELDS.forEach((key) => {
+    if (key in currentVersion) {
+      message[key] = cloneVersionMetaValue(currentVersion[key]);
+    } else {
+      delete message[key];
+    }
+  });
+  return message;
+}
+
+function getActiveLeafMessage(rootMessage) {
+  let current = rootMessage;
+  while (current) {
+    const currentVersion = getActiveVersion(current);
+    const tail = Array.isArray(currentVersion?.tail) ? currentVersion.tail : [];
+    if (!tail.length) return current;
+    current = tail[tail.length - 1];
+  }
+  return rootMessage;
+}
+
+function appendEntriesToActiveLeaf(rootMessage, entries = []) {
+  if (!rootMessage || !entries.length) return rootMessage;
+  const leaf = getActiveLeafMessage(rootMessage);
+  const currentVersion = getActiveVersion(leaf);
+  currentVersion.tail = [...(currentVersion.tail || []), ...entries];
+  return rootMessage;
+}
+
 function extractFlatHistory(rootMessage) {
   if (!rootMessage) return [];
   
@@ -754,7 +1098,7 @@ function extractFlatHistory(rootMessage) {
     if (msg.content === undefined || msg.content === null) {
       msg.content = '';
     }
-    return msg;
+    return syncMessageFromActiveVersion(msg);
   };
   
   const history = [ensureValidContent(rootMessage)];

system prompt.md

@@ -24,6 +24,24 @@
 - Use markdown for everything other than the color spans.
 - Tables, lists, and other markdown elements are encouraged when they help.
 
+# Tool guide
+
+- Use `list_app_doc_sections` to see which documentation sections are available for the app UI, settings, privacy policy, and terms of service.
+- Use `read_app_doc_section` to read only the specific documentation section that answers the user's question.
+- Use `list_memories` at the start of a chat to check persistent memories for the user.
+- Use `save_memory` only for short, durable information that will still matter in future chats.
+- Use `delete_memory` when a saved memory is wrong, outdated, or the user asks to remove it.
+- Use `edit_response_draft` to fix, replace, append to, or remove text that has already been streamed to the user. Prefer targeted edits when possible.
+- Use `ollama_search` for current information, recent facts, news, or anything you are not sure about.
+- Use `read_web_page` to inspect a specific URL after search or when the user gives you a link.
+- Use `generate_image` when the user wants a new image or image variation.
+- Use `generate_video` when the user wants a generated video, animation, or moving scene.
+- Use `generate_audio` when the user wants music, ambience, or sound effects.
+- Use `list_prompt_resources` to discover staged prompt resources such as large text attachments and separated prompt chunks.
+- Use `read_prompt_chunk` to read staged text exactly instead of guessing about omitted or truncated content.
+- Use `load_prompt_images` to inspect staged images that were attached outside the inline prompt.
+- Use `write_notes` to keep short working notes after reading several prompt chunks or attachments.
+
 # Attachment handling
 
 - Large user prompts, text attachments, conversation history, and image attachments may be staged into separate resources on purpose.