@aj-archipelago/cortex 1.3.55 → 1.3.57

package/server/modelExecutor.js

@@ -29,6 +29,10 @@ import ReplicateApiPlugin from './plugins/replicateApiPlugin.js';
 import AzureVideoTranslatePlugin from './plugins/azureVideoTranslatePlugin.js';
 import OllamaChatPlugin from './plugins/ollamaChatPlugin.js';
 import OllamaCompletionPlugin from './plugins/ollamaCompletionPlugin.js';
+import ApptekTranslatePlugin from './plugins/apptekTranslatePlugin.js';
+import GoogleTranslatePlugin from './plugins/googleTranslatePlugin.js';
+import GroqChatPlugin from './plugins/groqChatPlugin.js';
+import VeoVideoPlugin from './plugins/veoVideoPlugin.js';
 
 class ModelExecutor {
     constructor(pathway, model) {
@@ -117,6 +121,18 @@ class ModelExecutor {
             case 'OLLAMA-COMPLETION':
                 plugin = new OllamaCompletionPlugin(pathway, model);
                 break;
+            case 'APPTEK-TRANSLATE':
+                plugin = new ApptekTranslatePlugin(pathway, model);
+                break;
+            case 'GOOGLE-TRANSLATE':
+                plugin = new GoogleTranslatePlugin(pathway, model);
+                break;
+            case 'GROQ-CHAT':
+                plugin = new GroqChatPlugin(pathway, model);
+                break;
+            case 'VEO-VIDEO':
+                plugin = new VeoVideoPlugin(pathway, model);
+                break;
             default:
                 throw new Error(`Unsupported model type: ${model.type}`);
         }

package/server/plugins/apptekTranslatePlugin.js

@@ -0,0 +1,189 @@
+// ApptekTranslatePlugin.js
+import ModelPlugin from './modelPlugin.js';
+import logger from '../../lib/logger.js';
+const { callPathway } = await import('../../lib/pathwayTools.js');
+                
+
+class ApptekTranslatePlugin extends ModelPlugin {
+    constructor(pathway, model) {
+        super(pathway, model);
+        
+        // Get API configuration from environment variables through the base class
+        const apiEndpoint = this.environmentVariables.APPTEK_API_ENDPOINT;
+        const apiKey = this.environmentVariables.APPTEK_API_KEY;
+        
+        if (!apiEndpoint || !apiKey) {
+            throw new Error('AppTek API configuration missing. Please check APPTEK_API_ENDPOINT and APPTEK_API_KEY environment variables.');
+        }
+
+        this.apiEndpoint = apiEndpoint;
+        this.apiKey = apiKey;
+    }
+
+    // Set up parameters specific to the AppTek Translate API
+    getRequestParameters(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+        
+        // For AppTek, we don't need to wrap the text in an object since it expects raw text
+        return {
+            data: modelPromptText,
+            params: {
+                from: combinedParameters.from || 'auto',
+                to: combinedParameters.to,
+                glossaryId: combinedParameters.glossaryId || 'none'
+            }
+        };
+    }
+
+    // Execute the request to the AppTek Translate API
+    async execute(text, parameters, prompt, cortexRequest) {
+        try {
+            const requestParameters = this.getRequestParameters(text, parameters, prompt);
+            const { from = 'auto', to } = requestParameters.params;
+
+            let sourceLanguage = from;
+
+            // If source language is 'auto', detect it
+            if (from === 'auto') {
+                // Assuming requestParameters.data contains the text for language detection (usually same as 'text')
+                const detectedLang = await this.detectLanguage(requestParameters.data);
+                if (detectedLang) {
+                    sourceLanguage = detectedLang;
+                    requestParameters.params.from = detectedLang; // Update for subsequent use
+                } else {
+                    const warnMsg = `ApptekTranslatePlugin: Language detection for 'auto' did not return a language. Proceeding with 'auto' or default.`;
+                    logger.warn(warnMsg)
+                    // sourceLanguage remains 'auto'. The comparison 'auto' === to will likely be false.
+                }
+            }
+            // At this point, sourceLanguage is either the initially provided 'from' language,
+            // or the detected language if 'from' was 'auto' and detection was successful.
+            // requestParameters.params.from is also updated if detection occurred.
+
+            // Check if source and target languages are the same
+            // Ensure 'to' is a valid language string, not empty or null.
+            if (to && sourceLanguage && sourceLanguage !== 'auto' && sourceLanguage === to) {
+                const logMessage = `ApptekTranslatePlugin: Source language (${sourceLanguage}) matches target language (${to}). Skipping translation.`;
+                logger.verbose(logMessage)
+                // Return the original text. Ensure the return format matches what `this.executeRequest`
+                // would return for a successful translation (e.g., string or object).
+                // Assuming it's a string based on typical translation plugin behavior.
+                return text;
+            }
+
+            // Construct the URL with the (potentially detected) source language and target language
+            const langPair = `${requestParameters.params.from}-${to}`; // requestParameters.params.from is correctly set
+            cortexRequest.url = `${this.apiEndpoint}/api/v2/quicktranslate/${langPair}`;
+            cortexRequest.data = requestParameters.data; 
+            cortexRequest.method = 'POST';
+            cortexRequest.headers = {
+                'x-token': this.apiKey,
+                'Accept': 'application/json',
+                'Content-Type': 'text/plain'
+            };
+            
+            // Add glossary_id parameter if it's provided and not 'none'
+            if (requestParameters.params.glossaryId && requestParameters.params.glossaryId !== 'none') {
+                const url = new URL(cortexRequest.url);
+                url.searchParams.append('glossary_id', requestParameters.params.glossaryId);
+                cortexRequest.url = url.toString();
+                
+                const glossaryLogMessage = `ApptekTranslatePlugin: Using glossary ID: ${requestParameters.params.glossaryId}`;
+                logger.verbose(glossaryLogMessage)
+            }
+
+            return this.executeRequest(cortexRequest);
+        } catch (error) {
+            // If AppTek translation fails, use Groq as a fallback
+            logger.warn(`AppTek translation failed: ${error.message}. Falling back to Groq translate.`);
+            
+            try {
+                // Import the callPathway function if it hasn't been imported at the top
+                const { callPathway } = await import('../../lib/pathwayTools.js');
+                
+                // Call the Groq translate pathway as a fallback
+                const result = await callPathway('translate_groq', { 
+                    text, 
+                    to: parameters.to || this.promptParameters.to,
+                });
+                
+                logger.verbose('Successfully used Groq translate as fallback');
+                return result;
+            } catch (fallbackError) {
+                // If even the fallback fails, log it and rethrow the original error
+                logger.error(`Groq translate fallback also failed: ${fallbackError.message}`);
+                throw fallbackError;
+            }
+        }
+    }
+
+    // Detect language using AppTek's language detection API
+    async detectLanguage(text) {
+        try {
+            // Make language detection request
+            const resultResponse = await fetch(`${this.apiEndpoint}/api/v2/quick_lid`, {
+                method: 'POST',
+                headers: {
+                    'x-token': this.apiKey,
+                    'Accept': 'application/json',
+                    'Content-Type': 'text/plain'
+                },
+                body: text
+            });
+
+            let detectedLanguage = null;
+
+
+            if (resultResponse.status === 200) {
+                const result = await resultResponse.text();
+                detectedLanguage = result.split('\n')[0].split(';')[0];
+            }else {
+                logger.error(`Apptek Language detection failed with status: ${resultResponse.status}`);
+                logger.debug({error: resultResponse, text})
+            }
+
+            if (!detectedLanguage) {
+               throw new Error('Language detection failed');
+            }
+
+            return detectedLanguage;
+
+        } catch (error) {
+            try {
+                // Call the language pathway as a fallback
+                const detectedLanguage = await callPathway('language', { 
+                    text,
+                });
+                
+                logger.verbose('Successfully used language pathway as fallback', {detectedLanguage});
+                if (!detectedLanguage) {
+                    throw new Error('Language detection failed using fallback language pathway');
+                }
+                return detectedLanguage;
+            } catch (fallbackError) {
+                // If even the fallback fails, log it and rethrow the original error
+                logger.error(`Language pathway fallback also failed: ${fallbackError.message}`);
+                throw fallbackError;
+            }
+        }
+    }
+
+    // Parse the response from the AppTek Translate API
+    parseResponse(data) {
+        // AppTek returns the translated text directly
+        return data.trim();
+    }
+
+    // Override the logging function to display the request and response
+    logRequestData(data, responseData, prompt) {
+        logger.verbose(`Input: ${data}`);
+        logger.verbose(`Output: ${this.parseResponse(responseData)}`);
+
+        if (prompt?.debugInfo) {
+            prompt.debugInfo += `\nInput: ${data}\nOutput: ${responseData}`;
+        }
+    }
+}
+
+export default ApptekTranslatePlugin;

package/server/plugins/googleTranslatePlugin.js

@@ -0,0 +1,121 @@
+// GoogleTranslatePlugin.js
+import ModelPlugin from './modelPlugin.js';
+import logger from '../../lib/logger.js';
+
+class GoogleTranslatePlugin extends ModelPlugin {
+    constructor(pathway, model) {
+        super(pathway, model);
+        
+        // Get API configuration from environment variables through the base class
+        const projectId = this.environmentVariables.GOOGLE_CLOUD_PROJECT_ID;
+        const apiKey = this.environmentVariables.GOOGLE_CLOUD_API_KEY;
+        
+        if (!projectId && !apiKey) {
+            throw new Error('Google Cloud Translation API configuration missing. Please check GOOGLE_CLOUD_PROJECT_ID or GOOGLE_CLOUD_API_KEY environment variables.');
+        }
+
+        this.projectId = projectId;
+        this.apiKey = apiKey;
+        this.location = this.environmentVariables.GOOGLE_CLOUD_LOCATION || 'global';
+    }
+
+    // Set up parameters specific to the Google Translate API
+    getRequestParameters(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+
+        
+        const requestParameters = {
+            data: {
+                q: [modelPromptText],
+                target: combinedParameters.to
+            },
+            params: {}
+        };
+
+        // Add source language if provided and not 'auto'
+        if (combinedParameters.from && combinedParameters.from !== 'auto') {
+            requestParameters.data.source = combinedParameters.from;
+        }
+
+        // Configure API version - v2 is simpler for basic translation
+        if (this.apiKey) {
+            // Using API key authentication (v2 API)
+            requestParameters.params.key = this.apiKey;
+        } else {
+            // Using OAuth with project ID (v3 API)
+            requestParameters.data.parent = `projects/${this.projectId}/locations/${this.location}`;
+        }
+
+        return requestParameters;
+    }
+
+    // Execute the request to the Google Translate API
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+        
+        // Configure the API version based on authentication method
+        if (this.apiKey) {
+            // Using API key authentication (v2 API)
+            cortexRequest.url = 'https://translation.googleapis.com/language/translate/v2';
+            cortexRequest.method = 'POST';
+            cortexRequest.data = requestParameters.data;
+            cortexRequest.params = requestParameters.params;
+            cortexRequest.headers = {
+                'Content-Type': 'application/json'
+            };
+        } else {
+            // Using OAuth with project ID (v3 API)
+            cortexRequest.url = `https://translation.googleapis.com/v3/projects/${this.projectId}/locations/${this.location}:translateText`;
+            cortexRequest.method = 'POST';
+            cortexRequest.data = {
+                contents: requestParameters.data.q,
+                targetLanguageCode: requestParameters.data.target,
+                sourceLanguageCode: requestParameters.data.source,
+                mimeType: 'text/plain',
+            };
+            cortexRequest.headers = {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${await this.getAccessToken()}`
+            };
+        }
+
+        return this.executeRequest(cortexRequest);
+    }
+    
+    // Get access token for OAuth authentication
+    async getAccessToken() {
+        // This would be implemented if using OAuth authentication
+        // For simplicity, we recommend using API key authentication
+        return null;
+    }
+    
+    // Parse the response from the Google Translate API
+    parseResponse(data) {
+        // Handle v2 API response
+        if (data && data.data && data.data.translations) {
+            return data.data.translations[0].translatedText.trim();
+        }
+        // Handle v3 API response
+        else if (data && data.translations) {
+            return data.translations[0].translatedText.trim();
+        } else {
+            return data;
+        }
+    }
+
+    // Override the logging function to display the request and response
+    logRequestData(data, responseData, prompt) {
+        const modelInput = data.q ? data.q[0] : (data.contents ? data.contents[0] : '');
+        const translatedText = this.parseResponse(responseData);
+        
+        logger.verbose(`Input: ${modelInput}`);
+        logger.verbose(`Output: ${translatedText}`);
+
+        if (prompt?.debugInfo) {
+            prompt.debugInfo += `\nInput: ${modelInput}\nOutput: ${translatedText}`;
+        }
+    }
+}
+
+export default GoogleTranslatePlugin;

package/server/plugins/groqChatPlugin.js

@@ -0,0 +1,108 @@
+// GroqChatPlugin.js
+import ModelPlugin from './modelPlugin.js';
+import logger from '../../lib/logger.js';
+
+class GroqChatPlugin extends ModelPlugin {
+    constructor(pathway, model) {
+        super(pathway, model);
+    }
+    
+    // Set up parameters specific to the Groq API
+    getRequestParameters(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const { modelPromptText, modelPromptMessages, tokenLength, modelPrompt } = this.getCompiledPrompt(text, parameters, prompt);
+        
+        // Use modelPromptMessages if available, otherwise fall back to other formats
+        let messages = [];
+        
+        if (modelPromptMessages && Array.isArray(modelPromptMessages) && modelPromptMessages.length > 0) {
+            // Use the messages directly from modelPromptMessages
+            messages = modelPromptMessages;
+        } else if (modelPrompt && modelPrompt.messages) {
+            // If the prompt is already in a messages format, use it directly
+            messages = modelPrompt.messages;
+        } else if (typeof modelPromptText === 'string') {
+            // If it's a string, convert to a user message
+            messages = [
+                { role: 'user', content: modelPromptText }
+            ];
+            
+            // If a system message is provided in parameters, prepend it
+            if (combinedParameters.systemMessage) {
+                messages.unshift({
+                    role: 'system',
+                    content: combinedParameters.systemMessage
+                });
+            }
+        }
+        
+        // Build request parameters for Groq API
+        const requestParameters = {
+            data: {
+                model: this.model.params?.model || "meta-llama/llama-4-scout-17b-16e-instruct", // Default model if not specified
+                messages: messages,
+                temperature: combinedParameters.temperature !== undefined ? combinedParameters.temperature : 0.7,
+                max_completion_tokens: combinedParameters.max_tokens || 4096,
+                top_p: combinedParameters.top_p !== undefined ? combinedParameters.top_p : 1,
+                stream: combinedParameters.stream === true
+            }
+        };
+        
+        // Add optional parameters if they exist
+        if (combinedParameters.stop) {
+            requestParameters.data.stop = combinedParameters.stop;
+        }
+        
+        if (combinedParameters.presence_penalty !== undefined) {
+            requestParameters.data.presence_penalty = combinedParameters.presence_penalty;
+        }
+        
+        if (combinedParameters.frequency_penalty !== undefined) {
+            requestParameters.data.frequency_penalty = combinedParameters.frequency_penalty;
+        }
+        
+        return requestParameters;
+    }
+
+    // Execute the request to the Groq API
+    async execute(text, parameters, prompt, cortexRequest) {
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
+        
+        // Configure the request for Groq API
+        cortexRequest.url = this.model.url;
+        cortexRequest.method = 'POST';
+        cortexRequest.data = requestParameters.data;
+        cortexRequest.headers = this.model.headers;
+
+        return this.executeRequest(cortexRequest);
+    }
+    
+    // Parse the response from the Groq API
+    parseResponse(data) {
+        if (data && data.choices && data.choices.length > 0) {
+            if (data.choices[0].message && data.choices[0].message.content) {
+                return data.choices[0].message.content.trim();
+            } else if (data.choices[0].text) {
+                return data.choices[0].text.trim();
+            }
+        }
+        return data;
+    }
+    
+    // Override the logging function to display the request and response
+    logRequestData(data, responseData, prompt) {
+        // Find the user message
+        const userMessage = data.messages.find(msg => msg.role === 'user');
+        const modelInput = userMessage ? userMessage.content : JSON.stringify(data.messages);
+        const modelOutput = this.parseResponse(responseData);
+        
+        logger.verbose(`Input: ${modelInput}`);
+        logger.verbose(`Output: ${modelOutput}`);
+        
+        if (prompt?.debugInfo) {
+            prompt.debugInfo += `\nInput: ${modelInput}\nOutput: ${modelOutput}`;
+        }
+    }
+}
+
+export default GroqChatPlugin;

package/server/plugins/replicateApiPlugin.js

@@ -35,6 +35,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             height: combinedParameters.height,
             size: combinedParameters.size || "1024x1024",
             style: combinedParameters.style || "realistic_image",
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed) ? { seed: combinedParameters.seed } : {}),
           },
         };
         break;
@@ -109,6 +110,7 @@ class ReplicateApiPlugin extends ModelPlugin {
             input_image: combinedParameters.input_image,
             aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "1:1",
             safety_tolerance: safetyTolerance,
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
           },
         };
         break;
@@ -131,6 +133,26 @@ class ReplicateApiPlugin extends ModelPlugin {
             input_image_2: combinedParameters.input_image_2,
             aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "1:1",
             safety_tolerance: safetyTolerance,
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+          },
+        };
+        break;
+      }
+      case "replicate-seedance-1-pro": {
+        const validResolutions = ["480p", "1080p"];
+        const validRatios = ["16:9", "4:3", "9:16", "1:1", "3:4", "21:9", "9:21"];
+        const validFps = [24];
+
+        requestParameters = {
+          input: {
+            prompt: modelPromptText,
+            resolution: validResolutions.includes(combinedParameters.resolution) ? combinedParameters.resolution : "1080p",
+            aspect_ratio: validRatios.includes(combinedParameters.aspectRatio) ? combinedParameters.aspectRatio : "16:9",
+            ...(combinedParameters.seed && Number.isInteger(combinedParameters.seed && combinedParameters.seed > 0) ? { seed: combinedParameters.seed } : {}),
+            fps: validFps.includes(combinedParameters.fps) ? combinedParameters.fps : 24,
+            camera_fixed: combinedParameters.camera_fixed || false,
+            duration: combinedParameters.duration || 5,
+            ...(combinedParameters.image ? { image: combinedParameters.image } : {}),
           },
         };
         break;