briyah 1.0.0

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "singleQuote": true,
+  "trailingComma": "all",
+  "tabWidth": 4,
+  "semi": true,
+  "printWidth": 9999
+}

package/dist/ai/LLM/anthropic.module.d.ts

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

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

package/dist/ai/LLM/anthropic.service.d.ts

@@ -0,0 +1,27 @@
+import { Anthropic } from '@anthropic-ai/sdk';
+import { Agent } from '../agent';
+import { BaseAiService } from './base-ai.service';
+import { ConfigurationService } from '../../config/configuration.service';
+import { AgentStoreService } from '../agent-store.service';
+import { BalanceService } from '../../app/balance.service';
+import { ArtifactService } from '../artifact.service';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class AnthropicAiService extends BaseAiService {
+    protected anthropic: Anthropic;
+    constructor();
+    createAgent(configService: ConfigurationService, agentStoreService: AgentStoreService, balanceService: BalanceService, artifactService: ArtifactService, agentName: string, agentNickname: string, description: string, promptFolder: string, modelName: string, storageDir?: string): Agent;
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    supportsPromptCaching(): boolean;
+    getCacheConfig(agent: Agent, cacheMessage: boolean): {
+        type: string;
+        ttl: string;
+    } | {
+        type: string;
+        ttl?: undefined;
+    };
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    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;
+}

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

@@ -0,0 +1,329 @@
+"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.AnthropicAiService = void 0;
+const common_1 = require("@nestjs/common");
+const sdk_1 = require("@anthropic-ai/sdk");
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let AnthropicAiService = class AnthropicAiService extends base_ai_service_1.BaseAiService {
+    anthropic;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['ANTHROPIC_API_KEY'];
+            if (!apiKey) {
+                console.warn('ANTHROPIC_API_KEY environment variable not set. Anthropic service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            this.anthropic = new sdk_1.Anthropic({
+                apiKey: apiKey,
+                timeout: 1200000,
+                maxRetries: 3,
+            });
+        }
+        catch (error) {
+            console.error('Error initializing Anthropic service:', error);
+            this._isAvailable = false;
+        }
+    }
+    createAgent(configService, agentStoreService, balanceService, artifactService, agentName, agentNickname, description, promptFolder, modelName, storageDir = '') {
+        let agent = super.createAgent(configService, agentStoreService, balanceService, artifactService, agentName, agentNickname, description, promptFolder, modelName, storageDir);
+        agent.promptCacheTTL = 5;
+        return agent;
+    }
+    getServiceName() {
+        return 'Anthropic';
+    }
+    supportsImageGeneration() {
+        return false;
+    }
+    supportsPromptCaching() {
+        return true;
+    }
+    getCacheConfig(agent, cacheMessage) {
+        if (!cacheMessage)
+            return null;
+        if (agent.promptCacheTTL === 0)
+            return null;
+        if (agent.promptCacheTTL > 5)
+            return { type: 'ephemeral', ttl: '1h' };
+        return { type: 'ephemeral' };
+    }
+    async fetchModelsFromApi() {
+        try {
+            const modelsResponse = await this.anthropic.models.list();
+            return modelsResponse.data.map((model) => ({
+                name: model.id,
+                description: model.id,
+                model: model.id,
+                service: 'Anthropic',
+            }));
+        }
+        catch (error) {
+            console.error('Error fetching Anthropic models:', error);
+        }
+    }
+    addToConversationHistory(agent, message, fromSelf = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        agent.history.push({
+            role: fromSelf ? 'assistant' : 'user',
+            content: message,
+        });
+        agent.trimHistoryIfNeeded(10);
+    }
+    async textPrompt(agent, prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, cacheConfig = false, 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 attachedFiles = agent.attachedFiles.filter((file) => file.serviceMetadata?.fileData);
+        let documentMessages = [];
+        for (const file of attachedFiles) {
+            if (file.serviceMetadata?.fileData) {
+                const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                let fileContent;
+                if (file.mimeType === 'application/pdf') {
+                    const base64Data = Buffer.from(fileData).toString('base64');
+                    fileContent = {
+                        type: 'document',
+                        source: {
+                            type: 'base64',
+                            media_type: 'application/pdf',
+                            data: base64Data,
+                        },
+                    };
+                }
+                else {
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    fileContent = {
+                        type: 'text',
+                        text: `Attached file "${file.fileName}":\n\n${textContent}`,
+                    };
+                }
+                documentMessages.push({ role: 'user', content: [fileContent] });
+            }
+        }
+        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';
+                    const artifactMessage = {
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Document: ${fileName}\n\n${content}`,
+                            },
+                        ],
+                    };
+                    documentMessages.push(artifactMessage);
+                }
+            }
+        }
+        if (cacheConfig &&
+            documentMessages.length > 0 &&
+            documentMessages[documentMessages.length - 1].content &&
+            documentMessages[documentMessages.length - 1].content.length > 0) {
+            documentMessages[documentMessages.length - 1].content[0]['cache_control'] = cacheConfig;
+        }
+        let instructionText = promptInstructions || agent.systemInstruction;
+        if (jsonSchema) {
+            instructionText +=
+                '\n\nIMPORTANT: You MUST respond with ONLY valid JSON that conforms to the provided schema. Do not include any explanatory text, markdown formatting, or other content before or after the JSON. Your entire response should be parseable as JSON.\n\nJSON Schema:\n' +
+                    JSON.stringify(jsonSchema, null, 2);
+        }
+        const systemBlocks = [];
+        if (instructionText)
+            systemBlocks.push({ type: 'text', text: instructionText });
+        systemBlocks.push({
+            type: 'text',
+            text: `Your agent identity is ${agent.agentName}: ${agent.description}`,
+            cache_control: cacheConfig,
+        });
+        const messageHistory = agent.history.map((msg) => ({
+            role: msg.role,
+            content: [{ type: 'text', text: msg.content }],
+        }));
+        if (cacheConfig && messageHistory && messageHistory.length > 0) {
+            messageHistory[messageHistory.length - 1].content[0]['cache_control'] = cacheConfig;
+        }
+        const messages = [...documentMessages, ...messageHistory];
+        if (prompt) {
+            messages.push({
+                role: 'user',
+                content: [{ type: 'text', text: prompt }],
+            });
+        }
+        const tools = [];
+        if (agent.allowSearch) {
+            tools.push({
+                type: 'web_search_20250305',
+                name: 'web_search',
+                max_uses: 5,
+            });
+        }
+        const maxRetries = 3;
+        let lastError = null;
+        let thinkingTokens = 0;
+        if (agent.reasoningEffort === 'low')
+            thinkingTokens = 1024;
+        else if (agent.reasoningEffort === 'medium')
+            thinkingTokens = 2048;
+        else if (agent.reasoningEffort === 'high')
+            thinkingTokens = 4096;
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (modelInfo && !modelInfo.supports_reasoning)
+            thinkingTokens = 0;
+        let maxOutputTokens;
+        if (modelInfo && modelInfo.max_output_tokens) {
+            if (agent.maxOutputTokens > 0)
+                maxOutputTokens = Math.min(modelInfo.max_output_tokens, agent.maxOutputTokens);
+            else
+                maxOutputTokens = modelInfo.max_output_tokens;
+        }
+        for (let attempt = 1; attempt <= maxRetries; attempt++) {
+            try {
+                const response = await this.anthropic.messages.create({
+                    model: agent.modelName,
+                    messages: messages,
+                    system: systemBlocks,
+                    max_tokens: maxOutputTokens,
+                    temperature: thinkingTokens > 0 ? undefined : 0,
+                    thinking: {
+                        type: thinkingTokens > 0 ? 'enabled' : 'disabled',
+                        budget_tokens: thinkingTokens > 0 ? thinkingTokens : undefined,
+                    },
+                    tools: tools.length > 0 ? tools : undefined,
+                });
+                let responseText = '';
+                if (response.content && response.content.length > 0) {
+                    for (let i = 0; i < response.content.length; i++) {
+                        const content = response.content[i];
+                        if ('text' in content) {
+                            responseText += content.text;
+                        }
+                    }
+                }
+                if (jsonSchema) {
+                    responseText = this.trimToJson(responseText);
+                    responseText = this.sanitizeJsonString(responseText);
+                }
+                if (response.usage) {
+                    this.computeMessageCost(agent, response.usage);
+                }
+                let parsedResponse;
+                if (jsonSchema) {
+                    try {
+                        parsedResponse = JSON.parse(responseText);
+                        if (saveResponse) {
+                            agent.addToConversationHistory(prompt, false);
+                            agent.addToConversationHistory(responseText, true);
+                        }
+                        return parsedResponse;
+                    }
+                    catch (parseError) {
+                        lastError = parseError;
+                        console.warn(`JSON parse attempt ${attempt}/${maxRetries} failed:`, parseError);
+                        console.warn('Raw response:', responseText);
+                        if (attempt < maxRetries) {
+                            const retryMessage = `Your previous response was not valid JSON. Please respond with ONLY valid JSON that can be parsed. No explanatory text, no markdown, no formatting - just pure JSON that conforms to the schema. Here was the parsing error: ${parseError.message}`;
+                            messages.push({
+                                role: 'assistant',
+                                content: [{ type: 'text', text: responseText }],
+                            });
+                            messages.push({
+                                role: 'user',
+                                content: [{ type: 'text', text: retryMessage }],
+                            });
+                        }
+                    }
+                }
+                else {
+                    if (responseText.length > maxOutputChars && maxOutputChars > 0) {
+                        const retryMessage = `Your previous response exceeded the character limit of ${maxOutputChars}. Please try again with a shorter response.`;
+                        messages.push({
+                            role: 'assistant',
+                            content: [{ type: 'text', text: responseText }],
+                        });
+                        messages.push({
+                            role: 'user',
+                            content: [{ type: 'text', text: retryMessage }],
+                        });
+                    }
+                    else {
+                        if (saveResponse) {
+                            agent.addToConversationHistory(prompt, false);
+                            agent.addToConversationHistory(responseText, true);
+                        }
+                        return responseText;
+                    }
+                }
+            }
+            catch (apiError) {
+                lastError = apiError;
+                console.error(`API call attempt ${attempt}/${maxRetries} failed:`, apiError);
+                if (attempt < maxRetries) {
+                    await new Promise((resolve) => setTimeout(resolve, 1000 * attempt));
+                }
+            }
+        }
+        throw new Error(`Failed to get valid response after ${maxRetries} attempts. Last error: ${lastError?.message || 'Unknown error'}`);
+    }
+    computeMessageCost(agent, usage) {
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName}`);
+            return 0;
+        }
+        const cacheCreationTokens = usage.cache_creation_input_tokens || 0;
+        const cacheReadTokens = usage.cache_read_input_tokens || 0;
+        const standardInputTokens = usage.input_tokens || 0;
+        const outputTokens = usage.output_tokens || 0;
+        const standardCost = standardInputTokens * modelInfo.input_cost_per_token;
+        const cacheCreationCost = cacheCreationTokens *
+            (modelInfo.cache_creation_input_token_cost || modelInfo.input_cost_per_token * 1.25);
+        const cacheReadCost = cacheReadTokens *
+            (modelInfo.cache_read_input_token_cost || modelInfo.input_cost_per_token * 0.1);
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = standardCost + cacheCreationCost + cacheReadCost + outputCost + markup;
+        agent.totalInputTokens += standardInputTokens + cacheCreationTokens + cacheReadTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for ${agent.agentName} message: ${cost.toFixed(4)}, markup: ${markup.toFixed(4)}`);
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+        if (cacheCreationTokens > 0 || cacheReadTokens > 0) {
+            console.log(`Cache metrics for ${agent.agentName}: creation=${cacheCreationTokens}, read=${cacheReadTokens}, standard=${standardInputTokens}`);
+        }
+    }
+};
+exports.AnthropicAiService = AnthropicAiService;
+exports.AnthropicAiService = AnthropicAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], AnthropicAiService);

package/dist/ai/LLM/base-ai.service.d.ts

@@ -0,0 +1,45 @@
+import { Agent } from '../agent';
+import { ConfigurationService } from '../../config/configuration.service';
+import { ArtifactService } from '../artifact.service';
+import { AgentStoreService } from '../agent-store.service';
+import { BalanceService } from '../../app/balance.service';
+import { ModelInfo } from '@shared/types/app.types';
+export interface ImageGenerationOptions {
+    model?: string;
+    size?: '1024x1024' | '1536x1024' | '1024x1536' | 'auto';
+    quality?: 'auto' | 'high' | 'medium' | 'low';
+    format?: 'png' | 'jpeg' | 'webp';
+}
+export declare class BaseAiService {
+    protected modelsCache: ModelInfo[];
+    protected _isAvailable: boolean;
+    constructor();
+    get isAvailable(): boolean;
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    supportsPromptCaching(): boolean;
+    getCacheConfig(_agent: Agent, _cacheMessage: boolean): any;
+    stripQuotes(quotedText: string): string;
+    protected findPromptFile(agent: Agent, fileName: string, extension: string): string | null;
+    getPreparedPrompt(agent: Agent, promptFileName: string, variables: any): string;
+    protected getPreparedSchema(agent: Agent, promptFileName: string): any;
+    listModels(): Promise<ModelInfo[]>;
+    protected fetchModelsFromApi(): Promise<ModelInfo[]>;
+    createAgent(configService: ConfigurationService, agentStoreService: AgentStoreService, balanceService: BalanceService, artifactService: ArtifactService, agentName: string, agentNickname: string, description: string, promptFolder: string, modelName: string, storageDir?: string): Agent;
+    textPrompt(agent: Agent, prompt: string, _jsonSchema?: any, _saveResponse?: boolean, _promptInstructions?: string, _cacheConfig?: any, _maxOutputChars?: number): Promise<any>;
+    generateImage(_agent: Agent, _prompt: string, _width: number, _height: number, _quality: string, _referenceImageArtifactIds?: string[], _options?: ImageGenerationOptions): Promise<{
+        artifactId?: string;
+        error?: any;
+    }>;
+    protected loadReferenceImages(agent: Agent, artifactIds: string[]): Promise<File[]>;
+    protected saveImageAsArtifact(agent: Agent, base64Data: string, prompt: string): Promise<string>;
+    preparedPrompt(agent: Agent, promptFileName: string, variables: any, saveResponse?: boolean, cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    instructedPrompt(agent: Agent, prompt: string, instructionFileName: string, variables: any, saveResponse?: boolean, cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    attachDocument(agent: Agent, fileName: string, fileData: Uint8Array): Promise<string>;
+    finishAgent(_agent: Agent): Promise<void>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean, developer?: boolean): void;
+    formatMessage(message: any): string;
+    trimResponseText(str: string): string;
+    trimToJson(str: string): string;
+    sanitizeJsonString(str: string): string;
+}