@aj-archipelago/cortex 1.0.5 → 1.0.7

package/server/plugins/palmCodeCompletionPlugin.js

@@ -0,0 +1,46 @@
+// palmCodeCompletionPlugin.js
+
+import PalmCompletionPlugin from './palmCompletionPlugin.js';
+
+// PalmCodeCompletionPlugin class for handling requests and responses to the PaLM API Code Completion API
+class PalmCodeCompletionPlugin extends PalmCompletionPlugin {
+    constructor(config, pathway, modelName, model) {
+        super(config, pathway, modelName, model);
+    }
+
+    // Set up parameters specific to the PaLM API Code Completion API
+    getRequestParameters(text, parameters, prompt, pathwayResolver) {
+        const { modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
+        const { stream } = parameters;
+        // Define the model's max token length
+        const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
+    
+        const truncatedPrompt = this.truncatePromptIfNecessary(modelPromptText, tokenLength, this.getModelMaxTokenLength(), modelTargetTokenLength, pathwayResolver);
+    
+        const max_tokens = this.getModelMaxReturnTokens();
+    
+        if (max_tokens < 0) {
+            throw new Error(`Prompt is too long to successfully call the model at ${tokenLength} tokens.  The model will not be called.`);
+        }
+
+        if (!truncatedPrompt) {
+            throw new Error(`Prompt is empty.  The model will not be called.`);
+        }
+    
+        const requestParameters = {
+            instances: [
+                { prefix: truncatedPrompt }
+            ],
+            parameters: {
+                temperature: this.temperature ?? 0.7,
+                maxOutputTokens: max_tokens,
+                topP: parameters.topP ?? 0.95,
+                topK: parameters.topK ?? 40,
+            }
+        };
+    
+        return requestParameters;
+    }
+}
+
+export default PalmCodeCompletionPlugin;

package/{graphql → server}/plugins/palmCompletionPlugin.js

@@ -2,23 +2,21 @@
 
 import ModelPlugin from './modelPlugin.js';
 
-// Helper function to truncate the prompt if it is too long
-const truncatePromptIfNecessary = (text, textTokenCount, modelMaxTokenCount, targetTextTokenCount, pathwayResolver) => {
-    const maxAllowedTokens = textTokenCount + ((modelMaxTokenCount - targetTextTokenCount) * 0.5);
-
-    if (textTokenCount > maxAllowedTokens) {
-        pathwayResolver.logWarning(`Prompt is too long at ${textTokenCount} tokens (this target token length for this pathway is ${targetTextTokenCount} tokens because the response is expected to take up the rest of the model's max tokens (${modelMaxTokenCount}). Prompt will be truncated.`);
-        return pathwayResolver.truncate(text, maxAllowedTokens);
-    }
-    return text;
-}
-
 // PalmCompletionPlugin class for handling requests and responses to the PaLM API Text Completion API
 class PalmCompletionPlugin extends ModelPlugin {
-    constructor(config, pathway) {
-        super(config, pathway);
+    constructor(config, pathway, modelName, model) {
+        super(config, pathway, modelName, model);
     }
 
+    truncatePromptIfNecessary (text, textTokenCount, modelMaxTokenCount, targetTextTokenCount, pathwayResolver) {
+        const maxAllowedTokens = textTokenCount + ((modelMaxTokenCount - targetTextTokenCount) * 0.5);
+    
+        if (textTokenCount > maxAllowedTokens) {
+            pathwayResolver.logWarning(`Prompt is too long at ${textTokenCount} tokens (this target token length for this pathway is ${targetTextTokenCount} tokens because the response is expected to take up the rest of the model's max tokens (${modelMaxTokenCount}). Prompt will be truncated.`);
+            return pathwayResolver.truncate(text, maxAllowedTokens);
+        }
+        return text;
+    }
     // Set up parameters specific to the PaLM API Text Completion API
     getRequestParameters(text, parameters, prompt, pathwayResolver) {
         const { modelPromptText, tokenLength } = this.getCompiledPrompt(text, parameters, prompt);
@@ -26,9 +24,9 @@ class PalmCompletionPlugin extends ModelPlugin {
         // Define the model's max token length
         const modelTargetTokenLength = this.getModelMaxTokenLength() * this.getPromptTokenRatio();
     
-        const truncatedPrompt = truncatePromptIfNecessary(modelPromptText, tokenLength, this.getModelMaxTokenLength(), modelTargetTokenLength, pathwayResolver);
+        const truncatedPrompt = this.truncatePromptIfNecessary(modelPromptText, tokenLength, this.getModelMaxTokenLength(), modelTargetTokenLength, pathwayResolver);
     
-        const max_tokens = 1024//this.getModelMaxTokenLength() - tokenLength;
+        const max_tokens = this.getModelMaxReturnTokens();
     
         if (max_tokens < 0) {
             throw new Error(`Prompt is too long to successfully call the model at ${tokenLength} tokens.  The model will not be called.`);

package/server/rest.js

@@ -0,0 +1,321 @@
+// rest.js
+// Implement the REST endpoints for the pathways
+
+import { json } from 'express';
+import pubsub from './pubsub.js';
+import { requestState } from './requestState.js';
+import { v4 as uuidv4 } from 'uuid';
+
+
+const processRestRequest = async (server, req, pathway, name, parameterMap = {}) => {
+    const fieldVariableDefs = pathway.typeDef(pathway).restDefinition || [];
+
+    const convertType = (value, type) => {
+        if (type === 'Boolean') {
+            return Boolean(value);
+        } else if (type === 'Int') {
+            return parseInt(value, 10);
+        } else {
+            return value;
+        }
+    };
+
+    const variables = fieldVariableDefs.reduce((acc, variableDef) => {
+        const requestBodyParamName = Object.keys(parameterMap).includes(variableDef.name)
+            ? parameterMap[variableDef.name]
+            : variableDef.name;
+
+        if (Object.prototype.hasOwnProperty.call(req.body, requestBodyParamName)) {
+            acc[variableDef.name] = convertType(req.body[requestBodyParamName], variableDef.type);
+        }
+        return acc;
+    }, {});
+
+    const variableParams = fieldVariableDefs.map(({ name, type }) => `$${name}: ${type}`).join(', ');
+    const queryArgs = fieldVariableDefs.map(({ name }) => `${name}: $${name}`).join(', ');
+
+    const query = `
+            query ${name}(${variableParams}) {
+                    ${name}(${queryArgs}) {
+                        contextId
+                        previousResult
+                        result
+                    }
+                }
+            `;
+
+    const result = await server.executeOperation({ query, variables });
+    const resultText = result?.body?.singleResult?.data?.[name]?.result || result?.body?.singleResult?.errors?.[0]?.message || "";
+
+    return resultText;
+};
+
+const processIncomingStream = (requestId, res, jsonResponse) => {
+
+    const startStream = (res) => {
+        // Set the headers for streaming
+        res.setHeader('Content-Type', 'text/event-stream');
+        res.setHeader('Cache-Control', 'no-cache');
+        res.setHeader('Connection', 'keep-alive');
+        res.flushHeaders();
+    }
+    
+    const finishStream = (res, jsonResponse) => {
+    
+        // If we haven't sent the stop message yet, do it now
+        if (jsonResponse.choices?.[0]?.finish_reason !== "stop") {
+    
+            let jsonEndStream = JSON.parse(JSON.stringify(jsonResponse));
+    
+            if (jsonEndStream.object === 'text_completion') {
+                jsonEndStream.choices[0].index = 0;
+                jsonEndStream.choices[0].finish_reason = "stop";
+                jsonEndStream.choices[0].text = "";
+            } else {
+                jsonEndStream.choices[0].finish_reason = "stop";
+                jsonEndStream.choices[0].index = 0;
+                jsonEndStream.choices[0].delta = {};
+            }
+    
+            //console.log(`REST SEND: data: ${JSON.stringify(jsonEndStream)}`);
+            res.write(`data: ${JSON.stringify(jsonEndStream)}\n\n`);
+        }
+    
+        //console.log(`REST SEND: data: [DONE]\n\n`);
+        res.write(`data: [DONE]\n\n`);
+    }
+
+    const sendStreamData = (data) => {
+        //console.log(`REST SEND: data: ${JSON.stringify(data)}`);
+        res.write(`data: ${JSON.stringify(data)}\n\n`);
+    }
+
+    const fillJsonResponse = (jsonResponse, inputText, finishReason) => {
+
+        jsonResponse.choices[0].finish_reason = finishReason;
+        if (jsonResponse.object === 'text_completion') {
+            jsonResponse.choices[0].text = inputText;
+        } else {
+            jsonResponse.choices[0].delta.content = inputText;
+        }
+
+        return jsonResponse;
+    }
+
+    startStream(res);
+
+    let subscription;
+
+    const unsubscribe = async () => {
+        if (subscription) {
+            pubsub.unsubscribe(await subscription);
+        }
+    }
+
+    subscription = pubsub.subscribe('REQUEST_PROGRESS', (data) => {
+        if (data.requestProgress.requestId === requestId) {
+            //console.log(`REQUEST_PROGRESS received progress: ${data.requestProgress.progress}, data: ${data.requestProgress.data}`);
+            
+            const progress = data.requestProgress.progress;
+            const progressData = data.requestProgress.data;
+
+            try {
+                const messageJson = JSON.parse(progressData);
+                if (messageJson.choices) {
+                    const { text, delta, finish_reason } = messageJson.choices[0];
+
+                    if (messageJson.object === 'text_completion') {
+                        fillJsonResponse(jsonResponse, text, finish_reason);
+                    } else {
+                        fillJsonResponse(jsonResponse, delta.content, finish_reason);
+                    }
+                } else {
+                    fillJsonResponse(jsonResponse, messageJson, null);
+                }
+            } catch (error) {
+                console.log(`progressData not JSON: ${progressData}`);
+                fillJsonResponse(jsonResponse, progressData, "stop");
+            }
+
+            if (progress === 1 && progressData.trim() === "[DONE]") {
+                finishStream(res, jsonResponse);
+                unsubscribe();
+                return;
+            }
+            sendStreamData(jsonResponse);
+
+            if (progress === 1) {
+                finishStream(res, jsonResponse);
+                unsubscribe();
+            }
+        }
+    });
+
+    // Fire the resolver for the async requestProgress
+    console.log(`Rest Endpoint starting async requestProgress, requestId: ${requestId}`);
+    const { resolver, args } = requestState[requestId];
+    resolver(args);
+
+    return subscription;
+  
+}
+
+function buildRestEndpoints(pathways, app, server, config) {
+
+    if (config.get('enableRestEndpoints')) {
+        const openAIChatModels = {};
+        const openAICompletionModels = {};
+
+        // Create normal REST endpoints or emulate OpenAI API per pathway
+        for (const [name, pathway] of Object.entries(pathways)) {
+            // Only expose endpoints for enabled pathways that explicitly want to expose a REST endpoint
+            if (pathway.disabled) continue;
+
+            // The pathway can either emulate an OpenAI endpoint or be a normal REST endpoint
+            if (pathway.emulateOpenAIChatModel || pathway.emulateOpenAICompletionModel) {
+                if (pathway.emulateOpenAIChatModel) {
+                    openAIChatModels[pathway.emulateOpenAIChatModel] = name;
+                }
+                if (pathway.emulateOpenAICompletionModel) {
+                        openAICompletionModels[pathway.emulateOpenAICompletionModel] = name;
+                }
+            } else {
+                app.post(`/rest/${name}`, async (req, res) => {
+                    const resultText = await processRestRequest(server, req, pathway, name);
+                    res.send(resultText);
+                });
+            }
+        }
+
+        // Create OpenAI compatible endpoints
+        app.post('/v1/completions', async (req, res) => {
+            const modelName = req.body.model || 'gpt-3.5-turbo';
+            const pathwayName = openAICompletionModels[modelName] || openAICompletionModels['*'];
+
+            if (!pathwayName) {
+                res.status(404).json({
+                    error: `Model ${modelName} not found.`,
+                });
+                return;
+            }
+
+            const pathway = pathways[pathwayName];
+
+            const parameterMap = {
+                text: 'prompt'
+            };
+
+            const resultText = await processRestRequest(server, req, pathway, pathwayName, parameterMap);
+
+            const jsonResponse = {
+                id: `cmpl`,
+                object: "text_completion",
+                created: Date.now(),
+                model: req.body.model,
+                choices: [
+                {
+                    text: resultText,
+                    index: 0,
+                    logprobs: null,
+                    finish_reason: "stop"
+                }
+                ],
+            };
+
+            if (Boolean(req.body.stream)) {
+                jsonResponse.id = `cmpl-${resultText}`;
+                jsonResponse.choices[0].finish_reason = null;
+                //jsonResponse.object = "text_completion.chunk";
+
+                const subscription = processIncomingStream(resultText, res, jsonResponse);
+            } else {
+                const requestId = uuidv4();
+                jsonResponse.id = `cmpl-${requestId}`;
+                res.json(jsonResponse);
+            };
+        });
+        
+        app.post('/v1/chat/completions', async (req, res) => {
+            const modelName = req.body.model || 'gpt-3.5-turbo';
+            const pathwayName = openAIChatModels[modelName] || openAIChatModels['*'];
+
+            if (!pathwayName) {
+                res.status(404).json({
+                    error: `Model ${modelName} not found.`,
+                });
+                return;
+            }
+
+            const pathway = pathways[pathwayName];
+
+            const resultText = await processRestRequest(server, req, pathway, pathwayName);
+
+            const jsonResponse = {
+                id: `chatcmpl`,
+                object: "chat.completion",
+                created: Date.now(),
+                model: req.body.model,
+                choices: [
+                    {
+                        message: {
+                            role: "assistant",
+                            content: resultText
+                        },
+                        index: 0,
+                        finish_reason: "stop"
+                    }
+                ],
+            };
+
+            if (Boolean(req.body.stream)) {
+                jsonResponse.id = `chatcmpl-${resultText}`;
+                jsonResponse.choices[0] = {
+                    delta: {
+                        role: "assistant",
+                        content: resultText
+                    },
+                    finish_reason: null
+                }
+                jsonResponse.object = "chat.completion.chunk";
+
+                const subscription = processIncomingStream(resultText, res, jsonResponse);
+            } else {
+                const requestId = uuidv4();
+                jsonResponse.id = `chatcmpl-${requestId}`;
+
+                res.json(jsonResponse);
+            }
+
+        });
+
+        app.get('/v1/models', async (req, res) => {
+            const openAIModels = { ...openAIChatModels, ...openAICompletionModels };
+            const defaultModelId = 'gpt-3.5-turbo';
+
+            const models = Object.entries(openAIModels)
+                .map(([modelId]) => {
+                    if (modelId.includes('*')) {
+                        modelId = defaultModelId;
+                    }
+                    return {
+                        id: modelId,
+                        object: 'model',
+                        owned_by: 'openai',
+                        permission: '',
+                    };
+                })
+                .filter((model, index, self) => {
+                    return index === self.findIndex((m) => m.id === model.id);
+                })
+                .sort((a, b) => a.id.localeCompare(b.id));
+
+            res.json({
+                data: models,
+                object: 'list',
+            });
+        });
+
+    }
+};
+
+export { buildRestEndpoints };

package/{graphql → server}/typeDef.js

@@ -1,8 +1,30 @@
-const GRAPHQL_TYPE_MAP = {
-    boolean: 'Boolean',
-    string: 'String',
-    number: 'Int',
-  };
+const getGraphQlType = (value) => {
+  switch (typeof value) {
+    case 'boolean':
+      return {type: 'Boolean', defaultValue: 'false'};
+      break;
+    case 'string':
+      return {type: 'String', defaultValue: `""`};
+      break;
+    case 'number':
+      return {type: 'Int', defaultValue: '0'};
+      break;
+    case 'object':
+      if (Array.isArray(value)) {
+        if (value.length > 0 && typeof(value[0]) === 'string') {
+          return {type: '[String]', defaultValue: '[]'};
+        }
+        else {
+          return {type: '[Message]', defaultValue: '[]'};
+        }
+      } else {
+        return {type: `[${value.objName}]`, defaultValue: 'null'};
+      }
+      break;
+    default:
+      return {type: 'String', defaultValue: `""`};
+  }
+};
 
 const typeDef = (pathway) => {
   const { name, objName, defaultInputParameters, inputParameters, format } = pathway;
@@ -31,20 +53,15 @@ const typeDef = (pathway) => {
 
   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 { type, defaultValue } = getGraphQlType(value);
+      return `${key}: ${type} = ${defaultValue}`;
     })
     .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) ? '[]' : ''}`,
+      type: `${getGraphQlType(value).type}`,
     };
   });
 

package/tests/chunkfunction.test.js

@@ -1,5 +1,6 @@
 import test from 'ava';
-import { getSemanticChunks } from '../graphql/chunker.js';
+import { getSemanticChunks, determineTextFormat } from '../server/chunker.js';
+
 import { encode } from 'gpt-3-encoder';
 
 const testText = `Lorem ipsum dolor sit amet, consectetur adipiscing elit. In id erat sem. Phasellus ac dapibus purus, in fermentum nunc. Mauris quis rutrum magna. Quisque rutrum, augue vel blandit posuere, augue magna convallis turpis, nec elementum augue mauris sit amet nunc. Aenean sit amet leo est. Nunc ante ex, blandit et felis ut, iaculis lacinia est. Phasellus dictum orci id libero ullamcorper tempor.
@@ -69,34 +70,119 @@ test('should return identical text that chunker was passed, given tiny chunk siz
     t.is(recomposedText, testText); //check recomposition
 });
 
-/*
-it('should return identical text that chunker was passed, given tiny chunk size (1)', () => {
-    const maxChunkToken = 1;
-    const chunks = getSemanticChunks(testText, maxChunkToken);
-    expect(chunks.length).toBeGreaterThan(1); //check chunking
-    expect(chunks.every(chunk => encode(chunk).length <= maxChunkToken)).toBe(true); //check chunk size
-    const recomposedText = chunks.reduce((acc, chunk) => acc + chunk, '');
-    expect(recomposedText).toBe(testText); //check recomposition
+const htmlChunkOne = `<p>Lorem ipsum dolor sit amet, consectetur adipiscing elit. <a href="https://www.google.com">Google</a></p> Vivamus id pharetra odio.   Sed consectetur leo sed tortor dictum venenatis.Donec gravida libero non accumsan suscipit.Donec lectus turpis, ullamcorper eu pulvinar iaculis, ornare ut risus.Phasellus aliquam, turpis quis viverra condimentum, risus est pretium    metus, in porta ipsum tortor vitae elit.Pellentesque id finibus erat.  In suscipit, sapien non posuere dignissim, augue nisl ultrices tortor, sit amet eleifend nibh elit at risus.`
+const htmlVoidElement = `<br>`
+const htmlChunkTwo = `<p><img src="https://www.google.com/googlelogo_color_272x92dp.png"></p>`
+const htmlSelfClosingElement = `<img src="https://www.google.com/images/branding/googlelogo/1x/googlelogo_color_272x92dp.png" />`
+const plainTextChunk = 'Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae; Fusce at dignissim quam.'
+
+test('should throw an error if html cannot be accommodated within the chunk size', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const error = t.throws(() => getSemanticChunks(htmlChunkTwo, chunkSize - 1, 'html'));
+    t.is(error.message, 'The HTML contains elements that are larger than the chunk size. Please try again with HTML that has smaller elements.');
+});
+
+test('should chunk text between html elements if needed', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const chunks = getSemanticChunks(htmlChunkTwo + plainTextChunk + htmlChunkTwo, chunkSize, 'html');
+    
+    t.is(chunks.length, 4);
+    t.is(chunks[0], htmlChunkTwo);
+    t.is(chunks[1], 'Vestibulum ante ipsum primis in faucibus orci luctus et ultrices posuere cubilia curae');
+    t.is(encode(chunks[1]).length, chunkSize);
+    t.is(chunks[2], '; Fusce at dignissim quam.');
+    t.is(chunks[3], htmlChunkTwo);
+});
+
+test('should chunk html element correctly when chunk size is exactly the same as the element length', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const chunks = getSemanticChunks(htmlChunkTwo, chunkSize, 'html');
+    
+    t.is(chunks.length, 1);
+    t.is(chunks[0], htmlChunkTwo);
+});
+
+test('should chunk html element correctly when chunk size is greater than the element length', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const chunks = getSemanticChunks(htmlChunkTwo, chunkSize + 1, 'html');
+    
+    t.is(chunks.length, 1);
+    t.is(chunks[0], htmlChunkTwo);
+});
+
+test('should not break up second html element correctly when chunk size is greater than the first element length', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const chunks = getSemanticChunks(htmlChunkTwo + htmlChunkTwo, chunkSize + 10, 'html');
+    
+    t.is(chunks.length, 2);
+    t.is(chunks[0], htmlChunkTwo);
+    t.is(chunks[1], htmlChunkTwo);
+});
+
+test('should treat text chunks as also unbreakable chunks', async t => {
+    const chunkSize = encode(htmlChunkTwo).length;
+    const chunks = getSemanticChunks(htmlChunkTwo + plainTextChunk + htmlChunkTwo, chunkSize + 20, 'html');
+    
+    t.is(chunks.length, 3);
+    t.is(chunks[0], htmlChunkTwo);
+    t.is(chunks[1], plainTextChunk);
+    t.is(chunks[2], htmlChunkTwo);
+});
+
+
+test('should determine format correctly for text only', async t => {
+    const format = determineTextFormat(plainTextChunk);
+    t.is(format, 'text');
+});
+
+test('should determine format correctly for simple html element', async t => {
+    const format = determineTextFormat(htmlChunkTwo);
+    t.is(format, 'html');
+});
+
+test('should determine format correctly for simple html element embedded in text', async t => {
+    const format = determineTextFormat(plainTextChunk + htmlChunkTwo + plainTextChunk);
+    t.is(format, 'html');
+});
+
+test('should determine format correctly for self-closing html element', async t => {
+    const format = determineTextFormat(htmlSelfClosingElement);
+    t.is(format, 'html');
+});
+
+test('should determine format correctly for self-closing html element embedded in text', async t => {
+    const format = determineTextFormat(plainTextChunk + htmlSelfClosingElement + plainTextChunk);
+    t.is(format, 'html');
+});
+
+test('should determine format correctly for void element', async t => {
+    const format = determineTextFormat(htmlVoidElement);
+    t.is(format, 'html');
+});
+
+test('should determine format correctly for void element embedded in text', async t => {
+    const format = determineTextFormat(plainTextChunk + htmlVoidElement + plainTextChunk);
+    t.is(format, 'html');
 });
 
-it('should return identical text that chunker was passed, given huge chunk size (32000)', () => {
+test('should return identical text that chunker was passed, given huge chunk size (32000)', t => {
     const maxChunkToken = 32000;
     const chunks = getSemanticChunks(testText, maxChunkToken);
-    expect(chunks.length).toBe(1); //check chunking
-    expect(chunks.every(chunk => encode(chunk).length <= maxChunkToken)).toBe(true); //check chunk size
+    t.assert(chunks.length === 1); //check chunking
+    t.assert(chunks.every(chunk => encode(chunk).length <= maxChunkToken)); //check chunk size
     const recomposedText = chunks.reduce((acc, chunk) => acc + chunk, '');
-    expect(recomposedText).toBe(testText); //check recomposition
+    t.assert(recomposedText === testText); //check recomposition
 });
 
 const testTextNoSpaces = `Loremipsumdolorsitamet,consecteturadipiscingelit.Inideratsem.Phasellusacdapibuspurus,infermentumnunc.Maurisquisrutrummagna.Quisquerutrum,auguevelblanditposuere,auguemagnacon vallisturpis,necelementumauguemaurissitametnunc.Aeneansitametleoest.Nuncanteex,blanditetfelisut,iaculislaciniaest.Phasellusdictumorciidliberoullamcorpertempor.Vivamusidpharetraodioq.Sedconsecteturleosedtortordictumvenenatis.Donecgravidaliberononaccumsansuscipit.Doneclectusturpis,ullamcorpereupulvinariaculis,ornareutrisus.Phasellusaliquam,turpisquisviverracondimentum,risusestpretiummetus,inportaips umtortorvita elit.Pellentesqueidfinibuserat.Insuscipit,sapiennonposueredignissim,auguenisl ultricestortor,sitameteleifendnibhelitatrisus.`;
 
-it('should return identical text that chunker was passed, given no spaces and small chunks(5)', () => {
+test('should return identical text that chunker was passed, given no spaces and small chunks(5)', t => {
     const maxChunkToken = 5;
     const chunks = getSemanticChunks(testTextNoSpaces, maxChunkToken);
-    expect(chunks.length).toBeGreaterThan(0); //check chunking
-    expect(chunks.every(chunk => encode(chunk).length <= maxChunkToken)).toBe(true); //check chunk size
+    t.assert(chunks.length > 0); //check chunking
+    t.assert(chunks.every(chunk => encode(chunk).length <= maxChunkToken)); //check chunk size
     const recomposedText = chunks.reduce((acc, chunk) => acc + chunk, '');
-    expect(recomposedText).toBe(testTextNoSpaces); //check recomposition
+    t.assert(recomposedText === testTextNoSpaces); //check recomposition
 });
 
 const testTextShortWeirdSpaces=`Lorem ipsum dolor sit amet, consectetur adipiscing elit. In id erat sem. Phasellus ac dapibus purus, in fermentum nunc.............................. Mauris quis rutrum magna. Quisque rutrum, augue vel blandit posuere, augue magna convallis turpis, nec elementum augue mauris sit amet nunc. Aenean sit a;lksjdf 098098- -23 eln ;lkn l;kn09 oij[0u ,,,,,,,,,,,,,,,,,,,,, amet leo est. Nunc ante ex, blandit et felis ut, iaculis lacinia est. Phasellus dictum orci id libero ullamcorper tempor.
@@ -106,20 +192,20 @@ const testTextShortWeirdSpaces=`Lorem ipsum dolor sit amet, consectetur adipisci
 
     Vivamus id pharetra odio.   Sed consectetur leo sed tortor dictum venenatis.Donec gravida libero non accumsan suscipit.Donec lectus turpis, ullamcorper eu pulvinar iaculis, ornare ut risus.Phasellus aliquam, turpis quis viverra condimentum, risus est pretium    metus, in porta ipsum tortor vitae elit.Pellentesque id finibus erat.  In suscipit, sapien non posuere dignissim, augue nisl ultrices tortor, sit amet eleifend nibh elit at risus.`;
 
-it('should return identical text that chunker was passed, given weird spaces and tiny chunks(1)', () => {
+test('should return identical text that chunker was passed, given weird spaces and tiny chunks(1)', t => {
     const maxChunkToken = 1;
     const chunks = getSemanticChunks(testTextShortWeirdSpaces, maxChunkToken);
-    expect(chunks.length).toBeGreaterThan(0); //check chunking
-    expect(chunks.every(chunk => encode(chunk).length <= maxChunkToken)).toBe(true); //check chunk size
+    t.assert(chunks.length > 0); //check chunking
+    t.assert(chunks.every(chunk => encode(chunk).length <= maxChunkToken)); //check chunk size
     const recomposedText = chunks.reduce((acc, chunk) => acc + chunk, '');
-    expect(recomposedText).toBe(testTextShortWeirdSpaces); //check recomposition
+    t.assert(recomposedText === testTextShortWeirdSpaces); //check recomposition
 });
 
-it('should return identical text that chunker was passed, given weird spaces and small chunks(10)', () => {
+test('should return identical text that chunker was passed, given weird spaces and small chunks(10)', t => {
     const maxChunkToken = 1;
     const chunks = getSemanticChunks(testTextShortWeirdSpaces, maxChunkToken);
-    expect(chunks.length).toBeGreaterThan(0); //check chunking
-    expect(chunks.every(chunk => encode(chunk).length <= maxChunkToken)).toBe(true); //check chunk size
+    t.assert(chunks.length > 0); //check chunking
+    t.assert(chunks.every(chunk => encode(chunk).length <= maxChunkToken)); //check chunk size
     const recomposedText = chunks.reduce((acc, chunk) => acc + chunk, '');
-    expect(recomposedText).toBe(testTextShortWeirdSpaces); //check recomposition
-});*/
+    t.assert(recomposedText === testTextShortWeirdSpaces); //check recomposition
+});

package/tests/config.test.js

@@ -45,7 +45,7 @@ test('config enableRestEndpoints', (t) => {
 });
 
 test('config openaiDefaultModel', (t) => {
-    const expectedDefault = 'text-davinci-003';
+    const expectedDefault = 'gpt-3.5-turbo';
     t.is(config.get('openaiDefaultModel'), expectedDefault);
 });