@drax/ai-back 3.0.0 → 3.17.0

package/src/controllers/AIGenericController.ts

@@ -0,0 +1,97 @@
+import {z} from "zod";
+import {CommonController} from "@drax/common-back";
+import AiProviderFactory from "../factory/AiProviderFactory.js";
+import AIPermissions from "../permissions/AIPermissions.js";
+import type {IPromptParams} from "../interfaces/IAIProvider.js";
+
+const PromptImageSchema = z.object({
+    url: z.string().min(1),
+    detail: z.enum(["auto", "low", "high"]).optional(),
+})
+
+const PromptContentPartSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("text"),
+        text: z.string(),
+    }),
+    z.object({
+        type: z.literal("image"),
+        imageUrl: z.string().min(1),
+        detail: z.enum(["auto", "low", "high"]).optional(),
+    }),
+])
+
+const PromptMessageSchema = z.object({
+    role: z.enum(["user", "assistant", "system"]),
+    content: z.union([
+        z.string(),
+        z.array(PromptContentPartSchema),
+    ]),
+})
+
+const PromptMemorySchema = z.object({
+    key: z.string().min(1),
+    value: z.string(),
+})
+
+const PromptInputFileSchema = z.object({
+    filename: z.string().optional(),
+    filepath: z.string().optional(),
+    size: z.number().nullable().optional(),
+    mimetype: z.string().optional(),
+    url: z.string().optional(),
+})
+
+const GenericPromptRequestSchema = z.object({
+    systemPrompt: z.string().min(1),
+    userInput: z.string().optional(),
+    userImages: z.array(PromptImageSchema).optional(),
+    inputFiles: z.array(PromptInputFileSchema).optional(),
+    userContent: z.array(PromptContentPartSchema).optional(),
+    history: z.array(PromptMessageSchema).optional(),
+    memory: z.array(PromptMemorySchema).optional(),
+    memoryHeader: z.string().optional(),
+    knowledgeBase: z.array(z.string()).optional(),
+    knowledgeBaseHeader: z.string().optional(),
+    jsonSchema: z.record(z.string(), z.any()).or(z.array(z.any())).optional(),
+    model: z.string().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+})
+
+class AIGenericController extends CommonController {
+
+    async prompt(request, reply) {
+        try {
+            request.rbac.assertPermission(AIPermissions.Prompt)
+
+            const input = GenericPromptRequestSchema.parse(request.body ?? {})
+            const aiProvider = AiProviderFactory.instance()
+            const promptInput: IPromptParams = {
+                ...(input as IPromptParams),
+                operationTitle: input.operationTitle ?? "generic-ai-prompt",
+                operationGroup: input.operationGroup ?? "generic-ai-prompt",
+                ip: request.ip,
+                userAgent: request.headers["user-agent"],
+                tenant: request.rbac?.tenantId ?? null,
+                user: request.rbac?.userId ?? null,
+            }
+
+            const response = await aiProvider.prompt(promptInput)
+
+            return reply.send(response)
+        } catch (e: any) {
+            if (e?.name === "ZodError") {
+                return reply.status(400).send({
+                    message: e?.message || "AI prompt validation error",
+                })
+            }
+
+            this.handleError(e, reply)
+        }
+    }
+
+}
+
+export default AIGenericController;
+export {AIGenericController};

package/src/controllers/AILogController.ts

@@ -0,0 +1,29 @@
+
+import AILogServiceFactory from "../factory/services/AILogServiceFactory.js";
+import {AbstractFastifyController} from "@drax/crud-back";
+import AILogPermissions from "../permissions/AILogPermissions.js";
+import type {IAILog, IAILogBase} from "@drax/ai-share";
+
+class AILogController extends AbstractFastifyController<IAILog, IAILogBase, IAILogBase>   {
+
+    constructor() {
+        super(AILogServiceFactory.instance, AILogPermissions)
+        this.tenantField = "tenant";
+        this.userField = "user";
+
+        this.tenantFilter = true;
+        this.tenantSetter = true;
+        this.tenantAssert = true;
+
+        this.userFilter = true;
+        this.userSetter = true;
+        this.userAssert = true;
+    }
+
+}
+
+export default AILogController;
+export {
+    AILogController
+}
+

package/src/factory/AiProviderFactory.ts

@@ -4,7 +4,7 @@ import OpenAiProviderFactory from "./OpenAiProviderFactory.js";
 class AiProviderFactory {
     private static singleton: IAIProvider;
 
-    public static instance(provider: string): IAIProvider {
+    public static instance(provider: string = 'OpenAi'): IAIProvider {
         if (!AiProviderFactory.singleton) {
             switch (provider) {
                 case 'OpenAi':

package/src/factory/OpenAiProviderFactory.ts

@@ -2,6 +2,7 @@ import {DraxConfig} from "@drax/common-back";
 import OpenAiConfig from "../config/OpenAiConfig.js";
 import type {IAIProvider} from "../interfaces/IAIProvider"
 import OpenAiProvider from "../providers/OpenAiProvider.js";
+import AILogServiceFactory from "./services/AILogServiceFactory.js";
 
 class OpenAiProviderFactory {
     private static singleton: IAIProvider;
@@ -10,7 +11,9 @@ class OpenAiProviderFactory {
         if (!OpenAiProviderFactory.singleton) {
             OpenAiProviderFactory.singleton = new OpenAiProvider(
                 DraxConfig.getOrLoad(OpenAiConfig.OpenAiApiKey),
-                DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel)
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiModel),
+                DraxConfig.getOrLoad(OpenAiConfig.OpenAiVisionModel),
+                AILogServiceFactory.instance
             );
         }
         return OpenAiProviderFactory.singleton;
@@ -21,4 +24,3 @@ export default OpenAiProviderFactory
 export {
     OpenAiProviderFactory
 }
-

package/src/factory/services/AILogServiceFactory.ts

@@ -0,0 +1,41 @@
+
+import AILogMongoRepository from '../../repository/mongo/AILogMongoRepository.js'
+import AILogSqliteRepository from '../../repository/sqlite/AILogSqliteRepository.js'
+import type {IAILogRepository} from "../../interfaces/IAILogRepository";
+import {AILogService} from '../../services/AILogService.js'
+import {AILogBaseSchema, AILogSchema} from "../../schemas/AILogSchema.js";
+import {COMMON, CommonConfig, DraxConfig} from "@drax/common-back";
+
+class AILogServiceFactory {
+    private static service: AILogService;
+
+    public static get instance(): AILogService {
+        if (!AILogServiceFactory.service) {
+            
+            let repository: IAILogRepository
+            switch (DraxConfig.getOrLoad(CommonConfig.DbEngine)) {
+                case COMMON.DB_ENGINES.MONGODB:
+                    repository = new AILogMongoRepository()
+                    break;
+                case COMMON.DB_ENGINES.SQLITE:
+                    const dbFile = DraxConfig.getOrLoad(CommonConfig.SqliteDbFile)
+                    repository = new AILogSqliteRepository(dbFile, false)
+                    repository.build()
+                    break;
+                default:
+                    throw new Error("DraxConfig.DB_ENGINE must be one of " + Object.values(COMMON.DB_ENGINES).join(", "));
+            }
+            
+            const baseSchema = AILogBaseSchema;
+            const fullSchema = AILogSchema;
+            AILogServiceFactory.service = new AILogService(repository, baseSchema, fullSchema);
+        }
+        return AILogServiceFactory.service;
+    }
+}
+
+export default AILogServiceFactory
+export {
+    AILogServiceFactory
+}
+

package/src/index.ts

@@ -1,20 +1,66 @@
 import {OpenAiConfig} from "./config/OpenAiConfig.js";
+import {AILogSchema, AILogBaseSchema} from "./schemas/AILogSchema.js";
+import AILogModel from "./models/AILogModel.js";
+import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
+import AILogSqliteRepository from "./repository/sqlite/AILogSqliteRepository.js";
 import {OpenAiProviderFactory} from "./factory/OpenAiProviderFactory.js";
+import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
 import {OpenAiProvider} from "./providers/OpenAiProvider.js";
 import {KnowledgeService} from "./services/KnowledgeService.js";
-import type {IAIProvider, IPromptResponse, IPromptParams, IPromptMessage, IPromptMemory} from "./interfaces/IAIProvider.js";
+import {AILogService} from "./services/AILogService.js";
+import AILogPermissions from "./permissions/AILogPermissions.js";
+import AIPermissions from "./permissions/AIPermissions.js";
+import AILogController from "./controllers/AILogController.js";
+import AICrudController from "./controllers/AICrudController.js";
+import AIGenericController from "./controllers/AIGenericController.js";
+import AILogRoutes from "./routes/AILogRoutes.js";
+import AIRoutes from "./routes/AIRoutes.js";
+import type {IAILogRepository} from "./interfaces/IAILogRepository.js";
+import type {
+    IAIProvider,
+    IPromptContentPart,
+    IPromptContentPartImage,
+    IPromptContentPartText,
+    IPromptImage,
+    IPromptImageDetail,
+    IPromptMessage,
+    IPromptMemory,
+    IPromptParams,
+    IPromptResponse
+} from "./interfaces/IAIProvider.js";
 
 export type {
+
+    IAILogRepository,
     IAIProvider,
     IPromptParams,
     IPromptMessage,
     IPromptMemory,
+    IPromptImage,
+    IPromptImageDetail,
+    IPromptContentPart,
+    IPromptContentPartImage,
+    IPromptContentPartText,
     IPromptResponse,
 }
 
 export {
     OpenAiConfig,
+    AILogSchema,
+    AILogBaseSchema,
+    AILogModel,
+    AILogMongoRepository,
+    AILogSqliteRepository,
     OpenAiProviderFactory,
+    AILogServiceFactory,
     OpenAiProvider,
     KnowledgeService,
+    AILogService,
+    AILogPermissions,
+    AIPermissions,
+    AILogController,
+    AICrudController,
+    AIGenericController,
+    AILogRoutes,
+    AIRoutes
 }

package/src/interfaces/IAILogRepository.ts

@@ -0,0 +1,11 @@
+
+import type {IAILog, IAILogBase} from '@drax/ai-share'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface IAILogRepository extends IDraxCrudRepository<IAILog, IAILogBase, IAILogBase>{
+
+}
+
+export {IAILogRepository}
+
+

package/src/interfaces/IAIProvider.ts

@@ -2,9 +2,29 @@ import { ZodSchema } from 'zod'
 
 type Role = 'user' | 'assistant' | 'system';
 
+type IPromptImageDetail = 'auto' | 'low' | 'high';
+
+interface IPromptImage {
+    url: string;
+    detail?: IPromptImageDetail;
+}
+
+interface IPromptContentPartText {
+    type: 'text';
+    text: string;
+}
+
+interface IPromptContentPartImage {
+    type: 'image';
+    imageUrl: string;
+    detail?: IPromptImageDetail;
+}
+
+type IPromptContentPart = IPromptContentPartText | IPromptContentPartImage;
+
 interface IPromptMessage {
     role: Role;
-    content: string;
+    content: string | IPromptContentPart[];
 }
 
 interface IPromptMemory {
@@ -15,6 +35,15 @@ interface IPromptMemory {
 interface IPromptParams {
     systemPrompt: string,
     userInput?: string,
+    userImages?: IPromptImage[],
+    inputFiles?: Array<{
+        filename?: string,
+        filepath?: string,
+        size?: number | null,
+        mimetype?: string,
+        url?: string
+    }>,
+    userContent?: IPromptContentPart[],
     history?: IPromptMessage[],
     memory?: IPromptMemory[],
     memoryHeader?: string | '[MEMORY]' | '[MEMORIA]'
@@ -23,6 +52,12 @@ interface IPromptParams {
     zodSchema?: ZodSchema<any>,
     jsonSchema?: object,
     model?: string,
+    operationTitle?: string,
+    operationGroup?: string,
+    ip?: string,
+    userAgent?: string,
+    tenant?: string | null,
+    user?: string | null,
 }
 
 interface IPromptResponse {
@@ -37,4 +72,15 @@ interface IAIProvider {
     prompt(input: IPromptParams): Promise<IPromptResponse>
 }
 
-export type {IAIProvider, IPromptParams, IPromptResponse, IPromptMessage, IPromptMemory}
+export type {
+    IAIProvider,
+    IPromptParams,
+    IPromptResponse,
+    IPromptMessage,
+    IPromptMemory,
+    IPromptImage,
+    IPromptImageDetail,
+    IPromptContentPart,
+    IPromptContentPartImage,
+    IPromptContentPartText,
+}

package/src/models/AILogModel.ts

@@ -0,0 +1,65 @@
+
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {IAILog} from '@drax/ai-share'
+
+const AILogSchema = new mongoose.Schema<IAILog>({
+            provider: {type: String,   required: false, index: true, unique: false },
+            model: {type: String,   required: false, index: true, unique: false },
+            operationTitle: {type: String,   required: false, index: false, unique: false },
+            operationGroup: {type: String,   required: false, index: false, unique: false },
+            ip: {type: String,   required: false, index: false, unique: false },
+            userAgent: {type: String,   required: false, index: false, unique: false },
+            input: {type: String,   required: false, index: false, unique: false },
+            inputImages: [{
+                        filename: {type: String,   required: false, index: false, unique: false },
+            filepath: {type: String,   required: false, index: false, unique: false },
+            size: {type: Number,   required: false, index: false, unique: false },
+            mimetype: {type: String,   required: false, index: false, unique: false },
+            url: {type: String,   required: false, index: false, unique: false }
+            }],
+            inputFiles: [{
+                        filename: {type: String,   required: false, index: false, unique: false },
+            filepath: {type: String,   required: false, index: false, unique: false },
+            size: {type: Number,   required: false, index: false, unique: false },
+            mimetype: {type: String,   required: false, index: false, unique: false },
+            url: {type: String,   required: false, index: false, unique: false }
+            }],
+            inputTokens: {type: Number,   required: false, index: false, unique: false },
+            outputTokens: {type: Number,   required: false, index: false, unique: false },
+            tokens: {type: Number,   required: false, index: false, unique: false },
+            startedAt: {type: Date,   required: false, index: false, unique: false },
+            endedAt: {type: Date,   required: false, index: false, unique: false },
+            responseTime: {type: String,   required: false, index: false, unique: false },
+            output: {type: String,   required: false, index: false, unique: false },
+            success: {type: Boolean,   required: false, index: false, unique: false },
+            statusCode: {type: Number,   required: false, index: false, unique: false },
+            errorMessage: {type: String,   required: false, index: false, unique: false },
+            tenant: {type: mongoose.Schema.Types.ObjectId, ref: 'Tenant',  required: false, index: false, unique: false },
+            user: {type: mongoose.Schema.Types.ObjectId, ref: 'User',  required: false, index: false, unique: false }
+}, {timestamps: true});
+
+AILogSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+AILogSchema.plugin(mongoosePaginate);
+
+AILogSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+
+AILogSchema.set('toJSON', {getters: true, virtuals: true});
+
+AILogSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'AILog';
+const COLLECTION_NAME = 'AILog';
+const AILogModel = mongoose.model<IAILog, PaginateModel<IAILog>>(MODEL_NAME, AILogSchema,COLLECTION_NAME);
+
+export {
+    AILogSchema,
+    AILogModel
+}
+
+export default AILogModel

package/src/permissions/AILogPermissions.ts

@@ -0,0 +1,14 @@
+
+enum AILogPermissions {
+
+    Create = "ailog:create",
+    Update = "ailog:update",
+    Delete = "ailog:delete",
+    View = "ailog:view",
+    Manage = "ailog:manage"
+
+}
+
+export { AILogPermissions };
+export default AILogPermissions;
+

package/src/permissions/AIPermissions.ts

@@ -0,0 +1,11 @@
+
+enum AIPermissions {
+
+    Prompt = "ai:prompt",
+    PromptCrud = "ai:promptCrud",
+
+}
+
+export { AIPermissions };
+export default AIPermissions;
+