refactor ai templates and requests

Author: lebalz

prisma/migrations/20250604174413_remove_name_from_ai_template/migration.sql

@@ -1,18 +1,13 @@
 -- CreateTable
 CREATE TABLE "ai_templates" (
     "id" UUID NOT NULL DEFAULT gen_random_uuid(),
-    "name" TEXT NOT NULL DEFAULT '',
+    "author_id" UUID NOT NULL,
     "rate_limit" INTEGER NOT NULL DEFAULT 0,
     "rate_limit_period_ms" BIGINT NOT NULL DEFAULT 3600000,
     "is_active" BOOLEAN NOT NULL DEFAULT true,
-    "model" TEXT NOT NULL,
     "api_key" TEXT NOT NULL,
     "api_url" TEXT NOT NULL,
-    "temperature" DOUBLE PRECISION NOT NULL DEFAULT 0.5,
-    "max_tokens" INTEGER NOT NULL DEFAULT 2048,
-    "top_p" DOUBLE PRECISION NOT NULL DEFAULT 0.8,
-    "system_message" TEXT,
-    "json_schema" JSONB,
+    "config" JSONB NOT NULL,
     "created_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
     "updated_at" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
 
@@ -34,6 +29,9 @@ CREATE TABLE "ai_requests" (
     CONSTRAINT "ai_requests_pkey" PRIMARY KEY ("id")
 );
 
+-- AddForeignKey
+ALTER TABLE "ai_templates" ADD CONSTRAINT "ai_templates_author_id_fkey" FOREIGN KEY ("author_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
+
 -- AddForeignKey
 ALTER TABLE "ai_requests" ADD CONSTRAINT "ai_requests_user_id_fkey" FOREIGN KEY ("user_id") REFERENCES "users"("id") ON DELETE CASCADE ON UPDATE CASCADE;
 

prisma/migrations/20250602195519_add_ai_models/migration.sql renamed to prisma/migrations/20250608170858_add_ai_models/migration.sql

@@ -29,25 +29,24 @@ model User {
   cmsSettings                     CmsSettings?
   studentGroups                   UserStudentGroup[]                @relation("user_student_groups")
   aiRequests                      AiRequest[]
+  aiTemplates                     AiTemplate[]                      @relation("ai_templates")
 
   @@map("users")
 }
 
 model AiTemplate {
-  id                String  @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+  id String @id @default(dbgenerated("gen_random_uuid()")) @db.Uuid
+
+  author            User    @relation("ai_templates", fields: [authorId], references: [id], onDelete: Cascade)
+  authorId          String  @map("author_id") @db.Uuid
   rateLimit         Int     @default(0) @map("rate_limit")
   rateLimitPeriodMs BigInt  @default(3600000) @map("rate_limit_period_ms") // Default to 1 hour
   isActive          Boolean @default(true) @map("is_active")
 
-  model  String @map("model")
   apiKey String @map("api_key")
   apiUrl String @map("api_url")
 
-  temperature   Float   @default(0.5) @map("temperature")
-  maxTokens     Int     @default(2048) @map("max_tokens")
-  topP          Float   @default(0.8) @map("top_p")
-  systemMessage String? @map("system_message")
-  jsonSchema    Json?   @map("json_schema")
+  config Json @map("config") // Configuration for the AI template, e.g., model, parameters
 
   aiRequests AiRequest[]
 

prisma/schema.prisma

@@ -48,19 +48,16 @@ function AiRequest(db: PrismaClient['aiRequest']) {
                 baseURL: template.apiUrl
             });
 
-            const requestInput: OpenAI.Responses.ResponseInput = [];
-            if (template.systemMessage) {
-                requestInput.push({
-                    role: 'system',
-                    content: [
-                        {
-                            type: 'input_text',
-                            text: template.systemMessage
-                        }
-                    ]
-                });
-            }
-            requestInput.push({
+            const templateConfig =
+                template.config as unknown as OpenAI.Responses.ResponseCreateParamsNonStreaming;
+            const config: OpenAI.Responses.ResponseCreateParamsNonStreaming = {
+                ...templateConfig,
+                input: Array.isArray(templateConfig.input)
+                    ? (templateConfig.input as OpenAI.Responses.ResponseInput)
+                    : [templateConfig.input as unknown as OpenAI.Responses.ResponseInputItem]
+            };
+
+            (config.input as OpenAI.Responses.ResponseInput).push({
                 role: 'user',
                 content: [
                     {
@@ -81,26 +78,7 @@ function AiRequest(db: PrismaClient['aiRequest']) {
             });
 
             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
-                })
+                .create(config)
                 .then((response) => {
                     db.update({
                         where: { id: aiRequest.id },

src/models/AiRequest.ts

@@ -30,19 +30,24 @@ function AiTemplate(db: PrismaClient['aiTemplate']) {
                 throw new HTTP403Error('Not authorized to update AI templates');
             }
             const record = await this.findModel(actor, id);
+            if (record.authorId !== actor.id) {
+                throw new HTTP403Error('Not authorized to update this AI template');
+            }
+            const updateData: Prisma.AiTemplateUpdateInput = {
+                config: data.config as Prisma.InputJsonValue,
+                apiKey: data.apiKey,
+                apiUrl: data.apiUrl,
+                isActive: data.isActive,
+                rateLimit: data.rateLimit,
+                rateLimitPeriodMs: data.rateLimitPeriodMs
+            };
             /** remove fields not updatable*/
             return db
                 .update({
                     where: {
                         id: record.id
                     },
-                    data: {
-                        ...data,
-                        jsonSchema:
-                            typeof data.jsonSchema === 'object'
-                                ? (data.jsonSchema as Prisma.JsonObject)
-                                : undefined
-                    }
+                    data: updateData
                 })
                 .then((v) => prepareAiTemplate(v));
         },
@@ -59,7 +64,12 @@ function AiTemplate(db: PrismaClient['aiTemplate']) {
             }
             return db
                 .create({
-                    data: data
+                    data: {
+                        ...data,
+                        author: {
+                            connect: { id: actor.id }
+                        }
+                    }
                 })
                 .then((v) => prepareAiTemplate(v));
         },