briyah 1.0.0

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

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

@@ -0,0 +1,18 @@
+import { BaseAiService } from './base-ai.service';
+import { Agent } from '../agent';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class TogetherAiService extends BaseAiService {
+    private togetherClient;
+    constructor();
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean, developer?: boolean): void;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    private computeMessageCost;
+    private computeImageCost;
+    generateImage(agent: Agent, prompt: string, width: number, height: number, quality: string, referenceImageArtifactIds?: string[]): Promise<{
+        artifactId?: string;
+        error?: any;
+    }>;
+}

package/dist/server/src/ai/LLM/together.service.js

@@ -0,0 +1,285 @@
+"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.TogetherAiService = void 0;
+const common_1 = require("@nestjs/common");
+const together_ai_1 = __importDefault(require("together-ai"));
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let TogetherAiService = class TogetherAiService extends base_ai_service_1.BaseAiService {
+    togetherClient;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['TOGETHER_API_KEY'];
+            if (!apiKey) {
+                console.warn('TOGETHER_API_KEY environment variable not set. Together AI service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            this.togetherClient = new together_ai_1.default({
+                apiKey: apiKey,
+                timeout: 600000,
+                maxRetries: 3,
+            });
+        }
+        catch (error) {
+            console.error('Error initializing Together AI service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'TogetherAI';
+    }
+    supportsImageGeneration() {
+        return true;
+    }
+    async fetchModelsFromApi() {
+        let models = await this.togetherClient.models.list();
+        return models
+            .filter((model) => model.type.includes('chat'))
+            .map((model) => {
+            return {
+                name: model.id,
+                description: model.id,
+                model: model.id,
+                service: 'TogetherAI',
+            };
+        });
+    }
+    addToConversationHistory(agent, message, fromSelf = false, developer = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        let role = fromSelf ? 'assistant' : 'user';
+        if (developer)
+            role = 'system';
+        agent.history.push({
+            role: role,
+            content: 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.');
+            }
+        }
+        const identity = `Your agent identity is ${agent.agentName}: ${agent.description}`;
+        const instructions = promptInstructions || agent.systemInstruction;
+        const messages = [];
+        if (instructions)
+            messages.push({ role: 'system', content: instructions });
+        messages.push({ role: 'system', content: identity });
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.fileData) {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    messages.push({
+                        role: 'user',
+                        content: `Attached file "${file.fileName}":\n\n${textContent}`,
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({
+                role: 'user',
+                content: prompt,
+            });
+        }
+        const responseFormat = jsonSchema
+            ? {
+                type: 'json_schema',
+                json_schema: {
+                    name: 'response',
+                    schema: jsonSchema,
+                    strict: true,
+                },
+            }
+            : undefined;
+        let responseText;
+        try {
+            const response = await this.togetherClient.chat.completions.create({
+                model: agent.modelName,
+                messages: messages,
+                temperature: 0,
+                response_format: responseFormat,
+            });
+            if (response.choices && response.choices[0]?.message?.content) {
+                responseText = response.choices[0].message.content;
+            }
+            else {
+                responseText = '';
+            }
+            if (jsonSchema) {
+                responseText = this.trimToJson(responseText);
+                responseText = this.sanitizeJsonString(responseText);
+            }
+            else {
+                responseText = this.trimResponseText(responseText);
+            }
+            if (response.usage) {
+                this.computeMessageCost(agent, response.usage);
+            }
+        }
+        catch (error) {
+            console.error('Error calling Together AI:', error);
+            throw error;
+        }
+        if (saveResponse) {
+            this.addToConversationHistory(agent, prompt, false);
+            this.addToConversationHistory(agent, responseText, true);
+        }
+        if (jsonSchema) {
+            return JSON.parse(responseText);
+        }
+        return responseText;
+    }
+    computeMessageCost(agent, usage) {
+        const promptTokens = usage.prompt_tokens || 0;
+        const completionTokens = usage.completion_tokens || 0;
+        let modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo && !agent.modelName.startsWith('together_ai/')) {
+            modelInfo = model_prices_1.default[`together_ai/${agent.modelName}`];
+        }
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName} or together_ai/${agent.modelName}`);
+            return;
+        }
+        const inputCost = promptTokens * modelInfo.input_cost_per_token;
+        const outputCost = completionTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = inputCost + outputCost + markup;
+        agent.totalInputTokens += promptTokens;
+        agent.totalOutputTokens += completionTokens;
+        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);
+        }
+    }
+    computeImageCost(agent, usage) {
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName}`);
+            return;
+        }
+        const inputImageTokens = usage.input_tokens_details?.image_tokens || 0;
+        const inputTextTokens = usage.input_tokens_details?.text_tokens || 0;
+        const outputImageTokens = usage.output_tokens_details?.image_tokens || 0;
+        const outputTextTokens = usage.output_tokens_details?.text_tokens || 0;
+        const totalInputTokens = usage.input_tokens || 0;
+        const totalOutputTokens = usage.output_tokens || 0;
+        agent.totalInputTokens += totalInputTokens;
+        agent.totalOutputTokens += totalOutputTokens;
+        let inputCost = 0;
+        if (inputImageTokens > 0) {
+            const cachedImageTokens = usage.input_tokens_details?.cached_image_tokens || 0;
+            const uncachedImageTokens = inputImageTokens - cachedImageTokens;
+            inputCost += uncachedImageTokens * (modelInfo.input_cost_per_image_token || 0);
+            if (cachedImageTokens > 0) {
+                inputCost +=
+                    cachedImageTokens *
+                        (modelInfo.cache_read_input_image_token_cost ||
+                            modelInfo.input_cost_per_image_token * 0.5);
+            }
+        }
+        if (inputTextTokens > 0) {
+            const cachedTextTokens = usage.input_tokens_details?.cached_text_tokens || 0;
+            const uncachedTextTokens = inputTextTokens - cachedTextTokens;
+            inputCost += uncachedTextTokens * (modelInfo.input_cost_per_token || 0);
+            if (cachedTextTokens > 0) {
+                inputCost +=
+                    cachedTextTokens *
+                        (modelInfo.cache_read_input_text_token_cost ||
+                            modelInfo.input_cost_per_token * 0.5);
+            }
+        }
+        let outputCost = 0;
+        if (outputImageTokens > 0) {
+            outputCost += outputImageTokens * (modelInfo.output_cost_per_image_token || 0);
+        }
+        if (outputTextTokens > 0) {
+            outputCost += outputTextTokens * (modelInfo.output_cost_per_token || 0);
+        }
+        const markup = outputCost * 0;
+        const cost = inputCost + outputCost + markup;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for image generation: ${cost} (markup: ${markup.toFixed(4)})`);
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+    async generateImage(agent, prompt, width, height, quality, referenceImageArtifactIds) {
+        if (agent.balanceService && !agent.disableBalanceCheck) {
+            const hasSufficientBalance = agent.balanceService.hasSufficientBalance();
+            if (!hasSufficientBalance) {
+                throw new errors_1.InsufficientBalanceError('Insufficient balance for image generation. Please add funds to continue.');
+            }
+        }
+        try {
+            let imageResponse;
+            if (referenceImageArtifactIds && referenceImageArtifactIds.length > 0) {
+                const referenceImages = await this.loadReferenceImages(agent, referenceImageArtifactIds);
+                imageResponse = await this.togetherClient.images.generate({
+                    reference_image: referenceImages.length === 1 ? referenceImages[0] : referenceImages,
+                    model: agent.modelName,
+                    prompt: prompt,
+                    height: height,
+                    width: width,
+                    n: 1,
+                    disable_safety_checker: true,
+                    response_format: 'base64',
+                });
+            }
+            else {
+                imageResponse = await this.togetherClient.images.generate({
+                    model: agent.modelName,
+                    prompt: prompt,
+                    height: height,
+                    width: width,
+                    n: 1,
+                    disable_safety_checker: true,
+                    response_format: 'base64',
+                });
+            }
+            if (imageResponse.usage) {
+                this.computeImageCost(agent, imageResponse.usage);
+            }
+            const base64Data = imageResponse.data[0].b64_json;
+            const artifactId = await this.saveImageAsArtifact(agent, base64Data, prompt);
+            return { artifactId };
+        }
+        catch (error) {
+            console.error('Error generating image:', error.error?.message || error.message);
+            console.log(prompt);
+            return { error };
+        }
+    }
+};
+exports.TogetherAiService = TogetherAiService;
+exports.TogetherAiService = TogetherAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], TogetherAiService);

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

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

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

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

@@ -0,0 +1,17 @@
+import { VertexAI } from '@google-cloud/vertexai';
+import { Agent } from '../agent';
+import { BaseAiService } from './base-ai.service';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class VertexAiService extends BaseAiService {
+    vertexAI: VertexAI;
+    constructor();
+    getServiceName(): string;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    uploadFile(fileContents: Uint8Array): Promise<string>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean): void;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    private computeMessageCost;
+    attachDocument(agent: Agent, fileName: string, fileData: Uint8Array): Promise<string>;
+    formatMessage(message: any): string;
+    finishAgent(agent: Agent): Promise<void>;
+}