Feature/v2/automate (#4248)

* automate feature
* Moved all providers to app level to simplify homepage 
* Circular dependency fixes
* You will see that now toolRegistry gets a tool config and a tool
settings object. These enable automate to run the tools using as much
static code as possible.

---------

Co-authored-by: Connor Yoh <[email protected]>

frontend/src/hooks/tools/addPassword/useAddPasswordOperation.test.ts

@@ -26,7 +26,7 @@ import { ToolOperationConfig, ToolOperationHook, useToolOperation } from '../sha
 describe('useAddPasswordOperation', () => {
   const mockUseToolOperation = vi.mocked(useToolOperation);
 
-  const getToolConfig = (): ToolOperationConfig<AddPasswordFullParameters> => mockUseToolOperation.mock.calls[0][0];
+  const getToolConfig = (): ToolOperationConfig<AddPasswordFullParameters> => mockUseToolOperation.mock.calls[0][0] as ToolOperationConfig<AddPasswordFullParameters>;
 
   const mockToolOperationReturn: ToolOperationHook<unknown> = {
     files: [],

frontend/src/hooks/tools/addPassword/useAddPasswordOperation.ts

@@ -1,30 +1,45 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { AddPasswordFullParameters } from './useAddPasswordParameters';
+import { AddPasswordFullParameters, defaultParameters } from './useAddPasswordParameters';
+import { defaultParameters as permissionsDefaults } from '../changePermissions/useChangePermissionsParameters';
 import { getFormData } from '../changePermissions/useChangePermissionsOperation';
 
+// Static function that can be used by both the hook and automation executor
+export const buildAddPasswordFormData = (parameters: AddPasswordFullParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  formData.append("password", parameters.password);
+  formData.append("ownerPassword", parameters.ownerPassword);
+  formData.append("keyLength", parameters.keyLength.toString());
+  getFormData(parameters.permissions).forEach(([key, value]) => {
+    formData.append(key, value);
+  });
+  return formData;
+};
+
+// Full default parameters including permissions for automation
+const fullDefaultParameters: AddPasswordFullParameters = {
+  ...defaultParameters,
+  permissions: permissionsDefaults,
+};
+
+// Static configuration object
+export const addPasswordOperationConfig = {
+  operationType: 'addPassword',
+  endpoint: '/api/v1/security/add-password',
+  buildFormData: buildAddPasswordFormData,
+  filePrefix: 'encrypted_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters: fullDefaultParameters,
+} as const;
+
 export const useAddPasswordOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: AddPasswordFullParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    formData.append("password", parameters.password);
-    formData.append("ownerPassword", parameters.ownerPassword);
-    formData.append("keyLength", parameters.keyLength.toString());
-    getFormData(parameters.permissions).forEach(([key, value]) => {
-      formData.append(key, value);
-    });
-    return formData;
-  };
-
   return useToolOperation<AddPasswordFullParameters>({
-    operationType: 'addPassword',
-    endpoint: '/api/v1/security/add-password',
-    buildFormData,
+    ...addPasswordOperationConfig,
     filePrefix: t('addPassword.filenamePrefix', 'encrypted') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('addPassword.error.failed', 'An error occurred while encrypting the PDF.'))
   });
 };

frontend/src/hooks/tools/addWatermark/useAddWatermarkOperation.ts

@@ -1,9 +1,10 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { AddWatermarkParameters } from './useAddWatermarkParameters';
+import { AddWatermarkParameters, defaultParameters } from './useAddWatermarkParameters';
 
-const buildFormData = (parameters: AddWatermarkParameters, file: File): FormData => {
+// Static function that can be used by both the hook and automation executor
+export const buildAddWatermarkFormData = (parameters: AddWatermarkParameters, file: File): FormData => {
   const formData = new FormData();
   formData.append("fileInput", file);
 
@@ -32,15 +33,22 @@ const buildFormData = (parameters: AddWatermarkParameters, file: File): FormData
   return formData;
 };
 
+// Static configuration object
+export const addWatermarkOperationConfig = {
+  operationType: 'watermark',
+  endpoint: '/api/v1/security/add-watermark',
+  buildFormData: buildAddWatermarkFormData,
+  filePrefix: 'watermarked_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
+
 export const useAddWatermarkOperation = () => {
   const { t } = useTranslation();
 
   return useToolOperation<AddWatermarkParameters>({
-    operationType: 'watermark',
-    endpoint: '/api/v1/security/add-watermark',
-    buildFormData,
+    ...addWatermarkOperationConfig,
     filePrefix: t('watermark.filenamePrefix', 'watermarked') + '_',
-    multiFileEndpoint: false, // Individual API calls per file
     getErrorMessage: createStandardErrorHandler(t('watermark.error.failed', 'An error occurred while adding watermark to the PDF.'))
   });
 };

frontend/src/hooks/tools/addWatermark/useAddWatermarkParameters.ts

@@ -46,3 +46,4 @@ export const useAddWatermarkParameters = (): AddWatermarkParametersHook => {
     },
   });
 };
+

frontend/src/hooks/tools/automate/useAutomateOperation.ts

@@ -0,0 +1,49 @@
+import { useToolOperation } from '../shared/useToolOperation';
+import { useCallback } from 'react';
+import { executeAutomationSequence } from '../../../utils/automationExecutor';
+import { useFlatToolRegistry } from '../../../data/useTranslatedToolRegistry';
+import { AutomateParameters } from '../../../types/automation';
+import { AUTOMATION_CONSTANTS } from '../../../constants/automation';
+
+export function useAutomateOperation() {
+  const toolRegistry = useFlatToolRegistry();
+
+  const customProcessor = useCallback(async (params: AutomateParameters, files: File[]) => {
+    console.log('🚀 Starting automation execution via customProcessor', { params, files });
+    
+    if (!params.automationConfig) {
+      throw new Error('No automation configuration provided');
+    }
+
+    // Execute the automation sequence and return the final results
+    const finalResults = await executeAutomationSequence(
+      params.automationConfig!,
+      files,
+      toolRegistry,
+      (stepIndex: number, operationName: string) => {
+        console.log(`Step ${stepIndex + 1} started: ${operationName}`);
+        params.onStepStart?.(stepIndex, operationName);
+      },
+      (stepIndex: number, resultFiles: File[]) => {
+        console.log(`Step ${stepIndex + 1} completed with ${resultFiles.length} files`);
+        params.onStepComplete?.(stepIndex, resultFiles);
+      },
+      (stepIndex: number, error: string) => {
+        console.error(`Step ${stepIndex + 1} failed:`, error);
+        params.onStepError?.(stepIndex, error);
+        throw new Error(`Automation step ${stepIndex + 1} failed: ${error}`);
+      }
+    );
+
+    console.log(`✅ Automation completed, returning ${finalResults.length} files`);
+    return finalResults;
+  }, [toolRegistry]);
+
+  return useToolOperation<AutomateParameters>({
+    operationType: 'automate',
+    endpoint: '/api/v1/pipeline/handleData', // Not used with customProcessor
+    buildFormData: () => new FormData(), // Not used with customProcessor
+    customProcessor,
+    filePrefix: AUTOMATION_CONSTANTS.FILE_PREFIX
+  });
+}

frontend/src/hooks/tools/automate/useAutomationForm.ts

@@ -0,0 +1,114 @@
+import { useState, useEffect } from 'react';
+import { useTranslation } from 'react-i18next';
+import { AutomationTool, AutomationConfig, AutomationMode } from '../../../types/automation';
+import { AUTOMATION_CONSTANTS } from '../../../constants/automation';
+import { ToolRegistryEntry } from '../../../data/toolsTaxonomy';
+
+interface UseAutomationFormProps {
+  mode: AutomationMode;
+  existingAutomation?: AutomationConfig;
+  toolRegistry: Record<string, ToolRegistryEntry>;
+}
+
+export function useAutomationForm({ mode, existingAutomation, toolRegistry }: UseAutomationFormProps) {
+  const { t } = useTranslation();
+  
+  const [automationName, setAutomationName] = useState('');
+  const [selectedTools, setSelectedTools] = useState<AutomationTool[]>([]);
+
+  const getToolName = (operation: string) => {
+    const tool = toolRegistry?.[operation] as any;
+    return tool?.name || t(`tools.${operation}.name`, operation);
+  };
+
+  const getToolDefaultParameters = (operation: string): Record<string, any> => {
+    const config = toolRegistry[operation]?.operationConfig;
+    if (config?.defaultParameters) {
+      return { ...config.defaultParameters };
+    }
+    return {};
+  };
+
+  // Initialize based on mode and existing automation
+  useEffect(() => {
+    if ((mode === AutomationMode.SUGGESTED || mode === AutomationMode.EDIT) && existingAutomation) {
+      setAutomationName(existingAutomation.name || '');
+
+      const operations = existingAutomation.operations || [];
+      const tools = operations.map((op, index) => {
+        const operation = typeof op === 'string' ? op : op.operation;
+        return {
+          id: `${operation}-${Date.now()}-${index}`,
+          operation: operation,
+          name: getToolName(operation),
+          configured: mode === AutomationMode.EDIT ? true : false,
+          parameters: typeof op === 'object' ? op.parameters || {} : {}
+        };
+      });
+
+      setSelectedTools(tools);
+    } else if (mode === AutomationMode.CREATE && selectedTools.length === 0) {
+      // Initialize with default empty tools for new automation
+      const defaultTools = Array.from({ length: AUTOMATION_CONSTANTS.DEFAULT_TOOL_COUNT }, (_, index) => ({
+        id: `tool-${index + 1}-${Date.now()}`,
+        operation: '',
+        name: t('automate.creation.tools.selectTool', 'Select a tool...'),
+        configured: false,
+        parameters: {}
+      }));
+      setSelectedTools(defaultTools);
+    }
+  }, [mode, existingAutomation, selectedTools.length, t, getToolName]);
+
+  const addTool = (operation: string) => {
+    const newTool: AutomationTool = {
+      id: `${operation}-${Date.now()}`,
+      operation,
+      name: getToolName(operation),
+      configured: false,
+      parameters: getToolDefaultParameters(operation)
+    };
+
+    setSelectedTools([...selectedTools, newTool]);
+  };
+
+  const removeTool = (index: number) => {
+    if (selectedTools.length <= AUTOMATION_CONSTANTS.MIN_TOOL_COUNT) return;
+    setSelectedTools(selectedTools.filter((_, i) => i !== index));
+  };
+
+  const updateTool = (index: number, updates: Partial<AutomationTool>) => {
+    const updatedTools = [...selectedTools];
+    updatedTools[index] = { ...updatedTools[index], ...updates };
+    setSelectedTools(updatedTools);
+  };
+
+  const hasUnsavedChanges = () => {
+    return (
+      automationName.trim() !== '' ||
+      selectedTools.some(tool => tool.operation !== '' || tool.configured)
+    );
+  };
+
+  const canSaveAutomation = () => {
+    return (
+      automationName.trim() !== '' &&
+      selectedTools.length > 0 &&
+      selectedTools.every(tool => tool.configured && tool.operation !== '')
+    );
+  };
+
+  return {
+    automationName,
+    setAutomationName,
+    selectedTools,
+    setSelectedTools,
+    addTool,
+    removeTool,
+    updateTool,
+    hasUnsavedChanges,
+    canSaveAutomation,
+    getToolName,
+    getToolDefaultParameters
+  };
+}

frontend/src/hooks/tools/automate/useSavedAutomations.ts

@@ -0,0 +1,55 @@
+import { useState, useEffect, useCallback } from 'react';
+import { AutomationConfig } from '../../../services/automationStorage';
+
+export interface SavedAutomation extends AutomationConfig {}
+
+export function useSavedAutomations() {
+  const [savedAutomations, setSavedAutomations] = useState<SavedAutomation[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<Error | null>(null);
+
+  const loadSavedAutomations = useCallback(async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const { automationStorage } = await import('../../../services/automationStorage');
+      const automations = await automationStorage.getAllAutomations();
+      setSavedAutomations(automations);
+    } catch (err) {
+      console.error('Error loading saved automations:', err);
+      setError(err as Error);
+      setSavedAutomations([]);
+    } finally {
+      setLoading(false);
+    }
+  }, []);
+
+  const refreshAutomations = useCallback(() => {
+    loadSavedAutomations();
+  }, [loadSavedAutomations]);
+
+  const deleteAutomation = useCallback(async (id: string) => {
+    try {
+      const { automationStorage } = await import('../../../services/automationStorage');
+      await automationStorage.deleteAutomation(id);
+      // Refresh the list after deletion
+      refreshAutomations();
+    } catch (err) {
+      console.error('Error deleting automation:', err);
+      throw err;
+    }
+  }, [refreshAutomations]);
+
+  // Load automations on mount
+  useEffect(() => {
+    loadSavedAutomations();
+  }, [loadSavedAutomations]);
+
+  return {
+    savedAutomations,
+    loading,
+    error,
+    refreshAutomations,
+    deleteAutomation
+  };
+}

frontend/src/hooks/tools/automate/useSuggestedAutomations.ts

@@ -0,0 +1,53 @@
+import { useMemo } from 'react';
+import { useTranslation } from 'react-i18next';
+import StarIcon from '@mui/icons-material/Star';
+import { SuggestedAutomation } from '../../../types/automation';
+
+export function useSuggestedAutomations(): SuggestedAutomation[] {
+  const { t } = useTranslation();
+
+  const suggestedAutomations = useMemo<SuggestedAutomation[]>(() => {
+    const now = new Date().toISOString();
+    return [
+      {
+        id: "compress-and-merge",
+        name: t("automation.suggested.compressAndMerge", "Compress & Merge"),
+        description: t("automation.suggested.compressAndMergeDesc", "Compress PDFs and merge them into one file"),
+        operations: [
+          { operation: "compress", parameters: {} },
+          { operation: "merge", parameters: {} }
+        ],
+        createdAt: now,
+        updatedAt: now,
+        icon: StarIcon,
+      },
+      {
+        id: "ocr-and-convert",
+        name: t("automation.suggested.ocrAndConvert", "OCR & Convert"),
+        description: t("automation.suggested.ocrAndConvertDesc", "Extract text via OCR and convert to different format"),
+        operations: [
+          { operation: "ocr", parameters: {} },
+          { operation: "convert", parameters: {} }
+        ],
+        createdAt: now,
+        updatedAt: now,
+        icon: StarIcon,
+      },
+      {
+        id: "secure-workflow",
+        name: t("automation.suggested.secureWorkflow", "Secure Workflow"),
+        description: t("automation.suggested.secureWorkflowDesc", "Sanitize, add password, and set permissions"),
+        operations: [
+          { operation: "sanitize", parameters: {} },
+          { operation: "addPassword", parameters: {} },
+          { operation: "changePermissions", parameters: {} }
+        ],
+        createdAt: now,
+        updatedAt: now,
+        icon: StarIcon,
+      },
+    ];
+  }, [t]);
+
+  return suggestedAutomations;
+}

frontend/src/hooks/tools/changePermissions/useChangePermissionsOperation.test.ts

@@ -25,7 +25,7 @@ import { ToolOperationConfig, ToolOperationHook, useToolOperation } from '../sha
 describe('useChangePermissionsOperation', () => {
   const mockUseToolOperation = vi.mocked(useToolOperation);
 
-  const getToolConfig = (): ToolOperationConfig<ChangePermissionsParameters> => mockUseToolOperation.mock.calls[0][0];
+  const getToolConfig = (): ToolOperationConfig<ChangePermissionsParameters> => mockUseToolOperation.mock.calls[0][0] as ToolOperationConfig<ChangePermissionsParameters>;
 
   const mockToolOperationReturn: ToolOperationHook<unknown> = {
     files: [],
@@ -109,7 +109,7 @@ describe('useChangePermissionsOperation', () => {
     { property: 'multiFileEndpoint' as const, expectedValue: false },
     { property: 'endpoint' as const, expectedValue: '/api/v1/security/add-password' },
     { property: 'filePrefix' as const, expectedValue: 'permissions_' },
-    { property: 'operationType' as const, expectedValue: 'changePermissions' }
+    { property: 'operationType' as const, expectedValue: 'change-permissions' }
   ])('should configure $property correctly', ({ property, expectedValue }) => {
     renderHook(() => useChangePermissionsOperation());
 

frontend/src/hooks/tools/changePermissions/useChangePermissionsOperation.ts

@@ -1,7 +1,7 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import type { ChangePermissionsParameters } from './useChangePermissionsParameters';
+import { ChangePermissionsParameters, defaultParameters } from './useChangePermissionsParameters';
 
 export const getFormData = ((parameters: ChangePermissionsParameters) =>
   Object.entries(parameters).map(([key, value]) =>
@@ -9,27 +9,34 @@ export const getFormData = ((parameters: ChangePermissionsParameters) =>
   ) as string[][]
 );
 
+// Static function that can be used by both the hook and automation executor
+export const buildChangePermissionsFormData = (parameters: ChangePermissionsParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+
+  // Add all permission parameters
+  getFormData(parameters).forEach(([key, value]) => {
+    formData.append(key, value);
+  });
+
+  return formData;
+};
+
+// Static configuration object
+export const changePermissionsOperationConfig = {
+  operationType: 'change-permissions',
+  endpoint: '/api/v1/security/add-password', // Change Permissions is a fake endpoint for the Add Password tool
+  buildFormData: buildChangePermissionsFormData,
+  filePrefix: 'permissions_',
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
+
 export const useChangePermissionsOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: ChangePermissionsParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-
-    // Add all permission parameters
-    getFormData(parameters).forEach(([key, value]) => {
-      formData.append(key, value);
-    });
-
-    return formData;
-  };
-
   return useToolOperation({
-    operationType: 'changePermissions',
-    endpoint: '/api/v1/security/add-password', // Change Permissions is a fake endpoint for the Add Password tool
-    buildFormData,
-    filePrefix: 'permissions_',
-    multiFileEndpoint: false,
+    ...changePermissionsOperationConfig,
     getErrorMessage: createStandardErrorHandler(
       t('changePermissions.error.failed', 'An error occurred while changing PDF permissions.')
     )

frontend/src/hooks/tools/compress/useCompressOperation.ts

@@ -1,9 +1,10 @@
 import { useTranslation } from 'react-i18next';
-import { useToolOperation } from '../shared/useToolOperation';
+import { useToolOperation, ToolOperationConfig } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { CompressParameters } from './useCompressParameters';
+import { CompressParameters, defaultParameters } from './useCompressParameters';
 
-const buildFormData = (parameters: CompressParameters, file: File): FormData => {
+// Static configuration that can be used by both the hook and automation executor
+export const buildCompressFormData = (parameters: CompressParameters, file: File): FormData => {
   const formData = new FormData();
   formData.append("fileInput", file);
 
@@ -21,15 +22,21 @@ const buildFormData = (parameters: CompressParameters, file: File): FormData =>
   return formData;
 };
 
+// Static configuration object
+export const compressOperationConfig = {
+  operationType: 'compress',
+  endpoint: '/api/v1/misc/compress-pdf',
+  buildFormData: buildCompressFormData,
+  filePrefix: 'compressed_',
+  multiFileEndpoint: false, // Individual API calls per file
+  defaultParameters,
+} as const;
+
 export const useCompressOperation = () => {
   const { t } = useTranslation();
 
   return useToolOperation<CompressParameters>({
-    operationType: 'compress',
-    endpoint: '/api/v1/misc/compress-pdf',
-    buildFormData,
-    filePrefix: 'compressed_',
-    multiFileEndpoint: false, // Individual API calls per file
+    ...compressOperationConfig,
     getErrorMessage: createStandardErrorHandler(t('compress.error.failed', 'An error occurred while compressing the PDF.'))
   });
 };

frontend/src/hooks/tools/compress/useCompressParameters.ts

@@ -10,7 +10,7 @@ export interface CompressParameters extends BaseParameters {
   fileSizeUnit: 'KB' | 'MB';
 }
 
-const defaultParameters: CompressParameters = {
+export const defaultParameters: CompressParameters = {
   compressionLevel: 5,
   grayscale: false,
   expectedSize: '',

frontend/src/hooks/tools/convert/useConvertOperation.ts

@@ -1,13 +1,14 @@
 import { useCallback } from 'react';
 import axios from 'axios';
 import { useTranslation } from 'react-i18next';
-import { ConvertParameters } from './useConvertParameters';
+import { ConvertParameters, defaultParameters } from './useConvertParameters';
 import { detectFileExtension } from '../../../utils/fileUtils';
 import { createFileFromApiResponse } from '../../../utils/fileResponseUtils';
 import { useToolOperation, ToolOperationConfig } from '../shared/useToolOperation';
 import { getEndpointUrl, isImageFormat, isWebFormat } from '../../../utils/convertUtils';
 
-const shouldProcessFilesSeparately = (
+// Static function that can be used by both the hook and automation executor
+export const shouldProcessFilesSeparately = (
   selectedFiles: File[],
   parameters: ConvertParameters
 ): boolean => {
@@ -29,7 +30,8 @@ const shouldProcessFilesSeparately = (
   );
 };
 
-const buildFormData = (parameters: ConvertParameters, selectedFiles: File[]): FormData => {
+// Static function that can be used by both the hook and automation executor
+export const buildConvertFormData = (parameters: ConvertParameters, selectedFiles: File[]): FormData => {
   const formData = new FormData();
 
   selectedFiles.forEach(file => {
@@ -69,7 +71,8 @@ const buildFormData = (parameters: ConvertParameters, selectedFiles: File[]): Fo
   return formData;
 };
 
-const createFileFromResponse = (
+// Static function that can be used by both the hook and automation executor
+export const createFileFromResponse = (
   responseData: any,
   headers: any,
   originalFileName: string,
@@ -81,6 +84,59 @@ const createFileFromResponse = (
   return createFileFromApiResponse(responseData, headers, fallbackFilename);
 };
 
+// Static processor that can be used by both the hook and automation executor
+export const convertProcessor = async (
+  parameters: ConvertParameters,
+  selectedFiles: File[]
+): Promise<File[]> => {
+  const processedFiles: File[] = [];
+  const endpoint = getEndpointUrl(parameters.fromExtension, parameters.toExtension);
+
+  if (!endpoint) {
+    throw new Error('Unsupported conversion format');
+  }
+
+  // Convert-specific routing logic: decide batch vs individual processing
+  if (shouldProcessFilesSeparately(selectedFiles, parameters)) {
+    // Individual processing for complex cases (PDF→image, smart detection, etc.)
+    for (const file of selectedFiles) {
+      try {
+        const formData = buildConvertFormData(parameters, [file]);
+        const response = await axios.post(endpoint, formData, { responseType: 'blob' });
+
+        const convertedFile = createFileFromResponse(response.data, response.headers, file.name, parameters.toExtension);
+
+        processedFiles.push(convertedFile);
+      } catch (error) {
+        console.warn(`Failed to convert file ${file.name}:`, error);
+      }
+    }
+  } else {
+    // Batch processing for simple cases (image→PDF combine)
+    const formData = buildConvertFormData(parameters, selectedFiles);
+    const response = await axios.post(endpoint, formData, { responseType: 'blob' });
+
+    const baseFilename = selectedFiles.length === 1
+      ? selectedFiles[0].name
+      : 'converted_files';
+
+    const convertedFile = createFileFromResponse(response.data, response.headers, baseFilename, parameters.toExtension);
+    processedFiles.push(convertedFile);
+  }
+
+  return processedFiles;
+};
+
+// Static configuration object
+export const convertOperationConfig = {
+  operationType: 'convert',
+  endpoint: '', // Not used with customProcessor but required
+  buildFormData: buildConvertFormData, // Not used with customProcessor but required
+  filePrefix: 'converted_',
+  customProcessor: convertProcessor,
+  defaultParameters,
+} as const;
+
 export const useConvertOperation = () => {
   const { t } = useTranslation();
 
@@ -88,52 +144,12 @@ export const useConvertOperation = () => {
     parameters: ConvertParameters,
     selectedFiles: File[]
   ): Promise<File[]> => {
-
-    const processedFiles: File[] = [];
-    const endpoint = getEndpointUrl(parameters.fromExtension, parameters.toExtension);
-
-    if (!endpoint) {
-      throw new Error(t('errorNotSupported', 'Unsupported conversion format'));
-    }
-
-    // Convert-specific routing logic: decide batch vs individual processing
-    if (shouldProcessFilesSeparately(selectedFiles, parameters)) {
-      // Individual processing for complex cases (PDF→image, smart detection, etc.)
-      for (const file of selectedFiles) {
-        try {
-          const formData = buildFormData(parameters, [file]);
-          const response = await axios.post(endpoint, formData, { responseType: 'blob' });
-
-          const convertedFile = createFileFromResponse(response.data, response.headers, file.name, parameters.toExtension);
-
-          processedFiles.push(convertedFile);
-        } catch (error) {
-          console.warn(`Failed to convert file ${file.name}:`, error);
-        }
-      }
-    } else {
-      // Batch processing for simple cases (image→PDF combine)
-      const formData = buildFormData(parameters, selectedFiles);
-      const response = await axios.post(endpoint, formData, { responseType: 'blob' });
-
-      const baseFilename = selectedFiles.length === 1
-        ? selectedFiles[0].name
-        : 'converted_files';
-
-      const convertedFile = createFileFromResponse(response.data, response.headers, baseFilename, parameters.toExtension);
-      processedFiles.push(convertedFile);
-
-    }
-
-    return processedFiles;
-  }, [t]);
+    return convertProcessor(parameters, selectedFiles);
+  }, []);
 
   return useToolOperation<ConvertParameters>({
-    operationType: 'convert',
-    endpoint: '', // Not used with customProcessor but required
-    buildFormData, // Not used with customProcessor but required
-    filePrefix: 'converted_',
-    customProcessor: customConvertProcessor, // Convert handles its own routing
+    ...convertOperationConfig,
+    customProcessor: customConvertProcessor, // Use instance-specific processor for translation support
     getErrorMessage: (error) => {
       if (error.response?.data && typeof error.response.data === 'string') {
         return error.response.data;

frontend/src/hooks/tools/convert/useConvertParameters.ts

@@ -8,7 +8,7 @@ import {
   type OutputOption,
   type FitOption
 } from '../../../constants/convertConstants';
-import { getEndpointName as getEndpointNameUtil, getEndpointUrl, isImageFormat, isWebFormat } from '../../../utils/convertUtils';
+import { getEndpointName as getEndpointNameUtil, getEndpointUrl, isImageFormat, isWebFormat, getAvailableToExtensions as getAvailableToExtensionsUtil } from '../../../utils/convertUtils';
 import { detectFileExtension as detectFileExtensionUtil } from '../../../utils/fileUtils';
 import { BaseParameters } from '../../../types/parameters';
 import { useBaseParameters, BaseParametersHook } from '../shared/useBaseParameters';
@@ -47,7 +47,7 @@ export interface ConvertParametersHook extends BaseParametersHook<ConvertParamet
   analyzeFileTypes: (files: Array<{name: string}>) => void;
 }
 
-const defaultParameters: ConvertParameters = {
+export const defaultParameters: ConvertParameters = {
   fromExtension: '',
   toExtension: '',
   imageOptions: {
@@ -155,30 +155,7 @@ export const useConvertParameters = (): ConvertParametersHook => {
     return getEndpointUrl(fromExtension, toExtension);
   };
 
-  const getAvailableToExtensions = (fromExtension: string) => {
-    if (!fromExtension) return [];
-
-    // Handle dynamic format identifiers (file-<extension>)
-    if (fromExtension.startsWith('file-')) {
-      // Dynamic format - use 'any' conversion options (file-to-pdf)
-      const supportedExtensions = CONVERSION_MATRIX['any'] || [];
-      return TO_FORMAT_OPTIONS.filter(option =>
-        supportedExtensions.includes(option.value)
-      );
-    }
-
-    let supportedExtensions = CONVERSION_MATRIX[fromExtension] || [];
-
-    // If no explicit conversion exists, but file-to-pdf might be available,
-    // fall back to 'any' conversion (which converts unknown files to PDF via file-to-pdf)
-    if (supportedExtensions.length === 0 && fromExtension !== 'any') {
-      supportedExtensions = CONVERSION_MATRIX['any'] || [];
-    }
-
-    return TO_FORMAT_OPTIONS.filter(option =>
-      supportedExtensions.includes(option.value)
-    );
-  };
+  const getAvailableToExtensions = getAvailableToExtensionsUtil;
 
 
   const analyzeFileTypes = useCallback((files: Array<{name: string}>) => {

frontend/src/hooks/tools/ocr/useOCROperation.ts

@@ -1,6 +1,6 @@
 import { useCallback } from 'react';
 import { useTranslation } from 'react-i18next';
-import { OCRParameters } from './useOCRParameters';
+import { OCRParameters, defaultParameters } from './useOCRParameters';
 import { useToolOperation, ToolOperationConfig } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
 import { useToolResources } from '../shared/useToolResources';
@@ -37,7 +37,8 @@ function stripExt(name: string): string {
   return i > 0 ? name.slice(0, i) : name;
 }
 
-const buildFormData = (parameters: OCRParameters, file: File): FormData => {
+// Static function that can be used by both the hook and automation executor
+export const buildOCRFormData = (parameters: OCRParameters, file: File): FormData => {
   const formData = new FormData();
   formData.append('fileInput', file);
   parameters.languages.forEach((lang) => formData.append('languages', lang));
@@ -51,57 +52,70 @@ const buildFormData = (parameters: OCRParameters, file: File): FormData => {
   return formData;
 };
 
+// Static response handler for OCR - can be used by automation executor  
+export const ocrResponseHandler = async (blob: Blob, originalFiles: File[], extractZipFiles: (blob: Blob) => Promise<File[]>): Promise<File[]> => {
+  const headBuf = await blob.slice(0, 8).arrayBuffer();
+  const head = new TextDecoder().decode(new Uint8Array(headBuf));
+
+  // ZIP: sidecar or multi-asset output
+  if (head.startsWith('PK')) {
+    const base = stripExt(originalFiles[0].name);
+    try {
+      const extractedFiles = await extractZipFiles(blob);
+      if (extractedFiles.length > 0) return extractedFiles;
+    } catch { /* ignore and try local extractor */ }
+    try {
+      const local = await extractZipFile(blob); // local fallback
+      if (local.length > 0) return local;
+    } catch { /* fall through */ }
+    return [new File([blob], `ocr_${base}.zip`, { type: 'application/zip' })];
+  }
+
+  // Not a PDF: surface error details if present
+  if (!head.startsWith('%PDF')) {
+    const textBuf = await blob.slice(0, 1024).arrayBuffer();
+    const text = new TextDecoder().decode(new Uint8Array(textBuf));
+    if (/error|exception|html/i.test(text)) {
+      if (text.includes('OCR tools') && text.includes('not installed')) {
+        throw new Error('OCR tools (OCRmyPDF or Tesseract) are not installed on the server. Use the standard or fat Docker image instead of ultra-lite, or install OCR tools manually.');
+      }
+      const title =
+        text.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1] ||
+        text.match(/<h1[^>]*>([^<]+)<\/h1>/i)?.[1] ||
+        'Unknown error';
+      throw new Error(`OCR service error: ${title}`);
+    }
+    throw new Error(`Response is not a valid PDF. Header: "${head}"`);
+  }
+
+  const base = stripExt(originalFiles[0].name);
+  return [new File([blob], `ocr_${base}.pdf`, { type: 'application/pdf' })];
+};
+
+// Static configuration object (without t function dependencies)
+export const ocrOperationConfig = {
+  operationType: 'ocr',
+  endpoint: '/api/v1/misc/ocr-pdf',
+  buildFormData: buildOCRFormData,
+  filePrefix: 'ocr_',
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
+
 export const useOCROperation = () => {
   const { t } = useTranslation();
   const { extractZipFiles } = useToolResources();
 
   // OCR-specific parsing: ZIP (sidecar) vs PDF vs HTML error
   const responseHandler = useCallback(async (blob: Blob, originalFiles: File[]): Promise<File[]> => {
-    const headBuf = await blob.slice(0, 8).arrayBuffer();
-    const head = new TextDecoder().decode(new Uint8Array(headBuf));
-
-    // ZIP: sidecar or multi-asset output
-    if (head.startsWith('PK')) {
-      const base = stripExt(originalFiles[0].name);
-      try {
-        const extracted = await extractZipFiles(blob);
-        if (extracted.length > 0) return extracted;
-      } catch { /* ignore and try local extractor */ }
-      try {
-        const local = await extractZipFile(blob); // local fallback
-        if (local.length > 0) return local;
-      } catch { /* fall through */ }
-      return [new File([blob], `ocr_${base}.zip`, { type: 'application/zip' })];
-    }
-
-    // Not a PDF: surface error details if present
-    if (!head.startsWith('%PDF')) {
-      const textBuf = await blob.slice(0, 1024).arrayBuffer();
-      const text = new TextDecoder().decode(new Uint8Array(textBuf));
-      if (/error|exception|html/i.test(text)) {
-        if (text.includes('OCR tools') && text.includes('not installed')) {
-          throw new Error('OCR tools (OCRmyPDF or Tesseract) are not installed on the server. Use the standard or fat Docker image instead of ultra-lite, or install OCR tools manually.');
-        }
-        const title =
-          text.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1] ||
-          text.match(/<h1[^>]*>([^<]+)<\/h1>/i)?.[1] ||
-          t('ocr.error.unknown', 'Unknown error');
-        throw new Error(`OCR service error: ${title}`);
-      }
-      throw new Error(`Response is not a valid PDF. Header: "${head}"`);
-    }
-
-    const base = stripExt(originalFiles[0].name);
-    return [new File([blob], `ocr_${base}.pdf`, { type: 'application/pdf' })];
-  }, [t, extractZipFiles]);
+    // extractZipFiles from useToolResources already returns File[] directly
+    const simpleExtractZipFiles = extractZipFiles;
+    return ocrResponseHandler(blob, originalFiles, simpleExtractZipFiles);
+  }, [extractZipFiles]);
 
   const ocrConfig: ToolOperationConfig<OCRParameters> = {
-    operationType: 'ocr',
-    endpoint: '/api/v1/misc/ocr-pdf',
-    buildFormData,
-    filePrefix: 'ocr_',
-    multiFileEndpoint: false, // Process files individually
-    responseHandler, // use shared flow
+    ...ocrOperationConfig,
+    responseHandler,
     getErrorMessage: (error) =>
       error.message?.includes('OCR tools') && error.message?.includes('not installed')
         ? 'OCR tools (OCRmyPDF or Tesseract) are not installed on the server. Use the standard or fat Docker image instead of ultra-lite, or install OCR tools manually.'

frontend/src/hooks/tools/ocr/useOCRParameters.ts

@@ -10,7 +10,7 @@ export interface OCRParameters extends BaseParameters {
 
 export type OCRParametersHook = BaseParametersHook<OCRParameters>;
 
-const defaultParameters: OCRParameters = {
+export const defaultParameters: OCRParameters = {
   languages: [],
   ocrType: 'skip-text',
   ocrRenderType: 'hocr',

frontend/src/hooks/tools/removeCertificateSign/useRemoveCertificateSignOperation.ts

@@ -1,23 +1,31 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { RemoveCertificateSignParameters } from './useRemoveCertificateSignParameters';
+import { RemoveCertificateSignParameters, defaultParameters } from './useRemoveCertificateSignParameters';
+
+// Static function that can be used by both the hook and automation executor
+export const buildRemoveCertificateSignFormData = (parameters: RemoveCertificateSignParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  return formData;
+};
+
+// Static configuration object
+export const removeCertificateSignOperationConfig = {
+  operationType: 'remove-certificate-sign',
+  endpoint: '/api/v1/security/remove-cert-sign',
+  buildFormData: buildRemoveCertificateSignFormData,
+  filePrefix: 'unsigned_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
 
 export const useRemoveCertificateSignOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: RemoveCertificateSignParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    return formData;
-  };
-
   return useToolOperation<RemoveCertificateSignParameters>({
-    operationType: 'removeCertificateSign',
-    endpoint: '/api/v1/security/remove-cert-sign',
-    buildFormData,
+    ...removeCertificateSignOperationConfig,
     filePrefix: t('removeCertSign.filenamePrefix', 'unsigned') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('removeCertSign.error.failed', 'An error occurred while removing certificate signatures.'))
   });
 };

frontend/src/hooks/tools/removePassword/useRemovePasswordOperation.test.ts

@@ -25,7 +25,7 @@ import { ToolOperationConfig, ToolOperationHook, useToolOperation } from '../sha
 describe('useRemovePasswordOperation', () => {
   const mockUseToolOperation = vi.mocked(useToolOperation);
 
-  const getToolConfig = (): ToolOperationConfig<RemovePasswordParameters> => mockUseToolOperation.mock.calls[0][0];
+  const getToolConfig = (): ToolOperationConfig<RemovePasswordParameters> => mockUseToolOperation.mock.calls[0][0] as ToolOperationConfig<RemovePasswordParameters>;
 
   const mockToolOperationReturn: ToolOperationHook<unknown> = {
     files: [],

frontend/src/hooks/tools/removePassword/useRemovePasswordOperation.ts

@@ -1,24 +1,32 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { RemovePasswordParameters } from './useRemovePasswordParameters';
+import { RemovePasswordParameters, defaultParameters } from './useRemovePasswordParameters';
+
+// Static function that can be used by both the hook and automation executor
+export const buildRemovePasswordFormData = (parameters: RemovePasswordParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  formData.append("password", parameters.password);
+  return formData;
+};
+
+// Static configuration object
+export const removePasswordOperationConfig = {
+  operationType: 'removePassword',
+  endpoint: '/api/v1/security/remove-password',
+  buildFormData: buildRemovePasswordFormData,
+  filePrefix: 'decrypted_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
 
 export const useRemovePasswordOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: RemovePasswordParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    formData.append("password", parameters.password);
-    return formData;
-  };
-
   return useToolOperation<RemovePasswordParameters>({
-    operationType: 'removePassword',
-    endpoint: '/api/v1/security/remove-password',
-    buildFormData,
+    ...removePasswordOperationConfig,
     filePrefix: t('removePassword.filenamePrefix', 'decrypted') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('removePassword.error.failed', 'An error occurred while removing the password from the PDF.'))
   });
 };

frontend/src/hooks/tools/repair/useRepairOperation.ts

@@ -1,23 +1,31 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { RepairParameters } from './useRepairParameters';
+import { RepairParameters, defaultParameters } from './useRepairParameters';
+
+// Static function that can be used by both the hook and automation executor
+export const buildRepairFormData = (parameters: RepairParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  return formData;
+};
+
+// Static configuration object
+export const repairOperationConfig = {
+  operationType: 'repair',
+  endpoint: '/api/v1/misc/repair',
+  buildFormData: buildRepairFormData,
+  filePrefix: 'repaired_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
 
 export const useRepairOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: RepairParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    return formData;
-  };
-
   return useToolOperation<RepairParameters>({
-    operationType: 'repair',
-    endpoint: '/api/v1/misc/repair',
-    buildFormData,
+    ...repairOperationConfig,
     filePrefix: t('repair.filenamePrefix', 'repaired') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('repair.error.failed', 'An error occurred while repairing the PDF.'))
   });
 };

frontend/src/hooks/tools/sanitize/useSanitizeOperation.ts

@@ -1,9 +1,10 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { SanitizeParameters } from './useSanitizeParameters';
+import { SanitizeParameters, defaultParameters } from './useSanitizeParameters';
 
-const buildFormData = (parameters: SanitizeParameters, file: File): FormData => {
+// Static function that can be used by both the hook and automation executor
+export const buildSanitizeFormData = (parameters: SanitizeParameters, file: File): FormData => {
   const formData = new FormData();
   formData.append('fileInput', file);
 
@@ -18,15 +19,22 @@ const buildFormData = (parameters: SanitizeParameters, file: File): FormData =>
   return formData;
 };
 
+// Static configuration object
+export const sanitizeOperationConfig = {
+  operationType: 'sanitize',
+  endpoint: '/api/v1/security/sanitize-pdf',
+  buildFormData: buildSanitizeFormData,
+  filePrefix: 'sanitized_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
+
 export const useSanitizeOperation = () => {
   const { t } = useTranslation();
 
   return useToolOperation<SanitizeParameters>({
-    operationType: 'sanitize',
-    endpoint: '/api/v1/security/sanitize-pdf',
-    buildFormData,
+    ...sanitizeOperationConfig,
     filePrefix: t('sanitize.filenamePrefix', 'sanitized') + '_',
-    multiFileEndpoint: false, // Individual API calls per file
     getErrorMessage: createStandardErrorHandler(t('sanitize.error.failed', 'An error occurred while sanitising the PDF.'))
   });
 };

frontend/src/hooks/tools/shared/useToolOperation.ts

@@ -61,6 +61,9 @@ export interface ToolOperationConfig<TParams = void> {
 
   /** Extract user-friendly error messages from API errors */
   getErrorMessage?: (error: any) => string;
+
+  /** Default parameter values for automation */
+  defaultParameters?: TParams;
 }
 
 /**

frontend/src/hooks/tools/singleLargePage/useSingleLargePageOperation.ts

@@ -1,23 +1,31 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { SingleLargePageParameters } from './useSingleLargePageParameters';
+import { SingleLargePageParameters, defaultParameters } from './useSingleLargePageParameters';
+
+// Static function that can be used by both the hook and automation executor
+export const buildSingleLargePageFormData = (parameters: SingleLargePageParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  return formData;
+};
+
+// Static configuration object
+export const singleLargePageOperationConfig = {
+  operationType: 'single-large-page',
+  endpoint: '/api/v1/general/pdf-to-single-page',
+  buildFormData: buildSingleLargePageFormData,
+  filePrefix: 'single_page_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
 
 export const useSingleLargePageOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: SingleLargePageParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    return formData;
-  };
-
   return useToolOperation<SingleLargePageParameters>({
-    operationType: 'singleLargePage',
-    endpoint: '/api/v1/general/pdf-to-single-page',
-    buildFormData,
+    ...singleLargePageOperationConfig,
     filePrefix: t('pdfToSinglePage.filenamePrefix', 'single_page') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('pdfToSinglePage.error.failed', 'An error occurred while converting to single page.'))
   });
 };

frontend/src/hooks/tools/split/useSplitOperation.ts

@@ -1,11 +1,11 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { SplitParameters } from './useSplitParameters';
+import { SplitParameters, defaultParameters } from './useSplitParameters';
 import { SPLIT_MODES } from '../../../constants/splitConstants';
 
-
-const buildFormData = (parameters: SplitParameters, selectedFiles: File[]): FormData => {
+// Static functions that can be used by both the hook and automation executor
+export const buildSplitFormData = (parameters: SplitParameters, selectedFiles: File[]): FormData => {
   const formData = new FormData();
 
   selectedFiles.forEach(file => {
@@ -40,7 +40,7 @@ const buildFormData = (parameters: SplitParameters, selectedFiles: File[]): Form
   return formData;
 };
 
-const getEndpoint = (parameters: SplitParameters): string => {
+export const getSplitEndpoint = (parameters: SplitParameters): string => {
   switch (parameters.mode) {
     case SPLIT_MODES.BY_PAGES:
       return "/api/v1/general/split-pages";
@@ -55,15 +55,21 @@ const getEndpoint = (parameters: SplitParameters): string => {
   }
 };
 
+// Static configuration object
+export const splitOperationConfig = {
+  operationType: 'splitPdf',
+  endpoint: getSplitEndpoint,
+  buildFormData: buildSplitFormData,
+  filePrefix: 'split_',
+  multiFileEndpoint: true, // Single API call with all files
+  defaultParameters,
+} as const;
+
 export const useSplitOperation = () => {
   const { t } = useTranslation();
 
   return useToolOperation<SplitParameters>({
-    operationType: 'split',
-    endpoint: (params) => getEndpoint(params),
-    buildFormData: buildFormData, // Multi-file signature: (params, selectedFiles) => FormData
-    filePrefix: 'split_',
-    multiFileEndpoint: true, // Single API call with all files
+    ...splitOperationConfig,
     getErrorMessage: createStandardErrorHandler(t('split.error.failed', 'An error occurred while splitting the PDF.'))
   });
 };

frontend/src/hooks/tools/split/useSplitParameters.ts

@@ -17,7 +17,7 @@ export interface SplitParameters extends BaseParameters {
 
 export type SplitParametersHook = BaseParametersHook<SplitParameters>;
 
-const defaultParameters: SplitParameters = {
+export const defaultParameters: SplitParameters = {
   mode: '',
   pages: '',
   hDiv: '2',

frontend/src/hooks/tools/unlockPdfForms/useUnlockPdfFormsOperation.ts

@@ -1,23 +1,31 @@
 import { useTranslation } from 'react-i18next';
 import { useToolOperation } from '../shared/useToolOperation';
 import { createStandardErrorHandler } from '../../../utils/toolErrorHandler';
-import { UnlockPdfFormsParameters } from './useUnlockPdfFormsParameters';
+import { UnlockPdfFormsParameters, defaultParameters } from './useUnlockPdfFormsParameters';
+
+// Static function that can be used by both the hook and automation executor
+export const buildUnlockPdfFormsFormData = (parameters: UnlockPdfFormsParameters, file: File): FormData => {
+  const formData = new FormData();
+  formData.append("fileInput", file);
+  return formData;
+};
+
+// Static configuration object
+export const unlockPdfFormsOperationConfig = {
+  operationType: 'unlock-pdf-forms',
+  endpoint: '/api/v1/misc/unlock-pdf-forms',
+  buildFormData: buildUnlockPdfFormsFormData,
+  filePrefix: 'unlocked_forms_', // Will be overridden in hook with translation
+  multiFileEndpoint: false,
+  defaultParameters,
+} as const;
 
 export const useUnlockPdfFormsOperation = () => {
   const { t } = useTranslation();
 
-  const buildFormData = (parameters: UnlockPdfFormsParameters, file: File): FormData => {
-    const formData = new FormData();
-    formData.append("fileInput", file);
-    return formData;
-  };
-
   return useToolOperation<UnlockPdfFormsParameters>({
-    operationType: 'unlockPdfForms',
-    endpoint: '/api/v1/misc/unlock-pdf-forms',
-    buildFormData,
+    ...unlockPdfFormsOperationConfig,
     filePrefix: t('unlockPDFForms.filenamePrefix', 'unlocked_forms') + '_',
-    multiFileEndpoint: false,
     getErrorMessage: createStandardErrorHandler(t('unlockPDFForms.error.failed', 'An error occurred while unlocking PDF forms.'))
   });
 };

frontend/src/hooks/useSuggestedTools.ts

@@ -1,5 +1,5 @@
 import { useMemo } from 'react';
-import { useToolWorkflow } from '../contexts/ToolWorkflowContext';
+import { useNavigationActions, useNavigationState } from '../contexts/NavigationContext';
 
 // Material UI Icons
 import CompressIcon from '@mui/icons-material/Compress';
@@ -44,7 +44,8 @@ const ALL_SUGGESTED_TOOLS: Omit<SuggestedTool, 'navigate'>[] = [
 ];
 
 export function useSuggestedTools(): SuggestedTool[] {
-  const { handleToolSelect, selectedToolKey } = useToolWorkflow();
+  const { actions } = useNavigationActions();
+  const { selectedToolKey } = useNavigationState();
 
   return useMemo(() => {
     // Filter out the current tool
@@ -53,7 +54,7 @@ export function useSuggestedTools(): SuggestedTool[] {
     // Add navigation function to each tool
     return filteredTools.map(tool => ({
       ...tool,
-      navigate: () => handleToolSelect(tool.id)
+      navigate: () => actions.handleToolSelect(tool.id)
     }));
-  }, [selectedToolKey, handleToolSelect]);
+  }, [selectedToolKey, actions]);
 }

frontend/src/hooks/useToolManagement.tsx

@@ -5,19 +5,16 @@ import { getAllEndpoints, type ToolRegistryEntry } from "../data/toolsTaxonomy";
 import { useMultipleEndpointsEnabled } from "./useEndpointConfig";
 
 interface ToolManagementResult {
-  selectedToolKey: string | null;
   selectedTool: ToolRegistryEntry | null;
   toolSelectedFileIds: string[];
   toolRegistry: Record<string, ToolRegistryEntry>;
-  selectTool: (toolKey: string) => void;
-  clearToolSelection: () => void;
   setToolSelectedFileIds: (fileIds: string[]) => void;
+  getSelectedTool: (toolKey: string | null) => ToolRegistryEntry | null;
 }
 
 export const useToolManagement = (): ToolManagementResult => {
   const { t } = useTranslation();
 
-  const [selectedToolKey, setSelectedToolKey] = useState<string /* FIX ME: Should be ToolId */ | null>(null);
   const [toolSelectedFileIds, setToolSelectedFileIds] = useState<string[]>([]);
 
   // Build endpoints list from registry entries with fallback to legacy mapping
@@ -56,35 +53,15 @@ export const useToolManagement = (): ToolManagementResult => {
     return availableToolRegistry;
   }, [isToolAvailable, t, baseRegistry]);
 
-  useEffect(() => {
-    if (!endpointsLoading && selectedToolKey && !toolRegistry[selectedToolKey]) {
-      const firstAvailableTool = Object.keys(toolRegistry)[0];
-      if (firstAvailableTool) {
-        setSelectedToolKey(firstAvailableTool);
-      } else {
-        setSelectedToolKey(null);
-      }
-    }
-  }, [endpointsLoading, selectedToolKey, toolRegistry]);
-
-  const selectTool = useCallback((toolKey: string) => {
-    setSelectedToolKey(toolKey);
-  }, []);
-
-  const clearToolSelection = useCallback(() => {
-    setSelectedToolKey(null);
-  }, []);
-
-  const selectedTool = selectedToolKey ? toolRegistry[selectedToolKey] : null;
+  const getSelectedTool = useCallback((toolKey: string | null): ToolRegistryEntry | null => {
+    return toolKey ? toolRegistry[toolKey] || null : null;
+  }, [toolRegistry]);
 
   return {
-    selectedToolKey,
-    selectedTool,
+    selectedTool: getSelectedTool(null), // This will be unused, kept for compatibility
     toolSelectedFileIds,
     toolRegistry,
-    selectTool,
-    clearToolSelection,
     setToolSelectedFileIds,
-
+    getSelectedTool,
   };
 };

frontend/src/hooks/useUrlSync.ts

@@ -3,7 +3,7 @@
  */
 
 import { useEffect, useCallback } from 'react';
-import { ModeType } from '../contexts/NavigationContext';
+import { ModeType } from '../types/navigation';
 import { parseToolRoute, updateToolRoute, clearToolRoute } from '../utils/urlRouting';
 
 /**