@goscribe/server 1.1.1 → 1.1.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@goscribe/server",
-  "version": "1.1.1",
+  "version": "1.1.2",
   "description": "",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",

package/prisma/schema.prisma

@@ -130,6 +130,8 @@ model Workspace {
 
   analysisProgress Json?
 
+  needsAnalysis Boolean @default(false)
+
   // Raw uploads attached to this workspace
   uploads     FileAsset[]
 
@@ -191,6 +193,7 @@ model FileAsset {
   objectKey String?
   url       String?  // optional if serving via signed GET per-view
   checksum  String?  // optional server-side integrity
+  aiTranscription String?
 
   meta      Json?    // arbitrary metadata
 

package/src/lib/ai-session.ts

@@ -26,6 +26,19 @@ export interface AISession {
 
 const IMITATE_WAIT_TIME_MS = MOCK_MODE ?  1000 * 10 : 0;
 
+export interface ProcessFileResult {
+  status: 'success' | 'error';
+  textContent: string | null;
+  imageDescriptions: Array<{
+    page: number;
+    description: string;
+    hasVisualContent: boolean;
+  }>;
+  comprehensiveDescription: string | null;
+  pageCount: number;
+  error?: string;
+}
+
 export class AISessionService {
   private sessions = new Map<string, AISession>();
 
@@ -115,56 +128,107 @@ export class AISessionService {
     });
   }
 
-  // Upload file to AI session
-  async uploadFile(sessionId: string, user: string, file: File, fileType: 'image' | 'pdf'): Promise<void> {
+  // Process file (PDF/image) and return comprehensive text descriptions
+  async processFile(
+    sessionId: string,
+    user: string,
+    fileUrl: string,
+    fileType: 'image' | 'pdf',
+    maxPages?: number
+  ): Promise<ProcessFileResult> {
     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
+    
+    // Mock mode - return fake processing result
     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;
+      logger.info(`🎭 MOCK MODE: Processing ${fileType} file from URL for session ${sessionId}`);
+      const mockPageCount = fileType === 'pdf' ? 15 : 1;
+      return {
+        status: 'success',
+        textContent: `Mock extracted text content from ${fileType} file. This would contain the full text extracted from the document.`,
+        imageDescriptions: Array.from({ length: mockPageCount }, (_, i) => ({
+          page: i + 1,
+          description: `Page ${i + 1} contains educational content with diagrams and text.`,
+          hasVisualContent: true,
+        })),
+        comprehensiveDescription: `DOCUMENT SUMMARY (${mockPageCount} ${mockPageCount === 1 ? 'page' : 'pages'})\n\nTEXT CONTENT:\nMock extracted text content...\n\nVISUAL CONTENT DESCRIPTIONS:\nPage-by-page descriptions of visual elements.`,
+        pageCount: mockPageCount,
+      };
     }
 
-    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',
-        body: formData,
-      });
+    formData.append('command', 'process_file');
+    formData.append('fileUrl', fileUrl);
+    formData.append('fileType', fileType);
+    if (maxPages) {
+      formData.append('maxPages', maxPages.toString());
+    }
 
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
+    // Retry logic for file processing
+    const maxRetries = 3;
+    let lastError: Error | null = null;
 
-      const result = await response.json();
-      console.log(`📋 Upload result:`, result);
-      if (!result.message) {
-        throw new Error(`AI service error: No response message`);
-      }
+    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
 
-      // Update session
-      session.files.push(file.name);
-      session.updatedAt = new Date();
-      this.sessions.set(sessionId, session);
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to upload file: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
+        const response = await fetch(AI_SERVICE_URL, {
+          method: 'POST',
+          body: formData,
+          signal: controller.signal,
+        });
+
+        clearTimeout(timeoutId);
+
+        if (!response.ok) {
+          const errorText = await response.text();
+          logger.error(`❌ File processing error response:`, errorText);
+          throw new Error(`AI service error: ${response.status} ${response.statusText} - ${errorText}`);
+        }
+
+        const result = await response.json();
+        logger.info(`📋 File processing result: status=${result.status}, pageCount=${result.pageCount}`);
+
+        if (result.status === 'error') {
+          throw new Error(result.error || 'File processing failed');
+        }
+
+        // Update session
+        session.files.push(fileUrl);
+        session.updatedAt = new Date();
+        this.sessions.set(sessionId, session);
+
+        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...`);
+          await new Promise(resolve => setTimeout(resolve, delay));
+        }
+      }
     }
+
+    logger.error(`💥 All ${maxRetries} file processing attempts failed. Last error:`, lastError?.message);
+    return {
+      status: 'error',
+      textContent: null,
+      imageDescriptions: [],
+      comprehensiveDescription: null,
+      pageCount: 0,
+      error: `Failed to process file after ${maxRetries} attempts: ${lastError?.message || 'Unknown error'}`,
+    };
   }
 
 
@@ -503,113 +567,6 @@ This mock study guide demonstrates the structure and format that would be genera
   }
   
 
-  // Analyse PDF
-  async analysePDF(sessionId: string, user: string): Promise<string> {
-    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',
-        body: formData,
-      });
-
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
-
-      const result = await response.json();
-      return result.message || 'PDF analysis completed';
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to analyse PDF: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
-  }
-
-  // Analyse Image
-  async analyseImage(sessionId: string, user: string): Promise<string> {
-    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',
-        body: formData,
-      });
-
-      if (!response.ok) {
-        throw new Error(`AI service error: ${response.status} ${response.statusText}`);
-      }
-
-      const result = await response.json();
-      return result.message || 'Image analysis completed';
-    } catch (error) {
-      throw new TRPCError({
-        code: 'INTERNAL_SERVER_ERROR',
-        message: `Failed to analyse image: ${error instanceof Error ? error.message : 'Unknown error'}`,
-      });
-    }
-  }
 
   async generatePodcastImage(sessionId: string, user: string, summary: string): Promise<string> {
 

package/src/routers/podcast.ts

@@ -877,7 +877,6 @@ export const podcast = router({
         updatedAt: segment.updatedAt,
       };
     }),
-
   // Get available voices for TTS
   getAvailableVoices: authedProcedure
     .query(async () => {

package/src/routers/worksheets.ts

@@ -281,6 +281,7 @@ export const worksheets = router({
           userAnswer: input.answer,
           completedAt: input.completed ? new Date() : null,
           attempts: { increment: 1 },
+          correct: input.correct,
         },
       });
 
@@ -490,7 +491,7 @@ export const worksheets = router({
       
       // Parse question meta to get mark_scheme
       const questionMeta = question.meta ? (typeof question.meta === 'object' ? question.meta : JSON.parse(question.meta as any)) : {} as any;
-      const markScheme = questionMeta.mark_scheme;
+      const markScheme = questionMeta.markScheme;
 
       let isCorrect = false;
       let userMarkScheme = null;
@@ -517,7 +518,7 @@ export const worksheets = router({
         }
       } else {
         // Simple string comparison if no mark scheme
-        isCorrect = question.answer === input.answer;
+        throw new TRPCError({ code: 'BAD_REQUEST', message: 'No mark scheme found for question' });
       }
 
 

package/src/routers/workspace.ts

@@ -6,6 +6,7 @@ import { ArtifactType } from '@prisma/client';
 import { aiSessionService } from '../lib/ai-session.js';
 import PusherService from '../lib/pusher.js';
 import { members } from './members.js';
+import { logger } from '../lib/logger.js';
 import type { PrismaClient } from '@prisma/client';
 
 // Helper function to update and emit analysis progress
@@ -353,7 +354,7 @@ export const workspace = router({
     }))
     .query(async ({ ctx, input }) => {
       const objectKey = `workspace_${ctx.session.user.id}/${input.workspaceId}-file_${input.filename}`;
-      await ctx.db.fileAsset.create({
+      const fileAsset = await ctx.db.fileAsset.create({
         data: {
           workspaceId: input.workspaceId,
           name: input.filename,
@@ -370,31 +371,28 @@ export const workspace = router({
       if (signedUrlError) {
         throw new TRPCError({ code: 'INTERNAL_SERVER_ERROR', message: `Failed to generate upload URL: ${signedUrlError.message}` });
       }
-      return signedUrlData.signedUrl;
+
+      await ctx.db.workspace.update({
+        where: { id: input.workspaceId },
+        data: { needsAnalysis: true },
+      });
+      
+      return {
+        fileId: fileAsset.id,
+        uploadUrl: signedUrlData.signedUrl,
+      };
     }),
     uploadAndAnalyzeMedia: authedProcedure
     .input(z.object({
       workspaceId: z.string(),
-      file: z.object({
-        filename: z.string(),
-        contentType: z.string(),
-        size: z.number(),
-        content: z.string(), // Base64 encoded file content
-      }),
+      files: z.array(z.object({
+        id: z.string(),
+      })),
       generateStudyGuide: z.boolean().default(true),
       generateFlashcards: z.boolean().default(true),
       generateWorksheet: z.boolean().default(true),
     }))
     .mutation(async ({ ctx, input }) => {
-      console.log('🚀 uploadAndAnalyzeMedia started', { 
-        workspaceId: input.workspaceId, 
-        filename: input.file.filename,
-        fileSize: input.file.size,
-        generateStudyGuide: input.generateStudyGuide,
-        generateFlashcards: input.generateFlashcards,
-        generateWorksheet: input.generateWorksheet
-      });
-
       // Verify workspace ownership
       const workspace = await ctx.db.workspace.findFirst({
         where: { id: input.workspaceId, ownerId: ctx.session.user.id }
@@ -404,39 +402,85 @@ export const workspace = router({
         throw new TRPCError({ code: 'NOT_FOUND' });
       }
 
-      const fileType = input.file.contentType.startsWith('image/') ? 'image' : 'pdf';
+      // Check if analysis is already in progress
+      if (workspace.fileBeingAnalyzed) {
+        throw new TRPCError({ 
+          code: 'CONFLICT', 
+          message: 'File analysis is already in progress for this workspace. Please wait for it to complete.' 
+        });
+      }
+
+      // Fetch files from database
+      const files = await ctx.db.fileAsset.findMany({
+        where: {
+          id: { in: input.files.map(file => file.id) },
+          workspaceId: input.workspaceId,
+          userId: ctx.session.user.id,
+        },
+      });
+
+      if (files.length === 0) {
+        throw new TRPCError({ 
+          code: 'NOT_FOUND', 
+          message: 'No files found with the provided IDs' 
+        });
+      }
+
+      // Validate all files have bucket and objectKey
+      for (const file of files) {
+        if (!file.bucket || !file.objectKey) {
+          throw new TRPCError({ 
+            code: 'BAD_REQUEST', 
+            message: `File ${file.id} does not have bucket or objectKey set` 
+          });
+        }
+      }
+
+      // Use the first file for progress tracking and artifact naming
+      const primaryFile = files[0];
+      const fileType = primaryFile.mimeType.startsWith('image/') ? 'image' : 'pdf';
       
+      // Set analysis in progress flag
       await ctx.db.workspace.update({
         where: { id: input.workspaceId },
         data: { fileBeingAnalyzed: true },
       });
 
-      try {
-      
-      await updateAnalysisProgress(ctx.db, input.workspaceId, {
+      PusherService.emitAnalysisProgress(input.workspaceId, {
         status: 'starting',
-        filename: input.file.filename,
+        filename: primaryFile.name,
         fileType,
         startedAt: new Date().toISOString(),
         steps: {
-          fileUpload: {
-            order: 1,
-            status: 'pending',
-          },
-          fileAnalysis: {
-            order: 2,
-            status: 'pending',
-          },
-          studyGuide: {
-            order: 3,
-            status: input.generateStudyGuide ? 'pending' : 'skipped',
-          },
-          flashcards: {
-            order: 4,
-            status: input.generateFlashcards ? 'pending' : 'skipped',
-          },
-        }
+          fileUpload: { order: 1, status: 'pending' },
+        },
       });
+
+      try {
+        await updateAnalysisProgress(ctx.db, input.workspaceId, {
+          status: 'starting',
+          filename: primaryFile.name,
+          fileType,
+          startedAt: new Date().toISOString(),
+          steps: {
+            fileUpload: {
+              order: 1,
+              status: 'pending',
+            },
+            fileAnalysis: {
+              order: 2,
+              status: 'pending',
+            },
+            studyGuide: {
+              order: 3,
+              status: input.generateStudyGuide ? 'pending' : 'skipped',
+            },
+            flashcards: {
+              order: 4,
+              status: input.generateFlashcards ? 'pending' : 'skipped',
+            },
+          }
+        });
       } catch (error) {
         console.error('❌ Failed to update analysis progress:', error);
         await ctx.db.workspace.update({
@@ -447,26 +491,9 @@ export const workspace = router({
         throw error;
       }
 
-      const fileBuffer = Buffer.from(input.file.content, 'base64');
-
-      // // Check AI service health first
-      // console.log('🏥 Checking AI service health...');
-      // const isHealthy = await aiSessionService.checkHealth();
-      // if (!isHealthy) {
-      //   console.error('❌ AI service is not available');
-      //   await PusherService.emitError(input.workspaceId, 'AI service is currently unavailable');
-      //   throw new TRPCError({
-      //     code: 'SERVICE_UNAVAILABLE',
-      //     message: 'AI service is currently unavailable. Please try again later.',
-      //   });
-      // }
-      // console.log('✅ AI service is healthy');
-
-      const fileObj = new File([fileBuffer], input.file.filename, { type: input.file.contentType });
-
       await updateAnalysisProgress(ctx.db, input.workspaceId, {
         status: 'uploading',
-        filename: input.file.filename,
+        filename: primaryFile.name,
         fileType,
         startedAt: new Date().toISOString(),
         steps: {
@@ -489,11 +516,62 @@ export const workspace = router({
         }
       });
 
-      await aiSessionService.uploadFile(input.workspaceId, ctx.session.user.id, fileObj, fileType);
+      // Process all files using the new process_file endpoint
+      for (const file of files) {
+        // TypeScript: We already validated bucket and objectKey exist above
+        if (!file.bucket || !file.objectKey) {
+          continue; // Skip if somehow missing (shouldn't happen due to validation above)
+        }
+        
+        const { data: signedUrlData, error: signedUrlError } = await supabaseClient.storage
+          .from(file.bucket)
+          .createSignedUrl(file.objectKey, 24 * 60 * 60); // 24 hours expiry
+        
+        if (signedUrlError) {
+          await ctx.db.workspace.update({
+            where: { id: input.workspaceId },
+            data: { fileBeingAnalyzed: false },
+          });
+          throw new TRPCError({ 
+            code: 'INTERNAL_SERVER_ERROR', 
+            message: `Failed to generate signed URL for file ${file.name}: ${signedUrlError.message}` 
+          });
+        }
+        
+        const fileUrl = signedUrlData.signedUrl;
+        const currentFileType = file.mimeType.startsWith('image/') ? 'image' : 'pdf';
+        
+        // Use maxPages for large PDFs (>50 pages) to limit processing
+        const maxPages = currentFileType === 'pdf' && file.size && file.size > 50 ? 50 : undefined;
+        
+        const processResult = await aiSessionService.processFile(
+          input.workspaceId,
+          ctx.session.user.id,
+          fileUrl,
+          currentFileType,
+          maxPages
+        );
+        
+        if (processResult.status === 'error') {
+          logger.error(`Failed to process file ${file.name}:`, processResult.error);
+          // Continue processing other files even if one fails
+          // Optionally, you could throw an error or mark this file as failed
+        } else {
+          logger.info(`Successfully processed file ${file.name}: ${processResult.pageCount} pages`);
+          
+          // Store the comprehensive description in aiTranscription field
+          await ctx.db.fileAsset.update({
+            where: { id: file.id },
+            data: {
+              aiTranscription: processResult.comprehensiveDescription || processResult.textContent || null,
+            }
+          });
+        }
+      }
 
       await updateAnalysisProgress(ctx.db, input.workspaceId, {
         status: 'analyzing',
-        filename: input.file.filename,
+        filename: primaryFile.name,
         fileType,
         startedAt: new Date().toISOString(),
         steps: {
@@ -517,15 +595,20 @@ export const workspace = router({
       });
 
       try {
-        if (fileType === 'image') {
-          await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id);
-        } else {
-          await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id );
-        }
+        // Analyze all files - use PDF analysis if any file is a PDF, otherwise use image analysis
+        // const hasPDF = files.some(f => !f.mimeType.startsWith('image/'));
+        // if (hasPDF) {
+        //   await aiSessionService.analysePDF(input.workspaceId, ctx.session.user.id, file.id);
+        // } else {
+        //   // If all files are images, analyze them
+        //   for (const file of files) {
+        //     await aiSessionService.analyseImage(input.workspaceId, ctx.session.user.id, file.id);
+        //   }
+        // }
         
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
           status: 'generating_artifacts',
-          filename: input.file.filename,
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
           steps: {
@@ -548,10 +631,10 @@ export const workspace = router({
           }
         });
       } catch (error) {
-        console.error('❌ Failed to analyze file:', error);
+        console.error('❌ Failed to analyze files:', error);
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
           status: 'error',
-          filename: input.file.filename,
+          filename: primaryFile.name,
           fileType,
           error: `Failed to analyze ${fileType}: ${error}`,
           startedAt: new Date().toISOString(),
@@ -574,6 +657,10 @@ export const workspace = router({
             },
           }
         });
+        await ctx.db.workspace.update({
+          where: { id: input.workspaceId },
+          data: { fileBeingAnalyzed: false },
+        });
         throw error;
       }
 
@@ -585,7 +672,7 @@ export const workspace = router({
           worksheet: any | null;
         };
       } = { 
-        filename: input.file.filename, 
+        filename: primaryFile.name, 
         artifacts: {
           studyGuide: null,
           flashcards: null,
@@ -597,7 +684,7 @@ export const workspace = router({
       if (input.generateStudyGuide) {
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
           status: 'generating_study_guide',
-          filename: input.file.filename,
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
           steps: {
@@ -626,11 +713,12 @@ export const workspace = router({
           where: { workspaceId: input.workspaceId, type: ArtifactType.STUDY_GUIDE },
         });
         if (!artifact) {
+          const fileNames = files.map(f => f.name).join(', ');
           artifact = await ctx.db.artifact.create({
             data: {
               workspaceId: input.workspaceId,
               type: ArtifactType.STUDY_GUIDE,
-              title: `Study Guide - ${input.file.filename}`,
+              title: files.length === 1 ? `Study Guide - ${primaryFile.name}` : `Study Guide - ${files.length} files`,
               createdById: ctx.session.user.id,
             },
           });
@@ -651,7 +739,7 @@ export const workspace = router({
       if (input.generateFlashcards) {
         await updateAnalysisProgress(ctx.db, input.workspaceId, {
           status: 'generating_flashcards',
-          filename: input.file.filename,
+          filename: primaryFile.name,
           fileType,
           startedAt: new Date().toISOString(),
           steps: {
@@ -680,7 +768,7 @@ export const workspace = router({
           data: {
             workspaceId: input.workspaceId,
             type: ArtifactType.FLASHCARD_SET,
-            title: `Flashcards - ${input.file.filename}`,
+            title: files.length === 1 ? `Flashcards - ${primaryFile.name}` : `Flashcards - ${files.length} files`,
             createdById: ctx.session.user.id,
           },
         });
@@ -737,7 +825,7 @@ export const workspace = router({
 
       await updateAnalysisProgress(ctx.db, input.workspaceId, {
         status: 'completed',
-        filename: input.file.filename,
+        filename: primaryFile.name,
         fileType,
         startedAt: new Date().toISOString(),
         completedAt: new Date().toISOString(),