added AI service

Author: ZibanPirate

api/package.json

@@ -15,6 +15,7 @@
     "@types/make-fetch-happen": "^10.0.4",
     "class-transformer": "^0.5.1",
     "class-validator": "^0.14.1",
+    "class-validator-jsonschema": "^5.0.1",
     "cors": "^2.8.5",
     "cron": "^3.1.7",
     "dotenv": "^16.4.5",

api/src/ai/service.ts

@@ -0,0 +1,66 @@
+import { ConfigService } from "src/config/service";
+import { LoggerService } from "src/logger/service";
+import { Service } from "typedi";
+import { targetConstructorToSchema } from "class-validator-jsonschema";
+import { FetchService } from "src/fetch/service";
+import { ClassConstructor, plainToClass } from "class-transformer";
+import { validateSync } from "class-validator";
+
+type AIChat = { role: "user" | "system"; content: string };
+
+type OpenAIResponse = {
+  choices: Array<{ message: AIChat }>;
+};
+
+@Service()
+export class AIService {
+  constructor(
+    private readonly configService: ConfigService,
+    private readonly logger: LoggerService,
+    private readonly fetchService: FetchService,
+  ) {}
+
+  public query = async <T extends object>(
+    payload: AIChat[],
+    ResponseDto: ClassConstructor<T>,
+  ): Promise<T> => {
+    const schema = targetConstructorToSchema(ResponseDto);
+
+    const payloadWithValidationPrompt: AIChat[] = [
+      {
+        role: "system",
+        content: `system response must strictly follow the schema:\n${JSON.stringify(schema)}`,
+      },
+      ...payload,
+    ];
+
+    const { OPENAI_KEY } = this.configService.env();
+
+    // todo: cache response
+    const res = await this.fetchService.post<OpenAIResponse>(
+      "https://api.openai.com/v1/chat/completions",
+      {
+        headers: { Authorization: `Bearer ${OPENAI_KEY}` },
+        body: {
+          model: "gpt-4o",
+          messages: payloadWithValidationPrompt,
+        },
+      },
+    );
+
+    const chatResponseUnchecked = JSON.parse(res.choices[0].message.content) as T;
+
+    const output = plainToClass(ResponseDto, chatResponseUnchecked);
+    const errors = validateSync(output);
+
+    if (errors.length > 0)
+      throw new Error(
+        `⚠️  Errors in AI response in the following keys:${errors.reduce(
+          (pV, cV) => (pV += "\n" + cV.property + " : " + JSON.stringify(cV.constraints)),
+          "",
+        )}`,
+      );
+
+    return output;
+  };
+}

api/src/config/types.ts

@@ -40,4 +40,7 @@ export class EnvRecord {
   }
 
   MEILISEARCH_MASTER_KEY = "default";
+
+  @IsString()
+  OPENAI_KEY!: string;
 }

api/src/fetch/service.ts

@@ -1,4 +1,4 @@
-import { defaults } from "make-fetch-happen";
+import { defaults, FetchOptions } from "make-fetch-happen";
 import { ConfigService } from "src/config/service";
 import { LoggerService } from "src/logger/service";
 import { Service } from "typedi";
@@ -18,21 +18,36 @@ export class FetchService {
     });
   }
 
+  public post = async <T>(
+    url: string,
+    { headers = {}, body }: FetchConfig = {},
+  ): Promise<Awaited<T>> => {
+    const response = await this.fetch<T>(url, {
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+      },
+      method: "POST",
+      body: body ? JSON.stringify(body) : undefined,
+    });
+    return response;
+  };
+
   public get = async <T>(
     url: string,
     { params = {}, headers = {} }: FetchConfig = {},
   ): Promise<Awaited<T>> => {
     const _url = new URL(url);
     Object.keys(params).forEach((key) => _url.searchParams.append(key, String(params[key])));
 
-    const response = await this.fetch<T>(_url.toString(), { headers });
+    const response = await this.fetch<T>(_url.toString(), { headers, method: "GET" });
     return response;
   };
 
   private makeFetchHappenInstance;
-  private async fetch<T>(url: string, { headers }: Omit<FetchConfig, "params"> = {}) {
+  private async fetch<T>(url: string, options: FetchOptions) {
     this.logger.info({ message: `Fetching ${url}` });
-    const response = await this.makeFetchHappenInstance(url, { headers });
+    const response = await this.makeFetchHappenInstance(url, options);
     const jsonResponse = (await response.json()) as T;
     return jsonResponse;
   }

api/src/fetch/types.ts

@@ -1,4 +1,5 @@
 export interface FetchConfig {
   params?: Record<string, string | number | boolean>;
   headers?: Record<string, string>;
+  body?: Record<string, unknown>;
 }