Update web/src/lib/api.ts

web/src/lib/api.ts

@@ -1,61 +1,118 @@
-// --- Feedback API (NEW) ---
-export type FeedbackRating = 'helpful' | 'not_helpful';
+// web/src/lib/api.ts
+export type LearningMode = 'concept' | 'socratic' | 'exam' | 'assignment' | 'summary';
+export type Language = 'auto' | 'en' | 'zh';
+export type FileType = 'syllabus' | 'lecture-slides' | 'literature-review' | 'other';
 
-export interface FeedbackParams {
-  user: User;
-
-  rating: FeedbackRating;
+export interface User {
+  name: string;
+  email: string; // use email as user_id
+}
 
-  // which assistant msg is being rated (optional but recommended)
-  assistantMessageId?: string;
+const modeMap: Record<LearningMode, string> = {
+  concept: 'Concept Explainer',
+  socratic: 'Socratic Tutor',
+  exam: 'Exam Prep / Quiz',
+  assignment: 'Assignment Helper',
+  summary: 'Quick Summary',
+};
 
-  // texts
-  assistantText: string;
-  userText?: string;
+const langMap: Record<Language, string> = {
+  auto: 'Auto',
+  en: 'English',
+  zh: '简体中文',
+};
 
-  // UI details
-  tags?: string[];        // optional: structured tags
-  comment?: string;       // optional free-text
+const docTypeMap: Record<FileType, string> = {
+  syllabus: 'Syllabus',
+  'lecture-slides': 'Lecture Slides',
+  'literature-review': 'Literature Review / Paper',
+  other: 'Other',
+};
 
-  // context
-  refs?: string[];        // optional
-  learningMode?: LearningMode;
-  docType?: FileType | string;
+async function mustJson<T>(res: Response): Promise<T> {
+  if (res.ok) return (await res.json()) as T;
+  const txt = await res.text().catch(() => '');
+  throw new Error(`${res.status} ${res.statusText}${txt ? ` — ${txt}` : ''}`);
+}
 
-  timestampMs?: number;
+export async function apiLogin(user: User) {
+  const res = await fetch('/api/login', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ name: user.name, user_id: user.email }),
+  });
+  return mustJson<{ ok: boolean; user: { name: string; user_id: string } }>(res);
 }
 
-export async function apiFeedback(params: FeedbackParams) {
-  const res = await fetch('/api/feedback', {
+export async function apiChat(params: {
+  user: User;
+  message: string;
+  learningMode: LearningMode;
+  language: Language;
+  docType?: string; // optional override
+}) {
+  const res = await fetch('/api/chat', {
     method: 'POST',
     headers: { 'Content-Type': 'application/json' },
     body: JSON.stringify({
       user_id: params.user.email,
-      rating: params.rating,
-      assistant_message_id: params.assistantMessageId ?? null,
-
-      assistant_text: params.assistantText,
-      user_text: (params.userText ?? '').trim(),
+      message: params.message,
+      learning_mode: modeMap[params.learningMode],
+      language_preference: langMap[params.language],
+      doc_type: params.docType ?? 'Syllabus',
+    }),
+  });
 
-      // If your backend supports tags, send tags directly.
-      // If not, still safe to send; FastAPI will reject unknown fields unless you allow extra.
-      // So: by default send tags ONLY if you add backend field. Otherwise comment-merge in UI layer.
-      tags: params.tags ?? [],
+  return mustJson<{
+    reply: string;
+    refs?: Array<{ source_file?: string; section?: string }>;
+    latency_ms?: number;
+    session_status_md?: string;
+  }>(res);
+}
 
-      comment: (params.comment ?? '').trim(),
-      refs: params.refs ?? [],
+export async function apiUpload(params: {
+  user: User;
+  file: File;
+  fileType: FileType;
+}) {
+  const fd = new FormData();
+  fd.append('user_id', params.user.email);
+  fd.append('doc_type', docTypeMap[params.fileType]);
+  fd.append('file', params.file);
 
-      learning_mode: params.learningMode ? modeMap[params.learningMode] : undefined,
-      doc_type:
-        typeof params.docType === 'string'
-          ? params.docType
-          : params.docType
-          ? docTypeMap[params.docType]
-          : undefined,
+  const res = await fetch('/api/upload', { method: 'POST', body: fd });
+  return mustJson<{ ok: boolean; added_chunks: number; status_md: string }>(res);
+}
 
-      timestamp_ms: params.timestampMs ?? Date.now(),
+export async function apiExport(params: {
+  user: User;
+  learningMode: LearningMode;
+}) {
+  const res = await fetch('/api/export', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      user_id: params.user.email,
+      learning_mode: modeMap[params.learningMode],
     }),
   });
+  return mustJson<{ markdown: string }>(res);
+}
 
-  return mustJson<{ ok: boolean }>(res);
+export async function apiSummary(params: {
+  user: User;
+  learningMode: LearningMode;
+  language: Language;
+}) {
+  const res = await fetch('/api/summary', {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({
+      user_id: params.user.email,
+      learning_mode: modeMap[params.learningMode],
+      language_preference: langMap[params.language],
+    }),
+  });
+  return mustJson<{ markdown: string }>(res);
 }