@drax/ai-back 3.0.0 → 3.16.0

package/src/routes/AILogRoutes.ts

@@ -0,0 +1,38 @@
+
+import AILogController from "../controllers/AILogController.js";
+import {CrudSchemaBuilder} from "@drax/crud-back";
+import {AILogSchema, AILogBaseSchema} from '../schemas/AILogSchema.js'
+
+async function AILogFastifyRoutes(fastify, options) {
+
+    const controller: AILogController = new AILogController()
+    const schemas = new CrudSchemaBuilder(AILogSchema, AILogBaseSchema,AILogBaseSchema, 'AILog', 'openapi-3.0', ['ai']);
+
+    fastify.get('/api/ailog', {schema: schemas.paginateSchema}, (req,rep) => controller.paginate(req,rep))
+    
+    fastify.get('/api/ailog/find', {schema: schemas.findSchema}, (req,rep) => controller.find(req,rep))
+    
+    fastify.get('/api/ailog/search', {schema: schemas.searchSchema}, (req,rep) => controller.search(req,rep))
+    
+    fastify.get('/api/ailog/:id', {schema: schemas.findByIdSchema}, (req,rep) => controller.findById(req,rep))
+    
+    fastify.get('/api/ailog/find-one', {schema: schemas.findOneSchema}, (req,rep) => controller.findOne(req,rep))
+    
+    fastify.get('/api/ailog/group-by', {schema: schemas.groupBySchema}, (req,rep) => controller.groupBy(req,rep))
+
+    fastify.post('/api/ailog', {schema: schemas.createSchema}, (req,rep) =>controller.create(req,rep))
+
+    fastify.put('/api/ailog/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.update(req,rep))
+    
+    fastify.patch('/api/ailog/:id', {schema: schemas.updateSchema}, (req,rep) =>controller.updatePartial(req,rep))
+
+    fastify.delete('/api/ailog/:id', {schema: schemas.deleteSchema}, (req,rep) =>controller.delete(req,rep))
+    
+    fastify.get('/api/ailog/export', (req,rep) =>controller.export(req,rep))
+    
+    fastify.post('/api/ailog/import', (req,rep) => controller.import(req,rep))
+    
+}
+
+export default AILogFastifyRoutes;
+export {AILogFastifyRoutes}

package/src/schemas/AILogSchema.ts

@@ -0,0 +1,52 @@
+import {z} from 'zod';
+
+
+const AILogBaseSchema = z.object({
+    provider: z.string().optional(),
+    model: z.string().optional(),
+    operationTitle: z.string().optional(),
+    operationGroup: z.string().optional(),
+    ip: z.string().optional(),
+    userAgent: z.string().optional(),
+    input: z.string().optional(),
+    inputImages: z.array(
+        z.object({
+            filename: z.string().optional(),
+            filepath: z.string().optional(),
+            size: z.number().nullable().optional(),
+            mimetype: z.string().optional(),
+            url: z.string().optional()
+        })
+    ).optional(),
+    inputFiles: z.array(
+        z.object({
+            filename: z.string().optional(),
+            filepath: z.string().optional(),
+            size: z.number().nullable().optional(),
+            mimetype: z.string().optional(),
+            url: z.string().optional()
+        })
+    ).optional(),
+    inputTokens: z.number().nullable().optional(),
+    outputTokens: z.number().nullable().optional(),
+    tokens: z.number().nullable().optional(),
+    startedAt: z.coerce.date().nullable().optional(),
+    endedAt: z.coerce.date().nullable().optional(),
+    responseTime: z.string().optional(),
+    output: z.string().optional(),
+    success: z.boolean().optional(),
+    statusCode: z.number().nullable().optional(),
+    errorMessage: z.string().optional(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+
+const AILogSchema = AILogBaseSchema
+    .extend({
+        _id: z.coerce.string(),
+        tenant: z.object({_id: z.coerce.string(), name: z.string()}).nullable().optional(),
+        user: z.object({_id: z.coerce.string(), username: z.string()}).nullable().optional()
+    })
+
+export default AILogSchema;
+export {AILogSchema, AILogBaseSchema}

package/src/services/AILogService.ts

@@ -0,0 +1,20 @@
+
+import type{IAILogRepository} from "../interfaces/IAILogRepository";
+import type {IAILogBase, IAILog} from "@drax/ai-share";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class AILogService extends AbstractService<IAILog, IAILogBase, IAILogBase> {
+
+
+    constructor(AILogRepository: IAILogRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(AILogRepository, baseSchema, fullSchema);
+
+        this._validateOutput = true
+
+    }
+
+}
+
+export default AILogService
+export {AILogService}

package/test/OpenAiProvider.test.ts

@@ -6,6 +6,97 @@ import {IPromptMemory, IPromptMessage} from "../src/interfaces/IAIProvider";
 
 describe('OpenAi Test', () => {
 
+    test('OpenAi prompt supports image inputs and vision model fallback', async () => {
+        let request: any
+
+        class MockedOpenAiProvider extends OpenAiProvider {
+            constructor() {
+                super('test-key', 'gpt-4.1-mini', 'gpt-4o-mini')
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                request = payload
+                                return {
+                                    choices: [{message: {content: '{"name":"invoice"}'}}],
+                                    usage: {
+                                        total_tokens: 10,
+                                        prompt_tokens: 7,
+                                        completion_tokens: 3
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const openAi = new MockedOpenAiProvider()
+
+        const r = await openAi.prompt({
+            systemPrompt: 'Extract invoice data',
+            userInput: 'Read this invoice',
+            userImages: [{url: 'data:image/png;base64,abc123', detail: 'high'}]
+        })
+
+        expect(r.output).toBe('{"name":"invoice"}')
+        expect(request.model).toBe('gpt-4o-mini')
+        expect(request.messages[1]).toEqual({
+            role: 'user',
+            content: [
+                {type: 'text', text: 'Read this invoice'},
+                {
+                    type: 'image_url',
+                    image_url: {
+                        url: 'data:image/png;base64,abc123',
+                        detail: 'high'
+                    }
+                }
+            ]
+        })
+    })
+
+    test('OpenAi prompt keeps default model for text-only inputs', async () => {
+        let request: any
+
+        class MockedOpenAiProvider extends OpenAiProvider {
+            constructor() {
+                super('test-key', 'gpt-4.1-mini', 'gpt-4o-mini')
+                this._client = {
+                    chat: {
+                        completions: {
+                            create: async (payload: any) => {
+                                request = payload
+                                return {
+                                    choices: [{message: {content: 'Buenos Aires'}}],
+                                    usage: {
+                                        total_tokens: 8,
+                                        prompt_tokens: 6,
+                                        completion_tokens: 2
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        const openAi = new MockedOpenAiProvider()
+
+        await openAi.prompt({
+            systemPrompt: 'You are an AI assistant.',
+            userInput: 'What is the capital of Argentina?'
+        })
+
+        expect(request.model).toBe('gpt-4.1-mini')
+        expect(request.messages[1]).toEqual({
+            role: 'user',
+            content: 'What is the capital of Argentina?'
+        })
+    })
+
     test('OpenAi Factory', () => {
         const openAi = OpenAiProviderFactory.instance()
         expect(openAi).toBeInstanceOf(OpenAiProvider)