@adminforth/bulk-ai-flow 1.8.0 → 1.9.0

package/index.ts

@@ -3,8 +3,10 @@ import type { IAdminForth, IHttpServer, AdminForthComponentDeclaration, AdminFor
 import type { PluginOptions } from './types.js';
 import Handlebars from 'handlebars';
 import { RateLimiter } from "adminforth";
+import { randomUUID } from "crypto";
 
-
+const STUB_MODE = false;
+const jobs = new Map();
 export default class  BulkAiFlowPlugin extends AdminForthPlugin {
   options: PluginOptions;
   uploadPlugin: AdminForthPlugin;
@@ -65,6 +67,243 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
     }
   }
 
+  private async analyze_image(jobId: string, recordId: string, adminUser: any, headers: Record<string, string | string[] | undefined>) {
+    const selectedId = recordId;
+    let isError = false;
+    if (typeof(this.options.rateLimits?.fillFieldsFromImages) === 'string'){
+      if (this.checkRateLimit("fillFieldsFromImages" ,this.options.rateLimits.fillFieldsFromImages, headers)) {
+        jobs.set(jobId, { status: 'failed', error: "Rate limit exceeded" });
+        return { error: "Rate limit exceeded" };
+      }
+    }
+    // Fetch the record using the provided ID
+    const primaryKeyColumn = this.resourceConfig.columns.find((col) => col.primaryKey);
+    const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(primaryKeyColumn.name, selectedId)] );
+
+    //recieve image URLs to analyze
+    const attachmentFiles = await this.options.attachFiles({ record: record });
+    if (STUB_MODE) {
+      await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * 8000) + 1000));
+      jobs.set(jobId, { status: 'completed', result: {} });
+      return {};
+    } else if (attachmentFiles.length !== 0) {
+      //create prompt for OpenAI
+      const compiledOutputFields = this.compileOutputFieldsTemplates(record);
+      const prompt = `Analyze the following image(s) and return a single JSON in format like: {'param1': 'value1', 'param2': 'value2'}. 
+        Do NOT return array of objects. Do NOT include any Markdown, code blocks, explanations, or extra text. Only return valid JSON. 
+        Each object must contain the following fields: ${JSON.stringify(compiledOutputFields)} Use the exact field names. If it's number field - return only number.
+        Image URLs:`;
+        
+      //send prompt to OpenAI and get response
+      let chatResponse;
+      try {
+        chatResponse = await this.options.visionAdapter.generate({ prompt, inputFileUrls: attachmentFiles });
+      } catch (e) {
+        isError = true;
+        jobs.set(jobId, { status: 'failed', error: 'AI provider refused to analyze images' });
+        return { ok: false, error: 'AI provider refused to analyze images' };
+      }
+      if (!isError) {
+        const resp: any = (chatResponse as any).response;
+        const topLevelError = (chatResponse as any).error;
+        if (topLevelError || resp?.error) {
+          jobs.set(jobId, { status: 'failed', error: `ERROR: ${JSON.stringify(topLevelError || resp?.error)}` });
+        }
+
+        const textOutput = resp?.output?.[0]?.content?.[0]?.text ?? resp?.output_text ?? resp?.choices?.[0]?.message?.content;
+        if (!textOutput || typeof textOutput !== 'string') {
+          jobs.set(jobId, { status: 'failed', error: 'Unexpected AI response format' });
+        }
+
+        //parse response and update record
+        const resData = JSON.parse(textOutput);
+        const result = resData;
+        jobs.set(jobId, { status: 'completed', result });
+        return { ok: true };
+      }
+    };
+  }
+
+  private async analyzeNoImages(jobId: string, recordId: string, adminUser: any, headers: Record<string, string | string[] | undefined>) {
+    const selectedId = recordId;
+    let isError = false;
+    if (typeof(this.options.rateLimits?.fillPlainFields) === 'string'){
+      if (this.checkRateLimit("fillPlainFields", this.options.rateLimits.fillPlainFields, headers)) {
+        jobs.set(jobId, { status: 'failed', error: "Rate limit exceeded" });
+        return { error: "Rate limit exceeded" };
+      }
+    }
+    if (STUB_MODE) {
+      await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * 20000) + 1000));
+      jobs.set(jobId, { status: 'completed', result: {} });
+      return {};
+    } else {
+      const primaryKeyColumn = this.resourceConfig.columns.find((col) => col.primaryKey);
+      const record = await this.adminforth.resource(this.resourceConfig.resourceId).get( [Filters.EQ(primaryKeyColumn.name, selectedId)] );
+
+      const compiledOutputFields = this.compileOutputFieldsTemplatesNoImage(record);
+      const prompt = `Analyze the following fields and return a single JSON in format like: {'param1': 'value1', 'param2': 'value2'}. 
+        Do NOT return array of objects. Do NOT include any Markdown, code blocks, explanations, or extra text. Only return valid JSON. 
+        Each object must contain the following fields: ${JSON.stringify(compiledOutputFields)} Use the exact field names. 
+        If it's number field - return only number.`;
+      //send prompt to OpenAI and get response
+      const numberOfTokens = this.options.fillPlainFieldsMaxTokens ? this.options.fillPlainFieldsMaxTokens : 1000;
+      let resp: any;
+      try {
+        const { content: chatResponse } = await this.options.textCompleteAdapter.complete(prompt, [], numberOfTokens);
+        resp = (chatResponse as any).response;
+        const topLevelError = (chatResponse as any).error;
+        if (topLevelError || resp?.error) {
+          isError = true;
+          jobs.set(jobId, { status: 'failed', error: `ERROR: ${JSON.stringify(topLevelError || resp?.error)}` });
+        }
+        resp = chatResponse
+      } catch (e) {
+        isError = true;
+        jobs.set(jobId, { status: 'failed', error: 'AI provider refused to fill fields' });
+        return { ok: false, error: 'AI provider refused to fill fields' };
+      }
+      const resData = JSON.parse(resp);
+      const result = resData;
+      jobs.set(jobId, { status: 'completed', result });
+      return { ok: true };
+    }
+  }
+
+  private async initialImageGenerate(jobId: string, recordId: string, adminUser: any, headers: Record<string, string | string[] | undefined>) {
+    const selectedId = recordId;
+    let isError = false;
+    if (typeof(this.options.rateLimits?.generateImages) === 'string'){
+      if (this.checkRateLimit("generateImages", this.options.rateLimits.generateImages, headers)) {
+        jobs.set(jobId, { status: 'failed', error: "Rate limit exceeded" });
+        return { error: "Rate limit exceeded" };
+      }
+    }
+    const start = +new Date();
+    const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.resourceConfig.columns.find(c => c.primaryKey)?.name, selectedId)]);
+    let attachmentFiles
+    if(!this.options.attachFiles){
+      attachmentFiles = [];
+    } else {
+      attachmentFiles = await this.options.attachFiles({ record });
+    }
+    const fieldTasks = Object.keys(this.options?.generateImages || {}).map(async (key) => {
+      const prompt = this.compileGenerationFieldTemplates(record)[key];
+      let images;
+        if (this.options.attachFiles && attachmentFiles.length === 0) {
+          jobs.set(jobId, { status: 'failed', error: "No attachment files found" });
+          return { key, images: [] };
+        } else {
+          if (STUB_MODE) {
+            await new Promise((resolve) => setTimeout(resolve, Math.floor(Math.random() * 20000) + 1000));
+            images = `https://pic.re/image`;
+          } else {
+            let generationAdapter;
+            if (this.options.generateImages[key].adapter) {
+              generationAdapter = this.options.generateImages[key].adapter;
+            } else {
+              generationAdapter = this.options.imageGenerationAdapter;
+            }
+            let resp;
+            try {
+              resp = await generationAdapter.generate(
+                {
+                  prompt,
+                  inputFiles: attachmentFiles,
+                  n: 1,
+                  size: this.options.generateImages[key].outputSize,
+                }
+              )
+            } catch (e) {
+              jobs.set(jobId, { status: 'failed', error: "AI provider refused to generate image" });
+              isError = true;
+              return { key, images: [] };
+            }
+            images = resp.imageURLs[0];
+          }
+        return { key, images };
+      }
+    });
+
+    const fieldResults = await Promise.all(fieldTasks);
+    const recordResult: Record<string, string[]> = {};
+
+    fieldResults.forEach(({ key, images }) => {
+      recordResult[key] = images;
+    });
+
+    const result = recordResult;
+    
+    this.totalCalls++;
+    this.totalDuration += (+new Date() - start) / 1000;
+    if (!isError) {
+      jobs.set(jobId, { status: 'completed', result });
+      return { ok: true }
+    } else {
+      return { ok: false, error: 'Error during image generation' };
+    }
+  }
+  
+  private async regenerateImage(jobId: string, recordId: string, fieldName: string, prompt: string, adminUser: any, headers: Record<string, string | string[] | undefined>) {
+    const Id = recordId;
+    let isError = false;
+    if (this.checkRateLimit(fieldName, this.options.generateImages[fieldName].rateLimit, headers)) {
+      jobs.set(jobId, { status: 'failed', error: "Rate limit exceeded" });
+      return { error: "Rate limit exceeded" };
+    }
+    const start = +new Date();
+    const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.resourceConfig.columns.find(c => c.primaryKey)?.name, Id)]);
+    let attachmentFiles
+      if(!this.options.attachFiles){
+        attachmentFiles = [];
+      } else {
+        attachmentFiles = await this.options.attachFiles({ record });
+      }
+    const images = await Promise.all(
+      (new Array(this.options.generateImages[fieldName].countToGenerate)).fill(0).map(async () => {
+        if (this.options.attachFiles && attachmentFiles.length === 0) {
+          jobs.set(jobId, { status: 'failed', error: "No attachment files found" });
+          return null;
+        }
+        if (STUB_MODE) {
+          await new Promise((resolve) => setTimeout(resolve, 2000));
+          jobs.set(jobId, { status: 'completed', result: {} });
+          return `https://pic.re/image`;
+        }
+
+        let generationAdapter;
+        if (this.options.generateImages[fieldName].adapter) {
+          generationAdapter = this.options.generateImages[fieldName].adapter;
+        } else {
+          generationAdapter = this.options.imageGenerationAdapter;
+        }
+        let resp;
+        try {
+          resp = await generationAdapter.generate(
+            {
+              prompt,
+              inputFiles: attachmentFiles,
+              n: 1,
+              size: this.options.generateImages[fieldName].outputSize,
+            }
+          )
+        } catch (e) {
+          jobs.set(jobId, { status: 'failed', error: "AI provider refused to generate image" });
+          isError = true;
+          return [];
+        }
+        return resp.imageURLs[0]
+      })
+    );
+    this.totalCalls++;
+    this.totalDuration += (+new Date() - start) / 1000;
+    if (!isError) {
+      jobs.set(jobId, { status: 'completed', result: { [fieldName]: images } });
+      return { ok: true };
+    } else {
+      return { ok: false, error: 'Error during image generation' };
+    }
+  }
 
   async modifyResourceConfig(adminforth: IAdminForth, resourceConfig: AdminForthResource) {
     super.modifyResourceConfig(adminforth, resourceConfig);
@@ -112,9 +351,7 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
           p.resourceConfig!.resourceId === this.resourceConfig.resourceId &&
           p.pluginOptions.pathColumnName === key
         );
-        if (plugin && plugin.pluginOptions.storageAdapter.objectCanBeAccesedPublicly()) {
           outputImagesPluginInstanceIds[key] = plugin.pluginInstanceId;
-        }
       }
     }
 
@@ -142,6 +379,13 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         isFieldsForAnalizePlain: this.options.fillPlainFields ? Object.keys(this.options.fillPlainFields).length > 0 : false,
         isImageGeneration: this.options.generateImages ? Object.keys(this.options.generateImages).length > 0 : false,
         isAttachFiles: this.options.attachFiles ? true : false,
+        disabledWhenNoCheckboxes: true,
+        refreshRates: {
+          fillFieldsFromImages: this.options.refreshRates?.fillFieldsFromImages || 2_000,
+          fillPlainFields: this.options.refreshRates?.fillPlainFields || 1_000,
+          generateImages: this.options.refreshRates?.generateImages || 5_000,
+          regenerateImages: this.options.refreshRates?.regenerateImages || 5_000,
+        }
       }
     }
     
@@ -203,6 +447,12 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         if (!plugin) {
           throw new Error(`Plugin for attachment field '${key}' not found in resource '${this.resourceConfig.resourceId}', please check if Upload Plugin is installed on the field ${key}`);
         }
+        if (!plugin.pluginOptions || !plugin.pluginOptions.storageAdapter) {
+          throw new Error(`Upload Plugin for attachment field '${key}' in resource '${this.resourceConfig.resourceId}' is missing a storageAdapter configuration.`);
+        }
+        if (typeof plugin.pluginOptions.storageAdapter.objectCanBeAccesedPublicly !== 'function') {
+          throw new Error(`Upload Plugin for attachment field '${key}' in resource '${this.resourceConfig.resourceId}' uses a storage adapter without 'objectCanBeAccesedPublicly' method.`);
+        }
         if (!plugin.pluginOptions.storageAdapter.objectCanBeAccesedPublicly()) {
           throw new Error(`Upload Plugin for attachment field '${key}' in resource '${this.resourceConfig.resourceId}' 
             uses adapter which is not configured to store objects in public way, so it will produce only signed private URLs which can not be used in HTML text of blog posts.
@@ -218,96 +468,6 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
   }
 
   setupEndpoints(server: IHttpServer) {
-    server.endpoint({
-      method: 'POST',
-      path: `/plugin/${this.pluginInstanceId}/analyze`,
-      handler: async ({ body, adminUser, headers }) => {
-      const selectedIds = body.selectedIds || [];
-      if (typeof(this.options.rateLimits?.fillFieldsFromImages) === 'string'){
-        if (this.checkRateLimit("fillFieldsFromImages" ,this.options.rateLimits.fillFieldsFromImages, headers)) {
-          return { error: "Rate limit exceeded" };
-        }
-      }
-      const tasks = selectedIds.map(async (ID) => {
-        // Fetch the record using the provided ID
-        const primaryKeyColumn = this.resourceConfig.columns.find((col) => col.primaryKey);
-        const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(primaryKeyColumn.name, ID)] );
-
-        //recieve image URLs to analyze
-        const attachmentFiles = await this.options.attachFiles({ record: record });
-        if (attachmentFiles.length !== 0) {
-          //create prompt for OpenAI
-          const compiledOutputFields = this.compileOutputFieldsTemplates(record);
-          const prompt = `Analyze the following image(s) and return a single JSON in format like: {'param1': 'value1', 'param2': 'value2'}. 
-            Do NOT return array of objects. Do NOT include any Markdown, code blocks, explanations, or extra text. Only return valid JSON. 
-            Each object must contain the following fields: ${JSON.stringify(compiledOutputFields)} Use the exact field names. If it's number field - return only number.
-            Image URLs:`;
-            
-          //send prompt to OpenAI and get response
-          const chatResponse = await this.options.visionAdapter.generate({ prompt, inputFileUrls: attachmentFiles });
-
-          const resp: any = (chatResponse as any).response;
-          const topLevelError = (chatResponse as any).error;
-          if (topLevelError || resp?.error) {
-            throw new Error(`ERROR: ${JSON.stringify(topLevelError || resp?.error)}`);
-          }
-
-          const textOutput = resp?.output?.[0]?.content?.[0]?.text ?? resp?.output_text ?? resp?.choices?.[0]?.message?.content;
-          if (!textOutput || typeof textOutput !== 'string') {
-            throw new Error('Unexpected AI response format');
-          }
-
-          //parse response and update record
-          const resData = JSON.parse(textOutput);
-
-          return resData;
-        };
-      });
-
-      const result = await Promise.all(tasks);
-
-      return { result };
-      }
-    });
-
-    server.endpoint({
-      method: 'POST',
-      path: `/plugin/${this.pluginInstanceId}/analyze_no_images`,
-      handler: async ({ body, adminUser, headers }) => {
-      const selectedIds = body.selectedIds || [];
-      if (typeof(this.options.rateLimits?.fillPlainFields) === 'string'){
-        if (this.checkRateLimit("fillPlainFields", this.options.rateLimits.fillPlainFields, headers)) {
-          return { error: "Rate limit exceeded" };
-        }
-      }
-      const tasks = selectedIds.map(async (ID) => {
-        const primaryKeyColumn = this.resourceConfig.columns.find((col) => col.primaryKey);
-        const record = await this.adminforth.resource(this.resourceConfig.resourceId).get( [Filters.EQ(primaryKeyColumn.name, ID)] );
-
-        const compiledOutputFields = this.compileOutputFieldsTemplatesNoImage(record);
-        const prompt = `Analyze the following fields and return a single JSON in format like: {'param1': 'value1', 'param2': 'value2'}. 
-          Do NOT return array of objects. Do NOT include any Markdown, code blocks, explanations, or extra text. Only return valid JSON. 
-          Each object must contain the following fields: ${JSON.stringify(compiledOutputFields)} Use the exact field names. 
-          If it's number field - return only number.`;
-        //send prompt to OpenAI and get response
-        const numberOfTokens = this.options.fillPlainFieldsMaxTokens ? this.options.fillPlainFieldsMaxTokens : 1000;
-        const { content: chatResponse } = await this.options.textCompleteAdapter.complete(prompt, [], numberOfTokens);
-
-        const resp: any = (chatResponse as any).response;
-        const topLevelError = (chatResponse as any).error;
-        if (topLevelError || resp?.error) {
-          throw new Error(`ERROR: ${JSON.stringify(topLevelError || resp?.error)}`);
-        }
-        const resData = JSON.parse(chatResponse);
-
-        return resData;
-      });
-
-      const result = await Promise.all(tasks);
-
-      return { result };
-      }
-    });
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/get_records`,
@@ -328,6 +488,8 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         };
       }
     });
+
+
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/get_images`,
@@ -345,6 +507,8 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         };
       }
     });
+
+
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/update_fields`,
@@ -428,124 +592,8 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         }
       }
     });
-    server.endpoint({
-      method: 'POST',
-      path: `/plugin/${this.pluginInstanceId}/regenerate_images`,
-      handler: async ({ body, headers }) => {
-        const Id = body.recordId || [];
-        const prompt = body.prompt || '';
-        const fieldName = body.fieldName || '';
-        if (this.checkRateLimit(fieldName, this.options.generateImages[fieldName].rateLimit, headers)) {
-          return { error: "Rate limit exceeded" };
-        }
-        const start = +new Date();
-        const STUB_MODE = false;
-        const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.resourceConfig.columns.find(c => c.primaryKey)?.name, Id)]);
-        let attachmentFiles
-          if(!this.options.attachFiles){
-            attachmentFiles = [];
-          } else {
-            attachmentFiles = await this.options.attachFiles({ record });
-          }
-        const images = await Promise.all(
-          (new Array(this.options.generateImages[fieldName].countToGenerate)).fill(0).map(async () => {
-            if (this.options.attachFiles && attachmentFiles.length === 0) {
-              return null;
-            }
-            if (STUB_MODE) {
-              await new Promise((resolve) => setTimeout(resolve, 2000));
-              return `https://picsum.photos/200/300?random=${Math.floor(Math.random() * 1000)}`;
-            }
-
-            let generationAdapter;
-            if (this.options.generateImages[fieldName].adapter) {
-              generationAdapter = this.options.generateImages[fieldName].adapter;
-            } else {
-              generationAdapter = this.options.imageGenerationAdapter;
-            }
-            const resp = await generationAdapter.generate(
-              {
-                prompt,
-                inputFiles: attachmentFiles,
-                n: 1,
-                size: this.options.generateImages[fieldName].outputSize,
-              }
-            )
-            return resp.imageURLs[0]
-          })
-        );
-        this.totalCalls++;
-        this.totalDuration += (+new Date() - start) / 1000;
-        return { images };
-      }
-    });
-    server.endpoint({
-      method: 'POST',
-      path: `/plugin/${this.pluginInstanceId}/initial_image_generate`,
-      handler: async ({ body, headers }) => {
-        const selectedIds = body.selectedIds || [];
-        const STUB_MODE = false;
-        if (typeof(this.options.rateLimits?.generateImages) === 'string'){
-          if (this.checkRateLimit("generateImages", this.options.rateLimits.generateImages, headers)) {
-            return { error: "Rate limit exceeded" };
-          }
-        }
-        const start = +new Date();
-        const tasks = selectedIds.map(async (ID) => {
-          const record = await this.adminforth.resource(this.resourceConfig.resourceId).get([Filters.EQ(this.resourceConfig.columns.find(c => c.primaryKey)?.name, ID)]);
-          let attachmentFiles
-          if(!this.options.attachFiles){
-            attachmentFiles = [];
-          } else {
-            attachmentFiles = await this.options.attachFiles({ record });
-          }
-          const fieldTasks = Object.keys(this.options?.generateImages || {}).map(async (key) => {
-            const prompt = this.compileGenerationFieldTemplates(record)[key];
-            let images;
-              if (this.options.attachFiles && attachmentFiles.length === 0) {
-                return { key, images: [] };
-              } else {
-                if (STUB_MODE) {
-                  await new Promise((resolve) => setTimeout(resolve, 2000));
-                  images = `https://picsum.photos/200/300?random=${Math.floor(Math.random() * 1000)}`;
-                } else {
-                  let generationAdapter;
-                  if (this.options.generateImages[key].adapter) {
-                    generationAdapter = this.options.generateImages[key].adapter;
-                  } else {
-                    generationAdapter = this.options.imageGenerationAdapter;
-                  }
-                  const resp = await generationAdapter.generate(
-                    {
-                      prompt,
-                      inputFiles: attachmentFiles,
-                      n: 1,
-                      size: this.options.generateImages[key].outputSize,
-                    }
-                  )
-                  images = resp.imageURLs[0];
-                }
-              return { key, images };
-            }
-          });
 
-          const fieldResults = await Promise.all(fieldTasks);
-          const recordResult: Record<string, string[]> = {};
 
-          fieldResults.forEach(({ key, images }) => {
-            recordResult[key] = images;
-          });
-
-          return recordResult;
-        });
-        const result = await Promise.all(tasks);
-        
-        this.totalCalls++;
-        this.totalDuration += (+new Date() - start) / 1000;
-
-        return { result };
-      }
-    });
     server.endpoint({
       method: 'POST',
       path: `/plugin/${this.pluginInstanceId}/get_generation_prompts`,
@@ -556,6 +604,8 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         return { generationOptions: compiledGenerationOptions };
       }
     });
+
+
     server.endpoint({
       method: 'GET',
       path: `/plugin/${this.pluginInstanceId}/averageDuration`,
@@ -567,5 +617,67 @@ export default class  BulkAiFlowPlugin extends AdminForthPlugin {
         };
       }
     });
+
+
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/create-job`,
+      handler: async ({ body, adminUser, headers }) => {
+        const { actionType, recordId } = body;
+        const jobId = randomUUID();
+        jobs.set(jobId, { status: "in_progress" });
+
+        if (!actionType) {
+          jobs.set(jobId, { status: "failed", error: "Missing action type" });
+          return { error: "Missing action type" };
+        }
+        if (!recordId) {
+          jobs.set(jobId, { status: "failed", error: "Missing record id" });
+          return { error: "Missing record id" };
+        }
+
+        switch(actionType) {
+          case 'generate_images':
+            setTimeout(async () => await this.initialImageGenerate(jobId, recordId, adminUser, headers), 100);
+          break;
+          case 'analyze_no_images':
+            setTimeout(async () => await this.analyzeNoImages(jobId, recordId, adminUser, headers), 100);
+          break;
+          case 'analyze':
+            setTimeout(async () => await this.analyze_image(jobId, recordId, adminUser, headers), 100);
+          break;
+          case 'regenerate_images':
+            if (!body.prompt || !body.fieldName) {
+              jobs.set(jobId, { status: "failed", error: "Missing prompt or field name" });
+              break;
+            }
+            setTimeout(async () => await this.regenerateImage(jobId, recordId, body.fieldName, body.prompt, adminUser, headers), 100);
+          break;
+          default:
+            jobs.set(jobId, { status: "failed", error: "Unknown action type" });
+        }
+        setTimeout(() => jobs.delete(jobId), 300_000);
+        return { ok: true, jobId };
+      }
+    });
+
+
+    server.endpoint({
+      method: 'POST',
+      path: `/plugin/${this.pluginInstanceId}/get-job-status`,
+      handler: async ({ body, adminUser, headers }) => {
+        const jobId = body.jobId;
+        if (!jobId) {
+          return { error: "Can't find job id" };
+        }
+        const job = jobs.get(jobId);
+        if (!job) {
+          return { error: "Job not found" };
+        }
+        return { ok: true, job };
+      }
+    });
+
+
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adminforth/bulk-ai-flow",
-  "version": "1.8.0",
+  "version": "1.9.0",
   "publishConfig": {
     "access": "public"
   },

package/types.ts

@@ -85,6 +85,15 @@ export interface PluginOptions {
       generateImages?: string,
     },
 
+    /**
+     * Job refresh rate for each ai flow job in milliseconds
+     */
+    refreshRates?: {
+      fillFieldsFromImages?: number,
+      fillPlainFields?: number,
+      generateImages?: number,
+      regenerateImages?: number,
+    },
 
     /**
      * Whether the user is allowed to save the generated images