@goscribe/server 1.0.11 → 1.1.1

package/dist/lib/ai-session.d.ts

@@ -1,3 +1,4 @@
+import { MarkScheme, UserMarkScheme } from '../types/index.js';
 export interface AISession {
     id: string;
     workspaceId: string;
@@ -9,15 +10,25 @@ export interface AISession {
 }
 export declare class AISessionService {
     private sessions;
-    initSession(workspaceId: string): Promise<AISession>;
-    uploadFile(sessionId: string, file: File, fileType: 'image' | 'pdf'): Promise<void>;
-    setInstruction(sessionId: string, instructionText: string): Promise<void>;
-    startLLMSession(sessionId: string): Promise<void>;
-    generateStudyGuide(sessionId: string): Promise<string>;
-    generateFlashcardQuestions(sessionId: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string>;
-    generateWorksheetQuestions(sessionId: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string>;
-    analysePDF(sessionId: string): Promise<string>;
-    analyseImage(sessionId: string): Promise<string>;
+    initSession(workspaceId: string, user: string): Promise<AISession>;
+    uploadFile(sessionId: string, user: string, file: File, fileType: 'image' | 'pdf'): Promise<void>;
+    generateStudyGuide(sessionId: string, user: string): Promise<string>;
+    generateFlashcardQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'easy' | 'medium' | 'hard'): Promise<string>;
+    generateWorksheetQuestions(sessionId: string, user: string, numQuestions: number, difficulty: 'EASY' | 'MEDIUM' | 'HARD'): Promise<string>;
+    checkWorksheetQuestions(sessionId: string, user: string, question: string, answer: string, mark_scheme: MarkScheme): Promise<UserMarkScheme>;
+    generatePodcastStructure(sessionId: string, user: string, title: string, description: string, prompt: string, speakers: Array<{
+        id: string;
+        role: string;
+        name?: string;
+    }>): Promise<any>;
+    generatePodcastAudioFromText(sessionId: string, user: string, podcastId: string, segmentIndex: number, text: string, speakers: Array<{
+        id: string;
+        role: string;
+        name?: string;
+    }>, voiceId?: string): Promise<any>;
+    analysePDF(sessionId: string, user: string): Promise<string>;
+    analyseImage(sessionId: string, user: string): Promise<string>;
+    generatePodcastImage(sessionId: string, user: string, summary: string): Promise<string>;
     getSession(sessionId: string): AISession | undefined;
     getSessionsByUserAndWorkspace(userId: string, workspaceId: string): AISession[];
     deleteSession(sessionId: string): boolean;

package/dist/lib/ai-session.js

@@ -1,17 +1,41 @@
 import { TRPCError } from '@trpc/server';
+import { logger } from './logger.js';
 // External AI service configuration
-const AI_SERVICE_URL = 'https://txp-tckxn64wn5vtgip72-kzoemq8qw-custom.service.onethingrobot.com/upload';
-const AI_RESPONSE_URL = 'https://txp-tckxn64wn5vtgip72-kzoemq8qw-custom.service.onethingrobot.com/last_response';
+// const AI_SERVICE_URL = 'https://7gzvf7uib04yp9-61016.proxy.runpod.net/upload';
+// const AI_RESPONSE_URL = 'https://7gzvf7uib04yp9-61016.proxy.runpod.net/last_response';
+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);
+// Mock mode flag - when true, returns fake responses instead of calling AI service
+const MOCK_MODE = process.env.DONT_TEST_INFERENCE === 'true';
+const IMITATE_WAIT_TIME_MS = MOCK_MODE ? 1000 * 10 : 0;
 export class AISessionService {
     constructor() {
         this.sessions = new Map();
     }
     // Initialize a new AI session
-    async initSession(workspaceId) {
+    async initSession(workspaceId, user) {
         const sessionId = `${workspaceId}`;
+        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}`);
+            const session = {
+                id: sessionId,
+                workspaceId,
+                status: 'initialized',
+                files: [],
+                createdAt: new Date(),
+                updatedAt: new Date(),
+            };
+            this.sessions.set(sessionId, session);
+            return session;
+        }
         const formData = new FormData();
         formData.append('command', 'init_session');
-        formData.append('id', sessionId);
+        formData.append('session', sessionId);
+        formData.append('user', user);
         // Retry logic for AI service
         const maxRetries = 3;
         let lastError = null;
@@ -63,15 +87,26 @@ export class AISessionService {
         });
     }
     // Upload file to AI session
-    async uploadFile(sessionId, file, fileType) {
+    async uploadFile(sessionId, user, file, fileType) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
         }
+        await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
+        // Mock mode - simulate successful file upload
+        if (MOCK_MODE) {
+            console.log(`🎭 MOCK MODE: Uploading ${fileType} file "${file.name}" to session ${sessionId}`);
+            session.files.push(file.name);
+            session.updatedAt = new Date();
+            this.sessions.set(sessionId, session);
+            return;
+        }
         const command = fileType === 'image' ? 'append_image' : 'append_pdflike';
         const formData = new FormData();
         formData.append('command', command);
         formData.append('file', file);
+        formData.append('session', sessionId);
+        formData.append('user', user);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -97,15 +132,40 @@ export class AISessionService {
             });
         }
     }
-    // Set instruction text
-    async setInstruction(sessionId, instructionText) {
+    // Generate study guide
+    async generateStudyGuide(sessionId, user) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
         }
+        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}`);
+            return `# Mock Study Guide
+
+## Overview
+This is a mock study guide generated for testing purposes. In a real scenario, this would contain comprehensive study material based on the uploaded content.
+
+## Key Concepts
+1. **Concept A**: This is a mock concept that would be derived from the uploaded materials
+2. **Concept B**: Another mock concept with detailed explanations
+3. **Concept C**: A third concept with examples and applications
+
+## Summary
+This mock study guide demonstrates the structure and format that would be generated by the AI service when processing uploaded educational materials.
+
+## Practice Questions
+1. What is the main topic covered in this material?
+2. How do the key concepts relate to each other?
+3. What are the practical applications of these concepts?
+
+*Note: This is a mock response generated when DONT_TEST_INFERENCE=true*`;
+        }
         const formData = new FormData();
-        formData.append('command', 'set_instruct');
-        formData.append('instruction_text', instructionText);
+        formData.append('command', 'generate_study_guide');
+        formData.append('session', sessionId);
+        formData.append('user', user);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -115,30 +175,39 @@ export class AISessionService {
                 throw new Error(`AI service error: ${response.status} ${response.statusText}`);
             }
             const result = await response.json();
-            console.log(`📋 Set instruction result:`, result);
-            if (!result.message) {
-                throw new Error(`AI service error: No response message`);
-            }
-            // Update session
-            session.instructionText = instructionText;
-            session.updatedAt = new Date();
-            this.sessions.set(sessionId, session);
+            return result.markdown;
         }
         catch (error) {
             throw new TRPCError({
                 code: 'INTERNAL_SERVER_ERROR',
-                message: `Failed to set instruction: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                message: `Failed to generate study guide: ${error instanceof Error ? error.message : 'Unknown error'}`,
             });
         }
     }
-    // Start LLM session
-    async startLLMSession(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+    // Generate flashcard questions
+    async generateFlashcardQuestions(sessionId, user, numQuestions, difficulty) {
+        // const session = this.sessions.get(sessionId);
+        // if (!session) {
+        //   throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+        // }
+        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}`
+            })));
         }
         const formData = new FormData();
-        formData.append('command', 'start_LLM_session');
+        formData.append('command', 'generate_flashcard_questions');
+        formData.append('session', sessionId);
+        formData.append('user', user);
+        formData.append('num_questions', numQuestions.toString());
+        formData.append('difficulty', difficulty);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -148,30 +217,51 @@ export class AISessionService {
                 throw new Error(`AI service error: ${response.status} ${response.statusText}`);
             }
             const result = await response.json();
-            console.log(`📋 Start LLM result:`, result);
-            if (!result.message) {
-                throw new Error(`AI service error: No response message`);
-            }
-            // Update session
-            session.status = 'ready';
-            session.updatedAt = new Date();
-            this.sessions.set(sessionId, session);
+            console.log(JSON.parse(result.flashcards));
+            return JSON.parse(result.flashcards).flashcards;
         }
         catch (error) {
             throw new TRPCError({
                 code: 'INTERNAL_SERVER_ERROR',
-                message: `Failed to start LLM session: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                message: `Failed to generate flashcard questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
             });
         }
     }
-    // Generate study guide
-    async generateStudyGuide(sessionId) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+    // Generate worksheet questions
+    async generateWorksheetQuestions(sessionId, user, numQuestions, difficulty) {
+        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}`);
+            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
+                }
+            });
         }
         const formData = new FormData();
-        formData.append('command', 'generate_study_guide');
+        formData.append('command', 'generate_worksheet_questions');
+        formData.append('session', sessionId);
+        formData.append('user', user);
+        formData.append('num_questions', numQuestions.toString());
+        formData.append('difficulty', difficulty);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -180,92 +270,181 @@ export class AISessionService {
             if (!response.ok) {
                 throw new Error(`AI service error: ${response.status} ${response.statusText}`);
             }
-            // Get the generated content from the response endpoint
-            const contentResponse = await fetch(AI_RESPONSE_URL);
-            if (!contentResponse.ok) {
-                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
-            }
-            return (await contentResponse.json())['last_response'];
+            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 study guide: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                message: `Failed to generate worksheet questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
             });
         }
     }
-    // Generate flashcard questions
-    async generateFlashcardQuestions(sessionId, numQuestions, difficulty) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+    async checkWorksheetQuestions(sessionId, user, question, answer, mark_scheme) {
+        const formData = new FormData();
+        formData.append('command', 'mark_worksheet_questions');
+        formData.append('session', sessionId);
+        formData.append('user', user);
+        formData.append('question', question);
+        formData.append('answer', answer);
+        formData.append('mark_scheme', JSON.stringify(mark_scheme));
+        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();
+        console.log(result.marking);
+        return JSON.parse(result.marking);
+    }
+    // Generate podcast structure
+    async generatePodcastStructure(sessionId, user, title, description, prompt, speakers) {
+        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}`);
+            return {
+                success: true,
+                structure: {
+                    episodeTitle: `${title} - AI Generated Episode`,
+                    totalEstimatedDuration: "15 minutes",
+                    segments: [
+                        {
+                            title: "Welcome & Introduction",
+                            content: "HOST: Welcome to today's episode!\nGUEST: Thanks for having me!\nHOST: Let's dive into the topic.\nGUEST: Great! Let's start with the basics...",
+                            speaker: "dialogue",
+                            voiceId: speakers[0]?.id || "mock-voice-1",
+                            keyPoints: ["Introduction", "What to expect"],
+                            estimatedDuration: "3 minutes",
+                            order: 1
+                        },
+                        {
+                            title: "Main Discussion",
+                            content: "This is the main content section where we explore the key concepts in detail. We'll cover various aspects and provide practical examples.",
+                            speaker: "host",
+                            voiceId: speakers[0]?.id || "mock-voice-1",
+                            keyPoints: ["Key concept 1", "Key concept 2"],
+                            estimatedDuration: "8 minutes",
+                            order: 2
+                        },
+                        {
+                            title: "Conclusion & Takeaways",
+                            content: "HOST: Let's wrap up what we've learned today.\nGUEST: Yes, the main takeaway is...\nHOST: Thanks for joining us!\nGUEST: Thank you!",
+                            speaker: "dialogue",
+                            voiceId: speakers[0]?.id || "mock-voice-1",
+                            keyPoints: ["Summary", "Next steps"],
+                            estimatedDuration: "4 minutes",
+                            order: 3
+                        }
+                    ]
+                }
+            };
         }
         const formData = new FormData();
-        formData.append('command', 'generate_flashcard_questions');
-        formData.append('num_questions', numQuestions.toString());
-        formData.append('difficulty', difficulty);
+        formData.append('command', 'generate_podcast_structure');
+        formData.append('user', user);
+        formData.append('session', sessionId);
+        formData.append('title', title);
+        formData.append('description', description);
+        formData.append('prompt', prompt);
+        formData.append('speakers', JSON.stringify(speakers));
         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}`);
-            }
-            // Get the generated content from the response endpoint
-            const contentResponse = await fetch(AI_RESPONSE_URL);
-            if (!contentResponse.ok) {
-                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
+                const errorText = await response.text();
+                throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
             }
-            return (await contentResponse.json())['last_response'];
+            const result = await response.json();
+            return result;
         }
         catch (error) {
             throw new TRPCError({
                 code: 'INTERNAL_SERVER_ERROR',
-                message: `Failed to generate flashcard questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                message: `Failed to generate podcast structure: ${error instanceof Error ? error.message : 'Unknown error'}`,
             });
         }
     }
-    // Generate worksheet questions
-    async generateWorksheetQuestions(sessionId, numQuestions, difficulty) {
-        const session = this.sessions.get(sessionId);
-        if (!session) {
-            throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
+    // Generate podcast audio from text
+    async generatePodcastAudioFromText(sessionId, user, podcastId, segmentIndex, text, speakers, voiceId) {
+        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}`);
+            const isDialogue = text.includes('HOST:') || text.includes('GUEST:');
+            return {
+                success: true,
+                segmentIndex: segmentIndex,
+                objectKey: `${user}/${sessionId}/podcasts/${podcastId}/segment_${segmentIndex}.mp3`,
+                duration: 45 + Math.floor(Math.random() * 30), // Random duration between 45-75 seconds
+                type: isDialogue ? 'dialogue' : 'monologue',
+                ...(isDialogue && { partCount: 4 })
+            };
         }
         const formData = new FormData();
-        formData.append('command', 'generate_worksheet_questions');
-        formData.append('num_questions', numQuestions.toString());
-        formData.append('difficulty', difficulty);
+        formData.append('command', 'generate_podcast_audio_from_text');
+        formData.append('user', user);
+        formData.append('session', sessionId);
+        formData.append('podcast_id', podcastId);
+        formData.append('segment_index', segmentIndex.toString());
+        formData.append('text', text);
+        formData.append('speakers', JSON.stringify(speakers));
+        if (voiceId) {
+            formData.append('voice_id', voiceId);
+        }
         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 errorText = await response.text();
+                throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
             }
-            // Get the generated content from the response endpoint
-            const contentResponse = await fetch(AI_RESPONSE_URL);
-            if (!contentResponse.ok) {
-                throw new Error(`Failed to retrieve generated content: ${contentResponse.status}`);
-            }
-            return (await contentResponse.json())['last_response'];
+            const result = await response.json();
+            return result;
         }
         catch (error) {
             throw new TRPCError({
                 code: 'INTERNAL_SERVER_ERROR',
-                message: `Failed to generate worksheet questions: ${error instanceof Error ? error.message : 'Unknown error'}`,
+                message: `Failed to generate podcast audio: ${error instanceof Error ? error.message : 'Unknown error'}`,
             });
         }
     }
     // Analyse PDF
-    async analysePDF(sessionId) {
+    async analysePDF(sessionId, user) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
         }
+        await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
+        // Mock mode - return fake PDF analysis
+        if (MOCK_MODE) {
+            console.log(`🎭 MOCK MODE: Analysing PDF for session ${sessionId}`);
+            return `Mock PDF Analysis Results:
+
+Document Type: Educational Material
+Pages: 15
+Language: English
+Key Topics Identified:
+- Introduction to Machine Learning
+- Data Preprocessing Techniques
+- Model Training and Validation
+- Performance Metrics
+
+Summary: This mock PDF analysis shows the structure and content that would be extracted from an uploaded PDF document. The analysis includes document metadata, key topics, and a summary of the content.
+
+Note: This is a mock response generated when DONT_TEST_INFERENCE=true`;
+        }
         const formData = new FormData();
         formData.append('command', 'analyse_pdf');
+        formData.append('session', sessionId);
+        formData.append('user', user);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -285,13 +464,40 @@ export class AISessionService {
         }
     }
     // Analyse Image
-    async analyseImage(sessionId) {
+    async analyseImage(sessionId, user) {
         const session = this.sessions.get(sessionId);
         if (!session) {
             throw new TRPCError({ code: 'NOT_FOUND', message: 'AI session not found' });
         }
+        await new Promise(resolve => setTimeout(resolve, IMITATE_WAIT_TIME_MS));
+        // Mock mode - return fake image analysis
+        if (MOCK_MODE) {
+            console.log(`🎭 MOCK MODE: Analysing image for session ${sessionId}`);
+            return `Mock Image Analysis Results:
+
+Image Type: Educational Diagram
+Format: PNG
+Dimensions: 1920x1080
+Content Description:
+- Contains a flowchart or diagram
+- Shows a process or system architecture
+- Includes text labels and annotations
+- Educational or instructional content
+
+Key Elements Identified:
+- Process flow arrows
+- Decision points
+- Input/output elements
+- Descriptive text
+
+Summary: This mock image analysis demonstrates the type of content extraction that would be performed on uploaded images. The analysis identifies visual elements, text content, and overall structure.
+
+Note: This is a mock response generated when DONT_TEST_INFERENCE=true`;
+        }
         const formData = new FormData();
         formData.append('command', 'analyse_img');
+        formData.append('session', sessionId);
+        formData.append('user', user);
         try {
             const response = await fetch(AI_SERVICE_URL, {
                 method: 'POST',
@@ -310,6 +516,30 @@ export class AISessionService {
             });
         }
     }
+    async generatePodcastImage(sessionId, user, summary) {
+        const formData = new FormData();
+        formData.append('command', 'generate_podcast_image');
+        formData.append('session', sessionId);
+        formData.append('user', user);
+        formData.append('summary', summary);
+        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.image_key;
+        }
+        catch (error) {
+            throw new TRPCError({
+                code: 'INTERNAL_SERVER_ERROR',
+                message: `Failed to generate podcast image: ${error instanceof Error ? error.message : 'Unknown error'}`,
+            });
+        }
+    }
     // Get session by ID
     getSession(sessionId) {
         return this.sessions.get(sessionId);
@@ -324,6 +554,12 @@ export class AISessionService {
     }
     // Check if AI service is available
     async checkHealth() {
+        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');
+            return true;
+        }
         try {
             console.log('🏥 Checking AI service health...');
             const response = await fetch(AI_SERVICE_URL, {

package/dist/lib/auth.d.ts

@@ -1,3 +1,36 @@
-export declare function verifyCustomAuthCookie(cookieValue: string | undefined): {
+/**
+ * Authentication utilities for custom HMAC-based cookie verification.
+ *
+ * This module provides secure authentication using HMAC-SHA256 signatures
+ * to verify user identity through signed cookies.
+ *
+ * @fileoverview Custom authentication system with HMAC cookie verification
+ * @author Scribe Team
+ * @version 1.0.0
+ */
+/**
+ * Represents the result of successful authentication verification.
+ */
+export interface AuthResult {
+    /** The authenticated user's unique identifier */
     userId: string;
-} | null;
+}
+/**
+ * Verifies a custom HMAC-signed authentication cookie.
+ *
+ * The cookie format is: `base64(userId).hex(hmacSHA256(base64(userId), secret))`
+ *
+ * @param cookieValue - The raw cookie value to verify, or undefined if no cookie exists
+ * @returns Authentication result with userId if valid, null if invalid or missing
+ *
+ * @example
+ * ```typescript
+ * const result = verifyCustomAuthCookie("dXNlcjEyMw.abc123def456...");
+ * if (result) {
+ *   console.log(`Authenticated user: ${result.userId}`);
+ * }
+ * ```
+ *
+ * @throws {Error} Never throws - returns null for all error conditions
+ */
+export declare function verifyCustomAuthCookie(cookieValue: string | undefined): AuthResult | null;