@drax/ai-back 3.43.0 → 3.45.0

package/src/index.ts

@@ -4,10 +4,14 @@ import {OllamaAiConfig} from "./config/OllamaAiConfig.js";
 import {DeepSeekConfig} from "./config/DeepSeekConfig.js";
 import {ElevenLabsTTSConfig} from "./config/ElevenLabsTTSConfig.js";
 import {AILogSchema, AILogBaseSchema} from "./schemas/AILogSchema.js";
+import {TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceProviderSchema} from "./schemas/TTSVoiceSchema.js";
 import {TTSRequestSchema, TTSVoiceSettingsSchema} from "./schemas/TTSRequestSchema.js";
 import AILogModel from "./models/AILogModel.js";
+import TTSVoiceModel from "./models/TTSVoiceModel.js";
 import AILogMongoRepository from "./repository/mongo/AILogMongoRepository.js";
 import AILogSqliteRepository from "./repository/sqlite/AILogSqliteRepository.js";
+import TTSVoiceMongoRepository from "./repository/mongo/TTSVoiceMongoRepository.js";
+import TTSVoiceSqliteRepository from "./repository/sqlite/TTSVoiceSqliteRepository.js";
 import {OpenAiProviderFactory} from "./factory/ai/OpenAiProviderFactory.js";
 import {GoogleAiProviderFactory} from "./factory/ai/GoogleAiProviderFactory.js";
 import {OllamaAiProviderFactory} from "./factory/ai/OllamaAiProviderFactory.js";
@@ -18,6 +22,7 @@ import {TTSProviderFactory} from "./factory/tts/TTSProviderFactory.js";
 import type {TTSProviderInfo} from "./factory/tts/TTSProviderFactory.js";
 import {DraxAgentFactory} from "./factory/DraxAgentFactory.js";
 import AILogServiceFactory from "./factory/services/AILogServiceFactory.js";
+import TTSVoiceServiceFactory from "./factory/services/TTSVoiceServiceFactory.js";
 import {OpenAiProvider} from "./providers/ai/OpenAiProvider.js";
 import {GoogleAiProvider} from "./providers/ai/GoogleAiProvider.js";
 import {OllamaAiProvider} from "./providers/ai/OllamaAiProvider.js";
@@ -26,6 +31,7 @@ import {ElevenLabsTTSProvider} from "./providers/tts/ElevenLabsTTSProvider.js";
 import {BuilderTool} from "./tools/BuilderTool.js";
 import {KnowledgeService} from "./services/KnowledgeService.js";
 import {AILogService} from "./services/AILogService.js";
+import {TTSVoiceService} from "./services/TTSVoiceService.js";
 import {TTSGenericService} from "./services/TTSGenericService.js";
 import {PromptAudioService} from "./services/PromptAudioService.js";
 import AILogPermissions from "./permissions/AILogPermissions.js";
@@ -33,19 +39,24 @@ import AgentPermissions from "./permissions/AgentPermissions.js";
 import AgentSessionPermissions from "./permissions/AgentSessionPermissions.js";
 import AIPermissions from "./permissions/AIPermissions.js";
 import TTSPermissions from "./permissions/TTSPermissions.js";
+import TTSVoicePermissions from "./permissions/TTSVoicePermissions.js";
 import AILogController from "./controllers/AILogController.js";
 import AICrudController from "./controllers/AICrudController.js";
 import AIGenericController from "./controllers/AIGenericController.js";
 import TTSGenericController from "./controllers/TTSGenericController.js";
+import TTSVoiceController from "./controllers/TTSVoiceController.js";
 import DraxAgentController from "./controllers/DraxAgentController.js";
 import AgentSessionController from "./controllers/AgentSessionController.js";
 import AILogRoutes from "./routes/AILogRoutes.js";
 import AIRoutes from "./routes/AIRoutes.js";
 import TTSRoutes from "./routes/TTSRoutes.js";
+import TTSVoiceRoutes from "./routes/TTSVoiceRoutes.js";
 import DraxAgentRoutes from "./routes/DraxAgentRoutes.js";
 import AgentSessionRoutes from "./routes/AgentSessionRoutes.js";
 import {DraxAgent} from "./agents/DraxAgent.js";
+import {BuildContextTool} from "./tools/BuildContextTool.js";
 import type {IAILogRepository} from "./interfaces/IAILogRepository.js";
+import type {ITTSVoiceRepository} from "./interfaces/ITTSVoiceRepository.js";
 import type {
     IAIProvider,
     IPromptContentPart,
@@ -80,6 +91,10 @@ import type {
     ToolBuilderOptions,
     ToolBuilderService
 } from "./interfaces/IBuilderTool.js";
+import type {
+    BuildContextToolContext,
+    BuildContextToolOptions,
+} from "./tools/BuildContextTool.js";
 import type {
     DraxAgentControllerOptions
 } from "./interfaces/IDraxAgentController.js";
@@ -102,6 +117,7 @@ import type {
 export type {
 
     IAILogRepository,
+    ITTSVoiceRepository,
     IAIProvider,
     IPromptParams,
     IPromptMessage,
@@ -127,6 +143,8 @@ export type {
     ToolBuilderMethod,
     ToolBuilderOptions,
     ToolBuilderService,
+    BuildContextToolContext,
+    BuildContextToolOptions,
     DraxAgentControllerOptions,
     DraxAgentFastifyRoutesOptions,
     DraxAgentConfig,
@@ -149,11 +167,17 @@ export {
     ElevenLabsTTSConfig,
     AILogSchema,
     AILogBaseSchema,
+    TTSVoiceSchema,
+    TTSVoiceBaseSchema,
+    TTSVoiceProviderSchema,
     TTSRequestSchema,
     TTSVoiceSettingsSchema,
     AILogModel,
+    TTSVoiceModel,
     AILogMongoRepository,
     AILogSqliteRepository,
+    TTSVoiceMongoRepository,
+    TTSVoiceSqliteRepository,
     OpenAiProviderFactory,
     GoogleAiProviderFactory,
     OllamaAiProviderFactory,
@@ -163,15 +187,18 @@ export {
     TTSProviderFactory,
     DraxAgentFactory,
     AILogServiceFactory,
+    TTSVoiceServiceFactory,
     OpenAiProvider,
     GoogleAiProvider,
     OllamaAiProvider,
     DeepSeekAiProvider,
     ElevenLabsTTSProvider,
     BuilderTool,
+    BuildContextTool,
     //Service
     KnowledgeService,
     AILogService,
+    TTSVoiceService,
     TTSGenericService,
     PromptAudioService,
     //Permissions
@@ -179,18 +206,21 @@ export {
     AgentPermissions,
     AIPermissions,
     TTSPermissions,
+    TTSVoicePermissions,
     AgentSessionPermissions,
     //Controllers
     AILogController,
     AICrudController,
     AIGenericController,
     TTSGenericController,
+    TTSVoiceController,
     DraxAgentController,
     AgentSessionController,
     DraxAgent,
     AILogRoutes,
     AIRoutes,
     TTSRoutes,
+    TTSVoiceRoutes,
     DraxAgentRoutes,
     AgentSessionRoutes
 }

package/src/interfaces/ITTSVoice.ts

@@ -0,0 +1,20 @@
+interface ITTSVoiceBase {
+    name: string
+    ttsProvider: 'ElevenLabs'
+    voiceId: string
+    model?: string
+    languageCode?: string
+    tenant?: any
+    user?: any
+    createdAt?: Date
+    updatedAt?: Date
+}
+
+interface ITTSVoice extends ITTSVoiceBase {
+    _id: string
+}
+
+export type {
+    ITTSVoiceBase,
+    ITTSVoice,
+}

package/src/interfaces/ITTSVoiceRepository.ts

@@ -0,0 +1,8 @@
+import type {ITTSVoice, ITTSVoiceBase} from './ITTSVoice'
+import {IDraxCrudRepository} from "@drax/crud-share";
+
+interface ITTSVoiceRepository extends IDraxCrudRepository<ITTSVoice, ITTSVoiceBase, ITTSVoiceBase> {
+
+}
+
+export {ITTSVoiceRepository}

package/src/models/TTSVoiceModel.ts

@@ -0,0 +1,37 @@
+import {mongoose} from '@drax/common-back';
+import {PaginateModel} from "mongoose";
+import uniqueValidator from 'mongoose-unique-validator';
+import mongoosePaginate from 'mongoose-paginate-v2'
+import type {ITTSVoice} from '../interfaces/ITTSVoice'
+
+const TTSVoiceSchema = new mongoose.Schema<ITTSVoice>({
+    name: {type: String, required: true, index: true, unique: false},
+    ttsProvider: {type: String, enum: ['ElevenLabs'], required: true, index: true, unique: false},
+    voiceId: {type: String, required: true, index: true, unique: false},
+    model: {type: String, required: false, index: true, unique: false},
+    languageCode: {type: String, required: false, index: true, unique: false},
+    tenant: {type: mongoose.Schema.Types.ObjectId, ref: 'Tenant', required: false, index: true, unique: false},
+    user: {type: mongoose.Schema.Types.ObjectId, ref: 'User', required: false, index: true, unique: false}
+}, {timestamps: true});
+
+TTSVoiceSchema.index({ttsProvider: 1, voiceId: 1, tenant: 1}, {unique: true, sparse: true});
+TTSVoiceSchema.plugin(uniqueValidator, {message: 'validation.unique'});
+TTSVoiceSchema.plugin(mongoosePaginate);
+
+TTSVoiceSchema.virtual("id").get(function () {
+    return this._id.toString();
+});
+
+TTSVoiceSchema.set('toJSON', {getters: true, virtuals: true});
+TTSVoiceSchema.set('toObject', {getters: true, virtuals: true});
+
+const MODEL_NAME = 'TTSVoice';
+const COLLECTION_NAME = 'TTSVoice';
+const TTSVoiceModel = mongoose.model<ITTSVoice, PaginateModel<ITTSVoice>>(MODEL_NAME, TTSVoiceSchema, COLLECTION_NAME);
+
+export {
+    TTSVoiceSchema,
+    TTSVoiceModel
+}
+
+export default TTSVoiceModel

package/src/permissions/TTSVoicePermissions.ts

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

package/src/repository/mongo/TTSVoiceMongoRepository.ts

@@ -0,0 +1,19 @@
+import {AbstractMongoRepository} from "@drax/crud-back";
+import {TTSVoiceModel} from "../../models/TTSVoiceModel.js";
+import type {ITTSVoiceRepository} from '../../interfaces/ITTSVoiceRepository'
+import type {ITTSVoice, ITTSVoiceBase} from "../../interfaces/ITTSVoice";
+
+class TTSVoiceMongoRepository extends AbstractMongoRepository<ITTSVoice, ITTSVoiceBase, ITTSVoiceBase> implements ITTSVoiceRepository {
+
+    constructor() {
+        super();
+        this._model = TTSVoiceModel;
+        this._searchFields = ['name', 'ttsProvider', 'voiceId', 'model', 'languageCode'];
+        this._populateFields = ['tenant', 'user'];
+        this._lean = true
+    }
+
+}
+
+export default TTSVoiceMongoRepository
+export {TTSVoiceMongoRepository}

package/src/repository/sqlite/TTSVoiceSqliteRepository.ts

@@ -0,0 +1,33 @@
+import {AbstractSqliteRepository} from "@drax/crud-back";
+import type {ITTSVoiceRepository} from '../../interfaces/ITTSVoiceRepository'
+import type {ITTSVoice, ITTSVoiceBase} from "../../interfaces/ITTSVoice";
+import {SqliteTableField} from "@drax/common-back";
+
+class TTSVoiceSqliteRepository extends AbstractSqliteRepository<ITTSVoice, ITTSVoiceBase, ITTSVoiceBase> implements ITTSVoiceRepository {
+
+    protected db: any;
+    protected tableName: string = 'TTSVoice';
+    protected dataBaseFile: string;
+    protected searchFields: string[] = ['name', 'ttsProvider', 'voiceId', 'model', 'languageCode'];
+    protected booleanFields: string[] = [];
+    protected jsonFields: string[] = [];
+    protected identifier: string = '_id';
+    protected populateFields = [
+        {field: 'tenant', table: 'tenant', identifier: '_id'},
+        {field: 'user', table: 'user', identifier: '_id'}
+    ]
+    protected verbose: boolean = false;
+    protected tableFields: SqliteTableField[] = [
+        {name: "name", type: "TEXT", unique: false, primary: false},
+        {name: "ttsProvider", type: "TEXT", unique: false, primary: false},
+        {name: "voiceId", type: "TEXT", unique: false, primary: false},
+        {name: "model", type: "TEXT", unique: false, primary: false},
+        {name: "languageCode", type: "TEXT", unique: false, primary: false},
+        {name: "tenant", type: "TEXT", unique: false, primary: false},
+        {name: "user", type: "TEXT", unique: false, primary: false}
+    ]
+
+}
+
+export default TTSVoiceSqliteRepository
+export {TTSVoiceSqliteRepository}

package/src/routes/TTSVoiceRoutes.ts

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

package/src/schemas/TTSVoiceSchema.ts

@@ -0,0 +1,23 @@
+import {z} from 'zod';
+
+const TTSVoiceProviderSchema = z.enum(['ElevenLabs']);
+
+const TTSVoiceBaseSchema = z.object({
+    name: z.string().min(1, 'validation.required'),
+    ttsProvider: TTSVoiceProviderSchema,
+    voiceId: z.string().min(1, 'validation.required'),
+    model: z.string().optional().nullable(),
+    languageCode: z.string().optional().nullable(),
+    tenant: z.coerce.string().optional().nullable(),
+    user: z.coerce.string().optional().nullable()
+});
+
+const TTSVoiceSchema = TTSVoiceBaseSchema
+    .extend({
+        _id: z.coerce.string(),
+        tenant: z.object({_id: z.coerce.string(), name: z.string().optional()}).nullable().optional(),
+        user: z.object({_id: z.coerce.string(), username: z.string().optional()}).nullable().optional()
+    })
+
+export default TTSVoiceSchema;
+export {TTSVoiceSchema, TTSVoiceBaseSchema, TTSVoiceProviderSchema}

package/src/services/TTSVoiceService.ts

@@ -0,0 +1,16 @@
+import type {ITTSVoiceRepository} from "../interfaces/ITTSVoiceRepository";
+import type {ITTSVoiceBase, ITTSVoice} from "../interfaces/ITTSVoice";
+import {AbstractService} from "@drax/crud-back";
+import type {ZodObject, ZodRawShape} from "zod";
+
+class TTSVoiceService extends AbstractService<ITTSVoice, ITTSVoiceBase, ITTSVoiceBase> {
+
+    constructor(TTSVoiceRepository: ITTSVoiceRepository, baseSchema?: ZodObject<ZodRawShape>, fullSchema?: ZodObject<ZodRawShape>) {
+        super(TTSVoiceRepository, baseSchema, fullSchema);
+        this._validateOutput = true
+    }
+
+}
+
+export default TTSVoiceService
+export {TTSVoiceService}