briyah 1.0.0

package/dist/ai/LLM/vertexai.service.js

@@ -0,0 +1,323 @@
+"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 __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.VertexAiService = void 0;
+const common_1 = require("@nestjs/common");
+const vertexai_1 = require("@google-cloud/vertexai");
+const storage_1 = require("@google-cloud/storage");
+const crypto_1 = require("crypto");
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let VertexAiService = class VertexAiService extends base_ai_service_1.BaseAiService {
+    vertexAI = null;
+    constructor() {
+        super();
+        try {
+            if (!process.env.GOOGLE_PROJECT_ID || !process.env.GOOGLE_CLOUD_LOCATION) {
+                console.warn('GOOGLE_PROJECT_ID and GOOGLE_CLOUD_LOCATION environment variables are required for Vertex AI service. Service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            this.vertexAI = new vertexai_1.VertexAI({
+                project: process.env.GOOGLE_PROJECT_ID,
+                location: process.env.GOOGLE_CLOUD_LOCATION,
+            });
+        }
+        catch (error) {
+            console.error('Error initializing Vertex AI service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'Vertex AI';
+    }
+    async fetchModelsFromApi() {
+        return [
+            {
+                name: 'gemini-3-pro-preview',
+                description: 'gemini-3-pro-preview',
+                model: 'gemini-3-pro-preview',
+                service: 'Vertex AI',
+            },
+            {
+                name: 'gemini-2.5-pro',
+                description: 'gemini-2.5-pro',
+                model: 'gemini-2.5-pro',
+                service: 'Vertex AI',
+            },
+            {
+                name: 'gemini-2.5-flash',
+                description: 'gemini-2.5-flash',
+                model: 'gemini-2.5-flash',
+                service: 'Vertex AI',
+            },
+            {
+                name: 'gemini-2.5-flash-lite',
+                description: 'gemini-2.5-flash-lite',
+                model: 'gemini-2.5-flash-lite',
+                service: 'Vertex AI',
+            },
+            {
+                name: 'gemini-2.0-flash-lite',
+                description: 'gemini-2.0-flash-lite',
+                model: 'gemini-2.0-flash-lite',
+                service: 'Vertex AI',
+            },
+            {
+                name: 'gemini-2.0-flash',
+                description: 'gemini-2.0-flash',
+                model: 'gemini-2.0-flash',
+                service: 'Vertex AI',
+            },
+        ];
+    }
+    async uploadFile(fileContents) {
+        let cloudStorage = new storage_1.Storage();
+        let bucketName = process.env.GOOGLE_CLOUD_STORAGE_BUCKET;
+        const bucket = cloudStorage.bucket(bucketName);
+        const fileName = `${(0, crypto_1.randomUUID)()}.pdf`;
+        const file = bucket.file(fileName);
+        await file.save(Buffer.from(fileContents), {
+            metadata: { contentType: 'application/octet-stream' },
+        });
+        console.log(`Successfully uploaded ${fileName} to ${bucketName}`);
+        return `gs://${bucketName}/${fileName}`;
+    }
+    addToConversationHistory(agent, message, fromSelf = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        agent.history.push({
+            role: fromSelf ? 'model' : 'user',
+            parts: [{ text: message }],
+        });
+        agent.trimHistoryIfNeeded();
+    }
+    async textPrompt(agent, prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, _cacheConfig = null, maxOutputChars = 0) {
+        if (agent.balanceService && !agent.disableBalanceCheck) {
+            const hasSufficientBalance = agent.balanceService.hasSufficientBalance();
+            if (!hasSufficientBalance) {
+                throw new errors_1.InsufficientBalanceError('Insufficient balance. Please add funds to continue using AI services.');
+            }
+        }
+        let generationConfig = {
+            candidateCount: 1,
+            maxOutputTokens: 16384,
+            temperature: 0,
+        };
+        let instructions = promptInstructions || agent.systemInstruction;
+        if (jsonSchema) {
+            generationConfig.responseMimeType = 'application/json';
+            if (jsonSchema.description) {
+                instructions +=
+                    '\n\nPlease generate only valid JSON according to the schema.\n' +
+                        jsonSchema.description;
+            }
+            delete jsonSchema.name;
+            delete jsonSchema.description;
+            generationConfig.responseSchema = jsonSchema;
+        }
+        let generativeModel = this.vertexAI.getGenerativeModel({
+            model: agent.modelName,
+            generationConfig: generationConfig,
+            systemInstruction: instructions,
+        });
+        const identity = `Your agent identity is ${agent.agentName}: ${agent.description}`;
+        const messages = [{ role: 'user', parts: [{ text: identity }] }];
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.uri) {
+                    const ext = file.fileName.split('.').pop() || 'pdf';
+                    messages.push({
+                        role: 'user',
+                        parts: [
+                            {
+                                fileData: {
+                                    mimeType: 'application/' + ext,
+                                    fileUri: file.serviceMetadata.uri,
+                                },
+                            },
+                            {
+                                text: `This document will be referenced as ${file.fileName}.`,
+                            },
+                        ],
+                    });
+                }
+                else {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    messages.push({
+                        role: 'user',
+                        parts: [{ text: textContent }],
+                    });
+                }
+            }
+        }
+        if (agent.attachedArtifacts && agent.attachedArtifacts.length > 0) {
+            for (const artifactId of agent.attachedArtifacts) {
+                const content = agent.artifactService.getArtifact(artifactId);
+                if (content && typeof content === 'string') {
+                    const metadata = agent.artifactService.getArtifactMetadata(artifactId);
+                    const fileName = metadata ? `${metadata.name}.md` : 'artifact.md';
+                    messages.push({
+                        role: 'user',
+                        parts: [{ text: `Attached document: ${fileName}\n\n${content}` }],
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({ role: 'user', parts: [{ text: prompt }] });
+        }
+        let resp;
+        try {
+            resp = await generativeModel.generateContent({ contents: messages });
+        }
+        catch (error) {
+            console.error(error);
+            return error.message;
+        }
+        let responseText = resp.response.candidates[0].content.parts[0].text;
+        if (jsonSchema) {
+            responseText = this.trimToJson(responseText);
+            responseText = this.sanitizeJsonString(responseText);
+        }
+        let usage = resp.response.usageMetadata;
+        if (usage) {
+            this.computeMessageCost(agent, usage);
+        }
+        if (saveResponse) {
+            this.addToConversationHistory(agent, prompt, false);
+            this.addToConversationHistory(agent, responseText, true);
+        }
+        if (jsonSchema) {
+            return JSON.parse(responseText);
+        }
+        return responseText;
+    }
+    computeMessageCost(agent, usage) {
+        const inputTokens = usage.promptTokenCount || 0;
+        const outputTokens = usage.candidatesTokenCount || 0;
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName}`);
+            return;
+        }
+        const inputCost = inputTokens * modelInfo.input_cost_per_token;
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = inputCost + outputCost + markup;
+        agent.totalInputTokens += inputTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for ${agent.agentName} message: ${cost} (markup: ${markup.toFixed(4)})`);
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+    async attachDocument(agent, fileName, fileData) {
+        if (agent === null) {
+            throw new Error('Shared document attachment not supported by Vertex AI service');
+        }
+        if (agent.fullContextFiles) {
+            return super.attachDocument(agent, fileName, fileData);
+        }
+        let ext = fileName.split('.').pop();
+        const existingMetadata = agent.attachedFiles.find((f) => f.fileName === fileName &&
+            f.serviceMetadata?.serviceName === this.getServiceName() &&
+            f.serviceMetadata?.uri);
+        let gsUri;
+        if (existingMetadata?.serviceMetadata?.uri) {
+            gsUri = existingMetadata.serviceMetadata.uri;
+            console.log(`Using existing Google Cloud Storage file: ${gsUri}`);
+        }
+        else {
+            gsUri = await this.uploadFile(fileData);
+            const additionalMetadata = {
+                mimeType: 'application/' + ext,
+                serviceMetadata: {
+                    serviceName: this.getServiceName(),
+                    uri: gsUri,
+                },
+            };
+            const fileMetadataIndex = agent.attachedFiles.findIndex((f) => f.fileName === fileName);
+            if (fileMetadataIndex >= 0) {
+                agent.attachedFiles[fileMetadataIndex] = {
+                    ...agent.attachedFiles[fileMetadataIndex],
+                    ...additionalMetadata,
+                };
+            }
+        }
+        return existingMetadata?.serviceMetadata?.uri
+            ? `Using existing file ${fileName} from Google Cloud Storage`
+            : `Uploaded ${fileName} to Google Cloud Storage`;
+    }
+    formatMessage(message) {
+        if (!message) {
+            return 'No message';
+        }
+        if (message.role && message.parts) {
+            const parts = message.parts
+                .map((part) => {
+                if (part.text) {
+                    return part.text;
+                }
+                else if (part.fileData) {
+                    return `[File: ${part.fileData.fileUri || 'attached file'}]`;
+                }
+                else {
+                    return JSON.stringify(part);
+                }
+            })
+                .join('\n');
+            return `${message.role}: ${parts}`;
+        }
+        return super.formatMessage(message);
+    }
+    async finishAgent(agent) {
+        if (!agent)
+            return;
+        for (const metadata of agent.attachedFiles) {
+            if (metadata.serviceMetadata?.serviceName === this.getServiceName() &&
+                metadata.serviceMetadata?.uri) {
+                try {
+                    const uri = metadata.serviceMetadata.uri;
+                    const match = uri.match(/gs:\/\/([^\/]+)\/(.+)/);
+                    if (match) {
+                        const bucketName = match[1];
+                        const fileName = match[2];
+                        const storage = new storage_1.Storage();
+                        const bucket = storage.bucket(bucketName);
+                        const file = bucket.file(fileName);
+                        await file.delete();
+                        console.log(`Deleted Google Cloud Storage file ${uri} for agent ${agent.id}`);
+                    }
+                }
+                catch (error) {
+                    console.error(`Error deleting Google Cloud Storage file ${metadata.serviceMetadata.uri}:`, error);
+                }
+            }
+        }
+    }
+};
+exports.VertexAiService = VertexAiService;
+exports.VertexAiService = VertexAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], VertexAiService);

package/dist/ai/agent-config.d.ts

@@ -0,0 +1,32 @@
+import { FileMetadata } from './attached-file.service';
+export interface AgentConfig {
+    id: string;
+    agentName: string;
+    agentNickname: string;
+    description: string;
+    promptFolder: string;
+    systemInstruction: string;
+    modelName: string;
+    serviceName: string;
+    reasoningEffort: 'low' | 'medium' | 'high' | null;
+    allowSearch: boolean;
+    maxOutputTokens: number;
+    createdAt: string;
+    attachedFiles?: FileMetadata[];
+    attachedArtifacts?: string[];
+    history?: any[];
+    maxHistoryMessages: number;
+    totalInputTokens?: number;
+    totalOutputTokens?: number;
+    totalCost?: number;
+    totalMarkup?: number;
+    markupRate?: number;
+    disableMarkup?: boolean;
+    disableBalanceCheck?: boolean;
+    isControlledByHuman?: boolean;
+    isPublished?: boolean;
+    templateAgentId?: string;
+    beginInstruction?: string;
+    promptCacheTTL?: number;
+    ownerRoomId?: string;
+}

package/dist/ai/agent-config.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/ai/agent-factory.d.ts

@@ -0,0 +1,15 @@
+import { AiFactoryService } from './ai-factory.service';
+import { AgentStoreService } from './agent-store.service';
+import { ArtifactService } from './artifact.service';
+import { ConfigurationService } from '../config/configuration.service';
+import { BalanceService } from '../app/balance.service';
+import { Agent } from './agent';
+export declare class AgentFactory {
+    private readonly aiFactoryService;
+    private readonly agentStoreService;
+    private readonly configService;
+    private readonly balanceService;
+    private readonly artifactService;
+    constructor(aiFactoryService: AiFactoryService, agentStoreService: AgentStoreService, configService: ConfigurationService, balanceService: BalanceService, artifactService: ArtifactService);
+    createAgent(aiServiceName: string, agentName: string, agentNickname: string, description: string, promptFolder: string, modelName: string, storageDir?: string, artifactService?: ArtifactService): Agent;
+}

package/dist/ai/agent-factory.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AgentFactory = void 0;
+class AgentFactory {
+    aiFactoryService;
+    agentStoreService;
+    configService;
+    balanceService;
+    artifactService;
+    constructor(aiFactoryService, agentStoreService, configService, balanceService, artifactService) {
+        this.aiFactoryService = aiFactoryService;
+        this.agentStoreService = agentStoreService;
+        this.configService = configService;
+        this.balanceService = balanceService;
+        this.artifactService = artifactService;
+    }
+    createAgent(aiServiceName, agentName, agentNickname, description, promptFolder, modelName, storageDir = '', artifactService) {
+        const aiService = this.aiFactoryService.createAiService(aiServiceName);
+        const finalStorageDir = storageDir || this.agentStoreService.getDefaultStorageDir();
+        const finalArtifactService = artifactService || this.artifactService;
+        return aiService.createAgent(this.configService, this.agentStoreService, this.balanceService, finalArtifactService, agentName, agentNickname, description, promptFolder, modelName, finalStorageDir);
+    }
+}
+exports.AgentFactory = AgentFactory;

package/dist/ai/agent-message.service.d.ts

@@ -0,0 +1,9 @@
+import { EventEmitter } from 'events';
+export declare class AgentMessageService {
+    private messageEmitters;
+    getOrCreateEmitter(agentId: string): EventEmitter;
+    getEmitter(agentId: string): EventEmitter | undefined;
+    emitUpdate(agentId: string, agentState: any): void;
+    emitError(agentId: string, error: Error): void;
+    cleanup(agentId: string): void;
+}

package/dist/ai/agent-message.service.js

@@ -0,0 +1,56 @@
+"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.AgentMessageService = void 0;
+const common_1 = require("@nestjs/common");
+const events_1 = require("events");
+let AgentMessageService = class AgentMessageService {
+    messageEmitters = new Map();
+    getOrCreateEmitter(agentId) {
+        let emitter = this.messageEmitters.get(agentId);
+        if (!emitter) {
+            emitter = new events_1.EventEmitter();
+            this.messageEmitters.set(agentId, emitter);
+        }
+        return emitter;
+    }
+    getEmitter(agentId) {
+        return this.messageEmitters.get(agentId);
+    }
+    emitUpdate(agentId, agentState) {
+        const emitter = this.messageEmitters.get(agentId);
+        if (emitter) {
+            emitter.emit('update', {
+                timestamp: Date.now(),
+                state: agentState,
+            });
+        }
+    }
+    emitError(agentId, error) {
+        const emitter = this.messageEmitters.get(agentId);
+        if (emitter) {
+            emitter.emit('update', {
+                timestamp: Date.now(),
+                type: 'error',
+                errorType: error.name,
+                message: error.message,
+            });
+        }
+    }
+    cleanup(agentId) {
+        const emitter = this.messageEmitters.get(agentId);
+        if (emitter) {
+            emitter.removeAllListeners();
+            this.messageEmitters.delete(agentId);
+        }
+    }
+};
+exports.AgentMessageService = AgentMessageService;
+exports.AgentMessageService = AgentMessageService = __decorate([
+    (0, common_1.Injectable)()
+], AgentMessageService);

package/dist/ai/agent-store.module.d.ts

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

package/dist/ai/agent-store.module.js

@@ -0,0 +1,21 @@
+"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.AgentStoreModule = void 0;
+const common_1 = require("@nestjs/common");
+const agent_message_service_1 = require("./agent-message.service");
+let AgentStoreModule = class AgentStoreModule {
+};
+exports.AgentStoreModule = AgentStoreModule;
+exports.AgentStoreModule = AgentStoreModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        providers: [agent_message_service_1.AgentMessageService],
+        exports: [agent_message_service_1.AgentMessageService],
+    })
+], AgentStoreModule);

package/dist/ai/agent-store.service.d.ts

@@ -0,0 +1,31 @@
+import { Agent } from './agent';
+import { AiFactoryService } from './ai-factory.service';
+import { ArtifactService } from './artifact.service';
+import { ConfigurationService } from '../config/configuration.service';
+import { AttachedFileService } from './attached-file.service';
+import { BalanceService } from '../app/balance.service';
+export declare class AgentStoreService {
+    private readonly aiFactoryService;
+    private readonly configService;
+    private readonly attachedFileService;
+    private readonly balanceService;
+    private readonly artifactService;
+    private agents;
+    private readonly defaultStorageDir;
+    private loaded;
+    private loadPromise;
+    constructor(aiFactoryService: AiFactoryService, configService: ConfigurationService, attachedFileService: AttachedFileService, balanceService: BalanceService, artifactService: ArtifactService);
+    getDefaultStorageDir(): string;
+    storeAgent(agent: Agent, storageDir?: string): string;
+    getAgent(id: string): Promise<Agent | undefined>;
+    removeAgent(id: string): boolean;
+    getAllAgentIds(): Promise<string[]>;
+    getAgentCount(): Promise<number>;
+    cloneAgentAsPublished(templateId: string, publishedName: string, _userId: string): Promise<string>;
+    getPublishedInstances(templateId: string): Promise<Agent[]>;
+    resetPublishedInstance(instanceId: string, templateId: string): Promise<void>;
+    private ensureLoaded;
+    loadAgentsFromDirectory(storageDir: string, artifactService?: ArtifactService): Promise<void>;
+    private saveAgentToFile;
+    private deleteAgentFile;
+}