briyah 1.0.0

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

@@ -0,0 +1,194 @@
+"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);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockAiService = void 0;
+const common_1 = require("@nestjs/common");
+const base_ai_service_1 = require("./base-ai.service");
+const fs = __importStar(require("fs"));
+const model_prices_1 = __importDefault(require("../model_prices"));
+let MockAiService = class MockAiService extends base_ai_service_1.BaseAiService {
+    constructor() {
+        super();
+        this._isAvailable = true;
+    }
+    getServiceName() {
+        return 'Mock';
+    }
+    async fetchModelsFromApi() {
+        let name = 'mock-fast-v1';
+        return [
+            {
+                name: name,
+                description: name,
+                model: name,
+                service: 'Mock',
+            },
+        ];
+    }
+    async preparedPrompt(agent, promptFileName, variables, saveResponse = true, _cacheConfig = null) {
+        const mockFile = this.findPromptFile(agent, promptFileName, '.mock');
+        if (!mockFile) {
+            console.warn(`Mock file '${promptFileName}.mock' not found for agent '${agent.agentName}'. Using generic response.`);
+            const preparedPrompt = this.getPreparedPrompt(agent, promptFileName, variables);
+            const jsonSchema = this.getPreparedSchema(agent, promptFileName);
+            return this.textPrompt(agent, preparedPrompt, jsonSchema, saveResponse);
+        }
+        const mockResponse = fs.readFileSync(mockFile).toString('utf8');
+        const jsonSchema = this.getPreparedSchema(agent, promptFileName);
+        const preparedPrompt = this.getPreparedPrompt(agent, promptFileName, variables);
+        await this.trackMockCosts(agent, preparedPrompt, mockResponse);
+        if (jsonSchema) {
+            try {
+                const parsedResponse = JSON.parse(mockResponse);
+                if (saveResponse) {
+                    agent.addToConversationHistory(preparedPrompt, false);
+                    agent.addToConversationHistory(mockResponse, true);
+                }
+                return parsedResponse;
+            }
+            catch (error) {
+                console.error(`Error parsing mock JSON response from ${mockFile}:`, error);
+                throw new Error(`Invalid JSON in mock file: ${mockFile}`);
+            }
+        }
+        else {
+            if (saveResponse) {
+                agent.addToConversationHistory(preparedPrompt, false);
+                agent.addToConversationHistory(mockResponse, true);
+            }
+            return mockResponse;
+        }
+    }
+    getMockFile(promptFileName, prompt, variables) {
+        let mockFileName = promptFileName;
+        if (promptFileName === 'moderate') {
+            const senderMatch = prompt.match(/^Sender:\s*(.*)$/m);
+            const sender = senderMatch ? senderMatch[1].trim() : null;
+            const targetMatch = prompt.match(/, \s(.*)\?/m);
+            const target = targetMatch ? targetMatch[1].trim() : null;
+            const agents = variables.agents;
+            const targetAgent = agents.find((agent) => agent.agentName === target);
+            if (targetAgent)
+                mockFileName = `moderate_to_${targetAgent.agentName}`;
+            else if (sender === variables.humanAgentName || sender === 'system')
+                mockFileName = 'moderate';
+            else
+                mockFileName = 'moderate_to_alice';
+        }
+        return mockFileName;
+    }
+    async instructedPrompt(agent, prompt = null, promptFileName, variables = {}, saveResponse = true, cacheConfig = null) {
+        const mockFileBaseName = this.getMockFile(promptFileName, prompt, variables);
+        const mockFile = this.findPromptFile(agent, mockFileBaseName, '.mock');
+        if (!mockFile) {
+            console.warn(`Mock file '${mockFile}' not found for agent '${agent.agentName}'. Using generic response.`);
+            return this.textPrompt(agent, prompt || 'Mock prompt', null, saveResponse, cacheConfig);
+        }
+        const mockResponse = fs.readFileSync(mockFile).toString('utf8');
+        const jsonSchema = this.getPreparedSchema(agent, promptFileName);
+        await this.trackMockCosts(agent, prompt || mockResponse, mockResponse);
+        if (jsonSchema) {
+            try {
+                const parsedResponse = JSON.parse(mockResponse);
+                if (saveResponse) {
+                    agent.addToConversationHistory(prompt || 'Mock prompt', false);
+                    agent.addToConversationHistory(mockResponse, true);
+                }
+                return parsedResponse;
+            }
+            catch (error) {
+                console.error(`Error parsing mock JSON response from ${mockFile}:`, error);
+                throw new Error(`Invalid JSON in mock file: ${mockFile}`);
+            }
+        }
+        else {
+            if (saveResponse) {
+                agent.addToConversationHistory(prompt || 'Mock prompt', false);
+                agent.addToConversationHistory(mockResponse, true);
+            }
+            return mockResponse;
+        }
+    }
+    async textPrompt(agent, prompt, jsonSchema = null, saveResponse = true, _promptInstructions = null, _cacheConfig = null, maxOutputChars = 0) {
+        const mockResponse = jsonSchema
+            ? { action: 'SPEAK', content: 'Generic mock response' }
+            : 'Generic mock response';
+        const responseText = typeof mockResponse === 'string' ? mockResponse : JSON.stringify(mockResponse, null, 2);
+        await this.trackMockCosts(agent, prompt, responseText);
+        if (saveResponse) {
+            agent.addToConversationHistory(prompt, false);
+            agent.addToConversationHistory(responseText, true);
+        }
+        return mockResponse;
+    }
+    async trackMockCosts(agent, prompt, response) {
+        const inputTokens = Math.max(100, Math.floor(prompt.length / 4));
+        const outputTokens = Math.max(50, Math.floor(response.length / 4));
+        const modelInfo = model_prices_1.default['mock-fast-v1'];
+        if (!modelInfo) {
+            console.warn('Mock model pricing not found in model_prices.ts');
+            return;
+        }
+        const inputCost = inputTokens * modelInfo.input_cost_per_token;
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = outputCost * agent.markupRate;
+        const totalCost = inputCost + outputCost + markup;
+        agent.totalCost += totalCost;
+        agent.totalInputTokens += inputTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalMarkup += markup;
+        console.log(`Cost for ${agent.agentName} message: ${totalCost} (markup: ${markup.toFixed(4)})`);
+        if (agent.balanceService) {
+            await agent.balanceService.decrementBalance(totalCost, markup);
+        }
+    }
+};
+exports.MockAiService = MockAiService;
+exports.MockAiService = MockAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], MockAiService);

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

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

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

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

@@ -0,0 +1,21 @@
+import { Agent } from '../agent';
+import { BaseAiService } from './base-ai.service';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class OpenAiService extends BaseAiService {
+    private openai;
+    constructor();
+    getServiceName(): string;
+    supportsImageGeneration(): boolean;
+    supportsPromptCaching(): boolean;
+    fetchModelsFromApi(): Promise<ModelInfo[]>;
+    finishAgent(agent: Agent): Promise<void>;
+    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>;
+    addToConversationHistory(agent: Agent, message: string, fromSelf?: boolean, developer?: boolean): void;
+    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/openai.service.js

@@ -0,0 +1,421 @@
+"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.OpenAiService = void 0;
+const common_1 = require("@nestjs/common");
+const openai_1 = require("openai");
+const base_ai_service_1 = require("./base-ai.service");
+const openai_2 = require("openai");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let OpenAiService = class OpenAiService extends base_ai_service_1.BaseAiService {
+    openai;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['OPENAI_API_KEY'];
+            if (!apiKey) {
+                console.warn('OPENAI_API_KEY environment variable not set. OpenAI service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            const options = {
+                apiKey: apiKey,
+                timeout: 600000,
+                maxRetries: 3,
+            };
+            if (process.env.OPENAI_ORGANIZATION_ID) {
+                options.organization = process.env.OPENAI_ORGANIZATION_ID;
+            }
+            this.openai = new openai_2.OpenAI(options);
+        }
+        catch (error) {
+            console.error('Error initializing OpenAI service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'OpenAI';
+    }
+    supportsImageGeneration() {
+        return true;
+    }
+    supportsPromptCaching() {
+        return false;
+    }
+    async fetchModelsFromApi() {
+        const models = await this.openai.models.list();
+        return models.data.map((model) => {
+            return {
+                name: model.id,
+                description: model.id,
+                model: model.id,
+                service: 'OpenAI',
+            };
+        });
+    }
+    async finishAgent(agent) {
+        if (!agent)
+            return;
+        if (agent.vectorStore) {
+            try {
+                await this.openai.vectorStores.delete(agent.vectorStore.id);
+                console.log(`Deleted vector store for agent ${agent.id}`);
+            }
+            catch (error) {
+                console.error(`Error deleting vector store for agent ${agent.id}:`, error);
+            }
+        }
+        for (const metadata of agent.attachedFiles) {
+            if (metadata.serviceMetadata?.serviceName === this.getServiceName() &&
+                metadata.serviceMetadata?.resourceId) {
+                try {
+                    await this.openai.files.delete(metadata.serviceMetadata.resourceId);
+                    console.log(`Deleted OpenAI file ${metadata.serviceMetadata.resourceId} for agent ${agent.id}`);
+                }
+                catch (error) {
+                    console.error(`Error deleting OpenAI file ${metadata.serviceMetadata.resourceId}:`, error);
+                }
+            }
+        }
+    }
+    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 messages = [{ role: 'user', content: identity }];
+        let hasVectorStoreFiles = false;
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.serviceName === this.getServiceName() &&
+                    file.serviceMetadata?.resourceId) {
+                    hasVectorStoreFiles = true;
+                }
+                else if (file.serviceMetadata?.fileData) {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    messages.push({
+                        role: 'user',
+                        content: `File "${file.fileName}":\n\n${textContent}`,
+                    });
+                }
+            }
+            if (hasVectorStoreFiles) {
+                const vectorStoreFileNames = agent.attachedFiles
+                    .filter((f) => f.serviceMetadata?.serviceName === this.getServiceName() &&
+                    f.serviceMetadata?.resourceId)
+                    .map((f) => f.fileName)
+                    .join(', ');
+                messages.push({
+                    role: 'user',
+                    content: `The following files are available in your vector store and can be searched using the file_search tool: ${vectorStoreFileNames}`,
+                });
+            }
+        }
+        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',
+                        content: `Attached document: ${fileName}\n\n${content}`,
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({ role: 'user', content: prompt });
+        }
+        let vectorStore = agent.vectorStore;
+        let tools = [];
+        if (vectorStore && hasVectorStoreFiles) {
+            tools.push({
+                type: 'file_search',
+                vector_store_ids: [vectorStore.id],
+            });
+        }
+        let format = jsonSchema
+            ? {
+                type: 'json_schema',
+                name: jsonSchema['name'],
+                schema: jsonSchema,
+                description: jsonSchema['description'],
+            }
+            : {
+                type: 'text',
+            };
+        let instructions = promptInstructions || agent.systemInstruction;
+        let response = null;
+        let responseText;
+        try {
+            response = await this.openai.responses.create({
+                model: agent.modelName,
+                reasoning: { effort: agent.reasoningEffort },
+                input: messages,
+                instructions: instructions,
+                store: false,
+                text: {
+                    format: format,
+                },
+                tools: tools,
+            });
+            if (jsonSchema) {
+                responseText = this.trimToJson(response.output_text);
+                responseText = this.sanitizeJsonString(responseText);
+            }
+            else {
+                responseText = response.output_text;
+            }
+            if (response.usage) {
+                this.computeMessageCost(agent, response.usage);
+            }
+        }
+        catch (error) {
+            console.error(error);
+            throw error;
+        }
+        if (saveResponse) {
+            this.addToConversationHistory(agent, prompt, false);
+            this.addToConversationHistory(agent, responseText, true);
+        }
+        if (jsonSchema)
+            return JSON.parse(responseText);
+        return responseText;
+    }
+    async attachDocument(agent, fileName, fileData) {
+        if (agent.fullContextFiles) {
+            return super.attachDocument(agent, fileName, fileData);
+        }
+        let resultText = '';
+        let vectorStore = agent.vectorStore;
+        if (!agent.vectorStore) {
+            try {
+                let vectorStoresPage = await this.openai.vectorStores.list();
+                let vectorStoreList = vectorStoresPage.data;
+                let foundVs = vectorStoreList.find((vs) => vs.name === agent.agentName);
+                if (!foundVs || foundVs.status === 'expired') {
+                    agent.vectorStore = await this.openai.vectorStores.create({
+                        name: agent.agentName,
+                        expires_after: { anchor: 'last_active_at', days: 1 },
+                    });
+                    resultText += `Created new vector store (${agent.agentName}). `;
+                }
+                else {
+                    agent.vectorStore = foundVs;
+                    resultText += `Found existing vector store (${agent.agentName}). `;
+                }
+            }
+            catch (error) {
+                agent.vectorStore = null;
+            }
+            vectorStore = agent.vectorStore;
+        }
+        if (!vectorStore)
+            throw new Error('No vector store could be created for this agent.');
+        const existingMetadata = agent.attachedFiles.find((f) => f.fileName === fileName && f.serviceMetadata?.serviceName === this.getServiceName());
+        if (existingMetadata?.serviceMetadata?.resourceId) {
+            const fileId = existingMetadata.serviceMetadata.resourceId;
+            const vectorStoresFilePage = await this.openai.vectorStores.files.list(vectorStore.id);
+            let vectorStoresFiles = vectorStoresFilePage.data;
+            let vectorStoresFileFound = vectorStoresFiles.find((f) => f.id === fileId);
+            if (vectorStoresFileFound) {
+                return (resultText +
+                    ` -- File found in vector store ${vectorStore.name} with file id: ${fileId}`);
+            }
+            else {
+                await this.openai.vectorStores.files.createAndPoll(vectorStore.id, {
+                    file_id: fileId,
+                });
+                return (resultText +
+                    ` -- Adding existing file to vector store ${vectorStore.name} with file id: ${fileId}`);
+            }
+        }
+        let fileInput = fileData;
+        let fileToUpload = await (0, openai_1.toFile)(fileInput, fileName);
+        const fileObject = await this.openai.files.create({
+            file: fileToUpload,
+            purpose: 'assistants',
+        });
+        await this.openai.vectorStores.files.createAndPoll(vectorStore.id, {
+            file_id: fileObject.id,
+        });
+        const additionalMetadata = {
+            serviceMetadata: {
+                serviceName: this.getServiceName(),
+                resourceId: fileObject.id,
+                vectorStoreId: vectorStore.id,
+            },
+        };
+        const fileMetadataIndex = agent.attachedFiles.findIndex((f) => f.fileName === fileName);
+        if (fileMetadataIndex >= 0) {
+            agent.attachedFiles[fileMetadataIndex] = {
+                ...agent.attachedFiles[fileMetadataIndex],
+                ...additionalMetadata,
+            };
+        }
+        return (resultText +
+            ` -- Uploaded new file to vector store ${vectorStore.name} with file id: ${fileObject.id}`);
+    }
+    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();
+    }
+    computeMessageCost(agent, usage) {
+        const totalInputTokens = usage.input_tokens || 0;
+        const cachedTokens = usage.input_tokens_details?.cached_tokens || 0;
+        const uncachedInputTokens = totalInputTokens - cachedTokens;
+        const outputTokens = usage.output_tokens || 0;
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName}`);
+            return;
+        }
+        const uncachedCost = uncachedInputTokens * modelInfo.input_cost_per_token;
+        const cachedCost = cachedTokens *
+            (modelInfo.cache_read_input_token_cost || modelInfo.input_cost_per_token * 0.5);
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = uncachedCost + cachedCost + outputCost + markup;
+        agent.totalInputTokens += totalInputTokens;
+        agent.totalOutputTokens += outputTokens;
+        agent.totalCost += cost;
+        agent.totalMarkup += markup;
+        console.log(`Cost for ${agent.agentName} message: ${cost} (markup: ${markup.toFixed(4)})`);
+        if (cachedTokens > 0) {
+            console.log(`Cache metrics for ${agent.agentName}: cached=${cachedTokens}, uncached=${uncachedInputTokens}`);
+        }
+        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) {
+            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;
+            const size = `${width}x${height}`;
+            if (referenceImageArtifactIds && referenceImageArtifactIds.length > 0) {
+                const referenceImages = await this.loadReferenceImages(agent, referenceImageArtifactIds);
+                imageResponse = await this.openai.images.edit({
+                    model: agent.modelName,
+                    prompt: prompt,
+                    image: referenceImages.length === 1 ? referenceImages[0] : referenceImages,
+                    size: size,
+                    n: 1,
+                });
+            }
+            else {
+                imageResponse = await this.openai.images.generate({
+                    model: agent.modelName,
+                    prompt: prompt,
+                    n: 1,
+                    size: size,
+                    quality: quality || 'auto',
+                    moderation: 'low',
+                });
+            }
+            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);
+            console.log(prompt);
+            return { error };
+        }
+    }
+};
+exports.OpenAiService = OpenAiService;
+exports.OpenAiService = OpenAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], OpenAiService);

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

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