briyah 1.0.0

package/dist/sdk/briyah-config.d.ts

@@ -0,0 +1,13 @@
+import { IConfigService } from '../app/user-service-manager';
+export interface BriyahConfigOptions {
+    dataPath?: string;
+    userServiceCacheTimeoutMinutes?: number;
+    startingBalance?: number;
+    envOverrides?: Record<string, string>;
+}
+export declare class BriyahConfigService implements IConfigService {
+    private env;
+    constructor(options?: BriyahConfigOptions);
+    get<T = string>(key: string, defaultValue?: T): T;
+    getAll(): Record<string, string>;
+}

package/dist/sdk/briyah-config.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BriyahConfigService = void 0;
+class BriyahConfigService {
+    env;
+    constructor(options) {
+        this.env = {
+            ...process.env,
+            ...(options?.envOverrides || {}),
+        };
+        if (options?.dataPath) {
+            this.env.SERVER_DATA_PATH = options.dataPath;
+        }
+        if (options?.userServiceCacheTimeoutMinutes !== undefined) {
+            this.env.USER_SERVICE_CACHE_TIMEOUT_MINUTES = String(options.userServiceCacheTimeoutMinutes);
+        }
+        if (options?.startingBalance !== undefined) {
+            this.env.STARTING_BALANCE = String(options.startingBalance);
+        }
+    }
+    get(key, defaultValue) {
+        const value = this.env[key];
+        if (value === undefined) {
+            return defaultValue;
+        }
+        return value;
+    }
+    getAll() {
+        return { ...this.env };
+    }
+}
+exports.BriyahConfigService = BriyahConfigService;

package/dist/sdk/briyah.d.ts

@@ -0,0 +1,36 @@
+import { AiFactoryService } from '../ai/ai-factory.service';
+import { PublishedAgentsService } from '../ai/published-agents.service';
+import { BriyahConfigService, BriyahConfigOptions } from './briyah-config';
+import { AppService } from '../app.service';
+export declare class Briyah {
+    private configService;
+    private aiFactoryService;
+    private agentMessageService;
+    private roomMessageService;
+    private storyProgressService;
+    private storyMessageService;
+    private publishedAgentsService;
+    private publishedRoomsService;
+    private balanceMessageService;
+    private userServiceFactory;
+    private userServiceManager;
+    private initialized;
+    constructor(options?: BriyahConfigOptions);
+    private validateEnvironment;
+    private initializeSingletons;
+    init(): Promise<void>;
+    getAppService(userId: string): AppService;
+    removeUserService(userId: string): void;
+    getCacheStats(): {
+        cachedUsers: number;
+        users: {
+            userId: string;
+            ageMinutes: number;
+        }[];
+    };
+    shutdown(): Promise<void>;
+    isInitialized(): boolean;
+    getConfigService(): BriyahConfigService;
+    getAiFactoryService(): AiFactoryService;
+    getPublishedAgentsService(): PublishedAgentsService;
+}

package/dist/sdk/briyah.js

@@ -0,0 +1,122 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Briyah = void 0;
+const ai_factory_service_1 = require("../ai/ai-factory.service");
+const openai_service_1 = require("../ai/LLM/openai.service");
+const anthropic_service_1 = require("../ai/LLM/anthropic.service");
+const vertexai_service_1 = require("../ai/LLM/vertexai.service");
+const grok_service_1 = require("../ai/LLM/grok.service");
+const deepseek_service_1 = require("../ai/LLM/deepseek.service");
+const together_service_1 = require("../ai/LLM/together.service");
+const mock_service_1 = require("../ai/LLM/mock.service");
+const googleai_service_1 = require("../ai/LLM/googleai.service");
+const agent_message_service_1 = require("../ai/agent-message.service");
+const room_message_service_1 = require("../room/room-message.service");
+const story_progress_service_1 = require("../story/story-progress.service");
+const story_message_service_1 = require("../story/story-message.service");
+const published_agents_service_1 = require("../ai/published-agents.service");
+const published_rooms_service_1 = require("../room/published-rooms.service");
+const balance_message_service_1 = require("../app/balance-message.service");
+const user_service_manager_1 = require("../app/user-service-manager");
+const user_service_factory_1 = require("../app/user-service-factory");
+const briyah_config_1 = require("./briyah-config");
+const fal_service_1 = require("../ai/LLM/fal.service");
+class Briyah {
+    configService;
+    aiFactoryService;
+    agentMessageService;
+    roomMessageService;
+    storyProgressService;
+    storyMessageService;
+    publishedAgentsService;
+    publishedRoomsService;
+    balanceMessageService;
+    userServiceFactory;
+    userServiceManager;
+    initialized = false;
+    constructor(options) {
+        this.configService = new briyah_config_1.BriyahConfigService(options);
+        this.validateEnvironment();
+        this.initializeSingletons(options?.dataPath);
+    }
+    validateEnvironment() {
+        const hasAnyProvider = this.configService.get('ANTHROPIC_API_KEY') ||
+            this.configService.get('OPENAI_API_KEY') ||
+            this.configService.get('GOOGLE_VERTEX_PROJECT_ID') ||
+            this.configService.get('XAI_API_KEY') ||
+            this.configService.get('DEEPSEEK_API_KEY') ||
+            this.configService.get('TOGETHER_API_KEY');
+        this.configService.get('FAL_API_KEY');
+        if (!hasAnyProvider) {
+            console.warn('[Briyah] No LLM provider API keys configured. Some features will not be available.');
+            console.warn('[Briyah] Set one or more of: ANTHROPIC_API_KEY, OPENAI_API_KEY, GOOGLE_VERTEX_PROJECT_ID, XAI_API_KEY, DEEPSEEK_API_KEY, TOGETHER_API_KEY');
+        }
+        const startingBalance = this.configService.get('STARTING_BALANCE');
+        if (!startingBalance) {
+            throw new Error('[Briyah] STARTING_BALANCE environment variable is required');
+        }
+    }
+    initializeSingletons(_baseDataPath) {
+        const openAiService = new openai_service_1.OpenAiService();
+        const anthropicService = new anthropic_service_1.AnthropicAiService();
+        const vertexService = new vertexai_service_1.VertexAiService();
+        const grokService = new grok_service_1.GrokAiService();
+        const deepseekService = new deepseek_service_1.DeepSeekAiService();
+        const togetherService = new together_service_1.TogetherAiService();
+        const mockService = new mock_service_1.MockAiService();
+        const googleAiService = new googleai_service_1.GoogleAiService();
+        const falAiService = new fal_service_1.FalAiService();
+        this.aiFactoryService = new ai_factory_service_1.AiFactoryService(openAiService, grokService, vertexService, anthropicService, deepseekService, togetherService, mockService, googleAiService, falAiService);
+        this.agentMessageService = new agent_message_service_1.AgentMessageService();
+        this.roomMessageService = new room_message_service_1.RoomMessageService();
+        this.storyProgressService = new story_progress_service_1.StoryProgressService();
+        this.storyMessageService = new story_message_service_1.StoryMessageService();
+        this.balanceMessageService = new balance_message_service_1.BalanceMessageService();
+        this.publishedAgentsService = new published_agents_service_1.PublishedAgentsService();
+        this.publishedRoomsService = new published_rooms_service_1.PublishedRoomsService();
+        this.userServiceFactory = new user_service_factory_1.UserServiceFactory(this.aiFactoryService, this.agentMessageService, this.roomMessageService, this.storyProgressService, this.storyMessageService, this.publishedAgentsService, this.publishedRoomsService, this.balanceMessageService);
+        this.userServiceManager = new user_service_manager_1.UserServiceManager(this.userServiceFactory, this.configService);
+    }
+    async init() {
+        if (this.initialized) {
+            console.warn('[Briyah] Already initialized');
+            return;
+        }
+        this.publishedAgentsService.onModuleInit();
+        this.userServiceManager.onModuleInit();
+        this.initialized = true;
+    }
+    getAppService(userId) {
+        if (!this.initialized) {
+            throw new Error('[Briyah] Must call init() before getAppService()');
+        }
+        return this.userServiceManager.getAppService(userId);
+    }
+    removeUserService(userId) {
+        this.userServiceManager.removeUserService(userId);
+    }
+    getCacheStats() {
+        return this.userServiceManager.getCacheStats();
+    }
+    async shutdown() {
+        if (!this.initialized) {
+            return;
+        }
+        this.userServiceManager.onModuleDestroy();
+        this.initialized = false;
+        console.log('[Briyah] Shutdown complete');
+    }
+    isInitialized() {
+        return this.initialized;
+    }
+    getConfigService() {
+        return this.configService;
+    }
+    getAiFactoryService() {
+        return this.aiFactoryService;
+    }
+    getPublishedAgentsService() {
+        return this.publishedAgentsService;
+    }
+}
+exports.Briyah = Briyah;

package/dist/sdk/index.d.ts

@@ -0,0 +1,6 @@
+export { Briyah } from './briyah';
+export { BriyahConfigService, BriyahConfigOptions } from './briyah-config';
+export type { AppService } from '../app.service';
+export type { AgentInfo, CreateAgentResponse, RoomInfo, RoomDetails, CreateRoomResponse, StoryInfo, CreateStoryResponse, ProcessTextResponse, FileList, PromptFileContent, AttachDocumentResponse, AgentMessagesResponse, RoomMessagesResponse, StoryState, Message, MessageAction, } from '@shared/types/app.types';
+export { Agent } from '../ai/agent';
+export { Room } from '../room/room';

package/dist/sdk/index.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Room = exports.Agent = exports.BriyahConfigService = exports.Briyah = void 0;
+var briyah_1 = require("./briyah");
+Object.defineProperty(exports, "Briyah", { enumerable: true, get: function () { return briyah_1.Briyah; } });
+var briyah_config_1 = require("./briyah-config");
+Object.defineProperty(exports, "BriyahConfigService", { enumerable: true, get: function () { return briyah_config_1.BriyahConfigService; } });
+var agent_1 = require("../ai/agent");
+Object.defineProperty(exports, "Agent", { enumerable: true, get: function () { return agent_1.Agent; } });
+var room_1 = require("../room/room");
+Object.defineProperty(exports, "Room", { enumerable: true, get: function () { return room_1.Room; } });

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

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

package/dist/server/src/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/server/src/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/server/src/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/server/src/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;
+}