@aj-archipelago/cortex 1.0.2 → 1.0.3

package/helper_apps/MediaFileChunker/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "@aj-archipelago/mediafilechunker",
+  "version": "1.0.0",
+  "description": "",
+  "type": "module",
+  "scripts": {
+    "start": "node start.js",
+    "test": "echo \"No tests yet...\""
+  },
+  "dependencies": {
+    "@azure/storage-blob": "^12.13.0",
+    "@ffmpeg-installer/ffmpeg": "^1.1.0",
+    "@ffprobe-installer/ffprobe": "^2.0.0",
+    "busboy": "^1.6.0",
+    "express": "^4.18.2",
+    "fluent-ffmpeg": "^2.1.2",
+    "ioredis": "^5.3.1",
+    "public-ip": "^6.0.1",
+    "uuid": "^9.0.0",
+    "ytdl-core": "git+ssh://git@github.com:khlevon/node-ytdl-core.git#v4.11.3-patch.1"
+  }
+}

package/helper_apps/MediaFileChunker/redis.js

@@ -0,0 +1,32 @@
+import redis from 'ioredis';
+const connectionString = process.env["REDIS_CONNECTION_STRING"];
+const client = redis.createClient(connectionString);
+// client.connect();
+
+const channel = 'requestProgress';
+
+const connectClient = async () => {
+    if (!client.connected) {
+        try {
+            await client.connect();
+        } catch (error) {
+            console.error(`Error reconnecting to Redis: ${error}`);
+            return;
+        }
+    }
+};
+
+const publishRequestProgress = async (data) => {
+    // await connectClient();
+    try {
+        const message = JSON.stringify(data);
+        console.log(`Publishing message ${message} to channel ${channel}`);
+        await client.publish(channel, message);
+    } catch (error) {
+        console.error(`Error publishing message: ${error}`);
+    }
+};
+
+export {
+    publishRequestProgress, connectClient
+}

package/helper_apps/MediaFileChunker/start.js

@@ -0,0 +1,27 @@
+import MediaFileChunker from "./index.js";
+import express from "express";
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+import { publicIpv4 } from 'public-ip';
+const ipAddress = await publicIpv4();
+
+const app = express();
+const port = process.env.PORT || 7071;
+const publicFolder = join(dirname(fileURLToPath(import.meta.url)), 'files');
+
+
+// Serve static files from the public folder
+app.use('/files', express.static(publicFolder));
+
+app.all('/api/MediaFileChunker', async (req, res) => {
+    const context = { req, res, log: console.log }
+    await MediaFileChunker(context, req);
+    res.send(context.res.body);
+});
+
+app.listen(port, () => {
+    console.log(`MediaFileChunker helper running on port ${port}`);
+});
+
+export { port, publicFolder, ipAddress };

package/lib/handleBars.js

@@ -0,0 +1,26 @@
+// handleBars.js
+
+import HandleBars from 'handlebars';
+
+// register functions that can be called directly in the prompt markdown
+HandleBars.registerHelper('stripHTML', function (value) {
+    return value.replace(/<[^>]*>/g, '');
+});
+
+HandleBars.registerHelper('now', function () {
+    return new Date().toISOString();
+});
+
+HandleBars.registerHelper('toJSON', function (object) {
+    return JSON.stringify(object);
+});
+
+HandleBars.registerHelper('ctoW', function (value) {
+    // if value is not a number, return it
+    if (isNaN(value)) {
+        return value;
+    }
+    return Math.round(value / 6.6);
+});
+
+export default HandleBars;

package/lib/pathwayTools.js

@@ -0,0 +1,15 @@
+// pathwayTools.js
+
+// callPathway - call a pathway from another pathway
+const callPathway = async (config, pathwayName, args) => {
+    const pathway = config.get(`pathways.${pathwayName}`);
+    if (!pathway) {
+        throw new Error(`Pathway ${pathwayName} not found`);
+    }
+    const requestState = {};
+    const parent = {};
+    const data = await pathway.rootResolver(parent, args, { config, pathway, requestState } );
+    return data?.result;
+};
+
+export { callPathway };

package/lib/redisSubscription.js

@@ -0,0 +1,51 @@
+import Redis from 'ioredis';
+import { config } from '../config.js';
+import pubsub from '../graphql/pubsub.js';
+
+const connectionString = config.get('storageConnectionString');
+const client = new Redis(connectionString);
+
+const channel = 'requestProgress';
+
+client.on('error', (error) => {
+    console.error(`Redis client error: ${error}`);
+});
+
+client.on('connect', () => {
+    client.subscribe(channel, (error) => {
+        if (error) {
+            console.error(`Error subscribing to channel ${channel}: ${error}`);
+        } else {
+            console.log(`Subscribed to channel ${channel}`);
+        }
+    });
+});
+
+client.on('message', (channel, message) => {
+    if (channel === 'requestProgress') {
+        console.log(`Received message from ${channel}: ${message}`);
+        let parsedMessage;
+
+        try {
+            parsedMessage = JSON.parse(message);
+        } catch (error) {
+            parsedMessage = message;
+        }
+
+        handleMessage(parsedMessage);
+    }
+});
+
+const handleMessage = (data) => {
+    // Process the received data
+    console.log('Processing data:', data);
+    try {
+        pubsub.publish('REQUEST_PROGRESS', { requestProgress: data });
+    } catch (error) {
+        console.error(`Error publishing data to pubsub: ${error}`);
+    }
+};
+
+export {
+    client as subscriptionClient,
+};

package/lib/request.js

@@ -80,8 +80,8 @@ const postRequest = async ({ url, data, params, headers, cache }, model) => {
             }           
             return await limiters[model].schedule(() => postWithMonitor(model, url, data, axiosConfigObj));
         } catch (e) {
-            console.error(`Failed request with data ${JSON.stringify(data)}: ${e}`);
-            if (e.response.status && e.response.status === 429) {
+            console.error(`Failed request with data ${JSON.stringify(data)}: ${e} - ${e.response?.data?.error?.type || 'error'}: ${e.response?.data?.error?.message}`);
+            if (e.response?.status && e.response?.status === 429) {
                 monitors[model].incrementError429Count();
             }
             errors.push(e);
@@ -94,7 +94,7 @@ const request = async (params, model) => {
     const response = await postRequest(params, model);
     const { error, data, cached } = response;
     if (cached) {
-        console.info('/Request served with cached response.');
+        console.info('=== Request served with cached response. ===');
     }
     if (error && error.length > 0) {
         const lastError = error[error.length - 1];
@@ -105,5 +105,5 @@ const request = async (params, model) => {
 }
 
 export {
-    request, postRequest, buildLimiters
+    axios,request, postRequest, buildLimiters
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aj-archipelago/cortex",
-  "version": "1.0.2",
+  "version": "1.0.3",
   "description": "Cortex is a GraphQL API for AI. It provides a simple, extensible interface for using AI services from OpenAI, Azure and others.",
   "repository": {
     "type": "git",
@@ -29,7 +29,6 @@
   "homepage": "https://github.com/aj-archipelago/cortex#readme",
   "dependencies": {
     "@apollo/utils.keyvadapter": "^1.1.2",
-    "@ffmpeg-installer/ffmpeg": "^1.1.0",
     "@graphql-tools/schema": "^9.0.12",
     "@keyv/redis": "^2.5.4",
     "apollo-server": "^3.12.0",
@@ -43,24 +42,24 @@
     "compromise-paragraphs": "^0.1.0",
     "convict": "^6.2.3",
     "express": "^4.18.2",
-    "fluent-ffmpeg": "^2.1.2",
     "form-data": "^4.0.0",
     "gpt-3-encoder": "^1.1.4",
     "graphql": "^16.6.0",
     "graphql-subscriptions": "^2.0.0",
     "graphql-ws": "^5.11.2",
     "handlebars": "^4.7.7",
+    "ioredis": "^5.3.1",
     "keyv": "^4.5.2",
     "langchain": "^0.0.47",
     "uuid": "^9.0.0",
-    "ws": "^8.12.0",
-    "ytdl-core": "^4.11.2"
+    "ws": "^8.12.0"
   },
   "devDependencies": {
     "ava": "^5.2.0",
     "dotenv": "^16.0.3",
     "eslint": "^8.38.0",
-    "eslint-plugin-import": "^2.27.5"
+    "eslint-plugin-import": "^2.27.5",
+    "sinon": "^15.0.3"
   },
   "publishConfig": {
     "access": "restricted"

package/pathways/transcribe.js

@@ -3,8 +3,9 @@ export default {
     model: `oai-whisper`,
     inputParameters: {
         file: ``,
+        language: ``,
     },
-    timeout: 600, // in seconds
+    timeout: 1800, // in seconds
 };
 
 

package/tests/config.test.js

@@ -0,0 +1,69 @@
+// config.test.js
+
+import test from 'ava';
+import path from 'path';
+import { config, buildPathways, buildModels } from '../config.js';
+
+test.before(async () => {
+    await buildPathways(config);
+    buildModels(config);
+});
+
+test('config pathwaysPath', (t) => {
+    const expectedDefault = path.join(process.cwd(), '/pathways');
+    t.is(config.get('pathwaysPath'), expectedDefault);
+});
+
+test('config corePathwaysPath', (t) => {
+    const expectedPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'pathways');
+    t.is(config.get('corePathwaysPath'), expectedPath);
+});
+
+test('config basePathwayPath', (t) => {
+    const expectedPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', 'pathways', 'basePathway.js');
+    t.is(config.get('basePathwayPath'), expectedPath);
+});
+
+test('config PORT', (t) => {
+    const expectedDefault = 4000;
+    t.is(config.get('PORT'), expectedDefault);
+});
+
+test('config enableCache', (t) => {
+    const expectedDefault = true;
+    t.is(config.get('enableCache'), expectedDefault);
+});
+
+test('config enableGraphqlCache', (t) => {
+    const expectedDefault = false;
+    t.is(config.get('enableGraphqlCache'), expectedDefault);
+});
+
+test('config enableRestEndpoints', (t) => {
+    const expectedDefault = false;
+    t.is(config.get('enableRestEndpoints'), expectedDefault);
+});
+
+test('config openaiDefaultModel', (t) => {
+    const expectedDefault = 'text-davinci-003';
+    t.is(config.get('openaiDefaultModel'), expectedDefault);
+});
+
+test('config openaiApiUrl', (t) => {
+    const expectedDefault = 'https://api.openai.com/v1/completions';
+    t.is(config.get('openaiApiUrl'), expectedDefault);
+});
+
+test('buildPathways adds pathways to config', (t) => {
+    const pathways = config.get('pathways');
+    t.true(Object.keys(pathways).length > 0);
+});
+
+test('buildModels adds models to config', (t) => {
+    const models = config.get('models');
+    t.true(Object.keys(models).length > 0);
+});
+
+test('buildModels sets defaultModelName if not provided', (t) => {
+    t.truthy(config.get('defaultModelName'));
+});

package/tests/handleBars.test.js

@@ -0,0 +1,43 @@
+// handleBars.test.js
+
+import test from 'ava';
+import HandleBars from '../lib/handleBars.js';
+
+test('stripHTML', (t) => {
+    const stringWithHTML = '<h1>Hello, World!</h1>';
+    const expectedResult = 'Hello, World!';
+
+    const result = HandleBars.helpers.stripHTML(stringWithHTML);
+    t.is(result, expectedResult);
+});
+
+test('now', (t) => {
+    const expectedResult = new Date().toISOString();
+
+    const result = HandleBars.helpers.now();
+    t.is(result.slice(0, 10), expectedResult.slice(0, 10)); // Comparing only the date part
+});
+
+test('toJSON', (t) => {
+    const object = { key: 'value' };
+    const expectedResult = '{"key":"value"}';
+
+    const result = HandleBars.helpers.toJSON(object);
+    t.is(result, expectedResult);
+});
+
+test('ctoW', (t) => {
+    const value = 66;
+    const expectedResult = 10;
+
+    const result = HandleBars.helpers.ctoW(value);
+    t.is(result, expectedResult);
+});
+
+test('ctoW non-numeric', (t) => {
+    const value = 'Hello, World!';
+    const expectedResult = 'Hello, World!';
+
+    const result = HandleBars.helpers.ctoW(value);
+    t.is(result, expectedResult);
+});

package/tests/mocks.js

@@ -0,0 +1,39 @@
+import { Prompt } from '../graphql/prompt.js';
+
+export const mockConfig = {
+    get: (key) => {
+      const configs = {
+        defaultModelName: 'testModel',
+        models: {
+          testModel: {
+            url: 'https://api.example.com/testModel',
+            type: 'OPENAI-COMPLETION',
+          },
+        },
+      };
+      return configs[key];
+    },
+    getEnv: () => ({}),
+  };
+  
+  export const mockPathwayString = {
+    model: 'testModel',
+    prompt: new Prompt('User: {{text}}\nAssistant: Please help {{name}} who is {{age}} years old.'),
+  };
+
+  export const mockPathwayFunction = {
+    model: 'testModel',
+    prompt: () => {
+        return new Prompt('User: {{text}}\nAssistant: Please help {{name}} who is {{age}} years old.')
+    },
+  };
+
+  export const mockPathwayMessages = {
+    model: 'testModel',
+    prompt: new Prompt({
+        messages: [
+          { role: 'user', content: 'Translate this: {{{text}}}' },
+          { role: 'assistant', content: 'Translating: {{{text}}}' },
+        ],
+      }),
+  };

package/tests/modelPlugin.test.js

@@ -0,0 +1,129 @@
+// test/ModelPlugin.test.js
+import test from 'ava';
+import ModelPlugin from '../graphql/plugins/modelPlugin.js';
+import HandleBars from '../lib/handleBars.js';
+import { mockConfig, mockPathwayString, mockPathwayFunction, mockPathwayMessages } from './mocks.js';
+
+const DEFAULT_MAX_TOKENS = 4096;
+const DEFAULT_PROMPT_TOKEN_RATIO = 0.5;
+
+// Mock configuration and pathway objects
+const config = mockConfig;
+const pathway = mockPathwayString;
+
+test('ModelPlugin constructor', (t) => {
+    const modelPlugin = new ModelPlugin(config, pathway);
+
+    t.is(modelPlugin.modelName, pathway.model, 'modelName should be set from pathway');
+    t.deepEqual(modelPlugin.model, config.get('models')[pathway.model], 'model should be set from config');
+    t.is(modelPlugin.temperature, pathway.temperature, 'temperature should be set from pathway');
+    t.is(modelPlugin.pathwayPrompt, pathway.prompt, 'pathwayPrompt should be set from pathway');
+});
+
+test.beforeEach((t) => {
+  t.context.modelPlugin = new ModelPlugin(mockConfig, mockPathwayString);
+});
+
+test('getCompiledPrompt - text and parameters', (t) => {
+  const { modelPlugin } = t.context;
+  const text = 'Hello, World!';
+  const parameters = { name: 'John', age: 30 };
+
+  const { modelPromptText, tokenLength } = modelPlugin.getCompiledPrompt(text, parameters, pathway.prompt);
+
+  t.true(modelPromptText.includes(text));
+  t.true(modelPromptText.includes(parameters.name));
+  t.true(modelPromptText.includes(parameters.age.toString()));
+  t.is(typeof tokenLength, 'number');
+});
+
+test('getCompiledPrompt - custom prompt function', (t) => {
+  const { modelPlugin } = t.context;
+  const text = 'Hello, World!';
+  const parameters = { name: 'John', age: 30 };
+
+  const { modelPromptText, tokenLength } = modelPlugin.getCompiledPrompt(text, parameters, mockPathwayFunction.prompt);
+
+  t.true(modelPromptText.includes(text));
+  t.true(modelPromptText.includes(parameters.name));
+  t.true(modelPromptText.includes(parameters.age.toString()));
+  t.is(typeof tokenLength, 'number');
+});
+
+test('getCompiledPrompt - model prompt messages', (t) => {
+  const { modelPlugin } = t.context;
+  const text = 'Translate the following text to French: "Hello, World!"';
+  const parameters = {}
+
+  const { modelPromptMessages, tokenLength } = modelPlugin.getCompiledPrompt(text, parameters, mockPathwayMessages.prompt);
+
+  t.true(modelPromptMessages[0].content.includes(text));
+  t.true(modelPromptMessages[1].content.includes(text));
+  t.is(typeof tokenLength, 'number');
+});
+
+test('getModelMaxTokenLength', (t) => {
+    const { modelPlugin } = t.context;
+    t.is(modelPlugin.getModelMaxTokenLength(), DEFAULT_MAX_TOKENS, 'getModelMaxTokenLength should return default max tokens');
+});
+
+test('getPromptTokenRatio', (t) => {
+    const { modelPlugin } = t.context;
+    t.is(modelPlugin.getPromptTokenRatio(), DEFAULT_PROMPT_TOKEN_RATIO, 'getPromptTokenRatio should return default prompt token ratio');
+});
+
+test('requestUrl', (t) => {
+    const { modelPlugin } = t.context;
+
+    const expectedUrl = HandleBars.compile(modelPlugin.model.url)({ ...modelPlugin.model, ...config.getEnv(), ...config });
+    t.is(modelPlugin.requestUrl(), expectedUrl, 'requestUrl should return the correct URL');
+});
+
+test('parseResponse - single choice', (t) => {
+    const { modelPlugin } = t.context;
+    const singleChoiceResponse = {
+        choices: [{
+            text: '42'
+        }]
+    };
+
+    const result = modelPlugin.parseResponse(singleChoiceResponse);
+    t.is(result, '42', 'parseResponse should return the correct value for a single choice response');
+});
+
+test('parseResponse - multiple choices', (t) => {
+    const { modelPlugin } = t.context;
+    const multipleChoicesResponse = {
+        choices: [
+            { text: '42' },
+            { text: 'life' }
+        ]
+    };
+
+    const result = modelPlugin.parseResponse(multipleChoicesResponse);
+    t.deepEqual(result, multipleChoicesResponse.choices, 'parseResponse should return the choices array for multiple choices response');
+});
+
+test('truncateMessagesToTargetLength', (t) => {
+    const { modelPlugin } = t.context;
+    const messages = [
+        { role: 'user', content: 'What is the meaning of life?' },
+        { role: 'assistant', content: 'The meaning of life is a philosophical question regarding the purpose and significance of life or existence in general.' }
+    ];
+    const targetTokenLength = 10;
+
+    const result = modelPlugin.truncateMessagesToTargetLength(messages, targetTokenLength);
+    t.true(Array.isArray(result), 'truncateMessagesToTargetLength should return an array');
+    t.true(result.length <= messages.length, 'truncateMessagesToTargetLength should not return more messages than the input');
+});
+
+test('messagesToChatML', (t) => {
+    const { modelPlugin } = t.context;
+    const messages = [
+        { role: 'user', content: 'What is the meaning of life?' },
+        { role: 'assistant', content: 'The meaning of life is a philosophical question regarding the purpose and significance of life or existence in general.' }
+    ];
+
+    const result = modelPlugin.messagesToChatML(messages);
+    t.is(typeof result, 'string', 'messagesToChatML should return a string');
+});

package/tests/pathwayResolver.test.js

@@ -0,0 +1,77 @@
+import test from 'ava';
+import { PathwayResolver } from '../graphql/pathwayResolver.js';
+import sinon from 'sinon';
+import { mockConfig, mockPathwayString } from './mocks.js';
+
+const mockPathway = mockPathwayString;
+mockPathway.useInputChunking = false;
+mockPathway.prompt = 'What is AI?';
+
+const mockArgs = {
+  text: 'Artificial intelligence',
+};
+
+test.beforeEach((t) => {
+  t.context.pathwayResolver = new PathwayResolver({
+    config: mockConfig,
+    pathway: mockPathway,
+    args: mockArgs,
+  });
+});
+
+test('constructor initializes properties correctly', (t) => {
+  const resolver = t.context.pathwayResolver;
+  t.deepEqual(resolver.config, mockConfig);
+  t.deepEqual(resolver.pathway, mockPathway);
+  t.deepEqual(resolver.args, mockArgs);
+  t.is(resolver.useInputChunking, mockPathway.useInputChunking);
+  t.is(typeof resolver.requestId, 'string');
+});
+
+test('resolve returns request id when async is true', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const requestId = await resolver.resolve({ ...mockArgs, async: true });
+  t.is(typeof requestId, 'string');
+  t.is(requestId, resolver.requestId);
+});
+
+test('resolve calls promptAndParse when async is false', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const promptAndParseStub = sinon.stub(resolver, 'promptAndParse').returns(Promise.resolve('test-result'));
+
+  const result = await resolver.resolve(mockArgs);
+  t.true(promptAndParseStub.calledOnce);
+  t.is(result, 'test-result');
+});
+
+test('processInputText returns input text if no chunking', (t) => {
+  const resolver = t.context.pathwayResolver;
+  const text = 'This is a test input text';
+  const result = resolver.processInputText(text);
+  t.deepEqual(result, [text]);
+});
+
+test('applyPromptsSerially returns result of last prompt', async (t) => {
+  const resolver = t.context.pathwayResolver;
+  const text = 'This is a test input text';
+  const applyPromptStub = sinon.stub(resolver, 'applyPrompt');
+  applyPromptStub.onCall(0).returns(Promise.resolve('result1'));
+  applyPromptStub.onCall(1).returns(Promise.resolve('result2'));
+
+  resolver.pathwayPrompt = ['prompt1', 'prompt2'];
+  const result = await resolver.applyPromptsSerially(text, mockArgs);
+
+  t.is(result, 'result2');
+});
+
+test('processRequest returns empty result when input text is empty', async (t) => {
+    const resolver = t.context.pathwayResolver;
+    const text = '';
+    const processRequestStub = sinon.stub(resolver, 'processRequest').returns(Promise.resolve(''));
+  
+    await resolver.resolve({ ...mockArgs, text });
+  
+    t.true(processRequestStub.calledOnce);
+    const returnValue = await processRequestStub.firstCall.returnValue;
+    t.is(returnValue, text);
+  });