@aj-archipelago/cortex 1.1.34 → 1.1.36

package/README.md

@@ -503,7 +503,8 @@ The configuration should include the following properties:
   "awsAccessKeyId": "your_access_key_id",  // Only for AWS S3
   "awsSecretAccessKey": "your_secret_access_key",  // Only for AWS S3
   "awsRegion": "your_aws_region",  // Only for AWS S3
-  "awsBucketName": "cortexdynamicpathways"  // Optional, default is "cortexdynamicpathways"
+  "awsBucketName": "cortexdynamicpathways",  // Optional, default is "cortexdynamicpathways"
+  "publishKey": "your_publish_key"
 }
 ```
 
@@ -559,7 +560,7 @@ query ExecuteWorkspace($userId: String!, $pathwayName: String!, $text: String!)
 
 To ensure the security of dynamic pathways:
 
-1. A `PATHWAY_PUBLISH_KEY` environment variable must be set to enable pathway publishing.
+1. A `publishKey` must be set in the dynamic pathways configuration to enable pathway publishing.
 2. This key must be provided in the `key` parameter when adding, updating, or deleting pathways.
 3. Each pathway is associated with a `userId` and `secret`. The secret must be provided to modify or delete an existing pathway.
 
@@ -567,4 +568,4 @@ To ensure the security of dynamic pathways:
 
 Each instance of Cortex maintains its own local cache of pathways. On every dynamic pathway request, it checks if the local cache is up to date by comparing the last modified timestamp of the storage with the last update time of the local cache. If the local cache is out of date, it reloads the pathways from storage.
 
-This approach ensures that all instances of Cortex will eventually have access to the most up-to-date dynamic pathways without requiring immediate synchronization.
+This approach ensures that all instances of Cortex will eventually have access to the most up-to-date dynamic pathways without requiring immediate synchronization.

package/config/dynamicPathwaysConfig.example.json

@@ -1,4 +1,5 @@
 {
     "storageType": "azure",
     "filePath": "./pathways/dynamic/pathways.json",
+    "publishKey": "development"
 }

package/config.js

@@ -321,6 +321,7 @@ const createDynamicPathwayManager = async (config, basePathway) => {
         awsSecretAccessKey: dynamicPathwayConfig.awsSecretAccessKey,
         awsRegion: dynamicPathwayConfig.awsRegion,
         awsBucketName: dynamicPathwayConfig.awsBucketName || 'cortexdynamicpathways',
+        publishKey: dynamicPathwayConfig.publishKey,
     };
 
     const pathwayManager = new PathwayManager(storageConfig, basePathway);

package/lib/pathwayManager.js

@@ -1,8 +1,8 @@
 import { BlobServiceClient } from '@azure/storage-blob';
 import { S3 } from '@aws-sdk/client-s3';
 import fs from 'fs';
+import path from 'path';
 import logger from './logger.js';
-const { PATHWAY_PUBLISH_KEY } = process.env;
 
 class StorageStrategy {
   async load() { throw new Error('Not implemented'); }
@@ -20,6 +20,8 @@ class LocalStorage extends StorageStrategy {
     if (!fs.existsSync(this.filePath)) {
       // create it. log
       logger.info(`Creating dynamic pathways local file: ${this.filePath}`);
+      // create directory if it doesn't exist
+      await fs.promises.mkdir(path.dirname(this.filePath), { recursive: true });
       await fs.promises.writeFile(this.filePath, JSON.stringify({}));
     }
 
@@ -80,7 +82,7 @@ class AzureBlobStorage extends StorageStrategy {
       }
 
       const downloadBlockBlobResponse = await blockBlobClient.download();
-      const data = await this.streamToString(downloadBlockBlobResponse.readableStreamBody);
+      const data = await streamToString(downloadBlockBlobResponse.readableStreamBody);
       const parsedData = JSON.parse(data);
       logger.info(`Loaded pathways from Azure Blob Storage. ${Object.keys(parsedData).map(user => `${user}(${Object.keys(parsedData[user])})`).join(', ')}`);
       return parsedData;
@@ -124,18 +126,33 @@ class AzureBlobStorage extends StorageStrategy {
 class S3Storage extends StorageStrategy {
   constructor(config) {
     super();
-    this.s3 = new S3(config);
-    this.bucketName = config.bucketName;
+    this.s3 = new S3({
+      credentials: {
+        accessKeyId: config.awsAccessKeyId,
+        secretAccessKey: config.awsSecretAccessKey
+      },
+      region: config.awsRegion
+    });
+    this.bucketName = config.awsBucketName;
   }
 
   async load() {
     try {
+      // Check if bucket exists, create if it doesn't
+      await this.ensureBucketExists();
+
+      // Check if file exists, create if it doesn't
+      await this.ensureFileExists();
+
       const params = {
         Bucket: this.bucketName,
         Key: 'pathways.json'
       };
       const data = await this.s3.getObject(params);
-      return JSON.parse(data.Body.toString());
+
+      const readableStream = data.Body;
+      const dataString = await streamToString(readableStream);
+      return JSON.parse(dataString);
     } catch (error) {
       logger.error('Error loading pathways from S3:', error);
       throw error;
@@ -164,11 +181,47 @@ class S3Storage extends StorageStrategy {
     const data = await this.s3.headObject(params);
     return new Date(data.LastModified).getTime();
   }
+
+  async ensureBucketExists() {
+    try {
+      await this.s3.headBucket({ Bucket: this.bucketName });
+    } catch (error) {
+      if (error.name === 'NotFound') {
+        logger.info(`Bucket ${this.bucketName} does not exist, creating it`);
+        await this.s3.createBucket({ Bucket: this.bucketName });
+      } else {
+        throw error;
+      }
+    }
+  }
+
+  async ensureFileExists() {
+    try {
+      await this.s3.headObject({
+        Bucket: this.bucketName,
+        Key: 'pathways.json'
+      });
+    } catch (error) {
+      if (error.name === 'NotFound') {
+        logger.info('pathways.json does not exist, creating it with empty object');
+        const emptyContent = JSON.stringify({});
+        await this.s3.putObject({
+          Bucket: this.bucketName,
+          Key: 'pathways.json',
+          Body: emptyContent,
+          ContentType: 'application/json'
+        });
+      } else {
+        throw error;
+      }
+    }
+  }
 }
 
 class PathwayManager {
   constructor(config, basePathway) {
     this.storage = this.getStorageStrategy(config);
+    this.publishKey = config.publishKey;
     this.pathways = {};
     this.lastUpdated = 0;
     this.basePathway = basePathway;
@@ -176,6 +229,10 @@ class PathwayManager {
     if (config.storageType === 'local') {
       logger.warn('WARNING: Local file storage is being used for dynamic pathways. If there are multiple instances of Cortex, they will not be synced. Consider using cloud storage such as S3 or Azure for production environments.');
     }
+
+    if (!this.publishKey) {
+      logger.warn('WARNING: dynamicPathwaysConfig.publishKey is not set. Dynamic pathways will not be editable in this instance of Cortex.');
+    }
   }
 
   getStorageStrategy(config) {
@@ -233,6 +290,7 @@ class PathwayManager {
       throw new Error('Both userId and secret are mandatory for adding or updating a pathway');
     }
 
+    await this.getLatestPathways();
     this.pathways[userId] = this.pathways[userId] || {};
 
     if (this.pathways[userId][name] && this.pathways[userId][name].secret !== secret) {
@@ -246,9 +304,12 @@ class PathwayManager {
   }
 
   async removePathway(name, userId, secret) {
+    await this.getLatestPathways();
+
     if (!this.pathways[userId] || !this.pathways[userId][name]) {
       return;
     }
+
     if (this.pathways[userId][name].secret !== secret) {
       throw new Error('Invalid secret');
     }
@@ -294,11 +355,11 @@ class PathwayManager {
     return {
       Mutation: {
         putPathway: async (_, { name, pathway, userId, secret, displayName, key }) => {
-          if (!PATHWAY_PUBLISH_KEY) {
+          if (!this.publishKey) {
             throw new Error("Invalid configuration. Pathway publishing key is not configured in Cortex.")
           }
 
-          if (key !== PATHWAY_PUBLISH_KEY) {
+          if (key !== this.publishKey) {
             throw new Error('Invalid pathway publishing key. The key provided did not match the key configured in Cortex.');
           }
 
@@ -310,10 +371,10 @@ class PathwayManager {
           }
         },
         deletePathway: async (_, { name, userId, secret, key }) => {
-          if (!PATHWAY_PUBLISH_KEY) {
+          if (!this.publishKey) {
             throw new Error("Invalid configuration. Pathway publishing key is not configured in Cortex.")
           }
-          if (key !== PATHWAY_PUBLISH_KEY) {
+          if (key !== this.publishKey) {
             throw new Error('Invalid pathway publishing key. The key provided did not match the key configured in Cortex.');
           }
 
@@ -328,7 +389,7 @@ class PathwayManager {
     };
   }
 
-  async getPathways() {
+  async getLatestPathways() {
     try {
       const currentTimestamp = await this.storage.getLastModified();
 
@@ -340,13 +401,13 @@ class PathwayManager {
 
       return this.pathways;
     } catch (error) {
-      logger.error('Error in getPathways:', error);
+      logger.error('Error in getLatestPathways:', error);
       throw error;
     }
   }
 
   async getPathway(userId, pathwayName) {
-    const pathways = await this.getPathways();
+    const pathways = await this.getLatestPathways();
 
     if (!pathways[userId] || !pathways[userId][pathwayName]) {
       throw new Error(`Pathway '${pathwayName}' not found for user '${userId}'`);
@@ -354,20 +415,19 @@ class PathwayManager {
 
     return pathways[userId][pathwayName];
   }
+}
 
-  // Helper function to convert a readable stream to a string
-  async streamToString(readableStream) {
-    return new Promise((resolve, reject) => {
-      const chunks = [];
-      readableStream.on('data', (data) => {
-        chunks.push(data.toString());
-      });
-      readableStream.on('end', () => {
-        resolve(chunks.join(''));
-      });
-      readableStream.on('error', reject);
+// Helper function to convert a readable stream to a string
+async function streamToString(readableStream) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    readableStream.on('data', (data) => {
+      chunks.push(data.toString());
     });
-  }
+    readableStream.on('end', () => {
+      resolve(chunks.join(''));
+    });
+    readableStream.on('error', reject);
+  });
 }
-
-export default PathwayManager;
+export default PathwayManager;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.1.34",
+  "version": "1.1.36",
   "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/server/plugins/openAiVisionPlugin.js

@@ -27,17 +27,18 @@ class OpenAIVisionPlugin extends OpenAIChatPlugin {
                 }
                 if (Array.isArray(message.content)) {
                     message.content = message.content.map(item => {
-                        if (typeof item === 'string') {
-                            const parsedItem = safeJsonParse(item);
-                            return parsedItem.type ? parsedItem : { type: 'text', text: item };
-                        } else if (typeof item === 'object') {
-                            const { type, image_url, url } = item;
-                            if (type === 'image_url') {
-                                image_url.url = url || image_url.url;
-                                return { type, image_url };
-                            }
+                        const parsedItem = safeJsonParse(item);
+
+                        if (typeof parsedItem === 'string') {
+                            return { type: 'text', text: parsedItem };
+                        }
+
+                        if (typeof parsedItem === 'object' && parsedItem !== null && parsedItem.type === 'image_url') {
+                            parsedItem.image_url.url = parsedItem.url || parsedItem.image_url.url;
+                            return parsedItem;
                         }
-                        return item;
+                        
+                        return parsedItem;
                     });
                 }
             } catch (e) {

package/server/plugins/replicateApiPlugin.js

@@ -0,0 +1,71 @@
+// replicateApiPlugin.js
+import ModelPlugin from "./modelPlugin.js";
+import logger from "../../lib/logger.js";
+
+class ReplicateApiPlugin extends ModelPlugin {
+  constructor(pathway, model) {
+    super(pathway, model);
+  }
+
+  // Set up parameters specific to the Replicate API
+  getRequestParameters(text, parameters, prompt) {
+    const combinedParameters = { ...this.promptParameters, ...parameters };
+    const { modelPromptText } = this.getCompiledPrompt(
+      text,
+      parameters,
+      prompt,
+    );
+
+    const requestParameters = {
+      input: {
+        aspect_ratio: "1:1",
+        output_format: "webp",
+        output_quality: 80,
+        prompt: modelPromptText,
+        //prompt_upsampling: false,
+        //safety_tolerance: 5,
+        go_fast: true,
+        megapixels: "1",
+        num_outputs: combinedParameters.numberResults,
+      },
+    };
+
+    return requestParameters;
+  }
+
+  // Execute the request to the Replicate API
+  async execute(text, parameters, prompt, cortexRequest) {
+    const requestParameters = this.getRequestParameters(
+      text,
+      parameters,
+      prompt,
+    );
+
+    cortexRequest.data = requestParameters;
+    cortexRequest.params = requestParameters.params;
+
+    return this.executeRequest(cortexRequest);
+  }
+
+  // Parse the response from the Replicate API
+  parseResponse(data) {
+    if (data.data) {
+      return JSON.stringify(data.data);
+    }
+    return JSON.stringify(data);
+  }
+
+  // Override the logging function to display the request and response
+  logRequestData(data, responseData, prompt) {
+    const modelInput = data?.input?.prompt;
+
+    logger.verbose(`${modelInput}`);
+    logger.verbose(`${this.parseResponse(responseData)}`);
+
+    prompt &&
+      prompt.debugInfo &&
+      (prompt.debugInfo += `\n${JSON.stringify(data)}`);
+  }
+}
+
+export default ReplicateApiPlugin;