Share-link generation and med math on request
All checks were successful
Verify and publish V2 container / build-and-push (push) Successful in 34s
All checks were successful
Verify and publish V2 container / build-and-push (push) Successful in 34s
- Visitors of class and exam links can generate NCLEX-style quizzes (default and maximum 50 questions, 25% select-all, Python-checked, optional 5 med math questions) and flashcard sets from chosen class materials, once the owner turns it on for the link. - 4 quizzes and 2 flashcard sets per link per day; failed attempts do not count; "Reset limits" in the share dialog gives a fresh allowance. - Sets are drafts tied to the link (migration 7): listed for every visitor, explainable, kept off the owner's drafts list, and reviewable or savable from the share dialog. - Generate gains "Include med math" with a count (default 5): exactly that many dosage calculation questions at the chosen difficulty, spread through the quiz, even when the material has none. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
parent
25bc03ea75
commit
e945f589ce
16 changed files with 807 additions and 44 deletions
|
|
@ -62,12 +62,14 @@ interface DraftRow {
|
|||
saved_kind: string | null;
|
||||
saved_id: string | null;
|
||||
conversation_id: string | null;
|
||||
/** Made by a visitor of this share link (not listed with the owner's drafts). */
|
||||
share_id: string | null;
|
||||
created_at: number;
|
||||
updated_at: number;
|
||||
}
|
||||
|
||||
export interface DraftMeta {
|
||||
origin?: 'generate' | 'assistant' | 'convert' | 'improve' | 'import';
|
||||
origin?: 'generate' | 'assistant' | 'convert' | 'improve' | 'import' | 'share';
|
||||
model?: string;
|
||||
request?: Record<string, unknown>;
|
||||
sources?: { documentId: string; title: string }[];
|
||||
|
|
@ -102,6 +104,7 @@ export function mapDraft(row: DraftRow) {
|
|||
savedKind: row.saved_kind,
|
||||
savedId: row.saved_id,
|
||||
conversationId: row.conversation_id,
|
||||
shareId: row.share_id ?? null,
|
||||
itemCount: payload.kind === 'quiz' ? payload.questions.length : payload.kind === 'deck' ? payload.cards.length : payload.content.length,
|
||||
createdAt: row.created_at,
|
||||
updatedAt: row.updated_at,
|
||||
|
|
@ -117,12 +120,22 @@ export function getDraft(db: DB, id: string): DraftDto {
|
|||
|
||||
export function createDraft(
|
||||
db: DB,
|
||||
input: { kind: DraftRow['kind']; classId?: string | null; folderId?: string | null; title: string; payload?: ContentDraft; meta?: DraftMeta; status?: DraftRow['status']; conversationId?: string | null },
|
||||
input: {
|
||||
kind: DraftRow['kind'];
|
||||
classId?: string | null;
|
||||
folderId?: string | null;
|
||||
title: string;
|
||||
payload?: ContentDraft;
|
||||
meta?: DraftMeta;
|
||||
status?: DraftRow['status'];
|
||||
conversationId?: string | null;
|
||||
shareId?: string | null;
|
||||
},
|
||||
): string {
|
||||
const id = newId();
|
||||
const at = now();
|
||||
db.run(
|
||||
`INSERT INTO drafts (id, kind, class_id, folder_id, title, payload, meta, status, conversation_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
`INSERT INTO drafts (id, kind, class_id, folder_id, title, payload, meta, status, conversation_id, share_id, created_at, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`,
|
||||
id,
|
||||
input.kind,
|
||||
input.classId ?? null,
|
||||
|
|
@ -132,6 +145,7 @@ export function createDraft(
|
|||
JSON.stringify(input.meta ?? {}),
|
||||
input.status ?? 'ready',
|
||||
input.conversationId ?? null,
|
||||
input.shareId ?? null,
|
||||
at,
|
||||
at,
|
||||
);
|
||||
|
|
@ -140,7 +154,7 @@ export function createDraft(
|
|||
|
||||
export function listDrafts(db: DB) {
|
||||
return db
|
||||
.all<DraftRow>(`SELECT * FROM drafts WHERE status IN ('generating', 'ready', 'failed') ORDER BY updated_at DESC LIMIT 50`)
|
||||
.all<DraftRow>(`SELECT * FROM drafts WHERE status IN ('generating', 'ready', 'failed') AND share_id IS NULL ORDER BY updated_at DESC LIMIT 50`)
|
||||
.map(mapDraft)
|
||||
.map(({ payload: _payload, ...rest }) => rest);
|
||||
}
|
||||
|
|
@ -252,7 +266,9 @@ export function discardDraft(db: DB, id: string): void {
|
|||
export function tidyDrafts(db: DB): void {
|
||||
db.run(`UPDATE drafts SET status = 'failed', error = 'Generation was interrupted by a restart. Start it again.' WHERE status = 'generating'`);
|
||||
db.run(`DELETE FROM drafts WHERE status IN ('saved', 'discarded') AND updated_at < ?`, now() - 14 * 86_400_000);
|
||||
db.run(`DELETE FROM drafts WHERE status IN ('ready', 'failed') AND updated_at < ?`, now() - 60 * 86_400_000);
|
||||
db.run(`DELETE FROM drafts WHERE status IN ('ready', 'failed') AND share_id IS NULL AND updated_at < ?`, now() - 60 * 86_400_000);
|
||||
// Sets made on a share link stay with the link; failed attempts go after a week.
|
||||
db.run(`DELETE FROM drafts WHERE status = 'failed' AND share_id IS NOT NULL AND updated_at < ?`, now() - 7 * 86_400_000);
|
||||
}
|
||||
|
||||
/* ------------------------------ request ------------------------------ */
|
||||
|
|
@ -286,6 +302,12 @@ export const generateRequestSchema = z.object({
|
|||
difficulty: z.enum(['easy', 'medium', 'hard', 'mixed']).optional(),
|
||||
/** Share of select-all-that-apply questions, 0..1. */
|
||||
sataShare: z.number().min(0).max(1).optional(),
|
||||
/**
|
||||
* Quizzes: exactly this many medication math (dosage calculation) questions, written at the
|
||||
* chosen difficulty even when the material has no calculations. Absent: calculations only
|
||||
* when the material involves them.
|
||||
*/
|
||||
mathQuestions: z.number().int().min(0).max(25).optional(),
|
||||
cardStyle: z.enum(['concise', 'detailed', 'medication', 'definition']).optional(),
|
||||
noteStyle: z.enum(['study_guide', 'summary', 'outline', 'cheat_sheet']).optional(),
|
||||
modelId: z.string().nullish(),
|
||||
|
|
@ -358,7 +380,15 @@ const CARD_SCHEMA = {
|
|||
required: ['cards'],
|
||||
};
|
||||
|
||||
const NUMERIC_RULE = `- Only write calculation items when the source material itself involves calculations, and never more than the number allowed in the request. Calculation items (dosages, weight-based doses, IV and drip rates, conversions, intake and output) use type "numeric": the student types the number instead of choosing. Give exactly one option, the correct answer with its unit (for example "12.5 mL"), marked correct, with "why" showing the working. State the unit and the rounding rule in the stem ("Round to the nearest tenth."). Only the number is checked, so the student may leave out the unit.`;
|
||||
/** What the medication math questions look like at each difficulty, when the user asks for them. */
|
||||
const MATH_LEVELS: Record<string, string> = {
|
||||
easy: 'single-step problems: tablets or capsules per dose, mL of an oral liquid, and simple unit conversions (g, mg, mcg; L, mL; lb to kg)',
|
||||
medium: 'weight-based doses (mg/kg), mL to draw up from a vial, and IV pump rates in mL/h',
|
||||
hard: 'multi-step problems: gravity drip rates in gtt/min with a drop factor, mcg/kg/min titrations, heparin units/h from a protocol, and reconstituted medications',
|
||||
mixed: 'a spread from single-step dose and conversion problems to weight-based doses, IV pump rates (mL/h) and drip rates (gtt/min)',
|
||||
};
|
||||
|
||||
const NUMERIC_RULE = `- Only write calculation items when the source material itself involves calculations (or the request asks for medication math), and never more than the number allowed in the request. Calculation items (dosages, weight-based doses, IV and drip rates, conversions, intake and output) use type "numeric": the student types the number instead of choosing. Give exactly one option, the correct answer with its unit (for example "12.5 mL"), marked correct, with "why" showing the working. State the unit and the rounding rule in the stem ("Round to the nearest tenth."). Only the number is checked, so the student may leave out the unit.`;
|
||||
|
||||
const NCLEX_RULES = `Write NCLEX-style (Next Generation NCLEX) items:
|
||||
- Test clinical judgment at the application and analysis level: recognise cues, analyse, prioritise, choose and evaluate actions. Avoid pure recall.
|
||||
|
|
@ -662,6 +692,25 @@ async function broadenTopics(app: AppContext, modelId: string | null | undefined
|
|||
return out;
|
||||
}
|
||||
|
||||
/** Places the matching items at even intervals among the others, keeping each group's order. */
|
||||
export function spreadEvenly<T>(list: T[], pick: (item: T) => boolean): T[] {
|
||||
const chosen = list.filter(pick);
|
||||
const rest = list.filter((x) => !pick(x));
|
||||
if (chosen.length === 0 || rest.length === 0) return list;
|
||||
const out: T[] = [];
|
||||
const step = (rest.length + chosen.length) / chosen.length;
|
||||
let next = Math.floor(step / 2);
|
||||
let c = 0;
|
||||
for (let i = 0, r = 0; i < list.length; i += 1) {
|
||||
if (c < chosen.length && i >= next) {
|
||||
out.push(chosen[c++]);
|
||||
next = Math.floor(step / 2 + c * step);
|
||||
} else if (r < rest.length) out.push(rest[r++]);
|
||||
else out.push(chosen[c++]);
|
||||
}
|
||||
return out;
|
||||
}
|
||||
|
||||
/** True when the material involves calculations, so calculation questions are fair game. */
|
||||
export function mentionsCalculations(text: string): boolean {
|
||||
return CALCULATION_RE.test(text);
|
||||
|
|
@ -710,7 +759,7 @@ const NOTE_TITLES: Record<string, string> = { study_guide: 'study guide', summar
|
|||
export function startGeneration(
|
||||
app: AppContext,
|
||||
input: z.input<typeof generateRequestSchema>,
|
||||
opts: { conversationId?: string | null; origin?: DraftMeta['origin']; onProgress?: (label: string) => void } = {},
|
||||
opts: { conversationId?: string | null; origin?: DraftMeta['origin']; onProgress?: (label: string) => void; shareId?: string } = {},
|
||||
): { draftId: string; done: Promise<DraftDto> } {
|
||||
const req = generateRequestSchema.parse(input);
|
||||
if (req.classId) getClass(app.db, req.classId);
|
||||
|
|
@ -727,6 +776,7 @@ export function startGeneration(
|
|||
title: req.title ?? '',
|
||||
status: 'generating',
|
||||
conversationId: opts.conversationId ?? null,
|
||||
shareId: opts.shareId ?? null,
|
||||
meta: { origin: opts.origin ?? 'generate', model: resolved.model.label, request: { ...req, source: { ...req.source, text: req.source.text ? `${req.source.text.slice(0, 200)}…` : undefined } } },
|
||||
});
|
||||
const controller = new AbortController();
|
||||
|
|
@ -795,22 +845,35 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
// Calculation questions: only when the material involves calculations, and at most 5 per
|
||||
// 50-question exam (10% of a practice set).
|
||||
const mathAllowed = isQuiz && mentionsCalculations([sourcesText(sources), req.focus ?? '', req.instructions ?? ''].join('\n'));
|
||||
const numericCap = !mathAllowed ? 0 : req.format === 'exam' ? Math.min(5, Math.max(1, Math.round(count / 10))) : Math.max(1, Math.round(count / 10));
|
||||
// Medication math on request: exactly that many, written in their own batches after the rest.
|
||||
const forcedMath = isQuiz && req.mathQuestions !== undefined ? Math.min(req.mathQuestions, count) : null;
|
||||
const regularCount = forcedMath === null ? count : count - forcedMath;
|
||||
const numericCap =
|
||||
forcedMath !== null ? forcedMath : !mathAllowed ? 0 : req.format === 'exam' ? Math.min(5, Math.max(1, Math.round(count / 10))) : Math.max(1, Math.round(count / 10));
|
||||
const numericCount = () => (draft.kind === 'quiz' ? draft.questions.filter((q) => q.type === 'numeric').length : 0);
|
||||
// Broad topic labels, shared with the class's existing quizzes so results group sensibly.
|
||||
const knownTopics = isQuiz && req.classId ? db.all<{ topic: string }>(`SELECT DISTINCT q.topic FROM questions q JOIN quizzes z ON z.id = q.quiz_id WHERE z.class_id = ? AND q.topic != '' LIMIT 60`, req.classId).map((r) => r.topic) : [];
|
||||
|
||||
const runBatch = async (index: number, want: number): Promise<number> => {
|
||||
const runBatch = async (index: number, want: number, math = false): Promise<number> => {
|
||||
const written = items().map((x) => `- ${('stem' in x ? x.stem : x.front).replace(/\s+/g, ' ').slice(0, 140)}`);
|
||||
const sataCount = Math.round(want * sata);
|
||||
const numericLeft = Math.max(0, numericCap - numericCount());
|
||||
// With requested math, the regular batches write none; the math batches write only those.
|
||||
const numericLeft = forcedMath !== null && !math ? 0 : Math.max(0, numericCap - numericCount());
|
||||
const topicsSoFar = [...new Set([...knownTopics, ...(draft.kind === 'quiz' ? draft.questions.map((q) => q.topic) : [])].filter(Boolean))];
|
||||
const ask = isQuiz
|
||||
const ask = math
|
||||
? [
|
||||
`Write ${want} medication math (dosage calculation) questions, all of type "numeric": the student types the number.`,
|
||||
`Difficulty ${difficulty}: ${MATH_LEVELS[difficulty] ?? MATH_LEVELS.mixed}.`,
|
||||
'These do not need to come from the course material: write standard nursing med math with realistic orders, labels and client weights, using generic drug names (drugs from the material are welcome where they fit).',
|
||||
'Each stem gives the order and what is on hand, and states the unit and the rounding rule ("Round to the nearest tenth."). Exactly one option: the correct answer with its unit, marked correct, with "why" showing the working step by step (dimensional analysis or desired over have). The rationale explains the method and one safety check.',
|
||||
'Set the topic to "Dosage calculation". Vary the problem types.',
|
||||
]
|
||||
: isQuiz
|
||||
? [
|
||||
`Write ${want} NCLEX-style questions${req.focus ? ` about: ${req.focus}` : ''}.`,
|
||||
sata <= 0 ? 'Use only multiple-choice (single) questions, apart from calculations.' : sata >= 1 ? 'Use only select-all-that-apply (multi) questions, apart from calculations.' : `Exactly ${sataCount} of them must be select-all-that-apply (type "multi"); the rest multiple choice (single).`,
|
||||
numericLeft === 0
|
||||
? 'Do not write any calculation (numeric) questions in this batch.'
|
||||
? `Do not write any calculation (numeric) questions in this batch.${forcedMath ? ' Calculation questions are written separately.' : ''}`
|
||||
: `The material involves calculations: you may include up to ${numericLeft} calculation question${numericLeft === 1 ? '' : 's'} (type "numeric", the student types the number). Do not exceed that.`,
|
||||
`Topic labels must be broad (the main condition, drug class or body system, 1-3 words), not subtypes or aspects.${topicsSoFar.length ? ` Reuse these existing topics wherever they fit: ${topicsSoFar.slice(0, 40).join(', ')}.` : ''}`,
|
||||
difficulty === 'mixed' ? 'Mix difficulty: mostly medium, with a few easy and a few hard.' : `Difficulty: ${difficulty}.`,
|
||||
|
|
@ -823,7 +886,8 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
req.source.quizId ? 'Turn the quiz questions into flashcards: the front asks for the key fact, the back states it with the essential reasoning.' : '',
|
||||
];
|
||||
if (written.length > 0) ask.push(`Already written (do not repeat or closely paraphrase these):\n${written.slice(-80).join('\n')}`);
|
||||
const user = [sourceBlock(sources, index), ask.filter(Boolean).join('\n')].filter(Boolean).join('\n\n======\n\n');
|
||||
// Med math is standard material: the excerpts would only cost tokens.
|
||||
const user = [math ? '' : sourceBlock(sources, index), ask.filter(Boolean).join('\n')].filter(Boolean).join('\n\n======\n\n');
|
||||
|
||||
const result = await generateStructured(app, {
|
||||
task: 'generate',
|
||||
|
|
@ -850,21 +914,25 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
const ref = (item.source ?? '').replace(/[[\]\s]/g, '');
|
||||
item.source = sources.refs.get(ref) ?? undefined;
|
||||
}
|
||||
if ('stem' in item && item.type === 'numeric' && numericCount() >= numericCap) continue; // over the calculation allowance; a top-up replaces it
|
||||
if ('stem' in item && item.type === 'numeric' && (numericLeft === 0 || numericCount() >= numericCap)) continue; // over the calculation allowance; a top-up replaces it
|
||||
if (math && (!('stem' in item) || item.type !== 'numeric')) continue; // a math batch keeps only calculations
|
||||
if ('stem' in item && item.type !== 'numeric') item.options = shuffleOptions(item.options);
|
||||
seen.add(k);
|
||||
(items() as (DraftQuestion | DraftCard)[]).push(item);
|
||||
added += 1;
|
||||
if (math ? numericCount() >= numericCap : items().length - numericCount() >= regularCount && forcedMath !== null) break;
|
||||
if (items().length >= count) break;
|
||||
}
|
||||
if (result.truncated) notes.push('One batch hit the model output limit, so it produced fewer items than requested.');
|
||||
return added;
|
||||
};
|
||||
|
||||
// Regular items written so far (with requested math, calculations are counted separately).
|
||||
const regularDone = () => (forcedMath === null ? items().length : items().length - numericCount());
|
||||
let failures = 0;
|
||||
for (let i = 0; i < batches && items().length < count; i += 1) {
|
||||
for (let i = 0; i < Math.ceil(regularCount / perBatch) && regularDone() < regularCount; i += 1) {
|
||||
if (signal.aborted) throw new AIError('aborted', 'Generation was cancelled.');
|
||||
const want = Math.min(perBatch, count - items().length);
|
||||
const want = Math.min(perBatch, regularCount - regularDone());
|
||||
setProgress(db, draftId, 0.05 + (0.9 * items().length) / count, `Writing ${isQuiz ? 'questions' : 'cards'} ${items().length + 1}-${Math.min(count, items().length + want)} of ${count}`, draft);
|
||||
try {
|
||||
await runBatch(i, want);
|
||||
|
|
@ -876,9 +944,9 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
}
|
||||
}
|
||||
// Top up when validation or de-duplication left the draft short.
|
||||
for (let extra = 0; extra < 2 && items().length < count && items().length > 0; extra += 1) {
|
||||
for (let extra = 0; extra < 2 && regularDone() < regularCount && items().length > 0; extra += 1) {
|
||||
if (signal.aborted) break;
|
||||
const want = Math.min(perBatch, count - items().length);
|
||||
const want = Math.min(perBatch, regularCount - regularDone());
|
||||
setProgress(db, draftId, 0.92, `Writing the last ${want} ${isQuiz ? 'questions' : 'cards'}`, draft);
|
||||
try {
|
||||
if ((await runBatch(batches + extra, want)) === 0) break;
|
||||
|
|
@ -886,6 +954,22 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
break;
|
||||
}
|
||||
}
|
||||
// Requested medication math, in batches of up to eight, then spread evenly through the quiz.
|
||||
if (forcedMath && draft.kind === 'quiz') {
|
||||
for (let attempt = 0; attempt < Math.ceil(forcedMath / perBatch) + 2 && numericCount() < forcedMath; attempt += 1) {
|
||||
if (signal.aborted) throw new AIError('aborted', 'Generation was cancelled.');
|
||||
const want = Math.min(perBatch, forcedMath - numericCount());
|
||||
setProgress(db, draftId, 0.9, `Writing ${want} med math question${want === 1 ? '' : 's'}`, draft);
|
||||
try {
|
||||
if ((await runBatch(batches + 10 + attempt, want, true)) === 0 && attempt > 0) break;
|
||||
} catch (err) {
|
||||
if (err instanceof AIError && err.code === 'aborted') throw err;
|
||||
notes.push(`A med math batch failed: ${err instanceof Error ? err.message : 'unknown error'}`);
|
||||
}
|
||||
}
|
||||
draft.questions = spreadEvenly(draft.questions, (q) => q.type === 'numeric');
|
||||
if (numericCount() < forcedMath) notes.push(`Wrote ${numericCount()} of the ${forcedMath} med math questions requested.`);
|
||||
}
|
||||
if (items().length === 0) throw new AIError('invalid_response', 'The model did not produce any usable items. Try again, or choose a different model for content generation.');
|
||||
if (items().length < count) notes.push(`Generated ${items().length} of the ${count} requested.`);
|
||||
|
||||
|
|
@ -901,7 +985,7 @@ async function runGeneration(app: AppContext, draftId: string, req: GenerateRequ
|
|||
// Check counts, the type mix, answer keys and calculations with Python before review.
|
||||
if (draft.kind === 'quiz' && req.verify !== false) {
|
||||
setProgress(db, draftId, 0.96, 'Checking the questions with Python', draft);
|
||||
const checked = await verifyQuizDraft(app, draft, { count, style, sataShare: sata, difficulty, numericCap }, { modelId: req.modelId, signal, onStep: (label) => setProgress(db, draftId, 0.97, label) });
|
||||
const checked = await verifyQuizDraft(app, draft, { count, style, sataShare: sata, difficulty, numericCap, numericRequested: forcedMath !== null }, { modelId: req.modelId, signal, onStep: (label) => setProgress(db, draftId, 0.97, label) });
|
||||
draft.questions = checked.draft.questions;
|
||||
notes.push(...checked.notes);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -76,6 +76,8 @@ export interface QuizRequestFacts {
|
|||
difficulty?: string;
|
||||
/** Most calculation (numeric) questions allowed; 0 when the material has no calculations. */
|
||||
numericCap?: number;
|
||||
/** The user asked for exactly `numericCap` medication math questions (not from the material). */
|
||||
numericRequested?: boolean;
|
||||
}
|
||||
|
||||
/** Long text is shortened rather than rejected: a verbose but correct review must not be lost. */
|
||||
|
|
@ -142,7 +144,7 @@ const SUBMIT_REVIEW: ToolDef = {
|
|||
function rulesFor(req: QuizRequestFacts): string {
|
||||
const expectedMulti = req.sataShare <= 0 ? 'none' : req.sataShare >= 1 ? 'all non-numeric questions' : `about ${Math.round(req.sataShare * 100)}% of the non-numeric questions`;
|
||||
return [
|
||||
`Requested: ${req.count} NCLEX-style questions, difficulty "${req.difficulty ?? 'mixed'}", select-all (multi) share: ${expectedMulti}, calculation (numeric) questions: ${req.numericCap ? `at most ${req.numericCap}` : 'none (the material has no calculations)'}.`,
|
||||
`Requested: ${req.count} NCLEX-style questions, difficulty "${req.difficulty ?? 'mixed'}", select-all (multi) share: ${expectedMulti}, calculation (numeric) questions: ${req.numericRequested ? (req.numericCap ? `exactly ${req.numericCap} medication math questions, requested by the user (they need not come from the material)` : 'none') : req.numericCap ? `at most ${req.numericCap}` : 'none (the material has no calculations)'}.`,
|
||||
'Rules each question must meet:',
|
||||
'- single: exactly one correct option and 4 options.',
|
||||
'- multi (select all that apply): at least 2 correct options; for NCLEX style 5 or 6 options with 2 to 5 correct and a stem ending with "Select all that apply."',
|
||||
|
|
|
|||
|
|
@ -440,6 +440,16 @@ UPDATE ai_providers SET
|
|||
WHERE kind = 'ollama';
|
||||
`;
|
||||
|
||||
/**
|
||||
* Quizzes and flashcards that share-link visitors generate are drafts tied to the link (kept
|
||||
* until the owner discards them or deletes the link); the daily allowance can be reset.
|
||||
*/
|
||||
const shareGeneration = `
|
||||
ALTER TABLE drafts ADD COLUMN share_id TEXT REFERENCES shares(id) ON DELETE CASCADE;
|
||||
CREATE INDEX drafts_share ON drafts(share_id, created_at);
|
||||
ALTER TABLE shares ADD COLUMN generate_reset_at INTEGER;
|
||||
`;
|
||||
|
||||
export const MIGRATIONS: Migration[] = [
|
||||
{ id: 1, name: 'init', sql: init },
|
||||
{ id: 2, name: 'embeddings', sql: embeddings },
|
||||
|
|
@ -447,4 +457,5 @@ export const MIGRATIONS: Migration[] = [
|
|||
{ id: 4, name: 'revision2', sql: revision2 },
|
||||
{ id: 5, name: 'revision3', sql: revision3 },
|
||||
{ id: 6, name: 'revision4', sql: revision4 },
|
||||
{ id: 7, name: 'share-generation', sql: shareGeneration },
|
||||
];
|
||||
|
|
|
|||
|
|
@ -10,12 +10,14 @@ import { citedPassages, citedPassagesPrompt, EXPLAIN_SYSTEM, explainPrompt } fro
|
|||
import { genUiPrompt } from '../ai/genui.ts';
|
||||
import { officePreviewHtml, PREVIEW_CSP } from '../documents/preview.ts';
|
||||
import { aiStatus, runChatWithMcp } from '../ai/service.ts';
|
||||
import { startGeneration } from '../ai/generate.ts';
|
||||
import { getAppSettings } from '../settings.ts';
|
||||
import { AIError, type ChatMessage } from '../ai/types.ts';
|
||||
import { HttpError, idParam, notFound, readBody, type AppContext } from '../http.ts';
|
||||
import { listCards, listQuestions } from '../services/content.ts';
|
||||
import { listChunks, searchChunks, sourceLabel, type ChunkHit } from '../services/documents.ts';
|
||||
import { hybridSearch } from '../services/semantic.ts';
|
||||
import { newId, newToken, now, parseJson } from '../util.ts';
|
||||
import { newId, newToken, now, parseJson, startOfDay } from '../util.ts';
|
||||
import type { ToolActivity } from '../ai/activity.ts';
|
||||
import { sourceActivity, sse, type ExplainEvent } from './ai.ts';
|
||||
|
||||
|
|
@ -33,6 +35,7 @@ interface ShareRow {
|
|||
created_at: number;
|
||||
updated_at: number;
|
||||
ai: string;
|
||||
generate_reset_at: number | null;
|
||||
}
|
||||
|
||||
/** AI features a share's visitors may use. Both are off until the owner turns them on. */
|
||||
|
|
@ -41,9 +44,55 @@ export interface ShareAi {
|
|||
explain: boolean;
|
||||
/** A chat assistant that answers from the shared material only. */
|
||||
assistant: boolean;
|
||||
/** Visitors of a shared class or exam can generate quizzes and flashcards from its materials. */
|
||||
generate: boolean;
|
||||
}
|
||||
|
||||
const shareAi = (row: Pick<ShareRow, 'ai'>): ShareAi => ({ explain: false, assistant: false, ...parseJson<Partial<ShareAi>>(row.ai, {}) });
|
||||
const shareAi = (row: Pick<ShareRow, 'ai'>): ShareAi => ({ explain: false, assistant: false, generate: false, ...parseJson<Partial<ShareAi>>(row.ai, {}) });
|
||||
|
||||
/** Sets a share link may generate per day (the app's time zone), until the owner resets it. */
|
||||
export const SHARE_GENERATE_LIMITS = { quiz: 4, deck: 2 } as const;
|
||||
/** A shared quiz is at most one exam long. */
|
||||
export const SHARE_QUIZ_MAX = 50;
|
||||
const SHARE_DECK_MAX = 50;
|
||||
/** Medication math questions in a visitor's quiz when they ask for them. */
|
||||
const SHARE_MATH_QUESTIONS = 5;
|
||||
|
||||
/** Today's generations on a link (since local midnight or the owner's last reset). */
|
||||
function generateUsage(app: AppContext, share: Pick<ShareRow, 'id' | 'generate_reset_at'>) {
|
||||
const s = getAppSettings(app.db, app.config.timezone);
|
||||
const at = now();
|
||||
const since = Math.max(startOfDay(at, s.timezone), share.generate_reset_at ?? 0);
|
||||
const used = (kind: 'quiz' | 'deck') =>
|
||||
app.db.get<{ n: number }>(`SELECT COUNT(*) AS n FROM drafts WHERE share_id = ? AND kind = ? AND status != 'failed' AND created_at >= ?`, share.id, kind, since)?.n ?? 0;
|
||||
return {
|
||||
quiz: { used: used('quiz'), limit: SHARE_GENERATE_LIMITS.quiz },
|
||||
deck: { used: used('deck'), limit: SHARE_GENERATE_LIMITS.deck },
|
||||
};
|
||||
}
|
||||
|
||||
/** The sets made on a link that visitors can open (or are still being written). */
|
||||
function generatedSets(app: AppContext, shareId: string) {
|
||||
return app.db
|
||||
.all<{ id: string; kind: 'quiz' | 'deck'; title: string; status: string; progress: number; progress_label: string; error: string; payload: string; created_at: number }>(
|
||||
`SELECT id, kind, title, status, progress, progress_label, error, payload, created_at FROM drafts WHERE share_id = ? AND status IN ('generating', 'ready', 'failed') ORDER BY created_at DESC LIMIT 60`,
|
||||
shareId,
|
||||
)
|
||||
.map((d) => {
|
||||
const payload = parseJson<{ questions?: unknown[]; cards?: unknown[] }>(d.payload, {});
|
||||
return {
|
||||
id: d.id,
|
||||
kind: d.kind,
|
||||
title: d.title || (d.kind === 'quiz' ? 'Practice quiz' : 'Flashcards'),
|
||||
status: d.status as 'generating' | 'ready' | 'failed',
|
||||
progress: d.progress,
|
||||
progressLabel: d.progress_label,
|
||||
error: d.status === 'failed' ? 'This set could not be made. Try again later.' : '',
|
||||
count: (d.kind === 'quiz' ? payload.questions?.length : payload.cards?.length) ?? 0,
|
||||
createdAt: d.created_at,
|
||||
};
|
||||
});
|
||||
}
|
||||
|
||||
const TABLE: Record<ShareKind, { table: string; title: string }> = {
|
||||
quiz: { table: 'quizzes', title: 'title' },
|
||||
|
|
@ -68,6 +117,11 @@ function mapShare(row: ShareRow) {
|
|||
};
|
||||
}
|
||||
|
||||
/** The owner's view of what visitors generated on a link. */
|
||||
function ownerGenerated(app: AppContext, row: ShareRow) {
|
||||
return { usage: generateUsage(app, row), sets: generatedSets(app, row.id).filter((s) => s.status !== 'failed') };
|
||||
}
|
||||
|
||||
/* ------------------------------ admin ------------------------------ */
|
||||
|
||||
export function shareRoutes(app: AppContext): Hono {
|
||||
|
|
@ -89,7 +143,7 @@ export function shareRoutes(app: AppContext): Hono {
|
|||
}
|
||||
const classId = row.kind === 'class' ? row.target_id : target.class_id;
|
||||
const cls = classId ? db.get<{ name: string; color: string }>('SELECT name, color FROM classes WHERE id = ?', classId) : undefined;
|
||||
out.push({ ...mapShare(row), title: target.title, classId: classId ?? null, className: cls?.name ?? '', classColor: cls?.color ?? 'slate' });
|
||||
out.push({ ...mapShare(row), title: target.title, classId: classId ?? null, className: cls?.name ?? '', classColor: cls?.color ?? 'slate', generated: row.kind === 'class' || row.kind === 'folder' ? ownerGenerated(app, row) : null });
|
||||
}
|
||||
return c.json({ shares: out });
|
||||
});
|
||||
|
|
@ -111,7 +165,7 @@ export function shareRoutes(app: AppContext): Hono {
|
|||
|
||||
r.patch('/shares/:id', async (c) => {
|
||||
const id = idParam(c);
|
||||
const body = await readBody(c, z.object({ enabled: z.boolean().optional(), ai: z.object({ explain: z.boolean(), assistant: z.boolean() }).partial().optional() }));
|
||||
const body = await readBody(c, z.object({ enabled: z.boolean().optional(), ai: z.object({ explain: z.boolean(), assistant: z.boolean(), generate: z.boolean() }).partial().optional() }));
|
||||
const row = db.get<ShareRow>('SELECT * FROM shares WHERE id = ?', id);
|
||||
if (!row) throw notFound('Share link');
|
||||
const enabled = body.enabled ?? Boolean(row.enabled);
|
||||
|
|
@ -120,6 +174,15 @@ export function shareRoutes(app: AppContext): Hono {
|
|||
return c.json({ share: mapShare(db.get<ShareRow>('SELECT * FROM shares WHERE id = ?', id)!) });
|
||||
});
|
||||
|
||||
/** Gives the link a fresh daily allowance of generated quizzes and flashcards. */
|
||||
r.post('/shares/:id/generate/reset', (c) => {
|
||||
const id = idParam(c);
|
||||
const { changes } = db.run('UPDATE shares SET generate_reset_at = ?, updated_at = ? WHERE id = ?', now(), now(), id);
|
||||
if (!changes) throw notFound('Share link');
|
||||
const row = db.get<ShareRow>('SELECT * FROM shares WHERE id = ?', id)!;
|
||||
return c.json({ share: mapShare(row), generated: ownerGenerated(app, row) });
|
||||
});
|
||||
|
||||
/** Issues a new token: the old link stops working immediately. */
|
||||
r.post('/shares/:id/rotate', (c) => {
|
||||
const id = idParam(c);
|
||||
|
|
@ -298,10 +361,12 @@ export function publicRoutes(app: AppContext): Hono {
|
|||
|
||||
/** The switches visitors see: on only when the owner allowed it and a model is configured. */
|
||||
const publicAi = (share: ShareRow): ShareAi => {
|
||||
const flags = shareAi(share);
|
||||
if (!flags.explain && !flags.assistant) return flags;
|
||||
const flags = { ...shareAi(share) };
|
||||
// Generating needs class materials, which only class and exam links have.
|
||||
if (share.kind !== 'class' && share.kind !== 'folder') flags.generate = false;
|
||||
if (!flags.explain && !flags.assistant && !flags.generate) return flags;
|
||||
const ready = aiStatus(app).ready;
|
||||
return { explain: flags.explain && ready, assistant: flags.assistant && ready };
|
||||
return { explain: flags.explain && ready, assistant: flags.assistant && ready, generate: flags.generate && ready };
|
||||
};
|
||||
|
||||
const load = (token: string): ShareRow => {
|
||||
|
|
@ -349,6 +414,13 @@ export function publicRoutes(app: AppContext): Hono {
|
|||
if (share.kind !== 'class' && share.kind !== 'folder') throw gone();
|
||||
const kind = c.req.param('kind');
|
||||
const id = c.req.param('id');
|
||||
if (kind === 'ai') {
|
||||
// A quiz or flashcard set a visitor generated on this link.
|
||||
const set = generatedSet(share, id);
|
||||
c.header('Cache-Control', 'no-store');
|
||||
c.header('X-Robots-Tag', 'noindex, nofollow');
|
||||
return c.json({ ...set, ai: publicAi(share) });
|
||||
}
|
||||
const allowed = collectionItems(app, share).some((i) => i.kind === kind && i.id === id);
|
||||
if (!allowed) throw gone();
|
||||
c.header('Cache-Control', 'no-store');
|
||||
|
|
@ -397,6 +469,90 @@ export function publicRoutes(app: AppContext): Hono {
|
|||
limitVisitor(share.id, visitorId(app, c));
|
||||
};
|
||||
|
||||
/** The class a class or exam link belongs to. */
|
||||
const sharedClassId = (share: ShareRow): string | null =>
|
||||
share.kind === 'class' ? share.target_id : share.kind === 'folder' ? (db.get<{ class_id: string }>('SELECT class_id FROM folders WHERE id = ?', share.target_id)?.class_id ?? null) : null;
|
||||
|
||||
/** A finished set generated on this link, shaped like a shared quiz or deck. */
|
||||
function generatedSet(share: ShareRow, id: string) {
|
||||
const row = db.get<{ id: string; kind: string; title: string; payload: string }>(`SELECT id, kind, title, payload FROM drafts WHERE id = ? AND share_id = ? AND status = 'ready'`, id, share.id);
|
||||
if (!row) throw gone();
|
||||
const payload = parseJson<Record<string, any>>(row.payload, {});
|
||||
if (row.kind === 'quiz') {
|
||||
type DraftQ = { type: 'single' | 'multi' | 'numeric'; stem: string; options: { text: string; correct: boolean; why?: string }[]; rationale?: string; topic?: string; difficulty?: string };
|
||||
const questions = (Array.isArray(payload.questions) ? (payload.questions as DraftQ[]) : []).map((q, i) => ({
|
||||
id: `q${i + 1}`,
|
||||
type: q.type,
|
||||
stem: q.stem,
|
||||
options: q.options,
|
||||
rationale: q.rationale ?? '',
|
||||
topic: q.topic ?? '',
|
||||
difficulty: q.difficulty ?? 'medium',
|
||||
}));
|
||||
return { kind: 'quiz' as const, id: row.id, title: row.title, description: 'Made with AI from the shared materials.', questions };
|
||||
}
|
||||
if (row.kind === 'deck') {
|
||||
const cards = (Array.isArray(payload.cards) ? payload.cards : []).map((card: any, i: number) => ({ id: `c${i + 1}`, front: card.front, back: card.back, hint: card.hint ?? '' }));
|
||||
return { kind: 'deck' as const, id: row.id, title: row.title, description: 'Made with AI from the shared materials.', cards };
|
||||
}
|
||||
throw gone();
|
||||
}
|
||||
|
||||
/** What visitors can generate on this link, and what was made on it. */
|
||||
r.get('/:token/generated', (c) => {
|
||||
const share = load(c.req.param('token'));
|
||||
if (!publicAi(share).generate) throw new HttpError(403, 'ai_disabled', 'The owner has not turned this on for this link.');
|
||||
c.header('Cache-Control', 'no-store');
|
||||
return c.json({ sets: generatedSets(app, share.id), usage: generateUsage(app, share), limits: { quizMax: SHARE_QUIZ_MAX, deckMax: SHARE_DECK_MAX, mathQuestions: SHARE_MATH_QUESTIONS } });
|
||||
});
|
||||
|
||||
const generateSchema = z.object({
|
||||
kind: z.enum(['quiz', 'deck']),
|
||||
count: z.number().int().min(1).max(Math.max(SHARE_QUIZ_MAX, SHARE_DECK_MAX)).optional(),
|
||||
difficulty: z.enum(['easy', 'medium', 'hard', 'mixed']).default('mixed'),
|
||||
/** Class materials to use; empty or absent: all of them. */
|
||||
documentIds: z.array(z.string().max(64)).max(50).optional(),
|
||||
/** Quizzes: add medication math questions, whatever the material covers. */
|
||||
math: z.boolean().optional(),
|
||||
});
|
||||
|
||||
/**
|
||||
* A visitor generates a quiz or flashcard set from the link's class materials. Simplified on
|
||||
* purpose: count, difficulty, materials and med math; NCLEX style with 25% select-all, checked
|
||||
* with Python. Limited per link per day (and by the per-device request limit).
|
||||
*/
|
||||
r.post('/:token/generate', async (c) => {
|
||||
const share = load(c.req.param('token'));
|
||||
const body = await readBody(c, generateSchema);
|
||||
if (share.kind !== 'class' && share.kind !== 'folder') throw gone();
|
||||
requireAi(c, share, 'generate');
|
||||
const docs = collectionItems(app, share).filter((i) => i.kind === 'document');
|
||||
if (docs.length === 0) throw new HttpError(400, 'no_materials', 'There are no class materials on this link to generate from.');
|
||||
const chosen = body.documentIds?.length ? body.documentIds : docs.map((d) => d.id);
|
||||
if (chosen.some((id) => !docs.some((d) => d.id === id))) throw gone();
|
||||
const usage = generateUsage(app, share)[body.kind];
|
||||
if (usage.used >= usage.limit) {
|
||||
const what = body.kind === 'quiz' ? `${usage.limit} quizzes` : `${usage.limit} flashcard sets`;
|
||||
throw new HttpError(429, 'generate_limit', `This link has made its ${what} for today. Try again tomorrow.`);
|
||||
}
|
||||
const isQuiz = body.kind === 'quiz';
|
||||
const count = Math.min(body.count ?? (isQuiz ? SHARE_QUIZ_MAX : 30), isQuiz ? SHARE_QUIZ_MAX : SHARE_DECK_MAX);
|
||||
const { draftId } = startGeneration(
|
||||
app,
|
||||
{
|
||||
kind: body.kind,
|
||||
classId: sharedClassId(share),
|
||||
folderId: share.kind === 'folder' ? share.target_id : null,
|
||||
source: { documentIds: chosen },
|
||||
count,
|
||||
difficulty: body.difficulty,
|
||||
...(isQuiz ? { format: count >= 40 ? 'exam' : 'practice', sataShare: 0.25, verify: true, ...(body.math ? { mathQuestions: Math.min(SHARE_MATH_QUESTIONS, count) } : {}) } : { cardStyle: 'concise' }),
|
||||
},
|
||||
{ origin: 'share', shareId: share.id },
|
||||
);
|
||||
return c.json({ set: generatedSets(app, share.id).find((s) => s.id === draftId), usage: generateUsage(app, share) }, 202);
|
||||
});
|
||||
|
||||
const explainSchema = z.discriminatedUnion('kind', [
|
||||
z.object({ kind: z.literal('question'), quizId: z.string().max(64), questionId: z.string().max(64), selected: z.array(z.string().max(4000)).max(12).optional(), ask: z.string().max(500).optional() }),
|
||||
z.object({ kind: z.literal('card'), deckId: z.string().max(64), cardId: z.string().max(64), ask: z.string().max(500).optional() }),
|
||||
|
|
@ -413,18 +569,20 @@ export function publicRoutes(app: AppContext): Hono {
|
|||
let prompt: string;
|
||||
let sources: ReturnType<typeof citedPassages> = [];
|
||||
if (body.kind === 'question') {
|
||||
if (!inScope(share, 'quiz', body.quizId)) throw gone();
|
||||
const q = listQuestions(db, body.quizId).find((x) => x.id === body.questionId);
|
||||
const made = inScope(share, 'quiz', body.quizId) ? null : generatedSet(share, body.quizId);
|
||||
if (made && made.kind !== 'quiz') throw gone();
|
||||
const q = made && made.kind === 'quiz' ? made.questions.find((x) => x.id === body.questionId) : listQuestions(db, body.quizId).find((x) => x.id === body.questionId);
|
||||
if (!q) throw gone();
|
||||
const texts = new Set(q.options.map((o) => o.text));
|
||||
prompt = explainPrompt({ kind: 'question', stem: q.stem, options: q.options.map((o) => ({ text: o.text, correct: o.correct })), selected: body.selected?.filter((s) => texts.has(s) || q.type === 'numeric').map((s) => s.slice(0, 200)), rationale: q.rationale, ask: body.ask });
|
||||
// The pages the rationale cites, read only from the quiz's own class.
|
||||
const classId = db.get<{ class_id: string }>('SELECT class_id FROM quizzes WHERE id = ?', body.quizId)?.class_id;
|
||||
const classId = made ? sharedClassId(share) : db.get<{ class_id: string }>('SELECT class_id FROM quizzes WHERE id = ?', body.quizId)?.class_id;
|
||||
if (classId && q.rationale) sources = citedPassages(db, q.rationale, { classIds: [classId], stem: q.stem });
|
||||
prompt += citedPassagesPrompt(sources);
|
||||
} else {
|
||||
if (!inScope(share, 'deck', body.deckId)) throw gone();
|
||||
const card = listCards(db, body.deckId).find((x) => x.id === body.cardId);
|
||||
const made = inScope(share, 'deck', body.deckId) ? null : generatedSet(share, body.deckId);
|
||||
if (made && made.kind !== 'deck') throw gone();
|
||||
const card = made && made.kind === 'deck' ? made.cards.find((x) => x.id === body.cardId) : listCards(db, body.deckId).find((x) => x.id === body.cardId);
|
||||
if (!card) throw gone();
|
||||
prompt = explainPrompt({ kind: 'card', front: card.front, back: card.back, ask: body.ask });
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue