briyah 1.0.0

package/dist/server/src/ai/agent-store.service.js

@@ -0,0 +1,352 @@
+"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 __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 __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;
+    };
+})();
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentStoreService = void 0;
+const common_1 = require("@nestjs/common");
+const agent_1 = require("./agent");
+const crypto_1 = require("crypto");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const ai_factory_service_1 = require("./ai-factory.service");
+const artifact_service_1 = require("./artifact.service");
+const configuration_service_1 = require("../config/configuration.service");
+const attached_file_service_1 = require("./attached-file.service");
+const balance_service_1 = require("../app/balance.service");
+let AgentStoreService = class AgentStoreService {
+    aiFactoryService;
+    configService;
+    attachedFileService;
+    balanceService;
+    artifactService;
+    agents = new Map();
+    defaultStorageDir;
+    loaded = false;
+    loadPromise = null;
+    constructor(aiFactoryService, configService, attachedFileService, balanceService, artifactService) {
+        this.aiFactoryService = aiFactoryService;
+        this.configService = configService;
+        this.attachedFileService = attachedFileService;
+        this.balanceService = balanceService;
+        this.artifactService = artifactService;
+        this.defaultStorageDir = path.join(this.configService.getUserDataDir(), 'agents');
+    }
+    getDefaultStorageDir() {
+        return this.defaultStorageDir;
+    }
+    storeAgent(agent, storageDir) {
+        if (!agent.id) {
+            agent.id = (0, crypto_1.randomUUID)();
+        }
+        this.agents.set(agent.id, agent);
+        const finalStorageDir = storageDir || agent.storageDir;
+        this.saveAgentToFile(agent, finalStorageDir);
+        return agent.id;
+    }
+    async getAgent(id) {
+        await this.ensureLoaded();
+        return this.agents.get(id);
+    }
+    removeAgent(id) {
+        const agent = this.agents.get(id);
+        if (!agent) {
+            return false;
+        }
+        if (agent.aiService) {
+            try {
+                agent.aiService.finishAgent(agent);
+            }
+            catch (error) {
+                console.error(`Error finishing agent ${id}:`, error);
+            }
+        }
+        this.attachedFileService.deleteAllFiles(agent.id);
+        const result = this.agents.delete(id);
+        if (result) {
+            this.deleteAgentFile(id, agent.storageDir);
+        }
+        return result;
+    }
+    async getAllAgentIds() {
+        await this.ensureLoaded();
+        return Array.from(this.agents.keys());
+    }
+    async getAgentCount() {
+        await this.ensureLoaded();
+        return this.agents.size;
+    }
+    async cloneAgentAsPublished(templateId, publishedName, _userId) {
+        await this.ensureLoaded();
+        const template = this.agents.get(templateId);
+        if (!template) {
+            throw new Error(`Template agent not found: ${templateId}`);
+        }
+        const instanceId = (0, crypto_1.randomUUID)();
+        const aiService = this.aiFactoryService.createAiService(template.serviceName);
+        const instance = new agent_1.Agent(instanceId, this.configService, this, this.balanceService, this.artifactService, publishedName, template.agentNickname || template.agentName, template.description, template.promptFolder, template.systemInstruction, [], template.modelName, template.serviceName, aiService, template.reasoningEffort, template.allowSearch, template.maxOutputTokens, template.beginInstruction, this.defaultStorageDir);
+        instance.templateAgentId = templateId;
+        instance.isPublished = true;
+        instance.createdAt = new Date();
+        instance.totalInputTokens = 0;
+        instance.totalOutputTokens = 0;
+        instance.totalCost = 0;
+        instance.totalMarkup = 0;
+        instance.attachedFiles = [...template.attachedFiles];
+        instance.attachedArtifacts = [...template.attachedArtifacts];
+        instance.maxHistoryMessages = template.maxHistoryMessages;
+        instance.promptCacheTTL = template.promptCacheTTL;
+        instance.markupRate = template.markupRate;
+        this.storeAgent(instance);
+        return instanceId;
+    }
+    async getPublishedInstances(templateId) {
+        await this.ensureLoaded();
+        const instances = [];
+        for (const agent of this.agents.values()) {
+            if (agent.templateAgentId === templateId) {
+                instances.push(agent);
+            }
+        }
+        return instances;
+    }
+    async resetPublishedInstance(instanceId, templateId) {
+        await this.ensureLoaded();
+        const instance = this.agents.get(instanceId);
+        if (!instance) {
+            throw new Error(`Instance agent not found: ${instanceId}`);
+        }
+        const template = this.agents.get(templateId);
+        if (!template) {
+            throw new Error(`Template agent not found: ${templateId}`);
+        }
+        if (instance.templateAgentId !== templateId) {
+            throw new Error(`Instance ${instanceId} does not belong to template ${templateId}`);
+        }
+        instance.description = template.description;
+        instance.agentNickname = template.agentNickname;
+        instance.promptFolder = template.promptFolder;
+        instance.systemInstruction = template.systemInstruction;
+        instance.modelName = template.modelName;
+        instance.serviceName = template.serviceName;
+        instance.reasoningEffort = template.reasoningEffort;
+        instance.allowSearch = template.allowSearch;
+        instance.maxOutputTokens = template.maxOutputTokens;
+        instance.attachedFiles = [...template.attachedFiles];
+        instance.attachedArtifacts = [...template.attachedArtifacts];
+        instance.beginInstruction = template.beginInstruction;
+        instance.maxHistoryMessages = template.maxHistoryMessages;
+        instance.promptCacheTTL = template.promptCacheTTL;
+        instance.markupRate = template.markupRate;
+        instance.history = [];
+        instance.totalInputTokens = 0;
+        instance.totalOutputTokens = 0;
+        instance.totalCost = 0;
+        instance.totalMarkup = 0;
+        instance.aiService = this.aiFactoryService.createAiService(instance.serviceName);
+        this.storeAgent(instance);
+    }
+    async ensureLoaded() {
+        if (this.loaded)
+            return;
+        if (!this.loadPromise) {
+            this.loadPromise = this.loadAgentsFromDirectory(this.defaultStorageDir)
+                .then(() => {
+                this.loaded = true;
+            })
+                .catch((error) => {
+                this.loadPromise = null;
+                throw error;
+            });
+        }
+        await this.loadPromise;
+    }
+    async loadAgentsFromDirectory(storageDir, artifactService) {
+        try {
+            try {
+                await fs.promises.access(storageDir);
+            }
+            catch {
+                console.log(`Agent storage directory not found: ${storageDir}`);
+                await fs.promises.mkdir(storageDir, { recursive: true });
+                return;
+            }
+            const allFiles = await fs.promises.readdir(storageDir);
+            const files = allFiles.filter((file) => file.endsWith('.json'));
+            console.log(`Loading ${files.length} agents from ${storageDir}`);
+            for (const file of files) {
+                try {
+                    const filePath = path.join(storageDir, file);
+                    const fileContent = await fs.promises.readFile(filePath, 'utf-8');
+                    const config = JSON.parse(fileContent);
+                    if (this.agents.has(config.id)) {
+                        console.log(`Agent ${config.agentName} (${config.id}) already loaded, skipping`);
+                        continue;
+                    }
+                    const aiService = this.aiFactoryService.createAiService(config.serviceName);
+                    const finalArtifactService = artifactService || this.artifactService;
+                    const agent = new agent_1.Agent(config.id, this.configService, this, this.balanceService, finalArtifactService, config.agentName, config.agentNickname || config.agentName, config.description, config.promptFolder, config.systemInstruction, config.history || [], config.modelName, config.serviceName, aiService, config.reasoningEffort, config.allowSearch, config.maxOutputTokens, config.beginInstruction || '', storageDir);
+                    agent.createdAt = new Date(config.createdAt);
+                    agent.configService = this.configService;
+                    agent.totalInputTokens = config.totalInputTokens || 0;
+                    agent.totalOutputTokens = config.totalOutputTokens || 0;
+                    agent.totalCost = config.totalCost || 0;
+                    agent.totalMarkup = config.totalMarkup || 0;
+                    agent.markupRate =
+                        config.markupRate ??
+                            (process.env.DEFAULT_MARKUP_RATE
+                                ? parseFloat(process.env.DEFAULT_MARKUP_RATE)
+                                : 2);
+                    agent.isControlledByHuman = config.isControlledByHuman || false;
+                    agent.disableMarkup = config.disableMarkup || false;
+                    agent.disableBalanceCheck = config.disableBalanceCheck || false;
+                    agent.isPublished = config.isPublished || false;
+                    agent.templateAgentId = config.templateAgentId;
+                    agent.ownerRoomId = config.ownerRoomId;
+                    agent.beginInstruction = config.beginInstruction || '';
+                    agent.maxHistoryMessages = config.maxHistoryMessages || undefined;
+                    agent.promptCacheTTL = Number(config.promptCacheTTL) ?? 0;
+                    agent.id = config.id;
+                    this.agents.set(config.id, agent);
+                    if (config.attachedFiles && config.attachedFiles.length > 0) {
+                        agent.attachedFiles = config.attachedFiles;
+                    }
+                    else {
+                        const fileMetadataList = this.attachedFileService.listFileMetadata(agent.id);
+                        agent.attachedFiles = fileMetadataList;
+                    }
+                    for (const metadata of agent.attachedFiles) {
+                        const fileData = this.attachedFileService.getFile(agent.id, metadata.fileId);
+                        if (fileData && metadata.serviceMetadata && agent.fullContextFiles) {
+                            metadata.serviceMetadata.fileData = Array.from(fileData);
+                            console.log(`Restored fileData for ${metadata.fileName} (fullContextFiles=true)`);
+                        }
+                    }
+                    if (config.attachedArtifacts && config.attachedArtifacts.length > 0) {
+                        agent.attachedArtifacts = config.attachedArtifacts;
+                    }
+                    console.log(`Loaded agent: ${config.agentName} (${config.id}) with ${agent.history.length} history items`);
+                }
+                catch (error) {
+                    console.error(`Error loading agent from file ${file}:`, error);
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error loading agents from directory ${storageDir}:`, error);
+        }
+    }
+    saveAgentToFile(agent, storageDir) {
+        try {
+            if (!fs.existsSync(storageDir)) {
+                fs.mkdirSync(storageDir, { recursive: true });
+            }
+            let attachedFilesWithoutFileData = agent.attachedFiles.map((file) => {
+                if (file.serviceMetadata?.fileData) {
+                    const { fileData: _fileData, ...serviceMetadataWithoutFileData } = file.serviceMetadata;
+                    return {
+                        ...file,
+                        serviceMetadata: serviceMetadataWithoutFileData,
+                    };
+                }
+                return file;
+            });
+            const config = {
+                id: agent.id,
+                agentName: agent.agentName,
+                agentNickname: agent.agentNickname,
+                description: agent.description,
+                promptFolder: agent.promptFolder,
+                systemInstruction: agent.systemInstruction,
+                modelName: agent.modelName,
+                serviceName: agent.serviceName,
+                reasoningEffort: agent.reasoningEffort,
+                allowSearch: agent.allowSearch,
+                maxOutputTokens: agent.maxOutputTokens,
+                createdAt: agent.createdAt.toISOString(),
+                attachedFiles: attachedFilesWithoutFileData,
+                attachedArtifacts: agent.attachedArtifacts,
+                history: agent.history,
+                maxHistoryMessages: agent.maxHistoryMessages,
+                totalInputTokens: agent.totalInputTokens,
+                totalOutputTokens: agent.totalOutputTokens,
+                totalCost: agent.totalCost,
+                totalMarkup: agent.totalMarkup,
+                markupRate: agent.markupRate,
+                disableMarkup: agent.disableMarkup,
+                disableBalanceCheck: agent.disableBalanceCheck,
+                isControlledByHuman: agent.isControlledByHuman,
+                isPublished: agent.isPublished,
+                templateAgentId: agent.templateAgentId,
+                beginInstruction: agent.beginInstruction,
+                promptCacheTTL: agent.promptCacheTTL,
+                ownerRoomId: agent.ownerRoomId,
+            };
+            const filePath = path.join(storageDir, `${agent.id}.json`);
+            fs.writeFileSync(filePath, JSON.stringify(config, null, 2), 'utf-8');
+        }
+        catch (error) {
+            console.error(`Error saving agent ${agent.id} to file:`, error);
+        }
+    }
+    deleteAgentFile(agentId, storageDir) {
+        try {
+            const filePath = path.join(storageDir, `${agentId}.json`);
+            if (fs.existsSync(filePath)) {
+                fs.unlinkSync(filePath);
+                console.log(`Deleted agent file: ${filePath}`);
+            }
+        }
+        catch (error) {
+            console.error(`Error deleting agent file ${agentId}:`, error);
+        }
+    }
+};
+exports.AgentStoreService = AgentStoreService;
+exports.AgentStoreService = AgentStoreService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [ai_factory_service_1.AiFactoryService,
+        configuration_service_1.ConfigurationService,
+        attached_file_service_1.AttachedFileService,
+        balance_service_1.BalanceService,
+        artifact_service_1.ArtifactService])
+], AgentStoreService);

package/dist/server/src/ai/agent.d.ts

@@ -0,0 +1,75 @@
+import { OpenAI } from 'openai';
+import { Assistant } from 'openai/resources/beta/assistants';
+import { VectorStore } from 'openai/resources/vector-stores';
+import { Message } from '@shared/types/app.types';
+import { BaseAiService } from './LLM/base-ai.service';
+import { FileMetadata } from './attached-file.service';
+import { ArtifactService } from './artifact.service';
+import { ConfigurationService } from '../config/configuration.service';
+import { BalanceService } from '../app/balance.service';
+import { AgentStoreService } from './agent-store.service';
+export declare class Agent {
+    id?: string;
+    agentName: string;
+    agentNickname: string;
+    history: any[];
+    fullContextFiles: boolean;
+    static generateNickname(agentName: string): string;
+    createdAt: Date;
+    totalInputTokens: number;
+    totalOutputTokens: number;
+    totalCost: number;
+    totalMarkup: number;
+    markupRate: number;
+    disableMarkup: boolean;
+    disableBalanceCheck: boolean;
+    isPublished: boolean;
+    templateAgentId?: string;
+    ownerRoomId?: string;
+    openai?: OpenAI;
+    assistant?: Assistant;
+    vectorStore?: VectorStore;
+    aiService: BaseAiService;
+    artifactService: ArtifactService;
+    configService: ConfigurationService;
+    balanceService?: BalanceService;
+    description: string;
+    promptFolder: string;
+    systemInstruction: string;
+    maxHistoryMessages?: number;
+    modelName: string;
+    serviceName: string;
+    reasoningEffort: 'low' | 'medium' | 'high' | null;
+    allowSearch: boolean;
+    maxOutputTokens: number;
+    attachedFiles: FileMetadata[];
+    attachedArtifacts: string[];
+    isControlledByHuman: boolean;
+    beginInstruction: string;
+    promptCacheTTL: number;
+    private onStateChange;
+    storageDir: string;
+    private agentStoreService;
+    constructor(id: string | null, configService: ConfigurationService, agentStoreService: AgentStoreService, balanceService: BalanceService, artifactService: ArtifactService, agentName: string, agentNickname: string, description: string, promptFolder: string, systemInstruction: string, history: any[], modelName: string, serviceName: string, aiService: BaseAiService, reasoningEffort: 'low' | 'medium' | 'high' | null, allowSearch: boolean, maxOutputTokens: number, beginInstruction: string, storageDir: string);
+    attachDocument(fileName: string, fileData: Uint8Array): Promise<string>;
+    attachArtifact(artifactId: string): void;
+    detachArtifact(artifactId: string): void;
+    getAttachedArtifacts(): string[];
+    save(): void;
+    finishAgent(): Promise<void>;
+    deleteAgent(): Promise<void>;
+    setOnStateChange(callback: () => void): void;
+    notifyStateChange(): void;
+    canRespond(message: Message): boolean;
+    getFormattedMessages(fromIndex?: number): string[];
+    getRawMessages(): string[];
+    addToConversationHistory(message: any, fromSelf?: boolean): void;
+    trimHistoryIfNeeded(threshold?: number): void;
+    instructedPrompt(prompt: string, instructionFileName: string, variables: any, saveResponse?: boolean, cacheMessage?: boolean, maxOutputChars?: number): Promise<any>;
+    preparedPrompt(promptFileName: string, variables: any, saveResponse?: boolean, cacheMessage?: boolean): Promise<any>;
+    textPrompt(prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, cacheMessage?: boolean, maxOutputChars?: number): Promise<any>;
+    generateImage(prompt: string, width: number, height: number, quality: string, referenceImageArtifactIds?: string[]): Promise<{
+        artifactId?: string;
+        error?: any;
+    }>;
+}

package/dist/server/src/ai/agent.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Agent = void 0;
+const app_types_1 = require("@shared/types/app.types");
+const crypto_1 = require("crypto");
+class Agent {
+    id;
+    agentName;
+    agentNickname;
+    history;
+    fullContextFiles = true;
+    static generateNickname(agentName) {
+        const firstName = agentName.trim().split(/\s+/)[0];
+        return firstName || agentName;
+    }
+    createdAt;
+    totalInputTokens = 0;
+    totalOutputTokens = 0;
+    totalCost = 0;
+    totalMarkup = 0;
+    markupRate = 2;
+    disableMarkup = false;
+    disableBalanceCheck = false;
+    isPublished = false;
+    templateAgentId;
+    ownerRoomId;
+    openai;
+    assistant;
+    vectorStore;
+    aiService;
+    artifactService;
+    configService;
+    balanceService;
+    description;
+    promptFolder;
+    systemInstruction;
+    maxHistoryMessages;
+    modelName;
+    serviceName;
+    reasoningEffort;
+    allowSearch;
+    maxOutputTokens = 0;
+    attachedFiles = [];
+    attachedArtifacts = [];
+    isControlledByHuman = false;
+    beginInstruction = '';
+    promptCacheTTL = 0;
+    onStateChange = null;
+    storageDir;
+    agentStoreService;
+    constructor(id, configService, agentStoreService, balanceService, artifactService, agentName = '', agentNickname = '', description = '', promptFolder = '', systemInstruction = '', history = [], modelName = '', serviceName = '', aiService, reasoningEffort = null, allowSearch = false, maxOutputTokens = 0, beginInstruction = '', storageDir) {
+        this.agentName = agentName;
+        this.agentNickname = agentNickname || Agent.generateNickname(agentName);
+        this.description = description;
+        this.promptFolder = promptFolder;
+        this.systemInstruction = systemInstruction;
+        this.history = history;
+        this.openai = null;
+        this.assistant = null;
+        this.vectorStore = null;
+        this.fullContextFiles = true;
+        this.createdAt = new Date();
+        this.modelName = modelName;
+        this.serviceName = serviceName;
+        this.aiService = aiService;
+        this.reasoningEffort = reasoningEffort;
+        this.allowSearch = allowSearch;
+        this.maxOutputTokens = maxOutputTokens;
+        this.beginInstruction = beginInstruction;
+        this.storageDir = storageDir;
+        this.configService = configService;
+        this.agentStoreService = agentStoreService;
+        this.balanceService = balanceService;
+        this.artifactService = artifactService;
+        this.id = id ? id : (0, crypto_1.randomUUID)();
+    }
+    async attachDocument(fileName, fileData) {
+        return await this.aiService.attachDocument(this, fileName, fileData);
+    }
+    attachArtifact(artifactId) {
+        if (!this.attachedArtifacts.includes(artifactId)) {
+            this.attachedArtifacts.push(artifactId);
+        }
+    }
+    detachArtifact(artifactId) {
+        this.attachedArtifacts = this.attachedArtifacts.filter((id) => id !== artifactId);
+    }
+    getAttachedArtifacts() {
+        return [...this.attachedArtifacts];
+    }
+    save() {
+        this.agentStoreService.storeAgent(this);
+        this.notifyStateChange();
+    }
+    async finishAgent() {
+        this.agentStoreService.removeAgent(this);
+    }
+    async deleteAgent() {
+        this.agentStoreService.removeAgent(this.id);
+    }
+    setOnStateChange(callback) {
+        this.onStateChange = callback;
+    }
+    notifyStateChange() {
+        if (this.onStateChange) {
+            this.onStateChange();
+        }
+    }
+    canRespond(message) {
+        if (!this.isControlledByHuman)
+            return true;
+        return message.targets.includes(this.agentNickname);
+    }
+    getFormattedMessages(fromIndex = 0) {
+        if (!this.history) {
+            return [];
+        }
+        return this.history
+            .slice(fromIndex)
+            .map((message) => this.aiService.formatMessage(message));
+    }
+    getRawMessages() {
+        if (!this.history) {
+            return [];
+        }
+        return this.history.map((message) => message.content);
+    }
+    addToConversationHistory(message, fromSelf = false) {
+        let formattedMessage = message;
+        if (typeof message === 'object') {
+            if (message.action && message.action == app_types_1.MessageAction.MODERATE) {
+                formattedMessage = `From: ${message.sender}\n${message.content}`;
+            }
+            else {
+                formattedMessage = JSON.stringify(message, null, 2);
+            }
+        }
+        this.aiService.addToConversationHistory(this, formattedMessage, fromSelf);
+    }
+    trimHistoryIfNeeded(threshold = 0) {
+        if (!this.maxHistoryMessages)
+            return;
+        let systemMessageCount = 0;
+        for (let i = 0; i < this.history.length; i++) {
+            if (this.history[i].role === 'developer') {
+                systemMessageCount++;
+            }
+            else if (this.history[i].content.includes('[CONVERSATION HISTORY SUMMARY]')) {
+                systemMessageCount++;
+            }
+            else {
+                break;
+            }
+        }
+        const conversationMessages = this.history.slice(systemMessageCount);
+        if (conversationMessages.length > this.maxHistoryMessages + threshold) {
+            const keepMessages = conversationMessages.slice(-this.maxHistoryMessages);
+            this.history = [...this.history.slice(0, systemMessageCount), ...keepMessages];
+        }
+    }
+    async instructedPrompt(prompt, instructionFileName, variables, saveResponse = true, cacheMessage = false, maxOutputChars = 0) {
+        return await this.aiService.instructedPrompt(this, prompt, instructionFileName, variables, saveResponse, this.aiService.getCacheConfig(this, cacheMessage), maxOutputChars);
+    }
+    async preparedPrompt(promptFileName, variables, saveResponse = true, cacheMessage = false) {
+        return await this.aiService.preparedPrompt(this, promptFileName, variables, saveResponse, this.aiService.getCacheConfig(this, cacheMessage));
+    }
+    async textPrompt(prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, cacheMessage = false, maxOutputChars = 0) {
+        return await this.aiService.textPrompt(this, prompt, jsonSchema, saveResponse, promptInstructions, this.aiService.getCacheConfig(this, cacheMessage), maxOutputChars);
+    }
+    async generateImage(prompt, width, height, quality, referenceImageArtifactIds) {
+        return await this.aiService.generateImage(this, prompt, width, height, quality, referenceImageArtifactIds);
+    }
+}
+exports.Agent = Agent;

package/dist/server/src/ai/ai-factory.module.d.ts

@@ -0,0 +1,2 @@
+export declare class AiFactoryModule {
+}

package/dist/server/src/ai/ai-factory.module.js

@@ -0,0 +1,40 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiFactoryModule = void 0;
+const common_1 = require("@nestjs/common");
+const ai_factory_service_1 = require("./ai-factory.service");
+const openai_module_1 = require("./LLM/openai.module");
+const grok_module_1 = require("./LLM/grok.module");
+const vertexai_module_1 = require("./LLM/vertexai.module");
+const anthropic_module_1 = require("./LLM/anthropic.module");
+const deepseek_module_1 = require("./LLM/deepseek.module");
+const together_module_1 = require("./LLM/together.module");
+const mock_module_1 = require("./LLM/mock.module");
+const googleai_module_1 = require("./LLM/googleai.module");
+const fal_module_1 = require("./LLM/fal.module");
+let AiFactoryModule = class AiFactoryModule {
+};
+exports.AiFactoryModule = AiFactoryModule;
+exports.AiFactoryModule = AiFactoryModule = __decorate([
+    (0, common_1.Module)({
+        imports: [
+            openai_module_1.OpenAiModule,
+            grok_module_1.GrokAiModule,
+            vertexai_module_1.VertexAiModule,
+            anthropic_module_1.AnthropicAiModule,
+            deepseek_module_1.DeepSeekAiModule,
+            together_module_1.TogetherAiModule,
+            mock_module_1.MockAiModule,
+            googleai_module_1.GoogleAiModule,
+            fal_module_1.FalAiModule,
+        ],
+        providers: [ai_factory_service_1.AiFactoryService],
+        exports: [ai_factory_service_1.AiFactoryService],
+    })
+], AiFactoryModule);

package/dist/server/src/ai/ai-factory.service.d.ts

@@ -0,0 +1,24 @@
+import { BaseAiService } from './LLM/base-ai.service';
+import { OpenAiService } from './LLM/openai.service';
+import { GrokAiService } from './LLM/grok.service';
+import { VertexAiService } from './LLM/vertexai.service';
+import { AnthropicAiService } from './LLM/anthropic.service';
+import { DeepSeekAiService } from './LLM/deepseek.service';
+import { TogetherAiService } from './LLM/together.service';
+import { MockAiService } from './LLM/mock.service';
+import { GoogleAiService } from './LLM/googleai.service';
+import { FalAiService } from './LLM/fal.service';
+export declare class AiFactoryService {
+    private readonly openAiService;
+    private readonly grokAiService;
+    private readonly vertexAiService;
+    private readonly anthropicAiService;
+    private readonly deepSeekAiService;
+    private readonly togetherAiService;
+    private readonly mockAiService;
+    private readonly googleAiService;
+    private readonly falAiService;
+    constructor(openAiService: OpenAiService, grokAiService: GrokAiService, vertexAiService: VertexAiService, anthropicAiService: AnthropicAiService, deepSeekAiService: DeepSeekAiService, togetherAiService: TogetherAiService, mockAiService: MockAiService, googleAiService: GoogleAiService, falAiService: FalAiService);
+    createAiService(serviceName: string): BaseAiService;
+    getAllAiServices(): BaseAiService[];
+}