Chat mode, phase 1: grounded streaming chat over your notes

Entry points (no sixth tab): Ask in the Library header (desktop button,
phone icon), Ask about this deck in the deck menu, Ask a question on
study/homework results (compact result travels as context), and a Chat
row in the desktop sidebar. Phones get a full-screen route with back +
New chat; the tab bar steps aside.

- Client-side retrieval: chunk scoped decks (~800 tokens), BM25 against
  the question + recent turns, top chunks under ~7k tokens, each
  labelled with deck + section. Notes come from the deck's stored
  sourceText (already kept for Regenerate); decks without it fall back
  to generated content and the UI says so.
- Stateless server: /api/chat validates against the CHAT_MODELS
  allowlist, trims the history to ~6k tokens, caps context at ~9k and
  streams token/thinking/done/error NDJSON. /api/chat/extract reduces
  attachments to text through the existing vision step.
- UI: user bubbles + full-width assistant text, streaming with stop,
  auto-scroll that pauses with a jump-to-bottom button, safe markdown
  (React nodes, no HTML injection; KaTeX dynamically imported only when
  a message has math), Thinking row for reasoning, copy/regenerate/
  edit-and-resend, model + context pickers (last model remembered),
  composer with visualViewport keyboard handling, safe-area, 16px
  textarea, Enter-to-send on desktop.
- Usage-limit failures keep the draft and show the shared message with
  Settings/Ollama actions; stopping maps the reader abort to a clean
  stopped state; offline disables sending with a reason.
- Settings: Keep notes text for chat toggle; deck menu: Delete notes
  text. RATE_LIMIT_CHAT + CHAT_MODELS in .env.example and README.
- Tests: chat suite (63 checks, stub Ollama) wired into run-all.
  Full set: 12/12 suites, 487 checks. SW -> freezmo-v32.

Also: tests/model-compare.mjs (diagnostic) benchmarks two models on the
same notes (latency, repair rounds, activity types) so the gpt-oss vs
gemma default can be decided on numbers; defaults unchanged.
This commit is contained in:
Martin Dvořák 2026-10-11 18:32:11 +00:00
commit 756a6257a2
46 changed files with 3840 additions and 56 deletions

View file

@ -0,0 +1,107 @@
import { z } from "zod";
import { extractNotes, notesToText } from "@/lib/ai";
import { authErrorMessage, authErrorKind, getServerConfig, resolveAuth } from "@/lib/config";
import { friendlyErrorMessage, OllamaError } from "@/lib/ollama";
import { rejectCrossOrigin, rejectOversizedBody, requestLocale } from "@/lib/http-guard";
import { clientKey, rateLimit, rateLimitResponse } from "@/lib/rate-limit";
import { translate } from "@/lib/i18n-dict";
export const runtime = "nodejs";
export const dynamic = "force-dynamic";
export const maxDuration = 300;
/** Same ceiling as deck generation: up to 16 resized photos. */
const MAX_BODY_BYTES = 33554432;
const MAX_IMAGE_CHARS = 8_000_000;
const requestSchema = z.object({
images: z.array(z.string().min(32).max(MAX_IMAGE_CHARS)).max(16).optional(),
text: z.string().max(120_000).optional(),
});
/**
* Turns chat attachments (photos, scanned pages, pasted document text) into
* plain text with the existing vision pipeline, so any chat model — including
* text-only ones — can use them. Never stores anything.
*/
export async function POST(request: Request) {
const locale = requestLocale(request);
const crossOrigin = rejectCrossOrigin(request);
if (crossOrigin) return crossOrigin;
const oversized = rejectOversizedBody(request, MAX_BODY_BYTES);
if (oversized) return oversized;
const config = getServerConfig();
const limit = rateLimit(`chat:${clientKey(request)}`, config.rateLimits.chat, config.rateLimits.windowMs);
if (!limit.allowed) return rateLimitResponse(limit, locale);
const auth = resolveAuth(config, request);
if ("error" in auth) {
return Response.json(
{ error: authErrorMessage(locale, auth.error), kind: authErrorKind(auth.error) },
{ status: 401 },
);
}
let payload: unknown;
try {
payload = await request.json();
} catch {
return Response.json({ error: translate(locale, "server.bodyNotJson") }, { status: 400 });
}
const parsed = requestSchema.safeParse(payload);
if (!parsed.success) {
return Response.json(
{ error: translate(locale, "server.invalidRequest", { detail: parsed.error.issues[0]?.message ?? "" }) },
{ status: 400 },
);
}
const images = (parsed.data.images ?? []).map(stripDataUrlPrefix).filter(Boolean);
const text = parsed.data.text?.trim() ?? "";
if (images.length === 0 && !text) {
return Response.json({ error: translate(locale, "server.needContent") }, { status: 400 });
}
const abort = new AbortController();
const timer = setTimeout(() => abort.abort(), config.timeoutMs);
try {
if (images.length === 0) {
// Plain text needs no model call at all.
return Response.json({ text: text.slice(0, 48_000) });
}
const extraction = await extractNotes({
model: config.visionModel,
repairModel: config.textModel,
auth: auth.auth,
images,
text: text || undefined,
signal: abort.signal,
});
const extracted = notesToText(extraction.notes).slice(0, 48_000);
if (!extracted.trim()) {
return Response.json({ error: translate(locale, "chat.attachEmpty"), kind: "bad_response" }, { status: 422 });
}
return Response.json({ text: extracted });
} catch (error) {
console.error("[api/chat/extract]", error instanceof OllamaError ? `${error.kind}: ${error.message}` : error);
return Response.json(
{
error: friendlyErrorMessage(error, auth.auth.baseUrl, locale),
kind: error instanceof OllamaError ? error.kind : "unknown",
},
{ status: 502 },
);
} finally {
clearTimeout(timer);
}
}
function stripDataUrlPrefix(value: string): string {
const commaIndex = value.indexOf(",");
if (value.startsWith("data:") && commaIndex !== -1) return value.slice(commaIndex + 1);
return value;
}

193
app/api/chat/route.ts Normal file
View file

@ -0,0 +1,193 @@
import { z } from "zod";
import { authErrorMessage, authErrorKind, getServerConfig, resolveAuth, resolveModelName } from "@/lib/config";
import { friendlyErrorMessage, ollamaChatStream, OllamaError } from "@/lib/ollama";
import { rejectCrossOrigin, rejectOversizedBody, requestLocale } from "@/lib/http-guard";
import { clientKey, rateLimit, rateLimitResponse } from "@/lib/rate-limit";
import { translate } from "@/lib/i18n-dict";
import { buildChatSystemPrompt } from "@/lib/prompts";
import { estimateTokens, trimHistory } from "@/lib/chat-trim";
export const runtime = "nodejs";
export const dynamic = "force-dynamic";
export const maxDuration = 300;
/** Context chunks (~7k tokens) plus a trimmed window plus JSON overhead. */
const MAX_BODY_BYTES = 1_000_000;
/** Hard cap on the attached context, whatever the client sends. */
const CONTEXT_TOKEN_BUDGET = 9000;
const requestSchema = z.object({
model: z.string().min(1).max(120).optional(),
messages: z
.array(
z.object({
role: z.enum(["user", "assistant"]),
content: z.string().min(1).max(20_000),
}),
)
.min(1)
.max(60),
context: z
.array(
z.object({
deckId: z.string().max(120),
deckTitle: z.string().max(200),
section: z.string().max(200),
text: z.string().min(1).max(12_000),
}),
)
.max(40)
.optional(),
});
type StreamEvent =
| { type: "token"; text: string }
| { type: "thinking"; text: string }
| { type: "done"; model: string }
| { type: "error"; error: string; kind?: string };
function encoder() {
const enc = new TextEncoder();
return (event: StreamEvent) => enc.encode(`${JSON.stringify(event)}\n`);
}
export async function POST(request: Request) {
const locale = requestLocale(request);
const crossOrigin = rejectCrossOrigin(request);
if (crossOrigin) return crossOrigin;
const oversized = rejectOversizedBody(request, MAX_BODY_BYTES);
if (oversized) return oversized;
const config = getServerConfig();
const limit = rateLimit(`chat:${clientKey(request)}`, config.rateLimits.chat, config.rateLimits.windowMs);
if (!limit.allowed) return rateLimitResponse(limit, locale);
const auth = resolveAuth(config, request);
if ("error" in auth) {
return Response.json(
{ error: authErrorMessage(locale, auth.error), kind: authErrorKind(auth.error) },
{ status: 401 },
);
}
let payload: unknown;
try {
payload = await request.json();
} catch {
return Response.json({ error: translate(locale, "server.bodyNotJson") }, { status: 400 });
}
const parsed = requestSchema.safeParse(payload);
if (!parsed.success) {
return Response.json(
{
error: translate(locale, "server.invalidRequest", {
detail: parsed.error.issues
.slice(0, 3)
.map((issue) => `${issue.path.join(".") || "body"} ${issue.message}`)
.join("; "),
}),
},
{ status: 400 },
);
}
const { messages, context } = parsed.data;
// The model must come from the server's allowlist — never from the client.
const allowed = config.chatModels.length > 0 ? config.chatModels : [config.textModel];
const model = parsed.data.model ?? allowed[0];
if (!allowed.some((entry) => entry.toLowerCase() === model.toLowerCase())) {
return Response.json(
{ error: translate(locale, "server.chatModelNotAllowed"), kind: "bad_model" },
{ status: 400 },
);
}
const last = messages[messages.length - 1];
if (last.role !== "user") {
return Response.json({ error: translate(locale, "server.chatNeedsQuestion") }, { status: 400 });
}
// Cap the context, then trim the conversation window.
const keptContext: typeof context = [];
let contextTokens = 0;
for (const chunk of context ?? []) {
const cost = estimateTokens(chunk.text);
if (contextTokens + cost > CONTEXT_TOKEN_BUDGET) break;
keptContext.push(chunk);
contextTokens += cost;
}
const history = trimHistory(messages);
const system = buildChatSystemPrompt({
context: keptContext.map((chunk) => ({
deckTitle: chunk.deckTitle,
section: chunk.section,
text: chunk.text,
})),
});
const encode = encoder();
const abort = new AbortController();
const globalTimer = setTimeout(() => abort.abort(), config.timeoutMs);
const stream = new ReadableStream<Uint8Array>({
async start(controller) {
const send = (event: StreamEvent) => {
try {
controller.enqueue(encode(event));
} catch {
/* client went away */
}
};
try {
const result = await ollamaChatStream({
model,
auth: auth.auth,
messages: [{ role: "system", content: system }, ...history],
signal: abort.signal,
onToken: (text) => send({ type: "token", text }),
onThinking: (text) => send({ type: "thinking", text }),
});
send({ type: "done", model: resolveModelName(result.model, auth.auth.directCloud) });
} catch (error) {
// A client-side stop aborts the upstream call: nothing to report.
if (abort.signal.aborted && request.signal.aborted) {
/* stopped by the user */
} else {
const message = friendlyErrorMessage(error, auth.auth.baseUrl, locale);
console.error("[api/chat]", error instanceof OllamaError ? `${error.kind}: ${error.message}` : error);
send({
type: "error",
error: message,
kind: error instanceof OllamaError ? error.kind : "unknown",
});
}
} finally {
clearTimeout(globalTimer);
try {
controller.close();
} catch {
/* already closed */
}
}
},
cancel() {
clearTimeout(globalTimer);
abort.abort();
},
});
return new Response(stream, {
headers: {
"Content-Type": "application/x-ndjson; charset=utf-8",
"Cache-Control": "no-store, no-transform",
Connection: "keep-alive",
},
});
}