@aj-archipelago/cortex 1.3.57 → 1.3.58

package/README.md

@@ -561,6 +561,12 @@ Each model configuration can include:
 }
 ```
 
+**Rate Limiting**: The `requestsPerSecond` parameter controls the rate limiting for each model endpoint. If not specified, Cortex defaults to **100 requests per second** per endpoint. This rate limiting is implemented using the Bottleneck library with a token bucket algorithm that includes:
+- Minimum time between requests (`minTime`)
+- Maximum concurrent requests (`maxConcurrent`)
+- Token reservoir that refreshes every second
+- Optional Redis clustering support when `storageConnectionString` is configured
+
 ### API Compatibility
 
 Cortex provides OpenAI-compatible REST endpoints that allow you to use various models through a standardized interface. When `enableRestEndpoints` is set to `true`, Cortex exposes the following endpoints:

package/config.js

@@ -435,6 +435,17 @@ var config = convict({
                 "maxReturnTokens": 4096,
                 "supportsStreaming": true
             },
+            "apptek-translate": {
+                "type": "APPTEK-TRANSLATE",
+                "url": "{{APPTEK_API_ENDPOINT}}",
+                "headers": {
+                    "x-token": "{{APPTEK_API_KEY}}",
+                    "Accept": "application/json",
+                    "Content-Type": "text/plain"
+                },
+                "requestsPerSecond": 10,
+                "maxTokenLength": 128000
+            },
         },
         env: 'CORTEX_MODELS'
     },
@@ -533,6 +544,17 @@ var config = convict({
         format: String,
         default: null,
         env: 'JINA_API_KEY'
+    },
+    apptekApiKey: {
+        format: String,
+        default: null,
+        env: 'APPTEK_API_KEY',
+        sensitive: true
+    },
+    apptekApiEndpoint: {
+        format: String,
+        default: null,
+        env: 'APPTEK_API_ENDPOINT'
     }
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.3.57",
+  "version": "1.3.58",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "private": false,
   "repository": {

package/pathways/translate_apptek.js

@@ -1,11 +1,44 @@
 // Description: Translate text using AppTek's translation service
 
+import logger from '../lib/logger.js';
+const { callPathway } = await import('../lib/pathwayTools.js');
+
 export default {
     inputParameters: {
         from: 'auto', // Source language, 'auto' for automatic detection
         to: 'en',     // Target language
         glossaryId: 'none', // Optional glossary ID
+        fallbackPathway: 'translate_groq', // Fallback pathway to use if AppTek fails
     },
     model: 'apptek-translate',
     timeout: 120,
+    
+    executePathway: async ({args, runAllPrompts, resolver}) => {
+        const pathwayResolver = resolver;
+        
+        try {
+            // Execute the primary AppTek translation
+            const result = await runAllPrompts(args);
+            return result;
+        } catch (error) {
+            // If AppTek translation fails, use the configured fallback pathway
+            const fallbackPathway = args.fallbackPathway || 'translate_groq';
+            logger.warn(`AppTek translation failed: ${error.message}. Falling back to ${fallbackPathway}.`);
+            
+            try {
+                // Call the fallback pathway
+                const fallbackResult = await callPathway(fallbackPathway, { 
+                    text: args.text, 
+                    to: args.to || pathwayResolver.pathway.inputParameters.to,
+                }, pathwayResolver);
+                
+                logger.verbose(`Successfully used ${fallbackPathway} as fallback`);
+                return fallbackResult;
+            } catch (fallbackError) {
+                // If even the fallback fails, log it and rethrow the original error
+                logger.error(`${fallbackPathway} fallback also failed: ${fallbackError.message}`);
+                throw error; // Throw the original AppTek error, not the fallback error
+            }
+        }
+    }
 }

package/server/plugins/apptekTranslatePlugin.js

@@ -7,17 +7,6 @@ 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
@@ -38,107 +27,73 @@ class ApptekTranslatePlugin extends ModelPlugin {
 
     // 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;
+        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') {
+            const detectedLang = await this.detectLanguage(requestParameters.data, cortexRequest);
+            if (detectedLang) {
+                sourceLanguage = detectedLang;
+                requestParameters.params.from = detectedLang;
+            } else {
+                const warnMsg = `ApptekTranslatePlugin: Language detection for 'auto' did not return a language. Proceeding with 'auto' or default.`;
+                logger.warn(warnMsg)
             }
+        }
 
-            // 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)
-            }
+        // Check if source and target languages are the same
+        if (to && sourceLanguage && sourceLanguage !== 'auto' && sourceLanguage === to) {
+            const logMessage = `ApptekTranslatePlugin: Source language (${sourceLanguage}) matches target language (${to}). Skipping translation.`;
+            logger.verbose(logMessage)
+            return text;
+        }
 
-            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.`);
+        // Transform the base URL for translation
+        const langPair = `${requestParameters.params.from}-${to}`;
+        const translateUrl = `${cortexRequest.url}/api/v2/quicktranslate/${langPair}`;
+        
+        // Set up the request using the standard pattern
+        cortexRequest.url = translateUrl;
+        cortexRequest.data = requestParameters.data;
+        cortexRequest.method = 'POST';
+        
+        // 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();
             
-            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;
-            }
+            const glossaryLogMessage = `ApptekTranslatePlugin: Using glossary ID: ${requestParameters.params.glossaryId}`;
+            logger.verbose(glossaryLogMessage)
         }
+
+        return this.executeRequest(cortexRequest);
     }
 
     // Detect language using AppTek's language detection API
-    async detectLanguage(text) {
+    async detectLanguage(text, cortexRequest) {
         try {
+            // Transform the base URL for language detection
+            const detectUrl = `${cortexRequest.url}/api/v2/quick_lid`;
+            
             // Make language detection request
-            const resultResponse = await fetch(`${this.apiEndpoint}/api/v2/quick_lid`, {
+            const resultResponse = await fetch(detectUrl, {
                 method: 'POST',
                 headers: {
-                    'x-token': this.apiKey,
-                    'Accept': 'application/json',
-                    'Content-Type': 'text/plain'
+                    ...cortexRequest.headers
                 },
                 body: text
             });
 
             let detectedLanguage = null;
 
-
             if (resultResponse.status === 200) {
                 const result = await resultResponse.text();
                 detectedLanguage = result.split('\n')[0].split(';')[0];
-            }else {
+            } else {
                 logger.error(`Apptek Language detection failed with status: ${resultResponse.status}`);
                 logger.debug({error: resultResponse, text})
             }

package/tests/apptekTranslatePlugin.test.js

@@ -50,8 +50,6 @@ test.afterEach.always((t) => {
 
 test('constructor initializes with correct configuration', (t) => {
     const plugin = t.context.plugin;
-    t.is(plugin.apiEndpoint, 'https://api.mock-apptek.com');
-    t.is(plugin.apiKey, 'mock-api-key');
     t.is(plugin.config, config); // Verify that it uses the imported config
     t.is(plugin.pathwayPrompt, mockPathway.prompt);
     t.is(plugin.modelName, mockModel.name);

package/tests/integration/apptekTranslatePlugin.integration.test.js

@@ -1,33 +1,19 @@
 import test from 'ava';
-import ApptekTranslatePlugin from '../../server/plugins/apptekTranslatePlugin.js';
-import CortexRequest from '../../lib/cortexRequest.js';
-import { createLimiter } from '../../lib/requestExecutor.js';
-import RequestMonitor from '../../lib/requestMonitor.js';
-import { Prompt } from '../../server/prompt.js';
-// Skip tests if API credentials are not available
-const skipIfNoCredentials = (t) => {
-    if (!process.env.APPTEK_API_ENDPOINT || !process.env.APPTEK_API_KEY) {
-        t.skip('AppTek API credentials not available. Set APPTEK_API_ENDPOINT and APPTEK_API_KEY environment variables.');
-        return true;
-    }
-    return false;
-};
+import serverFactory from '../../index.js';
 
-// Mock model configuration
-const mockModel = {
-    name: 'apptek-translate',
-    type: 'APPTEK-TRANSLATE',
-    endpoints: [{
-        name: 'apptek-translate',
-        type: 'APPTEK-TRANSLATE',
-        apiEndpoint: process.env.APPTEK_API_ENDPOINT,
-        apiKey: process.env.APPTEK_API_KEY,
-    }],
-};
+let testServer;
 
-createLimiter(mockModel.endpoints[0], 'apptek-translate', 0);
-mockModel.endpoints[0].monitor = new RequestMonitor();
+test.before(async () => {
+  const { server, startServer } = await serverFactory();
+  startServer && await startServer();
+  testServer = server;
+});
 
+test.after.always('cleanup', async () => {
+  if (testServer) {
+    await testServer.stop();
+  }
+});
 
 // Test data for different languages
 const testCases = [
@@ -78,79 +64,159 @@ const testCases = [
 // Direct AppTek plugin tests
 testCases.forEach((testCase) => {
     test.serial(`AppTek Plugin: ${testCase.name}`, async (t) => {
-        if (skipIfNoCredentials(t)) return;
-
-        // Create pathway configuration
-        const pathway = {
-            name: 'translate_apptek',
-            model: 'apptek-translate',
-            prompt: new Prompt('{{text}}'),
-            timeout: 1000000
-        };
-
-        // Create plugin instance
-        const plugin = new ApptekTranslatePlugin(pathway, mockModel);
+        const response = await testServer.executeOperation({
+            query: 'query translate_apptek($text: String!, $from: String, $to: String) { translate_apptek(text: $text, from: $from, to: $to) { result } }',
+            variables: {
+                text: testCase.text,
+                from: testCase.from,
+                to: testCase.to
+            }
+        });
         
-        // Set up parameters
-        const parameters = {
-            from: testCase.from,
-            to: testCase.to
-        };
+        t.is(response.body?.singleResult?.errors, undefined);
+        const result = response.body?.singleResult?.data?.translate_apptek?.result;
         
-        try {
-
-            const cortexRequest = new CortexRequest({pathwayResolver: {
-                requestId: 'test-request-id', 
-                pathway: pathway,
-                model: mockModel
-            }});
-            const result = await plugin.execute(testCase.text, parameters, pathway.prompt, cortexRequest);
-            
-            // Verify the result is a string
-            t.is(typeof result, 'string', 'Result should be a string');
-            
-            // Verify the result is not empty
-            t.true(result.length > 0, 'Result should not be empty');
-            
-            // Log the translation for manual verification
-            console.log(`\n${testCase.name}:`);
-            console.log(`Source (${testCase.from}): ${testCase.text}`);
-            console.log(`Target (${testCase.to}): ${result}`);
-            
-        } catch (error) {
-            t.fail(`Translation failed: ${error.message}`);
-        }
+        // Verify the result is a string
+        t.is(typeof result, 'string', 'Result should be a string');
+        
+        // Verify the result is not empty
+        t.true(result.length > 0, 'Result should not be empty');
+        
+        // Log the translation for manual verification
+        console.log(`\n${testCase.name}:`);
+        console.log(`Source (${testCase.from}): ${testCase.text}`);
+        console.log(`Target (${testCase.to}): ${result}`);
     });
 });
 
+// Test AppTek failure with GPT-4 Omni fallback
+test.serial('AppTek Plugin: Force failure and test GPT-4 Omni fallback', async (t) => {
+    // Store original environment variables
+    const originalEndpoint = process.env.APPTEK_API_ENDPOINT;
+    const originalApiKey = process.env.APPTEK_API_KEY;
+    
+    try {
+        // Force AppTek to fail by setting invalid endpoint
+        process.env.APPTEK_API_ENDPOINT = 'https://invalid-apptek-endpoint-that-will-fail.com';
+        process.env.APPTEK_API_KEY = 'invalid-api-key';
+        
+        const testText = 'Hello, this is a test for fallback translation.';
+        
+        const response = await testServer.executeOperation({
+            query: `
+                query translate_apptek_with_fallback($text: String!, $from: String, $to: String, $fallbackPathway: String) { 
+                    translate_apptek(text: $text, from: $from, to: $to, fallbackPathway: $fallbackPathway) { 
+                        result 
+                    } 
+                }
+            `,
+            variables: {
+                text: testText,
+                from: 'en',
+                to: 'es',
+                fallbackPathway: 'translate_gpt4_omni'
+            }
+        });
+        
+        // Check for errors in the response
+        t.is(response.body?.singleResult?.errors, undefined, 'Should not have GraphQL errors');
+        
+        const result = response.body?.singleResult?.data?.translate_apptek?.result;
+        
+        // Verify the result is a string
+        t.is(typeof result, 'string', 'Result should be a string');
+        
+        // Verify the result is not empty
+        t.true(result.length > 0, 'Result should not be empty');
+        
+        // Verify it's not the original text (translation should have occurred)
+        t.not(result, testText, 'Result should be translated, not the original text');
+        
+        // Log the fallback translation for manual verification
+        console.log('\nAppTek Failure with GPT-4 Omni Fallback:');
+        console.log(`Source (en): ${testText}`);
+        console.log(`Target (es): ${result}`);
+        console.log('✅ AppTek failed as expected and GPT-4 Omni fallback worked!');
+        
+    } finally {
+        // Restore original environment variables
+        if (originalEndpoint) {
+            process.env.APPTEK_API_ENDPOINT = originalEndpoint;
+        } else {
+            delete process.env.APPTEK_API_ENDPOINT;
+        }
+        
+        if (originalApiKey) {
+            process.env.APPTEK_API_KEY = originalApiKey;
+        } else {
+            delete process.env.APPTEK_API_KEY;
+        }
+    }
+});
 
-// Test language detection
-test.serial('AppTek Plugin: Language Detection', async (t) => {
-    if (skipIfNoCredentials(t)) return;
-
-    const pathway = { name: 'translate_apptek', model: 'apptek-translate' };
-    const plugin = new ApptekTranslatePlugin(pathway, mockModel);
-
-    const testTexts = [
-        { text: 'Hello world', expectedLang: 'en' },
-        { text: 'Hola mundo', expectedLang: 'es' },
-        { text: 'مرحبا بالعالم', expectedLang: 'ar' }
-    ];
-
-    for (const testText of testTexts) {
-        try {
-            const detectedLang = await plugin.detectLanguage(testText.text);
-            
-            t.is(typeof detectedLang, 'string', 'Detected language should be a string');
-            t.true(detectedLang.length > 0, 'Detected language should not be empty');
-            
-            console.log(`\nLanguage Detection:`);
-            console.log(`Text: ${testText.text}`);
-            console.log(`Detected: ${detectedLang}`);
-            console.log(`Expected: ${testText.expectedLang}`);
-            
-        } catch (error) {
-            t.fail(`Language detection failed: ${error.message}`);
+// Test AppTek failure with default fallback (translate_groq)
+test.skip('AppTek Plugin: Force failure and test default fallback', async (t) => {
+    // Set a longer timeout for this test since Groq might be slower
+    t.timeout(180000); // 3 minutes
+    
+    // Store original environment variables
+    const originalEndpoint = process.env.APPTEK_API_ENDPOINT;
+    const originalApiKey = process.env.APPTEK_API_KEY;
+    
+    try {
+        // Force AppTek to fail by setting invalid endpoint
+        process.env.APPTEK_API_ENDPOINT = 'https://invalid-apptek-endpoint-that-will-fail.com';
+        process.env.APPTEK_API_KEY = 'invalid-api-key';
+        
+        const testText = 'Hello, this is a test for default fallback translation.';
+        
+        const response = await testServer.executeOperation({
+            query: `
+                query translate_apptek_default_fallback($text: String!, $from: String, $to: String) { 
+                    translate_apptek(text: $text, from: $from, to: $to) { 
+                        result 
+                    } 
+                }
+            `,
+            variables: {
+                text: testText,
+                from: 'en',
+                to: 'fr'
+            }
+        });
+        
+        // Check for errors in the response
+        t.is(response.body?.singleResult?.errors, undefined, 'Should not have GraphQL errors');
+        
+        const result = response.body?.singleResult?.data?.translate_apptek?.result;
+        
+        // Verify the result is a string
+        t.is(typeof result, 'string', 'Result should be a string');
+        
+        // Verify the result is not empty
+        t.true(result.length > 0, 'Result should not be empty');
+        
+        // Verify it's not the original text (translation should have occurred)
+        t.not(result, testText, 'Result should be translated, not the original text');
+        
+        // Log the fallback translation for manual verification
+        console.log('\nAppTek Failure with Default Fallback:');
+        console.log(`Source (en): ${testText}`);
+        console.log(`Target (fr): ${result}`);
+        console.log('✅ AppTek failed as expected and default fallback worked!');
+        
+    } finally {
+        // Restore original environment variables
+        if (originalEndpoint) {
+            process.env.APPTEK_API_ENDPOINT = originalEndpoint;
+        } else {
+            delete process.env.APPTEK_API_ENDPOINT;
+        }
+        
+        if (originalApiKey) {
+            process.env.APPTEK_API_KEY = originalApiKey;
+        } else {
+            delete process.env.APPTEK_API_KEY;
         }
     }
 });

package/tests/translate_apptek.test.js

@@ -115,3 +115,19 @@ test('resolver uses correct model', (t) => {
     const model = resolver.model;
     t.is(model.type, 'APPTEK-TRANSLATE');
 });
+
+test('pathway has fallback pathway parameter', async (t) => {
+    // Import the actual pathway to test the new parameter
+    const pathway = await import('../pathways/translate_apptek.js');
+    
+    t.truthy(pathway.default.inputParameters.fallbackPathway);
+    t.is(pathway.default.inputParameters.fallbackPathway, 'translate_groq');
+});
+
+test('pathway has executePathway function', async (t) => {
+    // Import the actual pathway to test the executePathway function
+    const pathway = await import('../pathways/translate_apptek.js');
+    
+    t.truthy(pathway.default.executePathway);
+    t.is(typeof pathway.default.executePathway, 'function');
+});