@proteinjs/conversation 1.0.6 → 1.0.8

package/src/Conversation.ts

@@ -10,7 +10,7 @@ import { TiktokenModel, encoding_for_model } from 'tiktoken';
 import { searchLibrariesFunctionName } from './fs/package/PackageFunctions';
 
 export type ConversationParams = {
-  name: string,
+  name: string;
   modules?: ConversationModule[];
   logLevel?: LogLevel;
   limits?: {
@@ -18,7 +18,7 @@ export type ConversationParams = {
     maxMessagesInHistory?: number;
     tokenLimit?: number;
   };
-}
+};
 
 export class Conversation {
   private tokenLimit = 3000;
@@ -33,26 +33,30 @@ export class Conversation {
 
   constructor(params: ConversationParams) {
     this.params = params;
-    this.history = new MessageHistory({ maxMessages: params.limits?.maxMessagesInHistory, enforceMessageLimit: params.limits?.enforceLimits });
+    this.history = new MessageHistory({
+      maxMessages: params.limits?.maxMessagesInHistory,
+      enforceMessageLimit: params.limits?.enforceLimits,
+    });
     this.logger = new Logger(params.name, params.logLevel);
 
-    if (params.modules)
+    if (params.modules) {
       this.addModules(params.modules);
+    }
 
     if (typeof params.limits?.enforceLimits === 'undefined' || params.limits.enforceLimits) {
-      this.addFunctions('Conversation', [
-        summarizeConversationHistoryFunction(this),
-      ]);
+      this.addFunctions('Conversation', [summarizeConversationHistoryFunction(this)]);
     }
 
-    if (params.limits?.tokenLimit)
+    if (params.limits?.tokenLimit) {
       this.tokenLimit = params.limits.tokenLimit;
+    }
   }
 
   private addModules(modules: ConversationModule[]) {
-    for (let module of modules) {
-      if (module.getSystemMessages().length < 1)
+    for (const module of modules) {
+      if (module.getSystemMessages().length < 1) {
         continue;
+      }
 
       this.addSystemMessagesToHistory([
         `The following are instructions from the ${module.getName()} module: ${module.getSystemMessages().join('. ')}`,
@@ -66,10 +70,11 @@ export class Conversation {
     this.functions.push(...functions);
     let functionInstructions = `The following are instructions from functions in the ${moduleName} module:`;
     let functionInstructionsAdded = false;
-    for (let f of functions) {
+    for (const f of functions) {
       if (f.instructions) {
-        if (!f.instructions || f.instructions.length < 1)
+        if (!f.instructions || f.instructions.length < 1) {
           continue;
+        }
 
         functionInstructionsAdded = true;
         const instructionsParagraph = f.instructions.join('. ');
@@ -77,8 +82,9 @@ export class Conversation {
       }
     }
 
-    if (!functionInstructionsAdded)
+    if (!functionInstructionsAdded) {
       return;
+    }
 
     this.addSystemMessagesToHistory([functionInstructions]);
   }
@@ -88,21 +94,37 @@ export class Conversation {
   }
 
   private async enforceTokenLimit(messages: string[], model?: TiktokenModel) {
-    if (this.params.limits?.enforceLimits === false)
+    if (this.params.limits?.enforceLimits === false) {
       return;
-    
+    }
+
     const resolvedModel = model ? model : DEFAULT_MODEL;
     const encoder = encoding_for_model(resolvedModel);
     const conversation = this.history.toString() + messages.join('. ');
     const encoded = encoder.encode(conversation);
     console.log(`current tokens: ${encoded.length}`);
-    if (encoded.length < this.tokenLimit)
+    if (encoded.length < this.tokenLimit) {
       return;
+    }
 
     const summarizeConversationRequest = `First, call the ${summarizeConversationHistoryFunctionName} function`;
-    await OpenAi.generateResponse([summarizeConversationRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+    await OpenAi.generateResponse(
+      [summarizeConversationRequest],
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      this.params.logLevel
+    );
     const referenceSummaryRequest = `If there's a file mentioned in the conversation summary, find and read the file to better respond to my next request. If that doesn't find anything, call the ${searchLibrariesFunctionName} function on other keywords in the conversation summary to find a file to read`;
-    await OpenAi.generateResponse([referenceSummaryRequest], model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+    await OpenAi.generateResponse(
+      [referenceSummaryRequest],
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      this.params.logLevel
+    );
   }
 
   summarizeConversationHistory(summary: string) {
@@ -116,7 +138,9 @@ export class Conversation {
   }
 
   addSystemMessagesToHistory(messages: string[], unshift = false) {
-    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'system', content: message }});
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map((message) => {
+      return { role: 'system', content: message };
+    });
     if (unshift) {
       this.history.getMessages().unshift(...chatCompletions);
       this.history.prune();
@@ -128,40 +152,66 @@ export class Conversation {
   }
 
   addAssistantMessagesToHistory(messages: string[], unshift = false) {
-    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'assistant', content: message }});
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map((message) => {
+      return { role: 'assistant', content: message };
+    });
     if (unshift) {
       this.history.getMessages().unshift(...chatCompletions);
       this.history.prune();
-    } else
+    } else {
       this.history.push(chatCompletions);
+    }
   }
 
   addUserMessagesToHistory(messages: string[], unshift = false) {
-    const chatCompletions: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'user', content: message }});
+    const chatCompletions: ChatCompletionMessageParam[] = messages.map((message) => {
+      return { role: 'user', content: message };
+    });
     if (unshift) {
       this.history.getMessages().unshift(...chatCompletions);
       this.history.prune();
-    } else
+    } else {
       this.history.push(chatCompletions);
+    }
   }
 
   async generateResponse(messages: string[], model?: TiktokenModel) {
     await this.enforceTokenLimit(messages, model);
-    return await OpenAi.generateResponse(messages, model, this.history, this.functions, this.messageModerators, this.params.logLevel);
+    return await OpenAi.generateResponse(
+      messages,
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      this.params.logLevel
+    );
   }
 
   async generateCode(description: string[], model?: TiktokenModel) {
     this.logger.info(`Generating code for description:\n${description.join('\n')}`);
-    const code = await OpenAi.generateCode(description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+    const code = await OpenAi.generateCode(
+      description,
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      !this.generatedCode,
+      this.params.logLevel
+    );
     this.logger.info(`Generated code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}`);
     this.generatedCode = true;
     return code;
   }
 
-  async updateCodeFromFile(codeToUpdateFilePath: string, dependencyCodeFilePaths: string[], description: string, model?: TiktokenModel) {
+  async updateCodeFromFile(
+    codeToUpdateFilePath: string,
+    dependencyCodeFilePaths: string[],
+    description: string,
+    model?: TiktokenModel
+  ) {
     const codeToUpdate = await Fs.readFile(codeToUpdateFilePath);
     let dependencyDescription = `Assume the following exists:\n`;
-    for (let dependencyCodeFilePath of dependencyCodeFilePaths) {
+    for (const dependencyCodeFilePath of dependencyCodeFilePaths) {
       const dependencCode = await Fs.readFile(dependencyCodeFilePath);
       dependencyDescription += dependencCode + '\n\n';
     }
@@ -171,15 +221,34 @@ export class Conversation {
   }
 
   async updateCode(code: string, description: string, model?: TiktokenModel) {
-    this.logger.info(`Updating code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}\nFrom description: ${description}`);
-    const updatedCode = await OpenAi.updateCode(code, description, model, this.history, this.functions, this.messageModerators, !this.generatedCode, this.params.logLevel);
+    this.logger.info(
+      `Updating code:\n${code.slice(0, 150)}${code.length > 150 ? '...' : ''}\nFrom description: ${description}`
+    );
+    const updatedCode = await OpenAi.updateCode(
+      code,
+      description,
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      !this.generatedCode,
+      this.params.logLevel
+    );
     this.logger.info(`Updated code:\n${updatedCode.slice(0, 150)}${updatedCode.length > 150 ? '...' : ''}`);
     this.generatedCode = true;
     return updatedCode;
   }
 
   async generateList(description: string[], model?: TiktokenModel) {
-    const list = await OpenAi.generateList(description, model, this.history, this.functions, this.messageModerators, !this.generatedList, this.params.logLevel);
+    const list = await OpenAi.generateList(
+      description,
+      model,
+      this.history,
+      this.functions,
+      this.messageModerators,
+      !this.generatedList,
+      this.params.logLevel
+    );
     this.generatedList = true;
     return list;
   }
@@ -199,9 +268,9 @@ export const summarizeConversationHistoryFunction = (conversation: Conversation)
             description: 'A 1-3 sentence summary of the current chat history',
           },
         },
-        required: ['summary']
+        required: ['summary'],
       },
     },
     call: async (params: { summary: string }) => conversation.summarizeConversationHistory(params.summary),
-  }
-}
+  };
+};

package/src/ConversationModule.ts

@@ -2,7 +2,7 @@ import { Function } from './Function';
 import { MessageModerator } from './history/MessageModerator';
 
 export interface ConversationModule {
-  getName(): string,
+  getName(): string;
   getSystemMessages(): string[];
   getFunctions(): Function[];
   getMessageModerators(): MessageModerator[];
@@ -10,4 +10,4 @@ export interface ConversationModule {
 
 export interface ConversationModuleFactory {
   createModule(repoPath: string): Promise<ConversationModule>;
-}
+}

package/src/Function.ts

@@ -1,6 +1,5 @@
 import { ChatCompletionCreateParams } from 'openai/resources/chat';
 
-
 export interface Function {
   definition: ChatCompletionCreateParams.Function;
   call(obj: any): Promise<any>;

package/src/OpenAi.ts

@@ -7,26 +7,38 @@ import { MessageHistory } from './history/MessageHistory';
 import { TiktokenModel } from 'tiktoken';
 
 function delay(ms: number) {
-  return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
 export const DEFAULT_MODEL: TiktokenModel = 'gpt-3.5-turbo';
 export class OpenAi {
-  static async generateResponse(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], logLevel: LogLevel = 'info'): Promise<string> {
+  static async generateResponse(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    logLevel: LogLevel = 'info'
+  ): Promise<string> {
     const logger = new Logger('OpenAi.generateResponse', logLevel);
-    const messageParams: ChatCompletionMessageParam[] = messages.map(message => { return { role: 'user', content: message }});
-    if (history)
+    const messageParams: ChatCompletionMessageParam[] = messages.map((message) => {
+      return { role: 'user', content: message };
+    });
+    if (history) {
       history.push(messageParams);
+    }
     let messageParamsWithHistory = history ? history : new MessageHistory().push(messageParams);
-    if (messageModerators)
+    if (messageModerators) {
       messageParamsWithHistory = OpenAi.moderateHistory(messageParamsWithHistory, messageModerators);
+    }
     const response = await OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
     const responseMessage = response.choices[0].message;
     if (responseMessage.function_call) {
       messageParamsWithHistory.push([responseMessage]);
       const functionReturnMessage = await this.callFunction(logLevel, responseMessage.function_call, functions);
-      if (functionReturnMessage)
-        messageParamsWithHistory.push([functionReturnMessage])
+      if (functionReturnMessage) {
+        messageParamsWithHistory.push([functionReturnMessage]);
+      }
       return await this.generateResponse([], model, messageParamsWithHistory, functions, messageModerators, logLevel);
     }
 
@@ -41,50 +53,61 @@ export class OpenAi {
   }
 
   private static moderateHistory(history: MessageHistory, messageModerators: MessageModerator[]) {
-    for (let messageModerator of messageModerators)
+    for (const messageModerator of messageModerators) {
       history.setMessages(messageModerator.observe(history.getMessages()));
+    }
 
     return history;
   }
 
-  private static async executeRequest(messageParamsWithHistory: MessageHistory, logLevel: LogLevel, functions?: Function[], model?: string): Promise<ChatCompletion> {
+  private static async executeRequest(
+    messageParamsWithHistory: MessageHistory,
+    logLevel: LogLevel,
+    functions?: Function[],
+    model?: string
+  ): Promise<ChatCompletion> {
     const logger = new Logger('OpenAi.executeRequest', logLevel);
     const openaiApi = new OpenAIApi();
     let response: ChatCompletion;
     try {
       const latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
-      if (latestMessage.content)
+      if (latestMessage.content) {
         logger.info(`Sending request: ${latestMessage.content}`);
-      else if (latestMessage.role == 'function')
+      } else if (latestMessage.role == 'function') {
         logger.info(`Sending request: returning output of ${latestMessage.name} function`);
-      else
+      } else {
         logger.info(`Sending request`);
+      }
       logger.debug(`Sending messages: ${JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)}`, true);
       response = await openaiApi.chat.completions.create({
         model: model ? model : DEFAULT_MODEL,
         temperature: 0,
         messages: messageParamsWithHistory.getMessages(),
-        functions: functions?.map(f => f.definition),
+        functions: functions?.map((f) => f.definition),
       });
       const responseMessage = response.choices[0].message;
-      if (responseMessage.content)
+      if (responseMessage.content) {
         logger.info(`Received response: ${responseMessage.content}`);
-      else if (responseMessage.function_call)
+      } else if (responseMessage.function_call) {
         logger.info(`Received response: call ${responseMessage.function_call.name} function`);
-      else
+      } else {
         logger.info(`Received response`);
-      if (response.usage)
+      }
+      if (response.usage) {
         logger.info(JSON.stringify(response.usage));
-      else
+      } else {
         logger.info(JSON.stringify(`Usage data missing`));
-    } catch(error: any) {
+      }
+    } catch (error: any) {
       logger.info(`Received error response, error type: ${error.type}`);
       if (typeof error.status !== 'undefined' && error.status == 429) {
         if (error.type == 'tokens' && typeof error.headers['x-ratelimit-reset-tokens'] === 'string') {
           const waitTime = parseInt(error.headers['x-ratelimit-reset-tokens']);
           const remainingTokens = error.headers['x-ratelimit-remaining-tokens'];
           const delayMs = 15000;
-          logger.warn(`Waiting to retry in ${delayMs/1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`);
+          logger.warn(
+            `Waiting to retry in ${delayMs / 1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`
+          );
           await delay(delayMs);
           return await OpenAi.executeRequest(messageParamsWithHistory, logLevel, functions, model);
         }
@@ -96,21 +119,25 @@ export class OpenAi {
     return response;
   }
 
-  private static async callFunction(logLevel: LogLevel, functionCall: ChatCompletionMessage.FunctionCall, functions?: Function[]): Promise<ChatCompletionMessageParam|undefined> {
+  private static async callFunction(
+    logLevel: LogLevel,
+    functionCall: ChatCompletionMessage.FunctionCall,
+    functions?: Function[]
+  ): Promise<ChatCompletionMessageParam | undefined> {
     const logger = new Logger('OpenAi.callFunction', logLevel);
     if (!functions) {
       const warning = `Assistant attempted to call a function when no functions were provided`;
       logger.warn(warning);
-      const message: ChatCompletionMessageParam = { role: 'user', content: warning }
+      const message: ChatCompletionMessageParam = { role: 'user', content: warning };
       return message;
     }
 
     functionCall.name = functionCall.name.split('.').pop() as string;
-    const f = functions.find(f => f.definition.name === functionCall.name);
+    const f = functions.find((f) => f.definition.name === functionCall.name);
     if (!f) {
       const warning = `Assistant attempted to call nonexistent function: ${functionCall.name}`;
       logger.warn(warning);
-      const message: ChatCompletionMessageParam = { role: 'user', content: warning }
+      const message: ChatCompletionMessageParam = { role: 'user', content: warning };
       return message;
     }
 
@@ -118,46 +145,74 @@ export class OpenAi {
     try {
       logger.info(`Assistant calling function: ${f.definition.name}(${functionCall.arguments})`);
       returnObject = JSON.stringify(await f.call(JSON.parse(functionCall.arguments)));
-      logger.info(`Assistant called function: ${f.definition.name}(${functionCall.arguments}) => ${returnObject}`, 1000);
+      logger.info(
+        `Assistant called function: ${f.definition.name}(${functionCall.arguments}) => ${returnObject}`,
+        1000
+      );
     } catch (error: any) {
       logger.error(error.message);
     }
 
-    if (!returnObject)
+    if (!returnObject) {
       return;
+    }
 
     return {
-      role: 'function', 
-      name: f.definition.name, 
+      role: 'function',
+      name: f.definition.name,
       content: returnObject,
     };
   }
 
-  static async generateCode(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info') {
+  static async generateCode(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ) {
     const systemMessages: ChatCompletionMessageParam[] = [
-      { role: 'system', content: 'Return only the code and exclude example usage, markdown, explanations, comments and notes.' },
+      {
+        role: 'system',
+        content: 'Return only the code and exclude example usage, markdown, explanations, comments and notes.',
+      },
       { role: 'system', content: `Write code in typescript.` },
       { role: 'system', content: `Declare explicit types for all function parameters.` },
       { role: 'system', content: 'Export all functions and objects generated.' },
       { role: 'system', content: 'Do not omit function implementations.' },
     ];
-    const resolvedHistory = history ? 
-      includeSystemMessages ?
-        history.push(systemMessages)
-        :
-        history
-      :
-      includeSystemMessages ?
-        new MessageHistory().push(systemMessages)
-        :
-        undefined
-    ;
+    const resolvedHistory = history
+      ? includeSystemMessages
+        ? history.push(systemMessages)
+        : history
+      : includeSystemMessages
+        ? new MessageHistory().push(systemMessages)
+        : undefined;
     const code = await this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
     return this.parseCodeFromMarkdown(code);
   }
 
-  static async updateCode(code: string, description: string, model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info') {
-    return await this.generateCode([this.updateCodeDescription(code, description)], model, history, functions, messageModerators, includeSystemMessages, logLevel);
+  static async updateCode(
+    code: string,
+    description: string,
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ) {
+    return await this.generateCode(
+      [this.updateCodeDescription(code, description)],
+      model,
+      history,
+      functions,
+      messageModerators,
+      includeSystemMessages,
+      logLevel
+    );
   }
 
   static updateCodeDescription(code: string, description: string) {
@@ -165,22 +220,25 @@ export class OpenAi {
   }
 
   static parseCodeFromMarkdown(code: string) {
-    if (!code.match(/```([\s\S]+?)```/g))
+    if (!code.match(/```([\s\S]+?)```/g)) {
       return code;
+    }
 
     const filteredLines: string[] = [];
     let inCodeBlock = false;
-    for (let line of code.split('\n')) {
+    for (const line of code.split('\n')) {
       if (line.startsWith('```')) {
         inCodeBlock = !inCodeBlock;
-        if (!inCodeBlock)
+        if (!inCodeBlock) {
           filteredLines.push('');
-          
+        }
+
         continue;
       }
 
-      if (inCodeBlock)
+      if (inCodeBlock) {
         filteredLines.push(line);
+      }
     }
 
     // remove the last '' that will become a \n
@@ -190,23 +248,30 @@ export class OpenAi {
     return filteredLines.join('\n');
   }
 
-  static async generateList(messages: string[], model?: string, history?: MessageHistory, functions?: Function[], messageModerators?: MessageModerator[], includeSystemMessages: boolean = true, logLevel: LogLevel = 'info'): Promise<string[]> {
+  static async generateList(
+    messages: string[],
+    model?: string,
+    history?: MessageHistory,
+    functions?: Function[],
+    messageModerators?: MessageModerator[],
+    includeSystemMessages: boolean = true,
+    logLevel: LogLevel = 'info'
+  ): Promise<string[]> {
     const systemMessages: ChatCompletionMessageParam[] = [
-      { role: 'system', content: 'Return only the list and exclude example usage, markdown and all explanations, comments and notes.' },
+      {
+        role: 'system',
+        content: 'Return only the list and exclude example usage, markdown and all explanations, comments and notes.',
+      },
       { role: 'system', content: 'Separate each item in the list by a ;' },
     ];
-    const resolvedHistory = history ? 
-      includeSystemMessages ?
-        history.push(systemMessages)
-        :
-        history
-      :
-      includeSystemMessages ?
-        new MessageHistory().push(systemMessages)
-        :
-        undefined
-    ;
+    const resolvedHistory = history
+      ? includeSystemMessages
+        ? history.push(systemMessages)
+        : history
+      : includeSystemMessages
+        ? new MessageHistory().push(systemMessages)
+        : undefined;
     const list = await this.generateResponse(messages, model, resolvedHistory, functions, messageModerators, logLevel);
-    return list.split(';').map(item => item.trim());
+    return list.split(';').map((item) => item.trim());
   }
-}
+}

package/src/Paragraph.ts

@@ -9,9 +9,10 @@ export class Paragraph {
   }
 
   toString(): string {
-    if (this.sentences.length == 0)
+    if (this.sentences.length == 0) {
       return '';
+    }
 
     return this.sentences.join(' ');
   }
-}
+}

package/src/Sentence.ts

@@ -8,13 +8,15 @@ export class Sentence {
   }
 
   toString(): string {
-    if (this.lines.length == 0)
+    if (this.lines.length == 0) {
       return '';
+    }
 
     let sentence = this.lines.join(', ');
-    if (sentence.lastIndexOf('.') != (sentence.length - 1))
+    if (sentence.lastIndexOf('.') != sentence.length - 1) {
       sentence += '.';
+    }
 
     return sentence;
   }
-}
+}