@aj-archipelago/cortex 0.0.6 → 0.0.7

package/graphql/plugins/azureTranslatePlugin.js

@@ -1,19 +1,26 @@
 // AzureTranslatePlugin.js
 const ModelPlugin = require('./modelPlugin');
 const handlebars = require("handlebars");
+const { encode } = require("gpt-3-encoder");
 
 class AzureTranslatePlugin extends ModelPlugin {
-    constructor(config, modelName, pathway) {
-        super(config, modelName, pathway);
+    constructor(config, pathway) {
+        super(config, pathway);
     }
 
-    // Set up parameters specific to the Azure Translate API
-    requestParameters(text, parameters, prompt) {
+    getCompiledPrompt(text, parameters, prompt) {
         const combinedParameters = { ...this.promptParameters, ...parameters };
         const modelPrompt = this.getModelPrompt(prompt, parameters);
         const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
-
-        return {
+    
+        return { modelPromptText, tokenLength: encode(modelPromptText).length };
+    }
+    
+    // Set up parameters specific to the Azure Translate API
+    getRequestParameters(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+        const requestParameters = {
             data: [
                 {
                 Text: modelPromptText,
@@ -23,11 +30,12 @@ class AzureTranslatePlugin extends ModelPlugin {
                 to: combinedParameters.to
             }
         };
+        return requestParameters;
     }
 
     // Execute the request to the Azure Translate API
     async execute(text, parameters, prompt) {
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
 
         const url = this.requestUrl(text);
 
@@ -35,7 +43,7 @@ class AzureTranslatePlugin extends ModelPlugin {
         const params = requestParameters.params;
         const headers = this.model.headers || {};
 
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/modelPlugin.js

@@ -38,6 +38,41 @@ class ModelPlugin {
         this.shouldCache = config.get('enableCache') && (pathway.enableCache || pathway.temperature == 0);
     }
 
+    // Function to remove non-system messages until token length is less than target
+    removeMessagesUntilTarget = (messages, targetTokenLength) => {
+        let chatML = this.messagesToChatML(messages);
+        let tokenLength = encode(chatML).length;
+    
+        while (tokenLength > targetTokenLength) {
+            for (let i = 0; i < messages.length; i++) {
+                if (messages[i].role !== 'system') {
+                    messages.splice(i, 1);
+                    chatML = this.messagesToChatML(messages);
+                    tokenLength = encode(chatML).length;
+                    break;
+                }
+            }
+            if (messages.every(message => message.role === 'system')) {
+                break; // All remaining messages are 'system', stop removing messages
+            }
+        }
+        return messages;
+    }
+
+    //convert a messages array to a simple chatML format
+    messagesToChatML = (messages) => {
+        let output = "";
+        if (messages && messages.length) {
+            for (let message of messages) {
+                output += (message.role && message.content) ? `<|im_start|>${message.role}\n${message.content}\n<|im_end|>\n` : `${message}\n`;
+            }
+            // you always want the assistant to respond next so add a
+            // directive for that
+            output += "<|im_start|>assistant\n";
+        }
+        return output;
+    }
+
     getModelMaxTokenLength() {
         return (this.promptParameters.maxTokenLength ?? this.model.maxTokenLength ?? DEFAULT_MAX_TOKENS);
     }
@@ -120,40 +155,37 @@ class ModelPlugin {
         return messageResult ?? textResult ?? null;
     }
 
-    logMessagePreview(messages) {
-        messages.forEach((message, index) => {
-            const words = message.content.split(" ");
-            const tokenCount = encode(message.content).length;
-            let preview;
-    
-            if (index === 0) {
-                preview = message.content;
-            } else {
-                preview = words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
-            }
+    logRequestData(data, responseData, prompt) {
+        const separator = `\n=== ${this.pathwayName}.${this.requestCount++} ===\n`;
+        console.log(separator);
     
-            console.log(`Message ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"`);
-        });
-    }
+        const modelInput = data.prompt || (data.messages && data.messages[0].content) || (data.length > 0 && data[0].Text) || null;
     
-    async executeRequest(url, data, params, headers) {
-        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
-        const modelInput = data.prompt || (data.messages && data.messages[0].content) || data[0].Text || null;
-        
-        console.log(`=== ${this.pathwayName}.${this.requestCount++} ===`);
-        
         if (data.messages && data.messages.length > 1) {
-            this.logMessagePreview(data.messages);
+            data.messages.forEach((message, index) => {
+                const words = message.content.split(" ");
+                const tokenCount = encode(message.content).length;
+                const preview = words.length < 41 ? message.content : words.slice(0, 20).join(" ") + " ... " + words.slice(-20).join(" ");
+    
+                console.log(`\x1b[36mMessage ${index + 1}: Role: ${message.role}, Tokens: ${tokenCount}, Content: "${preview}"\x1b[0m`);
+            });
         } else {
             console.log(`\x1b[36m${modelInput}\x1b[0m`);
         }
-        
+    
         console.log(`\x1b[34m> ${this.parseResponse(responseData)}\x1b[0m`);
     
+        prompt.debugInfo += `${separator}${JSON.stringify(data)}`;
+    }
+    
+    async executeRequest(url, data, params, headers, prompt) {
+        const responseData = await request({ url, data, params, headers, cache: this.shouldCache }, this.modelName);
+        
         if (responseData.error) {
             throw new Exception(`An error was returned from the server: ${JSON.stringify(responseData.error)}`);
         }
     
+        this.logRequestData(data, responseData, prompt);
         return this.parseResponse(responseData);
     }
 

package/graphql/plugins/openAiChatPlugin.js

@@ -1,37 +1,61 @@
 // OpenAIChatPlugin.js
 const ModelPlugin = require('./modelPlugin');
 const handlebars = require("handlebars");
+const { encode } = require("gpt-3-encoder");
 
 class OpenAIChatPlugin extends ModelPlugin {
     constructor(config, pathway) {
         super(config, pathway);
     }
 
-    // Set up parameters specific to the OpenAI Chat API
-    requestParameters(text, parameters, prompt) {
+    getCompiledPrompt(text, parameters, prompt) {
         const combinedParameters = { ...this.promptParameters, ...parameters };
         const modelPrompt = this.getModelPrompt(prompt, parameters);
         const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
         const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
+        const modelPromptMessagesML = this.messagesToChatML(modelPromptMessages);
 
-        const { stream } = parameters;
+        if (modelPromptMessagesML) {
+            return { modelPromptMessages, tokenLength: encode(modelPromptMessagesML).length };
+        } else {
+            return { modelPromptText, tokenLength: encode(modelPromptText).length };
+        }
+    }
 
-        return {
-            messages: modelPromptMessages || [{ "role": "user", "content": modelPromptText }],
-            temperature: this.temperature ?? 0.7,
-            stream
+    // Set up parameters specific to the OpenAI Chat API
+    getRequestParameters(text, parameters, prompt) {
+        const { modelPromptText, modelPromptMessages, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+    
+        // Define the model's max token length
+        const modelMaxTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        let requestMessages = modelPromptMessages || [{ "role": "user", "content": modelPromptText }];
+    
+        // Check if the token length exceeds the model's max token length
+        if (tokenLength > modelMaxTokenLength) {
+            // Remove older messages until the token length is within the model's limit
+            requestMessages = this.removeMessagesUntilTarget(requestMessages, modelMaxTokenLength);
+        }
+    
+        const requestParameters = {
+        messages: requestMessages,
+        temperature: this.temperature ?? 0.7,
+        stream
         };
+    
+        return requestParameters;
     }
 
     // Execute the request to the OpenAI Chat API
     async execute(text, parameters, prompt) {
         const url = this.requestUrl(text);
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
 
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/openAiCompletionPlugin.js

@@ -3,65 +3,81 @@ const ModelPlugin = require('./modelPlugin');
 const handlebars = require("handlebars");
 const { encode } = require("gpt-3-encoder");
 
-//convert a messages array to a simple chatML format
-const messagesToChatML = (messages) => {
-    let output = "";
-    if (messages && messages.length) {
-        for (let message of messages) {
-            output += (message.role && message.content) ? `<|im_start|>${message.role}\n${message.content}\n<|im_end|>\n` : `${message}\n`;
-        }
-        // you always want the assistant to respond next so add a
-        // directive for that
-        output += "<|im_start|>assistant\n";
-    }
-    return output;
-}
-
 class OpenAICompletionPlugin extends ModelPlugin {
     constructor(config, pathway) {
         super(config, pathway);
     }
 
-    // Set up parameters specific to the OpenAI Completion API
-    requestParameters(text, parameters, prompt) {
+    getCompiledPrompt(text, parameters, prompt) {
         const combinedParameters = { ...this.promptParameters, ...parameters };
         const modelPrompt = this.getModelPrompt(prompt, parameters);
         const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
         const modelPromptMessages = this.getModelPromptMessages(modelPrompt, combinedParameters, text);
-        const modelPromptMessagesML = messagesToChatML(modelPromptMessages);
-
-        const { stream } = parameters;
+        const modelPromptMessagesML = this.messagesToChatML(modelPromptMessages);
 
         if (modelPromptMessagesML) {
-        return {
-            prompt: modelPromptMessagesML,
-            max_tokens: this.getModelMaxTokenLength() - encode(modelPromptMessagesML).length - 1,
-            temperature: this.temperature ?? 0.7,
-            top_p: 0.95,
-            frequency_penalty: 0,
-            presence_penalty: 0,
-            stop: ["<|im_end|>"],
-            stream
-        };
+            return { modelPromptMessages, tokenLength: encode(modelPromptMessagesML).length };
         } else {
-        return {
-            prompt: modelPromptText,
-            max_tokens: this.getModelMaxTokenLength() - encode(modelPromptText).length - 1,
-            temperature: this.temperature ?? 0.7,
-            stream
-        };
+            return { modelPromptText, tokenLength: encode(modelPromptText).length };
         }
     }
 
+    // Set up parameters specific to the OpenAI Completion API
+    getRequestParameters(text, parameters, prompt) {
+        let { modelPromptMessages, modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+        let modelPromptMessagesML = '';
+        const modelMaxTokenLength = this.getModelMaxTokenLength();
+        let requestParameters = {};
+    
+        if (modelPromptMessages) {
+            const requestMessages = this.removeMessagesUntilTarget(modelPromptMessages, modelMaxTokenLength - 1);
+            modelPromptMessagesML = this.messagesToChatML(requestMessages);
+            tokenLength = encode(modelPromptMessagesML).length;
+        
+            if (tokenLength >= modelMaxTokenLength) {
+                throw new Error(`The maximum number of tokens for this model is ${modelMaxTokenLength}. Please reduce the number of messages in the prompt.`);
+            }
+        
+            const max_tokens = modelMaxTokenLength - tokenLength - 1;
+        
+            requestParameters = {
+                prompt: modelPromptMessagesML,
+                max_tokens: max_tokens,
+                temperature: this.temperature ?? 0.7,
+                top_p: 0.95,
+                frequency_penalty: 0,
+                presence_penalty: 0,
+                stop: ["<|im_end|>"],
+                stream
+            };
+        } else {
+            if (tokenLength >= modelMaxTokenLength) {
+                throw new Error(`The maximum number of tokens for this model is ${modelMaxTokenLength}. Please reduce the length of the prompt.`);
+            }
+        
+            const max_tokens = modelMaxTokenLength - tokenLength - 1;
+        
+            requestParameters = {
+                prompt: modelPromptText,
+                max_tokens: max_tokens,
+                temperature: this.temperature ?? 0.7,
+                stream
+            };
+        }
+    
+        return requestParameters;
+    }
+
     // Execute the request to the OpenAI Completion API
     async execute(text, parameters, prompt) {
         const url = this.requestUrl(text);
-        const requestParameters = this.requestParameters(text, parameters, prompt);
+        const requestParameters = this.getRequestParameters(text, parameters, prompt);
     
         const data = { ...(this.model.params || {}), ...requestParameters };
         const params = {};
         const headers = this.model.headers || {};
-        return this.executeRequest(url, data, params, headers);
+        return this.executeRequest(url, data, params, headers, prompt);
     }
 }
 

package/graphql/plugins/openAiWhisperPlugin.js

@@ -0,0 +1,79 @@
+// OpenAICompletionPlugin.js
+const ModelPlugin = require('./modelPlugin');
+const handlebars = require("handlebars");
+const { encode } = require("gpt-3-encoder");
+const FormData = require('form-data');
+const fs = require('fs');
+const { splitMediaFile, isValidYoutubeUrl, processYoutubeUrl, deleteTempPath } = require('../../lib/fileChunker');
+const pubsub = require('../pubsub');
+
+class OpenAIWhisperPlugin extends ModelPlugin {
+    constructor(config, pathway) {
+        super(config, pathway);
+    }
+
+    getCompiledPrompt(text, parameters, prompt) {
+        const combinedParameters = { ...this.promptParameters, ...parameters };
+        const modelPrompt = this.getModelPrompt(prompt, parameters);
+        const modelPromptText = modelPrompt.prompt ? handlebars.compile(modelPrompt.prompt)({ ...combinedParameters, text }) : '';
+    
+        return { modelPromptText, tokenLength: encode(modelPromptText).length };
+    }
+
+    // Execute the request to the OpenAI Whisper API
+    async execute(text, parameters, prompt, pathwayResolver) {
+        const url = this.requestUrl(text);
+        const params = {};
+        const { modelPromptText } = this.getCompiledPrompt(text, parameters, prompt);
+
+        const processChunk = async (chunk) => {
+            try {
+                const formData = new FormData();
+                formData.append('file', fs.createReadStream(chunk));
+                formData.append('model', this.model.params.model);
+                formData.append('response_format', 'text');
+                // formData.append('language', 'tr');
+                modelPromptText && formData.append('prompt', modelPromptText);
+
+                return this.executeRequest(url, formData, params, { ...this.model.headers, ...formData.getHeaders() });
+            } catch (err) {
+                console.log(err);
+            }
+        }
+
+        let result;
+        let { file } = parameters;
+        let folder;
+        const isYoutubeUrl = isValidYoutubeUrl(file);
+
+        try {
+            if (isYoutubeUrl) {
+                file = await processYoutubeUrl(file);
+            }
+
+            const mediaSplit = await splitMediaFile(file);
+
+            const { requestId } = pathwayResolver;
+            pubsub.publish('REQUEST_PROGRESS', {
+                requestProgress: {
+                    requestId,
+                    progress: 0.5,
+                    data: null,
+                }
+            });
+
+            folder = mediaSplit.folder;
+            result = await Promise.all(mediaSplit.chunks.map(processChunk));
+
+        } catch (error) {
+            console.error("An error occurred:", error);
+        } finally {
+            isYoutubeUrl && (await deleteTempPath(file));
+            folder && (await deleteTempPath(folder));
+        }
+        return result.join('');
+    }
+}
+
+module.exports = OpenAIWhisperPlugin;
+

package/graphql/prompt.js

@@ -12,6 +12,7 @@ class Prompt {
 
         this.usesTextInput = promptContains('text', this.prompt ? this.prompt : this.messages);
         this.usesPreviousResult = promptContains('previousResult', this.prompt ? this.prompt : this.messages);
+        this.debugInfo = '';
     }
 }
 

package/graphql/resolver.js

@@ -12,16 +12,16 @@ const rootResolver = async (parent, args, contextValue, info) => {
         info.cacheControl.setCacheHint({ maxAge: 60 * 60 * 24, scope: 'PUBLIC' });
     }
 
-    const pathwayResolver = new PathwayResolver({ config, pathway, requestState });
+    const pathwayResolver = new PathwayResolver({ config, pathway, args, requestState });
     contextValue.pathwayResolver = pathwayResolver;
 
-    // Add request parameters back as debug
-    const requestParameters = pathwayResolver.prompts.map((prompt) => pathwayResolver.pathwayPrompter.plugin.requestParameters(args.text, args, prompt));
-    const debug = JSON.stringify(requestParameters);
-
     // Execute the request with timeout
     const result = await fulfillWithTimeout(pathway.resolver(parent, args, contextValue, info), pathway.timeout);
     const { warnings, previousResult, savedContextId } = pathwayResolver;
+    
+    // Add request parameters back as debug
+    const debug = pathwayResolver.prompts.map(prompt => prompt.debugInfo || '').join('\n').trim();
+    
     return { debug, result, warnings, previousResult, contextId: savedContextId }
 }
 

package/graphql/typeDef.js

@@ -2,51 +2,60 @@ const GRAPHQL_TYPE_MAP = {
     boolean: 'Boolean',
     string: 'String',
     number: 'Int',
-}
-
-
-const typeDef = (pathway) => {
+  };
+  
+  const typeDef = (pathway) => {
     const { name, objName, defaultInputParameters, inputParameters, format } = pathway;
-
+  
     const fields = format ? format.match(/\b(\w+)\b/g) : null;
-    const fieldsStr = !fields ? `` : fields.map(f => `${f}: String`).join('\n    ');
-
+    const fieldsStr = !fields ? `` : fields.map((f) => `${f}: String`).join('\n    ');
+  
     const typeName = fields ? `${objName}Result` : `String`;
     const messageType = `input Message { role: String, content: String }`;
-
+  
     const type = fields ? `type ${typeName} {
-    ${fieldsStr}
-    }` : ``;
-
+      ${fieldsStr}
+      }` : ``;
+  
     const resultStr = pathway.list ? `[${typeName}]` : typeName;
-
+  
     const responseType = `type ${objName} {
-        debug: String
-        result: ${resultStr}
-        previousResult: String
-        warnings: [String]
-        contextId: String
-}`;
-
-
+          debug: String
+          result: ${resultStr}
+          previousResult: String
+          warnings: [String]
+          contextId: String
+  }`;
+  
     const params = { ...defaultInputParameters, ...inputParameters };
-
-    const paramsStr = Object.entries(params).map(
-        ([key, value]) => {
-            if (typeof value === 'object' && Array.isArray(value)) {
-                return `${key}: [Message] = []`;
-            } else {
-                return `${key}: ${GRAPHQL_TYPE_MAP[typeof (value)]} = ${typeof (value) === 'string' ? `"${value}"` : value}`;
-            }
+  
+    const paramsStr = Object.entries(params)
+      .map(([key, value]) => {
+        if (typeof value === 'object' && Array.isArray(value)) {
+          return `${key}: [Message] = []`;
+        } else {
+          return `${key}: ${GRAPHQL_TYPE_MAP[typeof value]} = ${
+            typeof value === 'string' ? `"${value}"` : value
+          }`;
         }
-        ).join('\n');
-          
-
-    const definition = `${messageType}\n\n${type}\n\n${responseType}\n\nextend type Query {${name}(${paramsStr}): ${objName}}`;
-    //console.log(definition);
-    return definition;
-}
-
-module.exports = {
+      })
+      .join('\n');
+  
+    const restDefinition = Object.entries(params).map(([key, value]) => {
+      return {
+        name: key,
+        type: `${GRAPHQL_TYPE_MAP[typeof value]}${typeof value === 'object' && Array.isArray(value) ? '[]' : ''}`,
+      };
+    });
+  
+    const gqlDefinition = `${messageType}\n\n${type}\n\n${responseType}\n\nextend type Query {${name}(${paramsStr}): ${objName}}`;
+  
+    return {
+      gqlDefinition,
+      restDefinition,
+    };
+  };
+  
+  module.exports = {
     typeDef,
-}
+  };