@bpinhosilva/agent-orchestrator 1.0.0-alpha.12 → 1.0.0-alpha.14

package/CHANGELOG.md

@@ -1,3 +1,18 @@
+# [1.0.0-alpha.14](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.13...v1.0.0-alpha.14) (2026-03-27)
+
+
+### Features
+
+* add CreateTaskDto ([1604945](https://github.com/bpinhosilva/agent-orchestrator/commit/1604945737b5df5480c6c0814c369902f7cc9142))
+* implement transient agent instances with dynamic configurationn ([5d57b08](https://github.com/bpinhosilva/agent-orchestrator/commit/5d57b0886edf4b14d93ab76f245f4311b6657f7d))
+
+# [1.0.0-alpha.13](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.12...v1.0.0-alpha.13) (2026-03-26)
+
+
+### Features
+
+* add Claude agent implementation with Anthropic SDK and refactor agent-provider ([1400a0d](https://github.com/bpinhosilva/agent-orchestrator/commit/1400a0dec6beb8393ddc4c5a23b9b860532079e8))
+
 # [1.0.0-alpha.12](https://github.com/bpinhosilva/agent-orchestrator/compare/v1.0.0-alpha.11...v1.0.0-alpha.12) (2026-03-24)
 
 

package/dist/agents/agents.module.js

@@ -13,6 +13,7 @@ const agents_controller_1 = require("./agents.controller");
 const agents_service_1 = require("./agents.service");
 const agent_entity_1 = require("./entities/agent.entity");
 const gemini_agent_1 = require("./implementations/gemini.agent");
+const claude_agent_1 = require("./implementations/claude.agent");
 let AgentsModule = class AgentsModule {
 };
 exports.AgentsModule = AgentsModule;
@@ -20,7 +21,7 @@ exports.AgentsModule = AgentsModule = __decorate([
     (0, common_1.Module)({
         imports: [typeorm_1.TypeOrmModule.forFeature([agent_entity_1.AgentEntity])],
         controllers: [agents_controller_1.AgentsController],
-        providers: [agents_service_1.AgentsService, gemini_agent_1.GeminiAgent],
+        providers: [agents_service_1.AgentsService, gemini_agent_1.GeminiAgent, claude_agent_1.ClaudeAgent],
         exports: [agents_service_1.AgentsService],
     })
 ], AgentsModule);

package/dist/agents/agents.service.js

@@ -19,19 +19,24 @@ const typeorm_1 = require("@nestjs/typeorm");
 const typeorm_2 = require("typeorm");
 const agent_entity_1 = require("./entities/agent.entity");
 const agent_registry_1 = require("./registry/agent.registry");
+const core_1 = require("@nestjs/core");
+const AGENT_RELATIONS = ['model', 'provider'];
 let AgentsService = AgentsService_1 = class AgentsService {
-    constructor(agentRepository) {
+    constructor(agentRepository, moduleRef) {
         this.agentRepository = agentRepository;
+        this.moduleRef = moduleRef;
         this.logger = new common_1.Logger(AgentsService_1.name);
         this.agentInstances = new Map();
     }
     async onModuleInit() {
         this.logger.log('Initializing Agent instances from database...');
-        const agents = await this.agentRepository.find({ relations: ['model'] });
+        const agents = await this.agentRepository.find({
+            relations: AGENT_RELATIONS,
+        });
         for (const agentEntity of agents) {
             if (agentEntity.status !== 'inactive') {
                 try {
-                    this.syncAgentInstance(agentEntity);
+                    await this.syncAgentInstance(agentEntity);
                 }
                 catch (error) {
                     const errorMessage = error instanceof Error ? error.message : String(error);
@@ -41,29 +46,32 @@ let AgentsService = AgentsService_1 = class AgentsService {
         }
         this.logger.log(`Initialized ${this.agentInstances.size} agent instances.`);
     }
-    syncAgentInstance(agentEntity) {
+    async syncAgentInstance(agentEntity) {
         if (agentEntity.status === 'inactive') {
             this.agentInstances.delete(agentEntity.id);
             return;
         }
-        const provider = agentEntity.provider;
-        if (!provider) {
+        const providerName = agentEntity.provider?.name?.toLowerCase();
+        if (!providerName) {
             this.logger.warn(`No provider found for agent #${agentEntity.id}. Skipping instance creation.`);
             return;
         }
-        const AgentClass = (0, agent_registry_1.getAgentImplementation)(provider);
+        const AgentClass = (0, agent_registry_1.getAgentImplementation)(providerName);
         if (!AgentClass) {
-            this.logger.warn(`No implementation found for provider: ${provider}. Skipping instance creation.`);
+            this.logger.warn(`No implementation found for provider: ${providerName}. Skipping instance creation.`);
             return;
         }
         try {
-            const instance = new AgentClass(agentEntity.model?.name);
+            // Use resolve for TRANSIENT scoped providers. This ensures we get a fresh instance
+            // which we then configure and store in our Map (making it a singleton for this ID).
+            const instance = await this.moduleRef.resolve(AgentClass);
             instance.updateConfig?.({
                 name: agentEntity.name,
                 description: agentEntity.description,
                 systemInstructions: agentEntity.systemInstructions,
                 role: agentEntity.role,
-                provider: agentEntity.provider,
+                provider: providerName,
+                model: agentEntity.model?.name,
             });
             this.agentInstances.set(agentEntity.id, instance);
             this.logger.debug(`Synchronized agent instance #${agentEntity.id}`);
@@ -71,24 +79,41 @@ let AgentsService = AgentsService_1 = class AgentsService {
         catch (error) {
             const errorMessage = error instanceof Error ? error.message : String(error);
             this.logger.error(`Error synchronizing agent #${agentEntity.id}: ${errorMessage}`);
-            throw error;
+            throw new common_1.BadRequestException(`Failed to initialize agent instance: ${errorMessage}`);
         }
     }
     async create(createAgentDto) {
-        const agent = this.agentRepository.create(createAgentDto);
-        const savedAgent = await this.agentRepository.save(agent);
-        // Reload with relations for proper synchronization
-        const fullyLoadedAgent = await this.findOne(savedAgent.id);
-        this.syncAgentInstance(fullyLoadedAgent);
-        return fullyLoadedAgent;
+        const { modelId, providerId, ...rest } = createAgentDto;
+        const agentData = { ...rest };
+        if (modelId) {
+            agentData.model = { id: modelId };
+        }
+        if (providerId) {
+            agentData.provider = { id: providerId };
+        }
+        return await this.agentRepository.manager.transaction(async (manager) => {
+            const agent = manager.create(agent_entity_1.AgentEntity, agentData);
+            const savedAgent = await manager.save(agent);
+            // Reload with full relations for proper synchronization
+            const fullyLoadedAgent = await manager.findOne(agent_entity_1.AgentEntity, {
+                where: { id: savedAgent.id },
+                relations: AGENT_RELATIONS,
+            });
+            if (!fullyLoadedAgent) {
+                throw new Error(`Agent #${savedAgent.id} not found immediately after save`);
+            }
+            // This will throw BadRequestException if instantiation fails, rolling back the transaction
+            await this.syncAgentInstance(fullyLoadedAgent);
+            return fullyLoadedAgent;
+        });
     }
     async findAll() {
-        return this.agentRepository.find({ relations: ['model'] });
+        return this.agentRepository.find({ relations: AGENT_RELATIONS });
     }
     async findOne(id) {
         const agent = await this.agentRepository.findOne({
             where: { id },
-            relations: ['model'],
+            relations: AGENT_RELATIONS,
         });
         if (!agent) {
             throw new common_1.NotFoundException(`Agent #${id} not found`);
@@ -96,21 +121,27 @@ let AgentsService = AgentsService_1 = class AgentsService {
         return agent;
     }
     async update(id, updateAgentDto) {
-        const { modelId, ...rest } = updateAgentDto;
+        const { modelId, providerId, ...rest } = updateAgentDto;
         const updateData = { ...rest };
         if (modelId) {
             updateData.model = { id: modelId };
         }
-        await this.agentRepository.update(id, updateData);
-        const updatedAgent = await this.agentRepository.findOne({
-            where: { id },
-            relations: ['model'],
-        });
-        if (!updatedAgent) {
-            throw new common_1.NotFoundException(`Agent #${id} not found`);
+        if (providerId) {
+            updateData.provider = { id: providerId };
         }
-        this.syncAgentInstance(updatedAgent);
-        return updatedAgent;
+        return await this.agentRepository.manager.transaction(async (manager) => {
+            await manager.update(agent_entity_1.AgentEntity, id, updateData);
+            const updatedAgent = await manager.findOne(agent_entity_1.AgentEntity, {
+                where: { id },
+                relations: AGENT_RELATIONS,
+            });
+            if (!updatedAgent) {
+                throw new common_1.NotFoundException(`Agent #${id} not found`);
+            }
+            // This will throw BadRequestException if instantiation fails, rolling back the transaction
+            await this.syncAgentInstance(updatedAgent);
+            return updatedAgent;
+        });
     }
     async remove(id) {
         const agent = await this.findOne(id);
@@ -138,7 +169,7 @@ let AgentsService = AgentsService_1 = class AgentsService {
             this.logger.debug(`Agent instance #${agentId} not found in memory. Checking database...`);
             const agentEntity = await this.agentRepository.findOne({
                 where: { id: agentId },
-                relations: ['model'],
+                relations: AGENT_RELATIONS,
             });
             if (!agentEntity) {
                 throw new common_1.NotFoundException(`Agent #${agentId} not found`);
@@ -146,7 +177,7 @@ let AgentsService = AgentsService_1 = class AgentsService {
             if (agentEntity.status === 'inactive') {
                 throw new common_1.NotFoundException(`Agent #${agentId} is currently inactive and cannot be probed.`);
             }
-            this.syncAgentInstance(agentEntity);
+            await this.syncAgentInstance(agentEntity);
             agent = this.agentInstances.get(agentId);
             if (!agent) {
                 throw new common_1.NotFoundException(`Failed to initialize agent #${agentId} after database fetch`);
@@ -159,5 +190,6 @@ exports.AgentsService = AgentsService;
 exports.AgentsService = AgentsService = AgentsService_1 = __decorate([
     (0, common_1.Injectable)(),
     __param(0, (0, typeorm_1.InjectRepository)(agent_entity_1.AgentEntity)),
-    __metadata("design:paramtypes", [typeorm_2.Repository])
+    __metadata("design:paramtypes", [typeorm_2.Repository,
+        core_1.ModuleRef])
 ], AgentsService);

package/dist/agents/dto/create-agent.dto.js

@@ -45,7 +45,7 @@ __decorate([
     __metadata("design:type", String)
 ], CreateAgentDto.prototype, "status", void 0);
 __decorate([
-    (0, class_validator_1.IsString)(),
-    (0, class_validator_1.IsOptional)(),
+    (0, class_validator_1.IsUUID)(),
+    (0, class_validator_1.IsNotEmpty)(),
     __metadata("design:type", String)
-], CreateAgentDto.prototype, "provider", void 0);
+], CreateAgentDto.prototype, "providerId", void 0);

package/dist/agents/entities/agent.entity.js

@@ -12,6 +12,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AgentEntity = void 0;
 const typeorm_1 = require("typeorm");
 const model_entity_1 = require("../../models/entities/model.entity");
+const provider_entity_1 = require("../../providers/entities/provider.entity");
 let AgentEntity = class AgentEntity {
 };
 exports.AgentEntity = AgentEntity;
@@ -40,8 +41,13 @@ __decorate([
     __metadata("design:type", String)
 ], AgentEntity.prototype, "status", void 0);
 __decorate([
-    (0, typeorm_1.Column)({ type: 'text', nullable: true }),
-    __metadata("design:type", String)
+    (0, typeorm_1.ManyToOne)(() => provider_entity_1.Provider, {
+        nullable: true,
+        eager: true,
+        onDelete: 'SET NULL',
+    }),
+    (0, typeorm_1.JoinColumn)({ name: 'providerId' }),
+    __metadata("design:type", provider_entity_1.Provider)
 ], AgentEntity.prototype, "provider", void 0);
 __decorate([
     (0, typeorm_1.ManyToOne)(() => model_entity_1.Model, (model) => model.agents, {

package/dist/agents/implementations/claude.agent.js

@@ -0,0 +1,142 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __param = (this && this.__param) || function (paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+};
+var ClaudeAgent_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgent = void 0;
+const claude_agent_sdk_1 = require("@anthropic-ai/claude-agent-sdk");
+const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
+const agent_registry_1 = require("../registry/agent.registry");
+let ClaudeAgent = ClaudeAgent_1 = class ClaudeAgent {
+    constructor(configService, model = 'claude-opus-4-6') {
+        this.configService = configService;
+        this.logger = new common_1.Logger(ClaudeAgent_1.name);
+        this.name = 'ClaudeAgent';
+        this.provider = 'anthropic';
+        this.model = model;
+    }
+    validateApiKey() {
+        const apiKey = this.configService.get('ANTHROPIC_API_KEY');
+        if (!apiKey) {
+            this.logger.error('ANTHROPIC_API_KEY environment variable is not set');
+            throw new Error('ANTHROPIC_API_KEY is required to initialize ClaudeAgent');
+        }
+        return apiKey;
+    }
+    getName() {
+        return this.name;
+    }
+    getDescription() {
+        return this.description || '';
+    }
+    getSystemInstructions() {
+        return this.systemInstructions || '';
+    }
+    getRole() {
+        return this.role || '';
+    }
+    getProvider() {
+        return this.provider;
+    }
+    getModel() {
+        return this.model;
+    }
+    updateConfig(config) {
+        if (config['name'])
+            this.name = config['name'];
+        if (config['description'])
+            this.description = config['description'];
+        if (config['systemInstructions'])
+            this.systemInstructions = config['systemInstructions'];
+        if (config['role'])
+            this.role = config['role'];
+        if (config['provider'])
+            this.provider = config['provider'];
+        if (config['model'])
+            this.model = config['model'];
+    }
+    buildSystemPrompt() {
+        return [
+            `Your name is ${this.name}.`,
+            this.role ? `Your role is: ${this.role}.` : '',
+            this.description ? `Description of yourself: ${this.description}.` : '',
+            this.systemInstructions
+                ? `Instructions:\n${this.systemInstructions}`
+                : '',
+        ]
+            .filter(Boolean)
+            .join('\n');
+    }
+    async processText(input) {
+        this.validateApiKey();
+        this.logger.debug(`Processing input with ClaudeAgent. Model: ${this.model}`);
+        try {
+            const systemPrompt = this.buildSystemPrompt();
+            let resultContent = '';
+            let resultMetadata = {};
+            const q = (0, claude_agent_sdk_1.query)({
+                prompt: input,
+                options: {
+                    model: this.model,
+                    systemPrompt,
+                    permissionMode: 'bypassPermissions',
+                    persistSession: false,
+                    tools: [],
+                },
+            });
+            for await (const message of q) {
+                if (message.type === 'result' && message.subtype === 'success') {
+                    resultContent = message.result;
+                    resultMetadata = {
+                        model: this.model,
+                        usage: message.usage,
+                        totalCostUsd: message.total_cost_usd,
+                        numTurns: message.num_turns,
+                    };
+                }
+            }
+            return {
+                content: resultContent,
+                metadata: resultMetadata,
+            };
+        }
+        catch (error) {
+            this.logger.error(`Claude Error: ${error}`);
+            throw error;
+        }
+    }
+    isFeatureSupported(feature) {
+        void feature;
+        return false;
+    }
+    async performTask(task, project) {
+        this.logger.debug(`Performing task: ${task.title} for project: ${project.title}`);
+        const prompt = `
+Task: ${task.title}
+Description: ${task.description}
+Project: ${project.title}
+Project Description: ${project.description}
+
+Please perform the task and provide the output.
+`;
+        return this.processText(prompt);
+    }
+};
+exports.ClaudeAgent = ClaudeAgent;
+exports.ClaudeAgent = ClaudeAgent = ClaudeAgent_1 = __decorate([
+    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
+    (0, agent_registry_1.RegisterAgent)('anthropic'),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [config_1.ConfigService, String])
+], ClaudeAgent);

package/dist/agents/implementations/gemini.agent.js

@@ -16,20 +16,28 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.GeminiAgent = void 0;
 const genai_1 = require("@google/genai");
 const common_1 = require("@nestjs/common");
+const config_1 = require("@nestjs/config");
 const agent_registry_1 = require("../registry/agent.registry");
 let GeminiAgent = GeminiAgent_1 = class GeminiAgent {
-    constructor(model = 'gemini-2.5-flash-lite') {
+    constructor(configService, model = 'gemini-2.5-flash-lite') {
+        this.configService = configService;
         this.logger = new common_1.Logger(GeminiAgent_1.name);
+        this.genAI = null;
         this.name = 'GeminiAgent';
-        this.provider = 'Google';
+        this.provider = 'google';
         this.enableGrounding = true;
         this.model = model;
-        const apiKey = process.env.GEMINI_API_KEY;
+    }
+    getGenAI() {
+        if (this.genAI)
+            return this.genAI;
+        const apiKey = this.configService.get('GEMINI_API_KEY');
         if (!apiKey) {
             this.logger.error('GEMINI_API_KEY environment variable is not set');
             throw new Error('GEMINI_API_KEY is required to initialize GeminiAgent');
         }
         this.genAI = new genai_1.GoogleGenAI({ apiKey });
+        return this.genAI;
     }
     getName() {
         return this.name;
@@ -74,7 +82,8 @@ let GeminiAgent = GeminiAgent_1 = class GeminiAgent {
             if (tools.length > 0) {
                 this.logger.debug(`Adding tools to request: ${JSON.stringify(tools)}`);
             }
-            const response = await this.genAI.models.generateContent({
+            const genAI = this.getGenAI();
+            const response = await genAI.models.generateContent({
                 model: this.model,
                 contents,
                 config: {
@@ -172,8 +181,8 @@ Please perform the task and provide the output.
 };
 exports.GeminiAgent = GeminiAgent;
 exports.GeminiAgent = GeminiAgent = GeminiAgent_1 = __decorate([
-    (0, common_1.Injectable)(),
-    (0, agent_registry_1.RegisterAgent)('Google'),
-    __param(0, (0, common_1.Optional)()),
-    __metadata("design:paramtypes", [String])
+    (0, common_1.Injectable)({ scope: common_1.Scope.TRANSIENT }),
+    (0, agent_registry_1.RegisterAgent)('google'),
+    __param(1, (0, common_1.Optional)()),
+    __metadata("design:paramtypes", [config_1.ConfigService, String])
 ], GeminiAgent);

package/dist/app.module.js

@@ -22,21 +22,34 @@ const users_module_1 = require("./users/users.module");
 const common_module_1 = require("./common/common.module");
 const uploads_module_1 = require("./uploads/uploads.module");
 const schedule_1 = require("@nestjs/schedule");
+const config_1 = require("@nestjs/config");
+const env_validation_1 = require("./config/env.validation");
 let AppModule = class AppModule {
 };
 exports.AppModule = AppModule;
 exports.AppModule = AppModule = __decorate([
     (0, common_1.Module)({
         imports: [
+            config_1.ConfigModule.forRoot({
+                isGlobal: true,
+                validationSchema: env_validation_1.envValidationSchema,
+            }),
             schedule_1.ScheduleModule.forRoot(),
-            typeorm_1.TypeOrmModule.forRoot({
-                type: process.env.DATABASE_URL ? 'postgres' : 'sqlite',
-                database: process.env.DATABASE_URL
-                    ? undefined
-                    : (0, path_1.join)(process.cwd(), 'local.sqlite'),
-                url: process.env.DATABASE_URL,
-                autoLoadEntities: true,
-                synchronize: true, // Use only in development
+            typeorm_1.TypeOrmModule.forRootAsync({
+                imports: [config_1.ConfigModule],
+                inject: [config_1.ConfigService],
+                useFactory: (configService) => {
+                    const databaseUrl = configService.get('DATABASE_URL');
+                    return {
+                        type: databaseUrl ? 'postgres' : 'sqlite',
+                        database: databaseUrl
+                            ? undefined
+                            : (0, path_1.join)(process.cwd(), 'local.sqlite'),
+                        url: databaseUrl,
+                        autoLoadEntities: true,
+                        synchronize: configService.get('NODE_ENV') !== 'production',
+                    };
+                },
             }),
             serve_static_1.ServeStaticModule.forRoot({
                 rootPath: (0, path_1.join)(__dirname, '..', '..', 'ui', 'dist'),

package/dist/common/storage.service.js

@@ -48,6 +48,7 @@ const common_1 = require("@nestjs/common");
 const os = __importStar(require("os"));
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
 let StorageService = StorageService_1 = class StorageService {
     constructor() {
         this.logger = new common_1.Logger(StorageService_1.name);
@@ -65,11 +66,34 @@ let StorageService = StorageService_1 = class StorageService {
         return path.join(this.baseDir, 'artifacts');
     }
     getFullPath(relativePath) {
-        // relativePath is like /uploads/artifacts/<uuid>.extension
-        // We only care about the filename part if the prefix is fixed
         const filename = path.basename(relativePath);
         return path.join(this.getArtifactsPath(), filename);
     }
+    async saveBase64(base64, mimeType, originalName) {
+        const buffer = Buffer.from(base64, 'base64');
+        return this.saveBuffer(buffer, mimeType, originalName);
+    }
+    async saveBuffer(buffer, mimeType, originalName) {
+        const id = crypto.randomUUID();
+        const extension = mimeType.split('/')[1] || 'bin';
+        const filename = `${id}.${extension}`;
+        const filePath = path.join(this.getArtifactsPath(), filename);
+        await fs.promises.writeFile(filePath, buffer);
+        this.logger.debug(`Saved artifact to: ${filePath}`);
+        return {
+            id,
+            originalName,
+            mimeType,
+            filePath: `uploads/artifacts/${filename}`, // Publicly accessible path via UploadsController
+        };
+    }
+    async delete(relativePath) {
+        const fullPath = this.getFullPath(relativePath);
+        if (fs.existsSync(fullPath)) {
+            await fs.promises.unlink(fullPath);
+            this.logger.debug(`Deleted artifact file: ${fullPath}`);
+        }
+    }
 };
 exports.StorageService = StorageService;
 exports.StorageService = StorageService = StorageService_1 = __decorate([

package/dist/config/env.validation.js

@@ -0,0 +1,46 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.envValidationSchema = void 0;
+const Joi = __importStar(require("joi"));
+exports.envValidationSchema = Joi.object({
+    PORT: Joi.number().default(3000),
+    DATABASE_URL: Joi.string().optional(),
+    GEMINI_API_KEY: Joi.string().optional(),
+    ANTHROPIC_API_KEY: Joi.string().optional(),
+    NODE_ENV: Joi.string()
+        .valid('development', 'production', 'test', 'provision')
+        .default('development'),
+});

package/dist/providers/entities/provider.entity.js

@@ -28,7 +28,7 @@ __decorate([
     __metadata("design:type", String)
 ], Provider.prototype, "description", void 0);
 __decorate([
-    (0, typeorm_1.OneToMany)(() => model_entity_1.Model, (model) => model.provider),
+    (0, typeorm_1.OneToMany)(() => model_entity_1.Model, (model) => model.provider, { cascade: true }),
     __metadata("design:type", Array)
 ], Provider.prototype, "models", void 0);
 __decorate([

package/dist/providers/providers.service.js

@@ -21,6 +21,50 @@ let ProvidersService = class ProvidersService {
     constructor(providerRepository) {
         this.providerRepository = providerRepository;
     }
+    async onModuleInit() {
+        await this.seedProviders();
+    }
+    async seedProviders() {
+        const defaultProviders = [
+            {
+                name: 'google',
+                description: 'Google Generative AI (Gemini)',
+                models: [
+                    { name: 'gemini-2.5-flash-lite' },
+                    { name: 'gemini-2.5-flash-image' },
+                    { name: 'gemini-2.5-pro' },
+                ],
+            },
+            {
+                name: 'anthropic',
+                description: 'Anthropic Claude AI',
+                models: [{ name: 'claude-opus-4-6' }, { name: 'claude-haiku-4-5' }],
+            },
+        ];
+        for (const p of defaultProviders) {
+            let provider = await this.providerRepository.findOne({
+                where: { name: p.name },
+                relations: ['models'],
+            });
+            if (!provider) {
+                provider = this.providerRepository.create(p);
+                await this.providerRepository.save(provider);
+            }
+            else {
+                // Check for missing models
+                let changed = false;
+                for (const m of p.models) {
+                    if (!provider.models.some((existing) => existing.name === m.name)) {
+                        provider.models.push(m);
+                        changed = true;
+                    }
+                }
+                if (changed) {
+                    await this.providerRepository.save(provider);
+                }
+            }
+        }
+    }
     async create(createProviderDto) {
         const provider = this.providerRepository.create(createProviderDto);
         return this.providerRepository.save(provider);