@proteinjs/conversation 1.7.2 → 1.7.4

package/src/OpenAi.ts

@@ -5,7 +5,8 @@ import {
   ChatCompletionMessageToolCall,
   ChatCompletionChunk,
 } from 'openai/resources/chat';
-import { LogLevel, Logger, isInstanceOf } from '@proteinjs/util';
+import { isInstanceOf } from '@proteinjs/util';
+import { LogLevel, Logger } from '@proteinjs/logger';
 import { MessageModerator } from './history/MessageModerator';
 import { Function } from './Function';
 import { MessageHistory } from './history/MessageHistory';
@@ -80,11 +81,11 @@ export class OpenAi {
     logLevel: LogLevel = 'info',
     maxFunctionCalls: number = 50
   ): Promise<string | Readable> {
-    const logger = new Logger('OpenAi.generateResponseHelper', logLevel);
+    const logger = new Logger({ name: 'OpenAi.generateResponseHelper', logLevel });
     const updatedHistory = OpenAi.getUpdatedMessageHistory(messages, history, messageModerators);
     const response = await OpenAi.executeRequest(updatedHistory, stream, logLevel, functions, model, abortSignal);
     if (stream) {
-      logger.info(`Processing response stream`);
+      logger.info({ message: `Processing response stream` });
       const inputStream = response as Stream<ChatCompletionChunk>;
 
       // For subsequent tool calls, return the raw OpenAI stream to `OpenAiStreamProcessor`
@@ -174,7 +175,7 @@ export class OpenAi {
     model?: string,
     abortSignal?: AbortSignal
   ): Promise<ChatCompletion | Stream<ChatCompletionChunk>> {
-    const logger = new Logger('OpenAi.executeRequest', logLevel);
+    const logger = new Logger({ name: 'OpenAi.executeRequest', logLevel });
     const openaiApi = new OpenAIApi();
     try {
       const latestMessage = messageParamsWithHistory.getMessages()[messageParamsWithHistory.getMessages().length - 1];
@@ -211,7 +212,7 @@ export class OpenAi {
     messageParamsWithHistory: MessageHistory
   ) {
     if (latestMessage.role == 'tool') {
-      logger.info(`Sending request: returning output of tool call (${latestMessage.tool_call_id})`);
+      logger.info({ message: `Sending request: returning output of tool call (${latestMessage.tool_call_id})` });
     } else if (latestMessage.content) {
       const requestContent =
         typeof latestMessage.content === 'string'
@@ -219,31 +220,32 @@ export class OpenAi {
           : latestMessage.content[0].type === 'text'
             ? latestMessage.content[0].text
             : 'image';
-      logger.info(`Sending request: ${requestContent}`);
+      logger.info({ message: `Sending request`, obj: { requestContent } });
     } else {
-      logger.info(`Sending request`);
+      logger.info({ message: `Sending request` });
     }
 
     if (logLevel === 'debug') {
-      logger.debug(`Sending messages: ${JSON.stringify(messageParamsWithHistory.getMessages(), null, 2)}`, true);
+      logger.debug({ message: `Sending messages:`, obj: { messages: messageParamsWithHistory.getMessages() } });
     }
   }
 
   private static logResponseDetails(logger: Logger, response: ChatCompletion) {
     const responseMessage = response.choices[0].message;
     if (responseMessage.content) {
-      logger.info(`Received response: ${responseMessage.content}`);
+      logger.info({ message: `Received response`, obj: { response: responseMessage.content } });
     } else if (responseMessage.tool_calls) {
-      logger.info(
-        `Received response: call functions: ${JSON.stringify(responseMessage.tool_calls.map((toolCall) => toolCall.function.name))}`
-      );
+      logger.info({
+        message: `Received response: call functions`,
+        obj: { functions: responseMessage.tool_calls.map((toolCall) => toolCall.function.name) },
+      });
     } else {
-      logger.info(`Received response`);
+      logger.info({ message: `Received response` });
     }
     if (response.usage) {
-      logger.info(JSON.stringify(response.usage));
+      logger.info({ message: `Usage data`, obj: { usageData: response.usage } });
     } else {
-      logger.info(JSON.stringify(`Usage data missing`));
+      logger.info({ message: `Usage data missing` });
     }
   }
 
@@ -257,16 +259,16 @@ export class OpenAi {
     model?: string
   ): Promise<ChatCompletion | Stream<ChatCompletionChunk>> {
     if (error.type) {
-      logger.info(`Received error response, error type: ${error.type}`);
+      logger.info({ message: `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({
+          message: `Waiting to retry in ${delayMs / 1000}s, token reset in: ${waitTime}s, remaining tokens: ${remainingTokens}`,
+        });
         await delay(delayMs);
         return await OpenAi.executeRequest(messageParamsWithHistory, stream, logLevel, functions, model);
       }
@@ -343,27 +345,33 @@ export class OpenAi {
     toolCallId: string,
     functions?: Omit<Function, 'instructions'>[]
   ): Promise<ChatCompletionMessageParam[]> {
-    const logger = new Logger('OpenAi.callFunction', logLevel);
+    const logger = new Logger({ name: 'OpenAi.callFunction', logLevel });
     if (!functions) {
-      const error = `Assistant attempted to call a function when no functions were provided`;
-      logger.error(error);
-      return [{ role: 'tool', tool_call_id: toolCallId, content: JSON.stringify({ error }) }];
+      const errorMessage = `Assistant attempted to call a function when no functions were provided`;
+      logger.error({ message: errorMessage });
+      return [{ role: 'tool', tool_call_id: toolCallId, content: JSON.stringify({ error: errorMessage }) }];
     }
 
     functionCall.name = functionCall.name.split('.').pop() as string;
     const f = functions.find((f) => f.definition.name === functionCall.name);
     if (!f) {
-      const error = `Assistant attempted to call nonexistent function: ${functionCall.name}`;
-      logger.error(error);
-      return [{ role: 'tool', tool_call_id: toolCallId, content: JSON.stringify({ error }) }];
+      const errorMessage = `Assistant attempted to call nonexistent function`;
+      logger.error({ message: errorMessage, obj: { functionName: functionCall.name } });
+      return [
+        {
+          role: 'tool',
+          tool_call_id: toolCallId,
+          content: JSON.stringify({ error: errorMessage, functionName: functionCall.name }),
+        },
+      ];
     }
 
     try {
       const parsedArguments = JSON.parse(functionCall.arguments);
-      logger.info(
-        `Assistant calling function: (${toolCallId}) ${f.definition.name}(${JSON.stringify(parsedArguments, null, 2)})`,
-        1000
-      );
+      logger.info({
+        message: `Assistant calling function: (${toolCallId}) ${f.definition.name}`,
+        obj: { toolCallId, functionName: f.definition.name, args: parsedArguments },
+      });
       const returnObject = await f.call(parsedArguments);
 
       const returnObjectCompletionParams: ChatCompletionMessageParam[] = [];
@@ -377,10 +385,10 @@ export class OpenAi {
           content: `The the return data from this function is provided in the following messages`,
         };
         returnObjectCompletionParams.push(instructionMessageParam, ...messageParams);
-        logger.info(
-          `Assistant called function: (${toolCallId}) ${f.definition.name} => ${JSON.stringify(messageParams, null, 2)}`,
-          500
-        );
+        logger.info({
+          message: `Assistant called function: (${toolCallId}) ${f.definition.name}`,
+          obj: { toolCallId, functionName: f.definition.name, return: messageParams },
+        });
       } else {
         // handle all other functions
         const serializedReturnObject = JSON.stringify(returnObject);
@@ -389,10 +397,10 @@ export class OpenAi {
           tool_call_id: toolCallId,
           content: serializedReturnObject,
         });
-        logger.info(
-          `Assistant called function: (${toolCallId}) ${f.definition.name} => ${JSON.stringify(returnObject, null, 2)}`,
-          1000
-        );
+        logger.info({
+          message: `Assistant called function: (${toolCallId}) ${f.definition.name}`,
+          obj: { toolCallId, functionName: f.definition.name, return: returnObject },
+        });
       }
 
       if (typeof returnObject === 'undefined') {
@@ -407,8 +415,11 @@ export class OpenAi {
 
       return returnObjectCompletionParams;
     } catch (error: any) {
-      const errorMessage = `Error occurred while executing function ${f.definition.name}: (${toolCallId}) ${error.message}`;
-      logger.error(errorMessage);
+      logger.error({
+        message: `An error occurred while executing function`,
+        error,
+        obj: { toolCallId, functionName: f.definition.name },
+      });
       throw error;
     }
   }

package/src/OpenAiStreamProcessor.ts

@@ -1,8 +1,13 @@
 import { ChatCompletionMessageToolCall, ChatCompletionChunk } from 'openai/resources/chat';
-import { LogLevel, Logger } from '@proteinjs/util';
+import { LogLevel, Logger } from '@proteinjs/logger';
 import { Stream } from 'openai/streaming';
 import { Readable, Transform, TransformCallback, PassThrough } from 'stream';
 
+export interface AssistantResponseStreamChunk {
+  content?: string;
+  finishReason?: string;
+}
+
 /**
  * Processes streaming responses from OpenAI's `ChatCompletions` api.
  *   - When a tool call is received, it delegates processing to `onToolCalls`; this can happen recursively
@@ -26,15 +31,16 @@ export class OpenAiStreamProcessor {
     logLevel: LogLevel,
     private abortSignal?: AbortSignal
   ) {
-    this.logger = new Logger(this.constructor.name, logLevel);
+    this.logger = new Logger({ name: this.constructor.name, logLevel });
     this.inputStream = Readable.from(inputStream);
     this.controlStream = this.createControlStream();
-    this.outputStream = new PassThrough();
+    this.outputStream = new PassThrough({ objectMode: true });
     this.inputStream.pipe(this.controlStream);
   }
 
   /**
-   * @returns a `Readable` stream that will receive the assistant's text response to the user
+   * @returns a `Readable` stream, in object mode, that will receive the assistant's text response to the user.
+   *          The object chunks written to the stream will be of type `AssistantResponseStreamChunk`.
    */
   getOutputStream(): Readable {
     return this.outputStream;
@@ -49,7 +55,7 @@ export class OpenAiStreamProcessor {
       transform: (chunk: ChatCompletionChunk, encoding: string, callback: TransformCallback) => {
         try {
           if (this.outputStream.destroyed) {
-            this.logger.warn(`Destroying input and control streams since output stream is destroyed`);
+            this.logger.warn({ message: `Destroying input and control streams since output stream is destroyed` });
             this.inputStream.destroy();
             this.controlStream.destroy();
             return;
@@ -58,26 +64,29 @@ export class OpenAiStreamProcessor {
           if (!chunk || !chunk.choices) {
             throw new Error(`Received invalid chunk:\n${JSON.stringify(chunk, null, 2)}`);
           } else if (chunk.choices[0]?.delta?.content) {
-            this.outputStream.push(chunk.choices[0].delta.content);
+            this.outputStream.push({ content: chunk.choices[0].delta.content } as AssistantResponseStreamChunk);
           } else if (chunk.choices[0]?.delta?.tool_calls) {
             this.handleToolCallDelta(chunk.choices[0].delta.tool_calls);
           } else if (chunk.choices[0]?.finish_reason === 'tool_calls') {
             this.handleToolCalls();
           } else if (chunk.choices[0]?.finish_reason === 'stop') {
+            this.outputStream.push({ finishReason: 'stop' } as AssistantResponseStreamChunk);
             this.outputStream.push(null);
             this.destroyStreams();
           } else if (chunk.choices[0]?.finish_reason === 'length') {
-            this.logger.warn(`The maximum number of tokens specified in the request was reached`);
+            this.logger.info({ message: `The maximum number of output tokens was reached` });
+            this.outputStream.push({ finishReason: 'length' } as AssistantResponseStreamChunk);
             this.outputStream.push(null);
             this.destroyStreams();
           } else if (chunk.choices[0]?.finish_reason === 'content_filter') {
-            this.logger.error(`Content was omitted due to a flag from OpenAI's content filters`);
+            this.logger.warn({ message: `Content was omitted due to a flag from OpenAI's content filters` });
+            this.outputStream.push({ finishReason: 'content_filter' } as AssistantResponseStreamChunk);
             this.outputStream.push(null);
             this.destroyStreams();
           }
           callback();
         } catch (error: any) {
-          this.logger.error('Error tranforming chunk', error);
+          this.logger.error({ message: 'Error tranforming chunk', error });
           this.destroyStreams(error);
         }
       },
@@ -155,7 +164,7 @@ export class OpenAiStreamProcessor {
       this.toolCallsExecuted += completedToolCalls.length;
     } catch (error: any) {
       if (!this.abortSignal?.aborted) {
-        this.logger.error('Error processing tool calls:', error);
+        this.logger.error({ message: 'Error processing tool calls', error });
       }
       this.destroyStreams(error);
     }

package/src/code_template/CodeTemplate.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@proteinjs/util';
+import { Logger } from '@proteinjs/logger';
 import { Fs, PackageUtil, Package } from '@proteinjs/util-node';
 import { SourceFile } from './Code';
 
@@ -9,10 +9,11 @@ export type TemplateArgs = {
 };
 
 export abstract class CodeTemplate {
-  protected logger = new Logger(this.constructor.name);
+  protected logger: Logger;
   protected templateArgs: TemplateArgs;
 
   constructor(templateArgs: TemplateArgs) {
+    this.logger = new Logger({ name: this.constructor.name });
     this.templateArgs = templateArgs;
   }
 
@@ -23,10 +24,10 @@ export abstract class CodeTemplate {
     await PackageUtil.installPackages(this.resolvePackages());
     for (const sourceFile of this.sourceFiles()) {
       const filePath = Fs.baseContainedJoin(this.templateArgs.srcPath, sourceFile.relativePath);
-      this.logger.info(`Generating source file: ${filePath}`);
+      this.logger.info({ message: `Generating source file: ${filePath}` });
       const code = await sourceFile.code.generate();
       await Fs.writeFiles([{ path: filePath, content: code }]);
-      this.logger.info(`Generated source file: ${filePath}`);
+      this.logger.info({ message: `Generated source file: ${filePath}` });
     }
   }
 

package/src/code_template/Repo.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@proteinjs/util';
+import { Logger } from '@proteinjs/logger';
 import { FileDescriptor, Fs, PackageUtil } from '@proteinjs/util-node';
 import fs from 'fs/promises';
 import path from 'path';
@@ -24,7 +24,7 @@ export type RepoParams = {
 };
 
 export class Repo {
-  private logger = new Logger(this.constructor.name);
+  private logger = new Logger({ name: this.constructor.name });
   params: RepoParams;
 
   constructor(params: RepoParams) {
@@ -48,7 +48,7 @@ export class Repo {
   }
 
   searchFiles(params: { keyword: string }) {
-    this.logger.info(`Searching for file, keyword: ${params.keyword}`);
+    this.logger.info({ message: `Searching for file, keyword: ${params.keyword}` });
     const filePaths = this.keywordFilesIndex()[params.keyword];
     return filePaths || [];
   }
@@ -57,17 +57,17 @@ export class Repo {
     const queriedDeclarations: { [tsFilePath: string]: string } = {};
     for (const tsFilePath of params.tsFilePaths) {
       queriedDeclarations[tsFilePath] = this.params.tsFiles[tsFilePath].declaration;
-      this.logger.info(`Accessed declaration: ${tsFilePath}`);
+      this.logger.info({ message: `Accessed declaration: ${tsFilePath}` });
     }
     return queriedDeclarations;
   }
 }
 
 export class RepoFactory {
-  private static LOGGER = new Logger('RepoFactory');
+  private static LOGGER = new Logger({ name: 'RepoFactory' });
 
   public static async createRepo(dir: string): Promise<Repo> {
-    this.LOGGER.info(`Creating repo for dir: ${dir}`);
+    this.LOGGER.info({ message: `Creating repo for dir: ${dir}` });
     const repoParams: RepoParams = { packages: {}, slimPackages: {}, tsFiles: {}, keywordFilesIndex: {} };
 
     async function traverse(dir: string) {
@@ -106,13 +106,13 @@ export class RepoFactory {
       const { packageJSON, tsFiles, ...slimPackage } = repoParams.packages[packageName];
       repoParams.slimPackages[packageName] = slimPackage;
     });
-    this.LOGGER.info(`Created repo for dir: ${dir}`);
+    this.LOGGER.info({ message: `Created repo for dir: ${dir}` });
     return new Repo(repoParams);
   }
 
   private static async loadFiles(repoParams: RepoParams) {
     for (const packageName of Object.keys(repoParams.packages)) {
-      this.LOGGER.info(`Loading files for package: ${packageName}`);
+      this.LOGGER.info({ message: `Loading files for package: ${packageName}` });
       const dirPath = repoParams.packages[packageName].dirPath;
       if (dirPath) {
         repoParams.packages[packageName].fileDescriptors.push(

package/src/fs/conversation_fs/ConversationFsModerator.ts

@@ -1,5 +1,5 @@
 /* eslint-disable no-empty */
-import { LogLevel, Logger } from '@proteinjs/util';
+import { LogLevel, Logger } from '@proteinjs/logger';
 import { FileContentMap } from '@proteinjs/util-node';
 import { ChatCompletionMessageParam } from 'openai/resources/chat';
 import { MessageModerator } from '../../history/MessageModerator';
@@ -20,14 +20,14 @@ export class ConversationFsFactory {
 
   constructor(params?: Partial<ConversationFsFactoryParams>) {
     this.params = Object.assign({ maxFiles: 3, logLevel: 'info' }, params);
-    this.logger = new Logger(this.constructor.name, this.params.logLevel);
+    this.logger = new Logger({ name: this.constructor.name, logLevel: this.params.logLevel });
   }
 
   merge(existingFs: ConversationFs, updates: FileContentMap): ConversationFs {
     for (const filePath of Object.keys(updates)) {
       // if the file already exists in the fs
       if (existingFs.fileContentMap[filePath]) {
-        this.logger.debug(`Updating existing file: ${filePath}`);
+        this.logger.debug({ message: `Updating existing file: ${filePath}` });
         existingFs.fileContentMap[filePath] = updates[filePath];
         const oldIndex = existingFs.order.findIndex((item) => item == filePath);
         existingFs.order.splice(oldIndex, 1);
@@ -37,12 +37,12 @@ export class ConversationFsFactory {
 
       // if we have less than the max number of files in the fs
       if (Object.keys(existingFs.fileContentMap).length < this.params.maxFiles) {
-        this.logger.debug(`Adding new file (under limit): ${filePath}`);
+        this.logger.debug({ message: `Adding new file (under limit): ${filePath}` });
         existingFs.fileContentMap[filePath] = updates[filePath];
         existingFs.order.push(filePath);
         continue;
       } else {
-        this.logger.debug(`Adding new file (over limit): ${filePath}`);
+        this.logger.debug({ message: `Adding new file (over limit): ${filePath}` });
         const removedFilePath = existingFs.order.splice(0, 1)[0];
         delete existingFs.fileContentMap[removedFilePath];
         existingFs.fileContentMap[filePath] = updates[filePath];
@@ -56,11 +56,13 @@ export class ConversationFsFactory {
 
 export class ConversationFsModerator implements MessageModerator {
   private logLevel: LogLevel = 'info';
+  private logger: Logger;
 
   constructor(logLevel?: LogLevel) {
     if (logLevel) {
       this.logLevel = logLevel;
     }
+    this.logger = new Logger({ name: this.constructor.name, logLevel: this.logLevel });
   }
 
   observe(messages: ChatCompletionMessageParam[]): ChatCompletionMessageParam[] {

package/src/fs/keyword_to_files_index/KeywordToFilesIndexModule.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@proteinjs/util';
+import { Logger } from '@proteinjs/logger';
 import { Fs } from '@proteinjs/util-node';
 import { ConversationModule, ConversationModuleFactory } from '../../ConversationModule';
 import { Function } from '../../Function';
@@ -11,7 +11,7 @@ export type KeywordToFilesIndexModuleParams = {
 };
 
 export class KeywordToFilesIndexModule implements ConversationModule {
-  private logger = new Logger(this.constructor.name);
+  private logger = new Logger({ name: this.constructor.name });
   params: KeywordToFilesIndexModuleParams;
 
   constructor(params: KeywordToFilesIndexModuleParams) {
@@ -23,7 +23,7 @@ export class KeywordToFilesIndexModule implements ConversationModule {
   }
 
   searchFiles(params: { keyword: string }) {
-    this.logger.info(`Searching for file, keyword: ${params.keyword}`);
+    this.logger.info({ message: `Searching for file, keyword: ${params.keyword}` });
     const filePaths = this.params.keywordFilesIndex[params.keyword];
     return filePaths || [];
   }
@@ -44,13 +44,13 @@ export class KeywordToFilesIndexModule implements ConversationModule {
 }
 
 export class KeywordToFilesIndexModuleFactory implements ConversationModuleFactory {
-  private logger = new Logger(this.constructor.name);
+  private logger = new Logger({ name: this.constructor.name });
 
   async createModule(repoPath: string): Promise<KeywordToFilesIndexModule> {
-    this.logger.debug(`Creating module for repo: ${repoPath}`);
+    this.logger.debug({ message: `Creating module for repo: ${repoPath}` });
     const repoParams: KeywordToFilesIndexModuleParams = { keywordFilesIndex: {}, dir: repoPath };
     repoParams.keywordFilesIndex = await this.createKeywordFilesIndex(repoPath, ['**/node-typescript-parser/**']);
-    this.logger.debug(`Created module for repo: ${repoPath}`);
+    this.logger.debug({ message: `Created module for repo: ${repoPath}` });
     return new KeywordToFilesIndexModule(repoParams);
   }
 
@@ -82,7 +82,7 @@ export class KeywordToFilesIndexModuleFactory implements ConversationModuleFacto
         keywordFilesIndex[fileName] = [];
       }
 
-      this.logger.debug(`fileName: ${fileName}, filePath: ${filePath}`);
+      this.logger.debug({ message: `fileName: ${fileName}, filePath: ${filePath}` });
       keywordFilesIndex[fileName].push(filePath);
     }
 

package/src/history/MessageHistory.ts

@@ -1,5 +1,5 @@
 import { ChatCompletionMessageParam } from 'openai/resources/chat';
-import { Logger } from '@proteinjs/util';
+import { Logger } from '@proteinjs/logger';
 
 export interface MessageHistoryParams {
   enforceMessageLimit?: boolean;
@@ -7,7 +7,7 @@ export interface MessageHistoryParams {
 }
 
 export class MessageHistory {
-  private logger = new Logger(this.constructor.name);
+  private logger = new Logger({ name: this.constructor.name });
   private messages: ChatCompletionMessageParam[] = [];
   private params: MessageHistoryParams;
 
@@ -55,6 +55,6 @@ export class MessageHistory {
     }
 
     this.messages = this.messages.filter((message, i) => !messagesToRemoveIndexes.includes(i));
-    this.logger.debug(`Pruned ${messagesToRemoveIndexes.length} messages`);
+    this.logger.debug({ message: `Pruned ${messagesToRemoveIndexes.length} messages` });
   }
 }

package/src/template/ConversationTemplateModule.ts

@@ -1,4 +1,4 @@
-import { Logger } from '@proteinjs/util';
+import { Logger } from '@proteinjs/logger';
 import { ConversationTemplate } from './ConversationTemplate';
 import { createPackageConversationTemplate } from './createPackage/CreatePackageConversationTemplate';
 import { ConversationModule, ConversationModuleFactory } from '../ConversationModule';
@@ -23,10 +23,11 @@ export type ConversationTemplateModuleParams = {
 };
 
 export class ConversationTemplateModule implements ConversationModule {
-  private logger = new Logger(this.constructor.name);
+  private logger: Logger;
   params: ConversationTemplateModuleParams;
 
   constructor(params: ConversationTemplateModuleParams) {
+    this.logger = new Logger({ name: this.constructor.name });
     this.params = params;
   }
 
@@ -35,7 +36,7 @@ export class ConversationTemplateModule implements ConversationModule {
   }
 
   searchConversationTemplates(keyword: string) {
-    this.logger.info(`Searching for conversation template, keyword: ${keyword}`);
+    this.logger.info({ message: `Searching for conversation template, keyword: ${keyword}` });
     const conversationNames = this.params.conversationTemplateKeywordIndex[keyword];
     return conversationNames || [];
   }