request ai model async

Author: lebalz

src/controllers/aiRequest.ts

@@ -1,5 +1,8 @@
 import { RequestHandler } from 'express';
 import AiRequest from '../models/AiRequest';
+import { AiRequest as DbAiRequest } from '@prisma/client';
+import { IoRoom } from '../routes/socketEvents';
+import { IoEvent, RecordType } from '../routes/socketEventTypes';
 
 export const all: RequestHandler<{ aiTemplateId: string }> = async (req, res, next) => {
     try {
@@ -21,7 +24,13 @@ export const find: RequestHandler<{ id: string; requestId: string }> = async (re
 
 export const create: RequestHandler<{ id: string }, any, { request: string }> = async (req, res, next) => {
     try {
-        const request = await AiRequest.createModel(req.user!, req.params.id, req.body.request);
+        const onResponse = (aiRequest: DbAiRequest) => {
+            req.io?.to([req.user!.id, IoRoom.ADMIN]).emit(IoEvent.CHANGED_RECORD, {
+                type: RecordType.AiRequest,
+                record: aiRequest
+            });
+        };
+        const request = await AiRequest.createModel(req.user!, req.params.id, req.body.request, onResponse);
         res.status(201).json(request);
     } catch (error) {
         next(error);

src/models/AiRequest.ts

@@ -18,7 +18,12 @@ function AiRequest(db: PrismaClient['aiRequest']) {
             });
             return requests;
         },
-        async createModel(actor: DbUser, aiTemplateId: string, input: string): Promise<DbAiRequest> {
+        async createModel(
+            actor: DbUser,
+            aiTemplateId: string,
+            input: string,
+            onResponse?: (aiRequest: DbAiRequest) => void
+        ): Promise<DbAiRequest> {
             const template = await prisma.aiTemplate.findUniqueOrThrow({
                 where: { id: aiTemplateId }
             });
@@ -65,36 +70,61 @@ function AiRequest(db: PrismaClient['aiRequest']) {
                 ]
             });
 
-            const response = await client.responses.create({
-                model: template.model,
-                input: requestInput,
-                text: {
-                    format: template.jsonSchema
-                        ? {
-                              type: 'json_schema',
-                              name: 'tdev_ai_response',
-                              schema: {},
-                              ...(template.jsonSchema! as unknown as Partial<OpenAI.ResponseFormatJSONSchema>)
-                          }
-                        : ({ type: 'text' } as OpenAI.ResponseFormatText)
-                },
-                reasoning: {},
-                tools: [],
-                temperature: template.temperature,
-                max_output_tokens: template.maxTokens,
-                top_p: template.topP,
-                store: false
-            });
-
             const aiRequest = await db.create({
                 data: {
                     userId: actor.id,
                     aiTemplateId: aiTemplateId,
                     request: input,
-                    response: JSON.parse(response.output_text),
-                    status: 'success'
+                    status: 'pending',
+                    response: {}
                 }
             });
+
+            client.responses
+                .create({
+                    model: template.model,
+                    input: requestInput,
+                    text: {
+                        format: template.jsonSchema
+                            ? {
+                                  type: 'json_schema',
+                                  name: template.name || 'tdev-ai-response',
+                                  schema: {},
+                                  ...(template.jsonSchema as unknown as Partial<OpenAI.ResponseFormatJSONSchema>)
+                              }
+                            : ({ type: 'text' } as OpenAI.ResponseFormatText)
+                    },
+                    reasoning: {},
+                    tools: [],
+                    temperature: template.temperature,
+                    max_output_tokens: template.maxTokens,
+                    top_p: template.topP,
+                    store: false
+                })
+                .then((response) => {
+                    db.update({
+                        where: { id: aiRequest.id },
+                        data: {
+                            status: response.error ? 'error' : 'completed',
+                            response: response.error ? response.error : JSON.parse(response.output_text)
+                        }
+                    }).then((updatedRequest) => {
+                        onResponse?.(updatedRequest);
+                    });
+                })
+                .catch((error) => {
+                    db.update({
+                        where: { id: aiRequest.id },
+                        data: {
+                            status: 'error',
+                            response: {
+                                error: error.message || 'Unknown error occurred'
+                            }
+                        }
+                    }).then((updatedRequest) => {
+                        onResponse?.(updatedRequest);
+                    });
+                });
             return aiRequest;
         }
     });

src/routes/socketEventTypes.ts

@@ -1,4 +1,4 @@
-import { AllowedAction, CmsSettings, Prisma, User } from '@prisma/client';
+import { AiRequest, AllowedAction, CmsSettings, Prisma, User } from '@prisma/client';
 import { ApiDocument } from '../models/Document';
 import { ApiUserPermission } from '../models/RootUserPermission';
 import { ApiGroupPermission } from '../models/RootGroupPermission';
@@ -22,7 +22,8 @@ export enum RecordType {
     DocumentRoot = 'DocumentRoot',
     StudentGroup = 'StudentGroup',
     AllowedAction = 'AllowedAction',
-    CmsSettings = 'CmsSettings'
+    CmsSettings = 'CmsSettings',
+    AiRequest = 'AiRequest'
 }
 
 type TypeRecordMap = {
@@ -34,6 +35,7 @@ type TypeRecordMap = {
     [RecordType.StudentGroup]: ApiStudentGroup;
     [RecordType.AllowedAction]: AllowedAction;
     [RecordType.CmsSettings]: CmsSettings;
+    [RecordType.AiRequest]: AiRequest;
 };
 
 export interface NewRecord<T extends RecordType> {