@mate-academy/llm-gateway 0.0.1-canary.1

package/src/providers/OpenAI/services/OpenAIAssistance.service.ts

@@ -0,0 +1,304 @@
+import { createReadStream } from 'fs';
+import { Logger } from '@mate-academy/core';
+import { OpenAI } from 'openai';
+import {
+  LLMAssistanceOptions,
+  LLMAssistanceResult,
+  LLMCreateAssistantOptions,
+  LLMCreateAssistantResult,
+  LLMCreateChatOptions,
+  LLMCreateChatResult,
+  LLMCreateFileStorageOptions,
+  LLMCreateFileStorageResult,
+  LLMInstanceOptions,
+  LLMProviders,
+  LLMRoles,
+  LLMUploadFile,
+  LLMUploadFileResult,
+} from '../../../LLMService.typedefs';
+import { LLMAssistanceService } from '../../../services';
+import { OpenAIRoles } from '../OpenAI.typedefs';
+
+export class OpenAIAssistanceService
+  extends LLMAssistanceService<LLMProviders.OpenAI> {
+  #instance: OpenAI | null = null;
+
+  private uploadedFiles: Map<string, string> = new Map();
+
+  constructor(
+    logger: Logger,
+    options: LLMInstanceOptions[LLMProviders.OpenAI],
+  ) {
+    super(LLMProviders.OpenAI, logger, options);
+  }
+
+  protected get instance(): OpenAI {
+    if (!this.#instance) {
+      this.#instance = new OpenAI(this.options);
+    }
+
+    return this.#instance;
+  }
+
+  async uploadFile(file: LLMUploadFile): Promise<LLMUploadFileResult> {
+    try {
+      const { path } = file;
+
+      const exstingFileId = this.uploadedFiles.get(path);
+
+      if (exstingFileId) {
+        const storedFile = await this.instance.files.retrieve(exstingFileId);
+
+        if (storedFile.id) {
+          return {
+            ...file,
+            fileId: exstingFileId,
+          };
+        }
+      }
+
+      const readableStream = createReadStream(path);
+
+      const uploadedFile = await this.instance.files.create({
+        purpose: 'assistants',
+        file: readableStream,
+      });
+
+      await this.instance.files.waitForProcessing(uploadedFile.id);
+
+      this.uploadedFiles.set(path, uploadedFile.id);
+
+      return {
+        ...file,
+        fileId: uploadedFile.id,
+      };
+    } catch (error: any) {
+      this.logger
+        .child('uploadFile')
+        .error('Error uploading file', {
+          error,
+          file,
+        });
+
+      return { error };
+    }
+  }
+
+  async deleteFile(
+    fileId: string,
+  ): Promise<void> {
+    await this.instance.files.del(fileId);
+
+    this.uploadedFiles.delete(fileId);
+  }
+
+  async createFileStorage(
+    options: LLMCreateFileStorageOptions<LLMProviders.OpenAI>,
+  ): Promise<LLMCreateFileStorageResult> {
+    const { uploadedFiles } = options;
+
+    try {
+      const vectorStore = await this.instance.vectorStores.create({
+        expires_after: {
+          anchor: 'last_active_at',
+          days: 1,
+        },
+      });
+
+      await this.instance.vectorStores.fileBatches
+        .createAndPoll(
+          vectorStore.id,
+          { file_ids: uploadedFiles.map(({ fileId }) => fileId) },
+        );
+
+      return {
+        storageId: vectorStore.id,
+      };
+    } catch (error: any) {
+      this.logger
+        .child('createFileStorage')
+        .error('Error creating file storage', {
+          error,
+          uploadedFiles,
+        });
+
+      return { error };
+    }
+  }
+
+  async deleteFileStorage(
+    fileStorageId: string,
+  ): Promise<void> {
+    await this.instance.vectorStores.del(fileStorageId);
+  }
+
+  async createChat(
+    options: LLMCreateChatOptions<LLMProviders.OpenAI>,
+  ): Promise<LLMCreateChatResult> {
+    try {
+      const {
+        storageId,
+      } = options;
+
+      const fileSearchOptions = storageId
+        ? {
+          tool_resources: {
+            file_search: {
+              vector_store_ids: [storageId],
+            },
+          },
+        }
+        : {};
+
+      const thread = await this.instance.beta.threads.create({
+        ...fileSearchOptions,
+      });
+
+      return {
+        chatId: thread.id,
+      };
+    } catch (error: any) {
+      this.logger
+        .child('createChat')
+        .error('Error creating chat', {
+          error,
+          options,
+        });
+
+      return { error };
+    }
+  }
+
+  async deleteChat(
+    chatId: string,
+  ): Promise<void> {
+    await this.instance.beta.threads.del(chatId);
+  }
+
+  async createAssistant(
+    options: LLMCreateAssistantOptions<LLMProviders.OpenAI>,
+  ): Promise<LLMCreateAssistantResult> {
+    try {
+      const {
+        model,
+        instructions,
+        storageIds,
+      } = options;
+
+      const fileSearchOptions: Pick<
+        OpenAI.Beta.AssistantCreateParams,
+        'tools' | 'tool_resources'
+      > = storageIds?.length
+        ? {
+          tools: [
+            {
+              type: 'file_search',
+            },
+          ],
+          tool_resources: {
+            file_search: {
+              vector_store_ids: storageIds,
+            },
+          },
+        }
+        : {};
+
+      const assistant = await this.instance.beta.assistants.create({
+        model: model.name,
+        instructions,
+        temperature: model.config.temperature,
+        top_p: model.config.top_p,
+        ...fileSearchOptions,
+      });
+
+      return {
+        assistantId: assistant.id,
+      };
+    } catch (error: any) {
+      this.logger
+        .child('createAssistant')
+        .error('Error creating assistant', {
+          error,
+          options,
+        });
+
+      return { error };
+    }
+  }
+
+  async deleteAssistant(
+    assistantId: string,
+  ): Promise<void> {
+    await this.instance.beta.assistants.del(assistantId);
+  }
+
+  async assistInChat(
+    options: LLMAssistanceOptions<LLMProviders.OpenAI>,
+  ): Promise<LLMAssistanceResult> {
+    try {
+      const {
+        message,
+        chatId,
+        assistantId,
+      } = options;
+
+      const threadMessageData = {
+        content: message.content,
+        role: (
+          message.role === LLMRoles.User
+            ? OpenAIRoles.User
+            : OpenAIRoles.Assistant
+        ),
+      } as const;
+
+      await this.instance.beta.threads.messages.create(
+        chatId,
+        threadMessageData,
+      );
+
+      const threadRun = await this.instance.beta.threads.runs.createAndPoll(
+        chatId,
+        {
+          assistant_id: assistantId,
+        },
+      );
+
+      const { status } = threadRun;
+
+      if (status !== 'completed') {
+        throw new Error(`Thread run did not complete for message, status: ${status}`);
+      }
+
+      const threadRunMessages = await this.instance.beta.threads.messages.list(
+        chatId,
+        {
+          run_id: threadRun.id,
+        },
+      );
+
+      const assistantResponse = threadRunMessages.data.find(
+        (message) => message.role === OpenAIRoles.Assistant,
+      );
+
+      const textContent = assistantResponse?.content
+        .find(
+          (content): content is OpenAI.Beta.Threads.TextContentBlock => (
+            content.type === 'text' && 'text' in content
+          ),
+        );
+
+      return {
+        text: textContent?.text?.value ?? '',
+      };
+    } catch (error: any) {
+      this.logger
+        .child('assistInChat')
+        .error('Error assisting in chat', {
+          error,
+          options,
+        });
+
+      return { error };
+    }
+  }
+}

package/src/providers/OpenAI/services/OpenAICompletion.service.ts

@@ -0,0 +1,74 @@
+import { Logger } from '@mate-academy/core';
+import { OpenAI } from 'openai';
+import {
+  LLMCompletionResult,
+  LLMInstanceOptions,
+  LLMProviders,
+  LLMSendMessageOptions,
+} from '../../../LLMService.typedefs';
+import { LLMServiceEntity } from '../../../LLMService.entity';
+import {
+  LLMCompletionService,
+} from '../../../services';
+import { OpenAIEntity } from '../OpenAI.entity';
+
+export class OpenAICompletionService
+  extends LLMCompletionService<LLMProviders.OpenAI> {
+  #instance: OpenAI | null = null;
+
+  constructor(
+    logger: Logger,
+    options: LLMInstanceOptions[LLMProviders.OpenAI],
+  ) {
+    super(LLMProviders.OpenAI, logger, options);
+  }
+
+  protected get instance(): OpenAI {
+    if (!this.#instance) {
+      this.#instance = new OpenAI(this.options);
+    }
+
+    return this.#instance;
+  }
+
+  async sendMessage(
+    options: LLMSendMessageOptions<typeof this.provider>,
+  ): Promise<LLMCompletionResult> {
+    try {
+      const {
+        model,
+        message,
+        history = [],
+      } = options;
+
+      const countTokensFn = OpenAIEntity.getCountTokensFn();
+
+      const combinedMessages =    await LLMServiceEntity.combineMessagesWithLimit({
+        history,
+        message: message.content,
+        model,
+        countTokensFn,
+      });
+
+      const completion = await this.instance.chat.completions.create({
+        model: model.name,
+        messages: combinedMessages,
+        n: 1,
+        ...model.config,
+      });
+
+      return {
+        text: completion.choices[0]?.message.content ?? '',
+      };
+    } catch (error: any) {
+      this.logger
+        .child('sendMessage')
+        .error('Error sending message', {
+          error,
+          options,
+        });
+
+      return { error };
+    }
+  }
+}

package/src/providers/OpenAI/services/index.ts

@@ -0,0 +1,2 @@
+export * from './OpenAICompletion.service';
+export * from './OpenAIAssistance.service';

package/src/providers/index.ts

@@ -0,0 +1,2 @@
+export * from './OpenAI/OpenAIService.factory';
+export * from './GoogleGenerativeAI/GoogleGenerativeAIService.factory';

package/src/services/LLMAssistanceService.abstract.ts

@@ -0,0 +1,73 @@
+import { Logger } from '@mate-academy/core';
+import {
+  LLMAssistanceOptions,
+  LLMAssistanceResult,
+  LLMCreateAssistantOptions,
+  LLMCreateAssistantResult,
+  LLMCreateChatOptions,
+  LLMCreateChatResult,
+  LLMCreateFileStorageOptions,
+  LLMCreateFileStorageResult,
+  LLMInstanceOptions,
+  LLMProviders,
+  LLMPurposes,
+  LLMUploadFile,
+  LLMUploadFileResult,
+} from '../LLMService.typedefs';
+import { LLMBaseService } from '../services';
+
+export abstract class LLMAssistanceService<Provider extends LLMProviders>
+  extends LLMBaseService<
+    LLMPurposes.Assistance,
+    Provider
+  > {
+  constructor(
+    provider: Provider,
+    logger: Logger,
+    options: LLMInstanceOptions[Provider],
+  ) {
+    super(
+      provider,
+      'AssistanceService',
+      LLMPurposes.Assistance,
+      logger,
+      options,
+    );
+  }
+
+  abstract uploadFile(
+    file: LLMUploadFile,
+  ): Promise<LLMUploadFileResult>;
+
+  abstract deleteFile(
+    fileId: string,
+  ): Promise<void>;
+
+  abstract createFileStorage(
+    options: LLMCreateFileStorageOptions<Provider>,
+  ): Promise<LLMCreateFileStorageResult>;
+
+  abstract deleteFileStorage(
+    fileStorageId: string,
+  ): Promise<void>;
+
+  abstract createAssistant(
+    options: LLMCreateAssistantOptions<Provider>,
+  ): Promise<LLMCreateAssistantResult>;
+
+  abstract deleteAssistant(
+    assistantId: string,
+  ): Promise<void>;
+
+  abstract createChat(
+    options: LLMCreateChatOptions<Provider>,
+  ): Promise<LLMCreateChatResult>;
+
+  abstract deleteChat(
+    chatId: string,
+  ): Promise<void>;
+
+  abstract assistInChat(
+    options: LLMAssistanceOptions<Provider>,
+  ): Promise<LLMAssistanceResult>;
+}

package/src/services/LLMBaseService.abstract.ts

@@ -0,0 +1,34 @@
+import { Logger } from '@mate-academy/core';
+import {
+  LLMInstanceOptions,
+  LLMInstances,
+  LLMProviderAvailableModels,
+  LLMProviders,
+  LLMPurposes,
+} from '../LLMService.typedefs';
+import { LLM_SERVICE_MODELS } from '../LLMService.constants';
+
+export abstract class LLMBaseService<
+  Purpose extends LLMPurposes,
+  Provider extends LLMProviders
+> {
+  constructor(
+    public readonly provider: Provider,
+    public readonly serviceName: string,
+    public readonly purpose: Purpose,
+    public logger: Logger,
+    public options: LLMInstanceOptions[Provider],
+  ) {
+    this.initLogger();
+  }
+
+  protected abstract get instance(): LLMInstances[Provider];
+
+  public get models(): Partial<LLMProviderAvailableModels<Provider>> {
+    return LLM_SERVICE_MODELS[this.provider][this.purpose];
+  }
+
+  protected initLogger(): void {
+    this.logger = this.logger.child(`${this.provider}:${this.serviceName}`);
+  }
+}

package/src/services/LLMCompletionService.abstract.ts

@@ -0,0 +1,32 @@
+import { Logger } from '@mate-academy/core';
+import {
+  LLMPurposes,
+  LLMProviders,
+  LLMSendMessageOptions,
+  LLMCompletionResult,
+  LLMInstanceOptions,
+} from '../LLMService.typedefs';
+import { LLMBaseService } from '../services';
+
+export abstract class LLMCompletionService<
+  Provider extends LLMProviders
+>
+  extends LLMBaseService<LLMPurposes.Completion, Provider> {
+  constructor(
+    provider: Provider,
+    logger: Logger,
+    options: LLMInstanceOptions[Provider],
+  ) {
+    super(
+      provider,
+      'CompletionService',
+      LLMPurposes.Completion,
+      logger,
+      options,
+    );
+  }
+
+  abstract sendMessage(
+    options: LLMSendMessageOptions<Provider>,
+  ): Promise<LLMCompletionResult>;
+}

package/src/services/LLMServicePurposeFactory.abstract.ts

@@ -0,0 +1,15 @@
+import { Logger } from '@mate-academy/core';
+import {
+  LLMInstanceOptions,
+  LLMProviders,
+  LLMPurposes,
+  LLMServiceByPurpose,
+} from '../LLMService.typedefs';
+
+export abstract class LLMServicePurposeFactory<Provider extends LLMProviders> {
+  abstract createService<Purpose extends LLMPurposes>(
+    purpose: Purpose,
+    logger: Logger,
+    options: LLMInstanceOptions[Provider],
+  ): LLMServiceByPurpose<Provider>[Purpose];
+}

package/src/services/index.ts

@@ -0,0 +1,4 @@
+export * from './LLMBaseService.abstract';
+export * from './LLMCompletionService.abstract';
+export * from './LLMServicePurposeFactory.abstract';
+export * from './LLMAssistanceService.abstract';

package/tsconfig.json

@@ -0,0 +1,23 @@
+{
+  "extends": "@mate-academy/ts-config",
+  "compilerOptions": {
+    "target": "ESNext",
+    "module": "CommonJS",
+    "declaration": true,
+    "declarationDir": "./dist",
+    "baseUrl": "./src",
+    "outDir": "./dist",
+    "strict": true,
+    "types": [
+      "node",
+    ]
+  },
+  "include": [
+    "src/**/*",
+  ],
+  "exclude": [
+    "node_modules",
+    "dist"
+  ]
+}
+