@goscribe/server 1.1.7 → 1.3.0

package/src/lib/ai-session.ts

@@ -1,5 +1,6 @@
 import { TRPCError } from '@trpc/server';
 import { logger } from './logger.js';
+import { withRetry } from './retry.js';
 import { MarkScheme, UserMarkScheme } from '../types/index.js';
 
 // External AI service configuration
@@ -8,8 +9,8 @@ import { MarkScheme, UserMarkScheme } from '../types/index.js';
 const AI_SERVICE_URL = process.env.INFERENCE_API_URL + '/upload';
 const AI_RESPONSE_URL = process.env.INFERENCE_API_URL + '/last_response';
 
-console.log('AI_SERVICE_URL', AI_SERVICE_URL);
-console.log('AI_RESPONSE_URL', AI_RESPONSE_URL);
+logger.info(`AI_SERVICE_URL: ${AI_SERVICE_URL}`);
+logger.info(`AI_RESPONSE_URL: ${AI_RESPONSE_URL}`);
 
 // Mock mode flag - when true, returns fake responses instead of calling AI service
 const MOCK_MODE = process.env.DONT_TEST_INFERENCE === 'true';
@@ -24,7 +25,7 @@ export interface AISession {
   updatedAt: Date;
 }
 
-const IMITATE_WAIT_TIME_MS = MOCK_MODE ?  1000 * 10 : 0;
+const IMITATE_WAIT_TIME_MS = MOCK_MODE ? 1000 * 10 : 0;
 
 export interface ProcessFileResult {
   status: 'success' | 'error';
@@ -49,7 +50,7 @@ export class AISessionService {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake session
     if (MOCK_MODE) {
-      console.log(`🎭 MOCK MODE: Initializing AI session for workspace ${workspaceId}`);
+      logger.info(`MOCK MODE: Initializing AI session for workspace ${workspaceId}`);
       const session: AISession = {
         id: sessionId,
         workspaceId,
@@ -61,7 +62,7 @@ export class AISessionService {
       this.sessions.set(sessionId, session);
       return session;
     }
-    
+
     const formData = new FormData();
     formData.append('command', 'init_session');
     formData.append('session', sessionId);
@@ -73,24 +74,24 @@ export class AISessionService {
 
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        console.log(`🤖 AI Session init attempt ${attempt}/${maxRetries} for workspace ${workspaceId}`);
-        
+        logger.info(`AI Session init attempt ${attempt}/${maxRetries} for workspace ${workspaceId}`);
+
         const response = await fetch(AI_SERVICE_URL, {
           method: 'POST',
           body: formData,
         });
 
-        console.log(`📡 AI Service response status: ${response.status} ${response.statusText}`);
+        logger.info(`AI Service response status: ${response.status} ${response.statusText}`);
 
         if (!response.ok) {
           const errorText = await response.text();
-          console.error(`❌ AI Service error response:`, errorText);
+          logger.error(`AI Service error response: ${errorText}`);
           throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
         }
 
         const result = await response.json();
-        console.log(`📋 AI Service result:`, result);
-        
+        logger.debug(`AI Service result: ${JSON.stringify(result)}`);
+
         // If we get a response with a message, consider it successful
         if (!result.message) {
           throw new Error(`AI service error: No response message`);
@@ -106,22 +107,22 @@ export class AISessionService {
         };
 
         this.sessions.set(sessionId, session);
-        console.log(`✅ AI Session initialized successfully on attempt ${attempt}`);
+        logger.info(`AI Session initialized successfully on attempt ${attempt}`);
         return session;
-        
+
       } catch (error) {
         lastError = error instanceof Error ? error : new Error('Unknown error');
-        console.error(`❌ AI Session init attempt ${attempt} failed:`, lastError.message);
-        
+        logger.error(`AI Session init attempt ${attempt} failed: ${lastError.message}`);
+
         if (attempt < maxRetries) {
           const delay = Math.pow(2, attempt) * 1000; // Exponential backoff: 2s, 4s, 8s
-          console.log(`⏳ Retrying in ${delay}ms...`);
+          logger.info(`Retrying in ${delay}ms...`);
           await new Promise(resolve => setTimeout(resolve, delay));
         }
       }
     }
 
-    console.error(`💥 All ${maxRetries} attempts failed. Last error:`, lastError?.message);
+    logger.error(`All ${maxRetries} attempts failed. Last error: ${lastError?.message}`);
     throw new TRPCError({
       code: 'INTERNAL_SERVER_ERROR',
       message: `Failed to initialize AI session after ${maxRetries} attempts: ${lastError?.message || 'Unknown error'}`,
@@ -137,7 +138,7 @@ export class AISessionService {
     maxPages?: number
   ): Promise<ProcessFileResult> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    
+
     // Mock mode - return fake processing result
     if (MOCK_MODE) {
       logger.info(`🎭 MOCK MODE: Processing ${fileType} file from URL for session ${sessionId}`);
@@ -163,7 +164,7 @@ export class AISessionService {
       formData.append('maxPages', maxPages.toString());
     }
 
-    console.log('formData', formData);
+    logger.debug('Processing file with formData');
 
     // Retry logic for file processing
     const maxRetries = 3;
@@ -172,7 +173,7 @@ export class AISessionService {
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
         logger.info(`📄 Processing ${fileType} file attempt ${attempt}/${maxRetries} for session ${sessionId}`);
-        
+
         // Set timeout for large files (5 minutes)
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), 300000); // 5 min timeout
@@ -180,7 +181,7 @@ export class AISessionService {
         const response = await fetch(AI_SERVICE_URL, {
           method: 'POST',
           body: formData,
-          // signal: controller.signal,
+          signal: controller.signal,
         });
 
         clearTimeout(timeoutId);
@@ -199,11 +200,11 @@ export class AISessionService {
         }
 
         return result as ProcessFileResult;
-        
+
       } catch (error) {
         lastError = error instanceof Error ? error : new Error('Unknown error');
         logger.error(`❌ File processing attempt ${attempt} failed:`, lastError.message);
-        
+
         if (attempt < maxRetries) {
           const delay = Math.pow(2, attempt) * 1000; // Exponential backoff: 2s, 4s, 8s
           logger.info(`⏳ Retrying file processing in ${delay}ms...`);
@@ -230,7 +231,7 @@ export class AISessionService {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake study guide
     if (MOCK_MODE) {
-      console.log(`🎭 MOCK MODE: Generating study guide for session ${sessionId}`);
+      logger.info(`MOCK MODE: Generating study guide for session ${sessionId}`);
       return `# Mock Study Guide
 
 ## Overview
@@ -252,53 +253,55 @@ This mock study guide demonstrates the structure and format that would be genera
 *Note: This is a mock response generated when DONT_TEST_INFERENCE=true*`;
     }
 
-    const formData = new FormData();
-    formData.append('command', 'generate_study_guide');
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    try {
+    return withRetry(async () => {
+      const formData = new FormData();
+      formData.append('command', 'generate_study_guide');
+      formData.append('session', sessionId);
+      formData.append('user', user);
+
       const response = await fetch(AI_SERVICE_URL, {
         method: 'POST',
         body: formData,
       });
 
       if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+        const errorBody = await response.text().catch(() => '');
+        throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorBody}`);
       }
 
       const result = await response.json();
+      if (!result.markdown) {
+        throw new Error('AI service returned empty study guide');
+      }
       return result.markdown;
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to generate study guide: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
+    }, { maxRetries: 3, timeoutMs: 300000, label: 'generateStudyGuide' });
   }
 
-  // Generate flashcard questions
-  async generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string> {
+  async generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard', prompt?: string): Promise<string> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake flashcard questions
     if (MOCK_MODE) {
       logger.info(`🎭 MOCK MODE: Generating ${numQuestions} ${difficulty} flashcard questions for session ${sessionId}`);
       return JSON.stringify(Array.from({ length: numQuestions }, (_, i) => ({
-          id: `mock-flashcard-${i + 1}`,
-          question: `Mock question ${i + 1}: What is the main concept covered in this material?`,
-          answer: `Mock answer ${i + 1}: This is a sample answer that would be generated based on the uploaded content.`,
-          difficulty: difficulty,
-          category: `Mock Category ${(i % 3) + 1}`
-        })));
+        id: `mock-flashcard-${i + 1}`,
+        question: `Mock question ${i + 1}: What is the main concept covered in this material?`,
+        answer: `Mock answer ${i + 1}: This is a sample answer that would be generated based on the uploaded content.`,
+        difficulty: difficulty,
+        category: `Mock Category ${(i % 3) + 1}`
+      })));
     }
 
-    const formData = new FormData();
-    formData.append('command', 'generate_flashcard_questions');
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    formData.append('num_questions', numQuestions.toString());
-    formData.append('difficulty', difficulty);
+    return withRetry(async () => {
+      const formData = new FormData();
+      formData.append('command', 'generate_flashcard_questions');
+      formData.append('session', sessionId);
+      formData.append('user', user);
+      formData.append('num_questions', numQuestions.toString());
+      formData.append('difficulty', difficulty);
+      if (prompt) {
+        formData.append('prompt', prompt);
+      }
 
-    try {
       const response = await fetch(AI_SERVICE_URL, {
         method: 'POST',
         body: formData,
@@ -309,57 +312,73 @@ This mock study guide demonstrates the structure and format that would be genera
       }
 
       const result = await response.json();
-
-      console.log(JSON.parse(result.flashcards))
-
       return JSON.parse(result.flashcards).flashcards;
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to generate flashcard questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
+    }, { maxRetries: 3, timeoutMs: 300000, label: 'generateFlashcardQuestions' });
   }
 
   // Generate worksheet questions
-  async generateWorksheetQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'EASY' | 'MEDIUM' | 'HARD'): Promise<string> {
+  async generateWorksheetQuestions(
+    sessionId: string,
+    user: string,
+    numQuestions: number,
+    difficulty: 'EASY' | 'MEDIUM' | 'HARD',
+    options?: {
+      mode?: 'practice' | 'quiz';
+      mcqRatio?: number;
+      questionTypes?: string[];
+      prompt?: string;
+    },
+  ): Promise<string> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - return fake worksheet questions
     if (MOCK_MODE) {
       logger.info(`🎭 MOCK MODE: Generating ${numQuestions} ${difficulty} worksheet questions for session ${sessionId}`);
+      const mode = options?.mode ?? 'practice';
+      const isQuiz = mode === 'quiz';
       return JSON.stringify({
-        worksheet: {
-          title: `Mock Worksheet - ${difficulty} Level`,
-          questions: Array.from({ length: numQuestions }, (_, i) => ({
-            id: `mock-worksheet-q${i + 1}`,
-            question: `Mock worksheet question ${i + 1}: Based on the uploaded material, explain the key concept and provide examples.`,
-            type: i % 2 === 0 ? 'short_answer' : 'essay',
-            difficulty: difficulty,
-            estimatedTime: difficulty === 'EASY' ? '2-3 minutes' : difficulty === 'MEDIUM' ? '5-7 minutes' : '10-15 minutes',
-            points: difficulty === 'EASY' ? 5 : difficulty === 'MEDIUM' ? 10 : 15
-          })),
-          instructions: "This is a mock worksheet generated for testing purposes. Answer all questions based on the uploaded materials.",
-          totalPoints: numQuestions * (difficulty === 'EASY' ? 5 : difficulty === 'MEDIUM' ? 10 : 15),
-          estimatedTime: `${numQuestions * (difficulty === 'EASY' ? 3 : difficulty === 'MEDIUM' ? 6 : 12)} minutes`
-        },
-        metadata: {
-          totalQuestions: numQuestions,
-          difficulty: difficulty,
-          generatedAt: new Date().toISOString(),
-          isMock: true
-        }
+        title: isQuiz ? `Mock Quiz - ${difficulty}` : `Mock Worksheet - ${difficulty} Level`,
+        description: 'Mock generated content',
+        difficulty,
+        estimatedTime: `${numQuestions * 2} min`,
+        problems: Array.from({ length: numQuestions }, (_, i) => {
+          if (isQuiz) {
+            return {
+              question: `Mock MCQ ${i + 1}: What is 2+2?`,
+              answer: '1',
+              type: 'MULTIPLE_CHOICE',
+              options: ['3', '4', '5', '6'],
+              mark_scheme: { points: [{ point: 1, requirements: 'Select correct option' }], totalPoints: 1 },
+            };
+          }
+          return {
+            question: `Mock question ${i + 1}: Explain a concept.`,
+            answer: 'Mock answer',
+            type: 'TEXT',
+            options: [],
+            mark_scheme: { points: [{ point: 1, requirements: 'Clear explanation' }], totalPoints: 1 },
+          };
+        }),
       });
     }
 
-    const formData = new FormData();
-    formData.append('command', 'generate_worksheet_questions');
-    formData.append('session', sessionId);
-    formData.append('user', user);
-    formData.append('num_questions', numQuestions.toString());
-    formData.append('difficulty', difficulty);
-
+    return withRetry(async () => {
+      const formData = new FormData();
+      formData.append('command', 'generate_worksheet_questions');
+      formData.append('session', sessionId);
+      formData.append('user', user);
+      formData.append('num_questions', numQuestions.toString());
+      formData.append('difficulty', difficulty);
+      formData.append('mode', options?.mode ?? 'practice');
+      if (options?.mcqRatio !== undefined) {
+        formData.append('mcq_ratio', String(options.mcqRatio));
+      }
+      if (options?.questionTypes?.length) {
+        formData.append('question_types', JSON.stringify(options.questionTypes));
+      }
+      if (options?.prompt) {
+        formData.append('worksheet_prompt', options.prompt);
+      }
 
-    try {
       const response = await fetch(AI_SERVICE_URL, {
         method: 'POST',
         body: formData,
@@ -370,16 +389,8 @@ This mock study guide demonstrates the structure and format that would be genera
       }
 
       const result = await response.json();
-
-      console.log(JSON.parse(result.worksheet));
-
       return result.worksheet;
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to generate worksheet questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
+    }, { maxRetries: 3, timeoutMs: 300000, label: 'generateWorksheetQuestions' });
   }
 
   async checkWorksheetQuestions(sessionId: string, user: string, question: string, answer: string, mark_scheme: MarkScheme): Promise<UserMarkScheme> {
@@ -402,21 +413,21 @@ This mock study guide demonstrates the structure and format that would be genera
     }
 
     const result = await response.json();
-    console.log(result.marking);
+    logger.debug(`Worksheet marking result received`);
     return JSON.parse(result.marking);
   }
 
   // Generate podcast structure
   async generatePodcastStructure(
-    sessionId: string, 
-    user: string, 
-    title: string, 
-    description: string, 
+    sessionId: string,
+    user: string,
+    title: string,
+    description: string,
     prompt: string,
     speakers: Array<{ id: string; role: string; name?: string }>
   ): Promise<any> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    
+
     // Mock mode - return fake podcast structure
     if (MOCK_MODE) {
       logger.info(`🎭 MOCK MODE: Generating podcast structure for session ${sessionId}`);
@@ -499,7 +510,7 @@ This mock study guide demonstrates the structure and format that would be genera
     voiceId?: string
   ): Promise<any> {
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
-    
+
     // Mock mode - return fake audio generation result
     if (MOCK_MODE) {
       logger.info(`🎭 MOCK MODE: Generating audio for segment ${segmentIndex} of podcast ${podcastId}`);
@@ -522,7 +533,7 @@ This mock study guide demonstrates the structure and format that would be genera
     formData.append('segment_index', segmentIndex.toString());
     formData.append('text', text);
     formData.append('speakers', JSON.stringify(speakers));
-    
+
     if (voiceId) {
       formData.append('voice_id', voiceId);
     }
@@ -547,7 +558,7 @@ This mock study guide demonstrates the structure and format that would be genera
       });
     }
   }
-  
+
 
 
   async generatePodcastImage(sessionId: string, user: string, summary: string): Promise<string> {
@@ -576,6 +587,77 @@ This mock study guide demonstrates the structure and format that would be genera
       });
     }
   }
+
+  async segmentStudyGuide(sessionId: string, user: string, studyGuide: string): Promise<{
+    hint: string;
+    content: string
+  }[]> {
+    // def generate_study_guide_segmentation(request):
+    // user = request.form.get("user")
+    // session = request.form.get("session")
+    // study_guide = request.form.get("study_guide")
+
+    // if not user or not session:
+    //     return {"error": "Session not initialized."}, 400
+    // if not study_guide:
+    //     print("Study guide not provided.")
+    //     return {"error": "Study guide not provided."}, 400
+
+    // messages = generate_segmentation(study_guide)
+    // return {"segmentation": messages}, 200  
+
+    const formData = new FormData();
+    formData.append('command', 'generate_study_guide_segmentation');
+    formData.append('session', sessionId);
+    formData.append('user', user);
+    formData.append('study_guide', studyGuide);
+    try {
+      const response = await fetch(AI_SERVICE_URL, {
+        method: 'POST',
+        body: formData,
+      });
+      if (!response.ok) {
+        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+      }
+      const result = await response.json();
+      return result.segmentation;
+    } catch (error) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to segment study guide: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      });
+    }
+  }
+  async validateSegmentSummary(sessionId: string, user: string, segmentContent: string, studentResponse: string, studyGuide: string): Promise<{
+    valid: boolean;
+    feedback: string;
+  }> {
+    const formData = new FormData();
+    formData.append('command', 'validate_segment_summary');
+    formData.append('session', sessionId);
+    formData.append('user', user);
+
+    formData.append('segment_content', segmentContent);
+    formData.append('student_response', studentResponse);
+    formData.append('study_guide', studyGuide);
+    try {
+      const response = await fetch(AI_SERVICE_URL, {
+        method: 'POST',
+        body: formData,
+      });
+      if (!response.ok) {
+        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
+      }
+      const result = await response.json();
+      return result.feedback;
+    } catch (error) {
+      throw new TRPCError({
+        code: 'INTERNAL_SERVER_ERROR',
+        message: `Failed to validate segment summary: ${error instanceof Error ? error.message : 'Unknown error'}`,
+      });
+    }
+  }
+
   // Get session by ID
   getSession(sessionId: string): AISession | undefined {
     return this.sessions.get(sessionId);
@@ -598,21 +680,21 @@ This mock study guide demonstrates the structure and format that would be genera
     await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
     // Mock mode - always return healthy
     if (MOCK_MODE) {
-      console.log('🎭 MOCK MODE: AI service health check - returning healthy');
+      logger.info('MOCK MODE: AI service health check - returning healthy');
       return true;
     }
 
     try {
-      console.log('🏥 Checking AI service health...');
+      logger.info('Checking AI service health...');
       const response = await fetch(AI_SERVICE_URL, {
         method: 'POST',
         body: new FormData(), // Empty form data
       });
-      
-      console.log(`🏥 AI Service health check status: ${response.status}`);
+
+      logger.info(`AI Service health check status: ${response.status}`);
       return response.ok;
     } catch (error) {
-      console.error('🏥 AI Service health check failed:', error);
+      logger.error('AI Service health check failed:', error);
       return false;
     }
   }

package/src/lib/constants.ts

@@ -0,0 +1,14 @@
+/**
+ * Shared constants for artifact types.
+ * Mirrors the Prisma ArtifactType enum to avoid direct type imports
+ * in contexts where Prisma client types may not be available.
+ */
+export const ArtifactType = {
+  STUDY_GUIDE: 'STUDY_GUIDE',
+  FLASHCARD_SET: 'FLASHCARD_SET',
+  WORKSHEET: 'WORKSHEET',
+  MEETING_SUMMARY: 'MEETING_SUMMARY',
+  PODCAST_EPISODE: 'PODCAST_EPISODE',
+} as const;
+
+export type ArtifactTypeValue = (typeof ArtifactType)[keyof typeof ArtifactType];