briyah 1.0.0

package/dist/server/src/ai/LLM/base-ai.service.js

@@ -0,0 +1,409 @@
+"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.BaseAiService = void 0;
+const common_1 = require("@nestjs/common");
+const agent_1 = require("../agent");
+const path = __importStar(require("path"));
+const fs_1 = require("fs");
+const fs = __importStar(require("fs"));
+const handlebars_1 = require("handlebars");
+const errors_1 = require("../../common/errors");
+let BaseAiService = class BaseAiService {
+    modelsCache = null;
+    _isAvailable = true;
+    constructor() { }
+    get isAvailable() {
+        return this._isAvailable;
+    }
+    getServiceName() {
+        return '';
+    }
+    supportsImageGeneration() {
+        return false;
+    }
+    supportsPromptCaching() {
+        return false;
+    }
+    getCacheConfig(_agent, _cacheMessage) {
+        return null;
+    }
+    stripQuotes(quotedText) {
+        return quotedText.replace(/^['"]+|['"]+$/g, '');
+    }
+    findPromptFile(agent, fileName, extension) {
+        const configService = agent.configService;
+        if (!configService) {
+            throw new Error('Agent configService is not set');
+        }
+        const searchPaths = [
+            path.join(configService.getUserPromptsDir(), agent.promptFolder, `${fileName}${extension}`),
+            path.join(configService.getUserPromptsDir(), `${fileName}${extension}`),
+            path.join(configService.getCommonPromptsDir(), agent.promptFolder, `${fileName}${extension}`),
+            path.join(configService.getCommonPromptsDir(), `${fileName}${extension}`),
+        ];
+        for (const filePath of searchPaths) {
+            if (fs.existsSync(filePath)) {
+                return filePath;
+            }
+        }
+        return null;
+    }
+    getPreparedPrompt(agent, promptFileName, variables) {
+        const preparedFile = this.findPromptFile(agent, promptFileName, '.prompt');
+        if (!preparedFile) {
+            throw new errors_1.NotFoundError(`Prompt file '${promptFileName}.prompt' not found for agent '${agent.agentName}' (folder: ${agent.promptFolder})`);
+        }
+        const preparedPrompt = fs.readFileSync(preparedFile).toString('utf8');
+        const template = (0, handlebars_1.compile)(preparedPrompt);
+        return template(variables);
+    }
+    getPreparedSchema(agent, promptFileName) {
+        const jsonSchemaFile = this.findPromptFile(agent, promptFileName, '.json');
+        if (!jsonSchemaFile) {
+            return null;
+        }
+        let jsonSchemaString = (0, fs_1.readFileSync)(jsonSchemaFile).toString('utf8');
+        if (!jsonSchemaString) {
+            return null;
+        }
+        try {
+            return JSON.parse(jsonSchemaString);
+        }
+        catch (error) {
+            console.error(`Error parsing JSON schema from ${jsonSchemaFile}:`, error);
+            return null;
+        }
+    }
+    async listModels() {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        if (this.modelsCache) {
+            return this.modelsCache;
+        }
+        try {
+            const models = await this.fetchModelsFromApi();
+            this.modelsCache = models;
+            return models;
+        }
+        catch (error) {
+            console.error(`Error fetching models for ${this.getServiceName()}:`, error);
+            throw error;
+        }
+    }
+    async fetchModelsFromApi() {
+        throw new Error('fetchModelsFromApi method not implemented in base class');
+    }
+    createAgent(configService, agentStoreService, balanceService, artifactService, agentName, agentNickname, description, promptFolder, modelName, storageDir = '') {
+        if (!this.isAvailable) {
+            throw new Error(`${this.getServiceName()} service is not available. Check API key configuration.`);
+        }
+        if (!modelName) {
+            throw new Error('Model name is required');
+        }
+        if (!agentName) {
+            throw new Error('Agent name is required');
+        }
+        const tempAgent = { promptFolder, configService };
+        const systemInstructionFile = this.findPromptFile(tempAgent, 'system_instruction', '.prompt');
+        let systemInstructionPrompt = null;
+        if (systemInstructionFile) {
+            try {
+                systemInstructionPrompt = (0, fs_1.readFileSync)(systemInstructionFile).toString('utf8');
+            }
+            catch (error) {
+                console.error(`Error reading system instruction from ${systemInstructionFile}:`, error);
+                systemInstructionPrompt = null;
+            }
+        }
+        const agent = new agent_1.Agent(null, configService, agentStoreService, balanceService, artifactService, agentName, agentNickname, description, promptFolder, systemInstructionPrompt, [], modelName, this.getServiceName(), this, null, false, 0, '', storageDir);
+        return agent;
+    }
+    async textPrompt(agent, prompt, _jsonSchema = null, _saveResponse = true, _promptInstructions = null, _cacheConfig = null, _maxOutputChars = 0) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        throw new Error('Method not implemented in base class');
+    }
+    async generateImage(_agent, _prompt, _width, _height, _quality, _referenceImageArtifactIds, _options) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        throw new Error(`generateImage method not implemented for ${this.getServiceName()}`);
+    }
+    async loadReferenceImages(agent, artifactIds) {
+        const images = [];
+        for (const artifactId of artifactIds) {
+            const imageData = agent.artifactService.getArtifact(artifactId);
+            const metadata = agent.artifactService.getArtifactMetadata(artifactId);
+            if (imageData && Buffer.isBuffer(imageData) && metadata) {
+                const uint8Array = new Uint8Array(imageData);
+                const blob = new Blob([uint8Array], {
+                    type: metadata.mimeType || 'image/png',
+                });
+                const file = new File([blob], metadata.fileName, {
+                    type: metadata.mimeType || 'image/png',
+                });
+                images.push(file);
+            }
+        }
+        return images;
+    }
+    async saveImageAsArtifact(agent, base64Data, prompt) {
+        const buffer = Buffer.from(base64Data, 'base64');
+        const mimeType = 'image/png';
+        const name = prompt.substring(0, 50).trim() + ' (generated)';
+        return agent.artifactService.storeImageArtifact(name, buffer, mimeType);
+    }
+    async preparedPrompt(agent, promptFileName, variables, saveResponse = true, cacheConfig = false, maxOutputChars = 0) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        let preparedPrompt = this.getPreparedPrompt(agent, promptFileName, variables);
+        let jsonSchema = this.getPreparedSchema(agent, promptFileName);
+        return this.textPrompt(agent, preparedPrompt, jsonSchema, saveResponse, null, cacheConfig, maxOutputChars);
+    }
+    async instructedPrompt(agent, prompt, instructionFileName, variables, saveResponse = true, cacheConfig = null, maxOutputChars = 0) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        let promptInstructions = this.getPreparedPrompt(agent, instructionFileName, variables);
+        let jsonSchema = this.getPreparedSchema(agent, instructionFileName);
+        return this.textPrompt(agent, prompt, jsonSchema, saveResponse, promptInstructions, cacheConfig, maxOutputChars);
+    }
+    async attachDocument(agent, fileName, fileData) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+        if (agent === null) {
+            throw new Error('Shared document attachment not supported by this service');
+        }
+        try {
+            let ext = fileName.split('.').pop();
+            let mimeType = 'application/octet-stream';
+            if (ext.toLowerCase() === 'pdf') {
+                mimeType = 'application/pdf';
+            }
+            else if (ext.toLowerCase() === 'txt') {
+                mimeType = 'text/plain';
+            }
+            else if (ext.toLowerCase() === 'md') {
+                mimeType = 'text/plain';
+            }
+            else if (['doc', 'docx'].includes(ext.toLowerCase())) {
+                mimeType = 'application/msword';
+            }
+            else if (['xls', 'xlsx'].includes(ext.toLowerCase())) {
+                mimeType = 'application/vnd.ms-excel';
+            }
+            const fileMetadata = {
+                fileName,
+                mimeType,
+                size: fileData.length,
+                uploadDate: new Date().toISOString(),
+                serviceMetadata: {
+                    serviceName: this.getServiceName(),
+                    fileData: Array.from(fileData),
+                },
+            };
+            const existingFileIndex = agent.attachedFiles.findIndex((f) => f.fileName === fileName);
+            if (existingFileIndex >= 0) {
+                agent.attachedFiles[existingFileIndex] = {
+                    ...agent.attachedFiles[existingFileIndex],
+                    ...fileMetadata,
+                };
+            }
+            else {
+                agent.attachedFiles.push(fileMetadata);
+            }
+            return `Document attached: ${fileName}`;
+        }
+        catch (error) {
+            console.error(`Error attaching document in ${this.getServiceName()} service:`, error);
+            throw new Error(`Error attaching document: ${error.message}`);
+        }
+    }
+    async finishAgent(_agent) {
+        if (!this.isAvailable) {
+            return Promise.reject(new Error(`${this.getServiceName()} service is not available. Check API key configuration.`));
+        }
+    }
+    addToConversationHistory(agent, message, fromSelf = false, developer = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        let role = fromSelf ? 'assistant' : 'user';
+        if (developer)
+            role = 'developer';
+        agent.history.push({
+            role: role,
+            content: message,
+        });
+        agent.trimHistoryIfNeeded();
+    }
+    formatMessage(message) {
+        if (!message) {
+            return 'No message';
+        }
+        if (message.role && message.content) {
+            let content = message.content;
+            if (typeof content === 'object') {
+                content = JSON.stringify(content, null, 4);
+            }
+            return `${message.role}: ${content}`;
+        }
+        return JSON.stringify(message);
+    }
+    trimResponseText(str) {
+        if (!str) {
+            return str;
+        }
+        str = str.replace(/<think>[\s\S]*?<\/think>/gi, '').trim();
+        if (str.startsWith('```')) {
+            const lines = str.split('\n');
+            if (lines.length > 1) {
+                str = lines.slice(1).join('\n');
+            }
+            else {
+                str = '';
+            }
+        }
+        if (str.endsWith('```')) {
+            const lines = str.split('\n');
+            if (lines.length > 1) {
+                str = lines.slice(0, -1).join('\n');
+            }
+            else {
+                str = '';
+            }
+        }
+        return str;
+    }
+    trimToJson(str) {
+        let objectStart = str.indexOf('{');
+        let arrayStart = str.indexOf('[');
+        let startIndex = -1;
+        let endChar = '';
+        if (objectStart !== -1 && arrayStart !== -1) {
+            if (objectStart < arrayStart) {
+                startIndex = objectStart;
+                endChar = '}';
+            }
+            else {
+                startIndex = arrayStart;
+                endChar = ']';
+            }
+        }
+        else if (objectStart !== -1) {
+            startIndex = objectStart;
+            endChar = '}';
+        }
+        else if (arrayStart !== -1) {
+            startIndex = arrayStart;
+            endChar = ']';
+        }
+        if (startIndex !== -1) {
+            str = str.substring(startIndex);
+            let endIndex = str.lastIndexOf(endChar);
+            if (endIndex !== -1) {
+                str = str.slice(0, endIndex + 1);
+            }
+        }
+        return str;
+    }
+    sanitizeJsonString(str) {
+        let result = '';
+        let inString = false;
+        let escapeNext = false;
+        for (let i = 0; i < str.length; i++) {
+            const char = str[i];
+            if (escapeNext) {
+                if (char === "'") {
+                    result = result.slice(0, -1) + char;
+                }
+                else {
+                    result += char;
+                }
+                escapeNext = false;
+                continue;
+            }
+            if (char === '\\') {
+                result += char;
+                escapeNext = true;
+                continue;
+            }
+            if (char === '"') {
+                inString = !inString;
+                result += char;
+                continue;
+            }
+            if (inString) {
+                if (char === '\n') {
+                    result += '\\n';
+                }
+                else if (char === '\r') {
+                    result += '\\r';
+                }
+                else if (char === '\t') {
+                    result += '\\t';
+                }
+                else {
+                    result += char;
+                }
+            }
+            else {
+                result += char;
+            }
+        }
+        return result;
+    }
+};
+exports.BaseAiService = BaseAiService;
+exports.BaseAiService = BaseAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], BaseAiService);

package/dist/server/src/ai/LLM/deepseek.module.d.ts

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

package/dist/server/src/ai/LLM/deepseek.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.DeepSeekAiModule = void 0;
+const common_1 = require("@nestjs/common");
+const deepseek_service_1 = require("./deepseek.service");
+let DeepSeekAiModule = class DeepSeekAiModule {
+};
+exports.DeepSeekAiModule = DeepSeekAiModule;
+exports.DeepSeekAiModule = DeepSeekAiModule = __decorate([
+    (0, common_1.Module)({
+        imports: [],
+        providers: [deepseek_service_1.DeepSeekAiService],
+        exports: [deepseek_service_1.DeepSeekAiService],
+    })
+], DeepSeekAiModule);

package/dist/server/src/ai/LLM/deepseek.service.d.ts

@@ -0,0 +1,15 @@
+import { createDeepSeek } from '@ai-sdk/deepseek';
+import { Agent } from '../agent';
+import { BaseAiService } from './base-ai.service';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class DeepSeekAiService extends BaseAiService {
+    protected deepseekClient: ReturnType<typeof createDeepSeek>;
+    constructor();
+    getServiceName(): string;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean): void;
+    private jsonSchemaToZod;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    attachDocument(agent: Agent, fileName: string, fileData: Uint8Array): Promise<string>;
+    private computeMessageCost;
+}