@vertesia/workflow 0.51.0 → 0.54.0

package/src/activities/generateImageRendition.ts

@@ -1,39 +1,44 @@
-import { DSLActivityExecutionPayload, DSLActivitySpec, RenditionProperties } from "@vertesia/common";
 import { log } from "@temporalio/activity";
+import { NodeStreamSource } from "@vertesia/client/node";
+import { DSLActivityExecutionPayload, DSLActivitySpec, RenditionProperties } from "@vertesia/common";
+import ffmpeg from 'fluent-ffmpeg';
 import fs from 'fs';
-import sharp, { FormatEnum } from "sharp";
+import os from 'os';
+import path from 'path';
 import { imageResizer } from "../conversion/image.js";
-import { pdfToImages } from "../conversion/mutool.js";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
 import { NoDocumentFound, WorkflowParamNotFound } from "../errors.js";
-import { fetchBlobAsBuffer, saveBlobToTempFile } from "../utils/blobs.js";
-import { NodeStreamSource } from "../utils/memory.js";
+import { saveBlobToTempFile } from "../utils/blobs.js";
+
 interface GenerateImageRenditionParams {
-    max_hw: number; //maximum size of the longuest side of the image
-    format: keyof FormatEnum; //format of the output image
-    multi_page?: boolean; //if true, generate a multi-page rendition
+    max_hw: number; //maximum size of the longest side of the image
+    format: string; //format of the output image
 }
 
-
 export interface GenerateImageRendition extends DSLActivitySpec<GenerateImageRenditionParams> {
-
-    name: 'generateImageRendition';
-
+    name: "generateImageRendition";
 }
 
-
 export async function generateImageRendition(payload: DSLActivityExecutionPayload<GenerateImageRenditionParams>) {
-    const { client, objectId, params } = await setupActivity<GenerateImageRenditionParams>(payload);
+    const { client, objectId, params: originParams } = await setupActivity<GenerateImageRenditionParams>(payload);
+
+    // Fix: Use maxHeightWidth if max_hw is not provided
+    const params = {
+        ...originParams,
+        max_hw: originParams.max_hw || (originParams as any).maxHeightWidth || 1024, // Default to 1024 if both are missing
+        format: originParams.format || (originParams as any).format_output || 'png'  // Default to png if format is missing
+    };
+
+    log.info(`Generating image rendition for ${objectId}`, { originParams, params });
 
-    const supportedNonImageInputTypes = ['application/pdf']
     const inputObject = await client.objects.retrieve(objectId).catch((err) => {
-        log.error(`Failed to retrieve document ${objectId}`, err);
-        if (err.response?.status === 404) {
+        log.error(`Failed to retrieve document ${objectId}`, { err });
+        if (err.message.includes("not found")) {
             throw new NoDocumentFound(`Document ${objectId} not found`, [objectId]);
         }
         throw err;
     });
-    const renditionType = await client.types.getTypeByName('Rendition');
+    const renditionType = await client.types.getTypeByName("Rendition");
 
     if (!params.format) {
         log.error(`Format not found`);
@@ -50,85 +55,148 @@ export async function generateImageRendition(payload: DSLActivityExecutionPayloa
         throw new NoDocumentFound(`Document ${objectId} has no source`, [objectId]);
     }
 
-    if (!inputObject.content.type || (!inputObject.content.type?.startsWith('image/') && !supportedNonImageInputTypes.includes(inputObject.content.type))) {
-        log.error(`Document ${objectId} is not an image`);
-        throw new NoDocumentFound(`Document ${objectId} is not an image or pdf: ${inputObject.content.type}`, [objectId]);
+    if (!inputObject.content.type || (!inputObject.content.type?.startsWith("image/") && !inputObject.content.type?.startsWith("video/"))) {
+        log.error(`Document ${objectId} is not an image or a video: ${inputObject.content.type}`);
+        throw new NoDocumentFound(`Document ${objectId} is not an image or a video: ${inputObject.content.type}`, [objectId]);
     }
 
     //array of rendition files to upload
     let renditionPages: string[] = [];
 
-    //if PDF, convert to pages
-    if (inputObject.content.type === 'application/pdf') {
-        const pdfBuffer = await fetchBlobAsBuffer(client, inputObject.content.source);
-        const pages = await pdfToImages(pdfBuffer);
-        if (!pages.length) {
-            log.error(`Failed to convert pdf to image`);
-            throw new Error(`Failed to convert pdf to image`);
+    if (inputObject.content.type.startsWith('image/')) {
+        const imageFile = await saveBlobToTempFile(client, inputObject.content.source);
+        log.info(`Image ${objectId} copied to ${imageFile}`);
+        renditionPages.push(imageFile);
+    } else if (inputObject.content.type.startsWith('video/')) {
+        const videoFile = await saveBlobToTempFile(client, inputObject.content.source);
+        const tempOutputDir = fs.mkdtempSync(path.join(os.tmpdir(), 'video-rendition-'));
+        const thumbnailPath = path.join(tempOutputDir, 'thumbnail.png');
+
+        try {
+            // Extract a frame at 10% of the video duration
+            await new Promise<void>((resolve, reject) => {
+                ffmpeg.ffprobe(videoFile, (err, metadata) => {
+                    if (err) {
+                        log.error(`Failed to probe video metadata: ${err.message}`);
+                        return reject(err);
+                    }
+
+                    const duration = metadata.format.duration || 0;
+                    const timestamp = Math.max(0.1 * duration, 1);
+
+                    ffmpeg(videoFile)
+                        .screenshots({
+                            timestamps: [timestamp],
+                            filename: 'thumbnail.png',
+                            folder: tempOutputDir,
+                            size: `${params.max_hw}x?`
+                        })
+                        .on('end', () => {
+                            log.info(`Video frame extraction complete for ${objectId}`);
+                            resolve();
+                        })
+                        .on('error', (err) => {
+                            log.error(`Error extracting frame from video: ${err.message}`);
+                            reject(err);
+                        });
+                });
+            });
+
+            if (fs.existsSync(thumbnailPath)) {
+                renditionPages.push(thumbnailPath);
+            } else {
+                throw new Error(`Failed to generate thumbnail for video ${objectId}`);
+            }
+        } catch (error) {
+            log.error(`Error generating image rendition for video: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            throw new Error(`Failed to generate image rendition for video: ${objectId}`);
         }
-        renditionPages = [...pages];
-    } else if (inputObject.content.type.startsWith('image/')) {
-        const tmpFile = await saveBlobToTempFile(client, inputObject.content.source);
-        const filestats = fs.statSync(tmpFile);
-        log.info(`Image ${objectId} copied to ${tmpFile}`, { filestats });
-        renditionPages.push(tmpFile);
     }
 
     //generate rendition name, pass an index for multi parts
     const getRenditionName = (index: number = 0) => {
         const name = `renditions/${objectId}/${params.max_hw}/${index}.${params.format}`;
         return name;
-    }
+    };
 
     if (!renditionPages || !renditionPages.length) {
         log.error(`Failed to generate rendition for ${objectId}`);
         throw new Error(`Failed to generate rendition for ${objectId}`);
     }
 
-    log.info(`Uploading rendition for ${objectId} with ${renditionPages.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`, { renditionPages });
+    log.info(
+        `Uploading rendition for ${objectId} with ${renditionPages.length} pages (max_hw: ${params.max_hw}, format: ${params.format})`,
+        { renditionPages },
+    );
     const uploads = renditionPages.map(async (page, i) => {
         const pageId = getRenditionName(i);
-        const resized = sharp(page).pipe(imageResizer(params.max_hw, params.format));
-
-        const source = new NodeStreamSource(
-            resized,
-            pageId.replace('renditions/', '').replace('/', '_'),
-            'image/' + params.format,
-            pageId,
-        )
-
-        log.info(`Uploading rendition for ${objectId} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`);
-        return client.objects.upload(source).catch((err) => {
-            log.error(`Failed to upload rendition for ${objectId} page ${i}`, err);
-            return Promise.resolve(null);
-        });
+        let resizedImagePath = null;
+
+        try {
+            log.info(`Resizing image for ${objectId} page ${i}`, { page, params });
+            // Resize the image using ImageMagick
+            resizedImagePath = await imageResizer(page, params.max_hw, params.format);
+
+            // Create a read stream from the resized image file
+            const fileStream = fs.createReadStream(resizedImagePath);
+            const format = "image/" + params.format;
+            const fileId = pageId.split("/").pop() ?? "0." + params.format;
+            const source = new NodeStreamSource(
+                fileStream,
+                fileId,
+                format,
+                pageId,
+            );
+
+            log.info(
+                `Uploading rendition for ${objectId} page ${i} with max_hw: ${params.max_hw} and format: ${params.format}`, {
+                resizedImagePath,
+                fileId,
+                format,
+                pageId,
+            }
+            );
+
+            const result = await client.objects.upload(source).catch((err) => {
+                log.error(`Failed to upload rendition for ${objectId} page ${i}`, {
+                    error: err,
+                    errorMessage: err.message,
+                    stack: err.stack
+                });
+                return Promise.reject(`Upload failed: ${err.message}`);
+            });
+            log.info(`Rendition uploaded for ${objectId} page ${i}`, { result });
+
+            return result;
+        } catch (error) {
+            log.error(`Failed to process rendition for ${objectId} page ${i}`, { error });
+            return Promise.reject(error instanceof Error ? error.message : null);
+        }
     });
 
     const uploaded = await Promise.all(uploads);
     if (!uploaded || !uploaded.length || !uploaded[0]) {
-        log.error(`Failed to upload rendition for ${objectId}`);
-        throw new Error(`Failed to upload rendition for ${objectId}`);
+        log.error(`Failed to upload rendition for ${objectId}`, { uploaded });
+        throw new Error(`Failed to upload rendition for ${objectId} - upload object is empty`);
     }
 
-
-    log.info(`Creating rendition for ${objectId} with max_hw: ${params.max_hw} and format: ${params.format}`, { uploaded });
+    log.info(`Creating rendition for ${objectId} with max_hw: ${params.max_hw} and format: ${params.format}`, {
+        uploaded,
+    });
     const rendition = await client.objects.create({
         name: inputObject.name + ` [Rendition ${params.max_hw}]`,
         type: renditionType.id,
         parent: inputObject.id,
         content: uploaded[0],
         properties: {
-            mime_type: 'image/' + params.format,
+            mime_type: "image/" + params.format,
             source_etag: inputObject.content.source,
             height: params.max_hw,
             width: params.max_hw,
-            multipart: uploaded.length > 1,
-            total_parts: uploaded.length
-        } satisfies RenditionProperties
+        } satisfies RenditionProperties,
     });
 
     log.info(`Rendition ${rendition.id} created for ${objectId}`, { rendition });
 
     return { id: rendition.id, format: params.format, status: "success" };
-
 }

package/src/activities/generateOrAssignContentType.ts

@@ -1,11 +1,16 @@
 import { log } from "@temporalio/activity";
-import { CreateContentObjectTypePayload, DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
+import {
+    ContentObjectTypeItem,
+    CreateContentObjectTypePayload,
+    DSLActivityExecutionPayload,
+    DSLActivitySpec,
+} from "@vertesia/common";
 import { ActivityContext, setupActivity } from "../dsl/setup/ActivityContext.js";
 import { TruncateSpec, truncByMaxTokens } from "../utils/tokens.js";
 import { InteractionExecutionParams, executeInteractionFromActivity } from "./executeInteraction.js";
 
-const INT_SELECT_DOCUMENT_TYPE = "sys:SelectDocumentType"
-const INT_GENERATE_METADATA_MODEL = "sys:GenerateMetadataModel"
+const INT_SELECT_DOCUMENT_TYPE = "sys:SelectDocumentType";
+const INT_GENERATE_METADATA_MODEL = "sys:GenerateMetadataModel";
 
 export interface GenerateOrAssignContentTypeParams extends InteractionExecutionParams {
     typesHint?: string[];
@@ -21,20 +26,21 @@ export interface GenerateOrAssignContentTypeParams extends InteractionExecutionP
     interactionNames?: {
         selectDocumentType?: string;
         generateMetadataModel?: string;
-    }
+    };
 }
 
 export interface GenerateOrAssignContentType extends DSLActivitySpec<GenerateOrAssignContentTypeParams> {
-    name: 'generateOrAssignContentType';
+    name: "generateOrAssignContentType";
 }
 
-export async function generateOrAssignContentType(payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>) {
+export async function generateOrAssignContentType(
+    payload: DSLActivityExecutionPayload<GenerateOrAssignContentTypeParams>,
+) {
     const context = await setupActivity<GenerateOrAssignContentTypeParams>(payload);
     const { params, client, objectId } = context;
 
     const interactionName = params.interactionNames?.selectDocumentType ?? INT_SELECT_DOCUMENT_TYPE;
 
-
     log.info("SelectDocumentType for object: " + objectId, { payload });
 
     const object = await client.objects.retrieve(objectId, "+text");
@@ -48,57 +54,67 @@ export async function generateOrAssignContentType(payload: DSLActivityExecutionP
         return { status: "skipped", message: "Object already has a type: " + object.type.name };
     }
 
-    if (!object || (!object.text && !object.content?.type?.startsWith("image/") && !object.content?.type?.startsWith("application/pdf"))) {
+    if (
+        !object ||
+        (!object.text &&
+            !object.content?.type?.startsWith("image/") &&
+            !object.content?.type?.startsWith("application/pdf"))
+    ) {
         log.info(`Object ${objectId} not found or text is empty and not an image`, { object });
         return { status: "failed", error: "no-text" };
     }
 
-    const types = await client.types.list();
+    const types = await client.types.list(undefined, {
+        schema: true,
+    });
 
     //make a list of all existing types, and add hints if any
-    const existing_types = types.map(t => t.name).filter(n => !["DocumentPart", "Rendition"].includes(n));
-    if (params.typesHint) {
-        const newHints = params.typesHint.filter((t: string) => !existing_types.includes(t));
-        existing_types.push(...newHints);
-    }
-
-    const content = object.text ? truncByMaxTokens(object.text, params.truncate || 4000) : undefined;
+    const existing_types = types.filter((t) => !["DocumentPart", "Rendition"].includes(t.name));
+    const content = object.text ? truncByMaxTokens(object.text, params.truncate || 30000) : undefined;
 
     const getImage = async () => {
         if (object.content?.type?.includes("pdf") && object.text?.length && object.text?.length < 100) {
-            return "store:" + objectId
+            return "store:" + objectId;
         }
         if (!object.content?.type?.startsWith("image/")) {
             return undefined;
         }
-        const res = await client.objects.getRendition(objectId, { max_hw: 1024, format: "image/png", generate_if_missing: true });
+        const res = await client.objects.getRendition(objectId, {
+            max_hw: 1024,
+            format: "image/png",
+            generate_if_missing: true,
+        });
         if (!res.rendition && res.status === "generating") {
             //throw to try again
             throw new Error(`Rendition for object ${objectId} is in progress`);
         } else if (res.rendition) {
             return "store:" + objectId;
         }
-    }
+    };
 
     const fileRef = await getImage();
 
-    log.info("Execute SelectDocumentType interaction on content with \nexisting types: " + existing_types.join(","));
+    log.info(
+        "Execute SelectDocumentType interaction on content with \nexisting types - passing full types: " +
+            existing_types.filter((t) => !t.tags?.includes("system")),
+    );
 
     const res = await executeInteractionFromActivity(client, interactionName, params, {
-        existing_types, content, image: fileRef
+        existing_types,
+        content,
+        image: fileRef,
     });
 
     log.info("Selected Content Type Result: " + JSON.stringify(res.result));
 
     //if type is not identified or not present in the database, generate a new type
-    let selectedType: { id: string, name: string } | undefined = undefined;
+    let selectedType: { id: string; name: string } | undefined = undefined;
 
-    selectedType = types.find(t => t.name === res.result.document_type);
+    selectedType = types.find((t) => t.name === res.result.document_type);
 
     if (!selectedType) {
-        log.warn("Document type not idenfified: starting type generation");
+        log.warn("Document type not identified: starting type generation");
         const newType = await generateNewType(context, existing_types, content, fileRef);
-
         selectedType = { id: newType.id, name: newType.name };
     }
 
@@ -115,24 +131,28 @@ export async function generateOrAssignContentType(payload: DSLActivityExecutionP
     return {
         id: selectedType.id,
         name: selectedType.name,
-        isNew: !types.find(t => t.name === selectedType.name)
+        isNew: !types.find((t) => t.name === selectedType.name),
     };
 }
 
-async function generateNewType(context: ActivityContext<GenerateOrAssignContentTypeParams>, existing_types: string[], content?: string, fileRef?: string) {
+async function generateNewType(
+    context: ActivityContext<GenerateOrAssignContentTypeParams>,
+    existing_types: ContentObjectTypeItem[],
+    content?: string,
+    fileRef?: string,
+) {
     const { client, params } = context;
 
     const project = await context.fetchProject();
     const interactionName = params.interactionNames?.generateMetadataModel ?? INT_GENERATE_METADATA_MODEL;
 
     const genTypeRes = await executeInteractionFromActivity(client, interactionName, params, {
-        existing_types: existing_types,
+        existing_types,
         content: content,
         human_context: project?.configuration?.human_context ?? undefined,
-        image: fileRef ? fileRef : undefined
+        image: fileRef ? fileRef : undefined,
     });
 
-
     if (!genTypeRes.result.document_type) {
         log.error("No name generated for type", genTypeRes);
         throw new Error("No name generated for type");
@@ -143,10 +163,10 @@ async function generateNewType(context: ActivityContext<GenerateOrAssignContentT
         name: genTypeRes.result.document_type,
         object_schema: genTypeRes.result.metadata_schema,
         is_chunkable: genTypeRes.result.is_chunkable,
-    }
+        table_layout: genTypeRes.result.table_layout,
+    };
 
     const type = await client.types.create(typeData);
 
     return type;
-
 }

package/src/activities/getObjectFromStore.ts

@@ -12,7 +12,7 @@ export interface GetObject extends DSLActivitySpec<GetObjectParams> {
 }
 
 /**
- * We are using a union type for the status parameter since typescript enumbs breaks the workflow code generation
+ * We are using a union type for the status parameter since typescript enums breaks the workflow code generation
  * @param objectId
  * @param status
  */

package/src/activities/handleError.ts

@@ -0,0 +1,25 @@
+import { ContentObjectStatus, DSLActivityExecutionPayload } from "@vertesia/common";
+import { setupActivity } from "../dsl/setup/ActivityContext.js";
+import { log } from "@temporalio/activity"
+
+export interface HandleDslErrorParams {
+    errorMessage: string;
+}
+
+export async function handleDslError(payload: DSLActivityExecutionPayload<HandleDslErrorParams>): Promise<void> {
+    const { client, params, objectId } = await setupActivity<HandleDslErrorParams>(payload);
+    const isIntake = payload.workflow_name === "StandardDocumentIntake" || payload.workflow_name === "StandardImageIntake";
+    if (!isIntake) {
+        log.warn(`Workflow execution failed, but no error handler registered for this workflow: ${payload.workflow_name}`,
+            { error: params.errorMessage },
+        );
+        return;
+    }
+
+    try {
+        await client.objects.update(objectId, { status: ContentObjectStatus.failed });
+    } catch (e) {
+        log.error("Failed to handle error", { error: e });
+    }
+    return;
+}

package/src/activities/index-dsl.ts

@@ -11,6 +11,7 @@ export { generateEmbeddings } from "./generateEmbeddings.js";
 export { generateImageRendition } from "./generateImageRendition.js";
 export { generateOrAssignContentType } from "./generateOrAssignContentType.js";
 export { getObjectFromStore } from "./getObjectFromStore.js";
+export { handleDslError } from "./handleError.js";
 export { convertPdfToStructuredText } from "./media/processPdfWithTextract.js";
 export { transcribeMedia } from "./media/transcribeMediaWithGladia.js";
 export { notifyWebhook } from "./notifyWebhook.js";

package/src/activities/index.ts

@@ -2,4 +2,3 @@
  * Here we export all activities to be registered with the temporal worker
  */
 export * from "./index-dsl.js";
-export * from "../iterative-generation/activities/index.js";

package/src/activities/media/processPdfWithTextract.ts

@@ -91,11 +91,11 @@ export async function convertPdfToStructuredText(payload: DSLActivityExecutionPa
 
         if (jobStatus === "SUCCEEDED") {
             log.info(`Job ${jobId} succeeded, saving results`, { jobId });
-            const ftext = await processor.processResults(jobId);
-            const tokensData = countTokens(ftext);
-            const etag = object.content.etag ?? md5(ftext);
+            const fText = await processor.processResults(jobId);
+            const tokensData = countTokens(fText);
+            const etag = object.content.etag ?? md5(fText);
             const updateData: CreateContentObjectPayload = {
-                text: ftext,
+                text: fText,
                 text_etag: etag,
                 tokens: {
                     ...tokensData,

package/src/activities/media/transcribeMediaWithGladia.ts

@@ -74,7 +74,7 @@ export async function transcribeMedia(payload: DSLActivityExecutionPayload<Trans
 
 
 function generateCallbackUrlForGladia(baseUrl: string, authToken: string, taskToken: string, objectId: string) {
-    return `${baseUrl}/api/v1/webhooks/gladia/${objectId}?auth_token=${authToken}&task_token=${taskToken}`;
+    return `${baseUrl}/api/v1/webhooks/gladia/${objectId}?access_token=${authToken}&task_token=${taskToken}`;
 }
 
 interface GladiaTranscriptRequestResponse {

package/src/activities/notifyWebhook.ts

@@ -1,9 +1,9 @@
-import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { log } from "@temporalio/activity";
+import { DSLActivityExecutionPayload, DSLActivitySpec } from "@vertesia/common";
 import { setupActivity } from "../dsl/setup/ActivityContext.js";
 import { WorkflowParamNotFound } from "../errors.js";
 
-interface NotifyWebhookParams {
+export interface NotifyWebhookParams {
     target_url: string; //URL to send the notification to
     method: 'GET' | 'POST'; //HTTP method to use
     payload: Record<string, any>; //payload to send (if POST then as JSON body, if GET then as query string)

package/src/activities/setDocumentStatus.ts

@@ -11,7 +11,7 @@ export interface SetDocumentStatus extends DSLActivitySpec<SetDocumentStatusPara
 }
 
 /**
- * We are using a union type for the status parameter since typescript enumbs breaks the workflow code generation
+ * We are using a union type for the status parameter since typescript enums breaks the workflow code generation
  * @param objectId
  * @param status
  */

package/src/conversion/TextractProcessor.ts

@@ -472,21 +472,21 @@ export class TextractProcessor {
         }
     
         // Build final output
-        let fulltext = '';
+        let fullText = '';
         let imgNumber = 1;
         let tableNumber = 1;
         for (const page of pageContents) {
-            fulltext += `<page number="${page.pageNumber}">\n`;
+            fullText += `<page number="${page.pageNumber}">\n`;
             for (const block of page.blocks) {
                 if (block.type === 'text') {
-                    fulltext += `<text>\n${block.content}\n</text>\n\n`;
+                    fullText += `<text>\n${block.content}\n</text>\n\n`;
                 } else if (block.type === 'table') {
                     const confidenceAttr = block.confidence !== undefined && this.includeConfidenceInTables
                         ? ` confidence="${block.confidence.toFixed(2)}"`
                         : '';
-                    fulltext += `<table number=${tableNumber++} type="csv" ${confidenceAttr}>\n`;
-                    fulltext += `${block.content}\n`;
-                    fulltext += `</table>\n\n`;
+                    fullText += `<table number=${tableNumber++} type="csv" ${confidenceAttr}>\n`;
+                    fullText += `${block.content}\n`;
+                    fullText += `</table>\n\n`;
                 } else if (block.type === 'image') {
                     // Include geometry if you like
                     const leftAttr = block.left ? ` left="${block.left.toFixed(4)}"` : '';
@@ -494,13 +494,13 @@ export class TextractProcessor {
                     const widthAttr = block.width ? ` width="${block.width.toFixed(4)}"` : '';
                     const heightAttr = block.height ? ` height="${block.height.toFixed(4)}"` : '';
     
-                    fulltext += `<image id="${imgNumber++}" ${leftAttr}${topAttr}${widthAttr}${heightAttr}>\n${block.content.trim()}\n</image>\n\n`;
+                    fullText += `<image id="${imgNumber++}" ${leftAttr}${topAttr}${widthAttr}${heightAttr}>\n${block.content.trim()}\n</image>\n\n`;
                 }
             }
-            fulltext += `</page>\n\n`;
+            fullText += `</page>\n\n`;
         }
     
-        return fulltext;
+        return fullText;
     }
     
 }