@aj-archipelago/cortex 1.4.1 → 1.4.3

package/helper-apps/cortex-file-handler/tests/containerParameterFlow.test.js

@@ -71,11 +71,14 @@ test.after.always(async (t) => {
 
 // Test container parameter validation
 test("should validate container names correctly", (t) => {
+  // Get current container names
+  const currentContainers = AZURE_STORAGE_CONTAINER_NAMES;
+  
   // Test with valid container names from configuration
-  AZURE_STORAGE_CONTAINER_NAMES.forEach(containerName => {
+  currentContainers.forEach(containerName => {
     t.true(isValidContainerName(containerName), `${containerName} should be valid`);
   });
-
+  
   // Test with invalid container names
   const invalidNames = ["invalid-container", "", null, undefined, "nonexistent"];
   invalidNames.forEach(name => {

package/helper-apps/cortex-file-handler/tests/storage/StorageFactory.test.js

@@ -123,19 +123,27 @@ test("should get azure provider with specific container name", async (t) => {
     return;
   }
 
-  const factory = new StorageFactory();
-  
-  // Mock the blobHandler constants for this test
-  const mockConstants = {
-    AZURE_STORAGE_CONTAINER_NAMES: ["container1", "container2", "container3"],
-    DEFAULT_AZURE_STORAGE_CONTAINER_NAME: "container1",
-    isValidContainerName: (name) => ["container1", "container2", "container3"].includes(name)
-  };
+  // Save original env value
+  const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
   
-  // Test with valid container name
-  const provider = await factory.getAzureProvider("container2");
-  t.truthy(provider);
-  t.is(provider.containerName, "container2");
+  try {
+    // Set test container names in environment
+    process.env.AZURE_STORAGE_CONTAINER_NAME = "container1,container2,container3";
+    
+    const factory = new StorageFactory();
+    
+    // Test with valid container name
+    const provider = await factory.getAzureProvider("container2");
+    t.truthy(provider);
+    t.is(provider.containerName, "container2");
+  } finally {
+    // Restore original env
+    if (originalEnv) {
+      process.env.AZURE_STORAGE_CONTAINER_NAME = originalEnv;
+    } else {
+      delete process.env.AZURE_STORAGE_CONTAINER_NAME;
+    }
+  }
 });
 
 test("should throw error for invalid container name", async (t) => {
@@ -159,21 +167,25 @@ test("should cache providers by container name", async (t) => {
     return;
   }
 
-  const factory = new StorageFactory();
-  
-  // Mock valid container names for testing
+  // Save original env value
   const originalEnv = process.env.AZURE_STORAGE_CONTAINER_NAME;
-  process.env.AZURE_STORAGE_CONTAINER_NAME = "test1,test2,test3";
   
   try {
-    const provider1 = await factory.getAzureProvider("test1");
-    const provider2 = await factory.getAzureProvider("test1");
-    const provider3 = await factory.getAzureProvider("test2");
+    // Set test container names in environment
+    process.env.AZURE_STORAGE_CONTAINER_NAME = "container1,container2,container3";
+    
+    const factory = new StorageFactory();
+    
+    const provider1 = await factory.getAzureProvider("container1");
+    const provider2 = await factory.getAzureProvider("container1");
+    const provider3 = await factory.getAzureProvider("container2");
     
     // Same container should return same instance
     t.is(provider1, provider2);
     // Different container should return different instance
     t.not(provider1, provider3);
+    t.is(provider1.containerName, "container1");
+    t.is(provider3.containerName, "container2");
   } finally {
     // Restore original env
     if (originalEnv) {

package/lib/crypto.js

@@ -36,70 +36,6 @@ function decrypt(message, key) {
     }
 }
 
-// Double encryption: encrypt with user key first, then system key
-function doubleEncrypt(data, userContextKey, systemKey) {
-    if (!systemKey) {
-        logger.error('System key is required for encryption');
-        return null;
-    }
-    
-    if (!userContextKey) {
-        // If no user key provided, use single-layer encryption with system key
-        return encrypt(data, systemKey);
-    }
-    
-    try {
-        // First encrypt with user's contextKey
-        const userEncrypted = encrypt(data, userContextKey);
-        if (!userEncrypted) {
-            logger.error('User encryption failed, falling back to system encryption only');
-            return encrypt(data, systemKey);
-        }
-        
-        // Then encrypt with system key
-        return encrypt(userEncrypted, systemKey);
-    } catch (error) {
-        logger.error(`Double encryption failed: ${error.message}`);
-        // Fallback to single-layer system encryption
-        return encrypt(data, systemKey);
-    }
-}
-
-// Double decryption: decrypt with system key first, then user key
-function doubleDecrypt(encryptedData, userContextKey, systemKey) {
-    if (!systemKey) {
-        logger.error('System key is required for decryption');
-        return null;
-    }
-    
-    if (!userContextKey) {
-        // If no user key provided, use single-layer decryption with system key
-        return decrypt(encryptedData, systemKey);
-    }
-    
-    try {
-        // First decrypt with system key
-        const systemDecrypted = decrypt(encryptedData, systemKey);
-        if (!systemDecrypted) {
-            logger.error('System decryption failed');
-            return null;
-        }
-        
-        // Try to decrypt with user's contextKey
-        const userDecrypted = decrypt(systemDecrypted, userContextKey);
-        if (userDecrypted) {
-            // Successfully double-decrypted
-            return userDecrypted;
-        }
-        
-        // User decryption failed, but system decryption succeeded
-        // This means the data was single-encrypted with system key only
-        return systemDecrypted;
-    } catch (error) {
-        logger.error(`Double decryption failed: ${error.message}`);
-        return null;
-    }
-}
 
 function tryBufferKey(key) {
     if (key.length === 64) {
@@ -108,4 +44,4 @@ function tryBufferKey(key) {
     return key;
 }
 
-export { encrypt, decrypt, doubleEncrypt, doubleDecrypt };
+export { encrypt, decrypt };

package/lib/keyValueStorageClient.js

@@ -45,8 +45,60 @@ async function getv(key) {
     return keyValueStorageClient && (await keyValueStorageClient.get(key));
 }
 
+// Set values to keyv with additional context key encryption
+async function setvWithDoubleEncryption(key, value, contextKey) {
+    let processedValue = value;
+    
+    // If contextKey exists and is not empty, encrypt the value with it
+    if (contextKey && contextKey.trim() !== '' && value !== null && value !== undefined) {
+        try {
+            // Convert value to string for encryption
+            const stringValue = typeof value === 'string' ? value : JSON.stringify(value);
+            processedValue = encrypt(stringValue, contextKey);
+        } catch (error) {
+            logger.error(`Context key encryption failed: ${error.message}`);
+            // Continue with unencrypted value if context encryption fails
+        }
+    }
+    
+    return keyValueStorageClient && (await keyValueStorageClient.set(key, processedValue));
+}
+
+// Get values from keyv with additional context key decryption
+async function getvWithDoubleDecryption(key, contextKey) {
+    const result = keyValueStorageClient && (await keyValueStorageClient.get(key));
+    
+    if (result === null || result === undefined) {
+        return result;
+    }
+    
+    // If contextKey exists and is not empty, try to decrypt the result with it
+    if (contextKey && contextKey.trim() !== '') {
+        try {
+            // Try to decrypt with context key
+            const decrypted = decrypt(result, contextKey);
+            if (decrypted) {
+                // Try to parse as JSON, if it fails return the string as-is
+                try {
+                    return JSON.parse(decrypted);
+                } catch (parseError) {
+                    return decrypted;
+                }
+            }
+        } catch (error) {
+            // If context decryption fails, the data might not be context-encrypted
+            // or the context key might be wrong, so return the result as-is
+            logger.debug(`Context key decryption failed, returning original data: ${error.message}`);
+        }
+    }
+    
+    return result;
+}
+
 export {
     keyValueStorageClient,
     setv,
-    getv
+    getv,
+    setvWithDoubleEncryption,
+    getvWithDoubleDecryption
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.4.1",
+  "version": "1.4.3",
   "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/system/entity/memory/sys_read_memory.js

@@ -2,7 +2,7 @@
 // it should never try to call other pathways
 
 import { getv } from '../../../../lib/keyValueStorageClient.js';
-import { getvWithDoubleDecryption } from '../../../../lib/doubleEncryptionStorageClient.js';
+import { getvWithDoubleDecryption } from '../../../../lib/keyValueStorageClient.js';
 
 const isValidISOTimestamp = (timestamp) => {
     if (!timestamp) return false;

package/pathways/system/entity/memory/sys_save_memory.js

@@ -1,5 +1,5 @@
 import { getv } from '../../../../lib/keyValueStorageClient.js';
-import { setvWithDoubleEncryption } from '../../../../lib/doubleEncryptionStorageClient.js';
+import { setvWithDoubleEncryption } from '../../../../lib/keyValueStorageClient.js';
 
 export default {
     inputParameters: {

package/pathways/system/entity/memory/sys_search_memory.js

@@ -1,6 +1,6 @@
 import { Prompt } from '../../../../server/prompt.js';
 import { callPathway } from '../../../../lib/pathwayTools.js';
-import { setvWithDoubleEncryption } from '../../../../lib/doubleEncryptionStorageClient.js';
+import { setvWithDoubleEncryption } from '../../../../lib/keyValueStorageClient.js';
 
 export default {
     prompt:

package/server/modelExecutor.js

@@ -24,6 +24,7 @@ import Gemini15VisionPlugin from './plugins/gemini15VisionPlugin.js';
 import Gemini25ImagePlugin from './plugins/gemini25ImagePlugin.js';
 import AzureBingPlugin from './plugins/azureBingPlugin.js';
 import Claude3VertexPlugin from './plugins/claude3VertexPlugin.js';
+import Claude4VertexPlugin from './plugins/claude4VertexPlugin.js';
 import NeuralSpacePlugin from './plugins/neuralSpacePlugin.js';
 import RunwareAiPlugin from './plugins/runwareAiPlugin.js';
 import ReplicateApiPlugin from './plugins/replicateApiPlugin.js';
@@ -113,6 +114,9 @@ class ModelExecutor {
             case 'CLAUDE-3-VERTEX':
                 plugin = new Claude3VertexPlugin(pathway, model);
                 break;
+            case 'CLAUDE-4-VERTEX':
+                plugin = new Claude4VertexPlugin(pathway, model);
+                break;
             case 'RUNWARE-AI':
                 plugin = new RunwareAiPlugin(pathway, model);
                 break;

package/server/pathwayResolver.js

@@ -6,7 +6,7 @@ import { getFirstNToken, getLastNToken, getSemanticChunks } from './chunker.js';
 import { PathwayResponseParser } from './pathwayResponseParser.js';
 import { Prompt } from './prompt.js';
 import { getv, setv } from '../lib/keyValueStorageClient.js';
-import { getvWithDoubleDecryption, setvWithDoubleEncryption } from '../lib/doubleEncryptionStorageClient.js';
+import { getvWithDoubleDecryption, setvWithDoubleEncryption } from '../lib/keyValueStorageClient.js';
 import { requestState } from './requestState.js';
 import { callPathway, addCitationsToResolver } from '../lib/pathwayTools.js';
 import logger from '../lib/logger.js';