briyah 1.0.0

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

@@ -0,0 +1,271 @@
+"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.GoogleAiService = void 0;
+const common_1 = require("@nestjs/common");
+const genai_1 = require("@google/genai");
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let GoogleAiService = class GoogleAiService extends base_ai_service_1.BaseAiService {
+    googleAI = null;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['GOOGLE_GENAI_API_KEY'];
+            if (!apiKey) {
+                console.warn('GOOGLE_GENAI_API_KEY environment variable not set. Google AI service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            this.googleAI = new genai_1.GoogleGenAI({ apiKey });
+        }
+        catch (error) {
+            console.error('Error initializing Google AI service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'GoogleAI';
+    }
+    supportsImageGeneration() {
+        return true;
+    }
+    supportsPromptCaching() {
+        return false;
+    }
+    async fetchModelsFromApi() {
+        try {
+            const response = await this.googleAI.models.list();
+            return response.page.map((model) => {
+                const name = model.name.replace('models/', '');
+                return {
+                    name: name,
+                    description: name,
+                    model: name,
+                    service: 'GoogleAI',
+                };
+            });
+        }
+        catch (error) {
+            console.warn('Could not fetch models from Google AI API, using fallback list:', error.message);
+        }
+    }
+    addToConversationHistory(agent, message, fromSelf = false) {
+        if (!agent.history) {
+            agent.history = [];
+        }
+        if (!message)
+            return;
+        agent.history.push({
+            role: fromSelf ? 'model' : 'user',
+            parts: [{ text: 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 messages = [{ role: 'user', parts: [{ text: 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',
+                        parts: [{ text: `Attached file "${file.fileName}":\n\n${textContent}` }],
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({
+                role: 'user',
+                parts: [{ text: prompt }],
+            });
+        }
+        const generationConfig = {
+            maxOutputTokens: 8192,
+            temperature: 0,
+        };
+        if (jsonSchema) {
+            generationConfig.responseMimeType = 'application/json';
+            const { name: _name, description: _description, ...schemaOnly } = jsonSchema;
+            generationConfig.responseSchema = schemaOnly;
+        }
+        const instructions = promptInstructions || agent.systemInstruction;
+        let responseText;
+        try {
+            const response = await this.googleAI.models.generateContent({
+                model: agent.modelName,
+                contents: messages,
+                config: {
+                    systemInstruction: instructions,
+                    ...generationConfig,
+                },
+            });
+            if (response.text) {
+                responseText = response.text;
+            }
+            else if (response.candidates?.[0]?.content?.parts?.[0]?.text) {
+                responseText = response.candidates[0].content.parts[0].text;
+            }
+            else {
+                responseText = '';
+            }
+            if (jsonSchema) {
+                responseText = this.trimToJson(responseText);
+                responseText = this.sanitizeJsonString(responseText);
+            }
+            else {
+                responseText = this.trimResponseText(responseText);
+            }
+            if (response.usageMetadata) {
+                this.computeMessageCost(agent, response.usageMetadata);
+            }
+        }
+        catch (error) {
+            console.error('Error calling Google AI:', error);
+            throw error;
+        }
+        if (saveResponse) {
+            this.addToConversationHistory(agent, prompt, false);
+            this.addToConversationHistory(agent, responseText, true);
+        }
+        if (jsonSchema) {
+            return JSON.parse(responseText);
+        }
+        return responseText;
+    }
+    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 {
+            const modelName = agent.modelName;
+            let aspectRatio = '1:1';
+            if (width && height) {
+                const ratio = width / height;
+                if (ratio > 1.4)
+                    aspectRatio = '16:9';
+                else if (ratio > 1.2)
+                    aspectRatio = '3:2';
+                else if (ratio < 0.7)
+                    aspectRatio = '9:16';
+                else if (ratio < 0.8)
+                    aspectRatio = '2:3';
+            }
+            const config = {
+                numberOfImages: 1,
+                aspectRatio: aspectRatio,
+            };
+            if (quality && quality !== 'auto') {
+                config.outputOptions = {
+                    compressionQuality: quality === 'high' ? 90 : quality === 'medium' ? 70 : 50,
+                };
+            }
+            const response = await this.googleAI.models.generateImages({
+                model: modelName,
+                prompt: prompt,
+                config: config,
+            });
+            let base64Data;
+            if (response.generatedImages?.[0]?.image?.imageBytes) {
+                const imageBytes = response.generatedImages[0].image.imageBytes;
+                base64Data = Buffer.isBuffer(imageBytes)
+                    ? imageBytes.toString('base64')
+                    : imageBytes;
+            }
+            else {
+                throw new Error('No image data in response');
+            }
+            this.computeImageCost(agent, modelName);
+            const artifactId = await this.saveImageAsArtifact(agent, base64Data, prompt);
+            return { artifactId };
+        }
+        catch (error) {
+            console.error('Error generating image with Google AI:', error);
+            return { error };
+        }
+    }
+    computeMessageCost(agent, usage) {
+        const inputTokens = usage.promptTokenCount || 0;
+        const outputTokens = usage.candidatesTokenCount || 0;
+        const modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName}`);
+            return;
+        }
+        const inputCost = inputTokens * modelInfo.input_cost_per_token;
+        const outputCost = outputTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = inputCost + outputCost + markup;
+        agent.totalInputTokens += inputTokens;
+        agent.totalOutputTokens += outputTokens;
+        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, modelName) {
+        const modelInfo = model_prices_1.default[modelName];
+        if (!modelInfo || !modelInfo.output_cost_per_image) {
+            console.error(`No image price info found for model ${modelName}`);
+            return;
+        }
+        const outputCost = modelInfo.output_cost_per_image;
+        const markup = outputCost * 0;
+        const cost = 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);
+        }
+    }
+    formatMessage(message) {
+        if (!message) {
+            return 'No message';
+        }
+        if (message.role && message.parts) {
+            const parts = message.parts
+                .map((part) => {
+                if (part.text) {
+                    return part.text;
+                }
+                return JSON.stringify(part);
+            })
+                .join('\n');
+            return `${message.role}: ${parts}`;
+        }
+        return super.formatMessage(message);
+    }
+};
+exports.GoogleAiService = GoogleAiService;
+exports.GoogleAiService = GoogleAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], GoogleAiService);

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

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

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

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

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

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

@@ -0,0 +1,263 @@
+"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.GrokAiService = void 0;
+const common_1 = require("@nestjs/common");
+const openai_1 = require("openai");
+const openai_2 = require("openai");
+const base_ai_service_1 = require("./base-ai.service");
+const model_prices_1 = __importDefault(require("../model_prices"));
+const errors_1 = require("../../common/errors");
+let GrokAiService = class GrokAiService extends base_ai_service_1.BaseAiService {
+    openai;
+    constructor() {
+        super();
+        try {
+            const apiKey = process.env['XAI_API_KEY'];
+            if (!apiKey) {
+                console.warn('XAI_API_KEY environment variable not set. Grok service will not be available.');
+                this._isAvailable = false;
+                return;
+            }
+            const options = {
+                apiKey: apiKey,
+                baseURL: 'https://api.x.ai/v1',
+                timeout: 600000,
+                maxRetries: 3,
+            };
+            this.openai = new openai_1.OpenAI(options);
+        }
+        catch (error) {
+            console.error('Error initializing Grok service:', error);
+            this._isAvailable = false;
+        }
+    }
+    getServiceName() {
+        return 'Grok';
+    }
+    async fetchModelsFromApi() {
+        const models = await this.openai.models.list();
+        return models.data.map((model) => {
+            let name = model.id;
+            return {
+                name: name,
+                description: name,
+                model: name,
+                service: 'Grok',
+            };
+        });
+    }
+    async attachDocument(agent, fileName, fileData) {
+        if (agent.fullContextFiles) {
+            return super.attachDocument(agent, fileName, fileData);
+        }
+        const existingMetadata = agent.attachedFiles.find((f) => f.fileName === fileName && f.serviceMetadata?.serviceName === this.getServiceName());
+        if (existingMetadata?.serviceMetadata?.resourceId) {
+            const fileId = existingMetadata.serviceMetadata.resourceId;
+            return `File found with Grok file id: ${fileId}`;
+        }
+        let fileInput = fileData;
+        let fileToUpload = await (0, openai_2.toFile)(fileInput, fileName);
+        const fileObject = await this.openai.files.create({
+            file: fileToUpload,
+            purpose: 'assistants',
+        });
+        const additionalMetadata = {
+            serviceMetadata: {
+                serviceName: this.getServiceName(),
+                resourceId: fileObject.id,
+            },
+        };
+        const fileMetadataIndex = agent.attachedFiles.findIndex((f) => f.fileName === fileName);
+        if (fileMetadataIndex >= 0) {
+            agent.attachedFiles[fileMetadataIndex] = {
+                ...agent.attachedFiles[fileMetadataIndex],
+                ...additionalMetadata,
+            };
+        }
+        return `Uploaded file to Grok: ${fileName}`;
+    }
+    async finishAgent(agent) {
+        if (!agent)
+            return;
+        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 Grok file ${metadata.serviceMetadata.resourceId} for agent ${agent.id}`);
+                }
+                catch (error) {
+                    console.error(`Error deleting Grok 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 instructions = promptInstructions || agent.systemInstruction;
+        const messages = [];
+        if (instructions)
+            messages.push({
+                role: 'system',
+                content: [{ type: 'text', text: instructions }],
+            });
+        messages.push({
+            role: 'system',
+            content: [{ type: 'text', text: identity }],
+        });
+        if (agent.attachedFiles && agent.attachedFiles.length > 0) {
+            for (const file of agent.attachedFiles) {
+                if (file.serviceMetadata?.serviceName === this.getServiceName() &&
+                    file.serviceMetadata?.resourceId) {
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            {
+                                type: 'text',
+                                text: `File available for document_search: "${file.fileName}" (file_id: ${file.serviceMetadata.resourceId})`,
+                            },
+                            {
+                                type: 'file',
+                                file: { file_id: file.serviceMetadata.resourceId },
+                            },
+                        ],
+                    });
+                }
+                else {
+                    const fileData = new Uint8Array(file.serviceMetadata.fileData);
+                    const textContent = Buffer.from(fileData).toString('utf-8');
+                    messages.push({
+                        role: 'user',
+                        content: [
+                            { type: 'text', text: textContent },
+                        ],
+                    });
+                }
+            }
+        }
+        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: [
+                            {
+                                type: 'text',
+                                text: `Attached document: ${fileName}\n\n${content}`,
+                            },
+                        ],
+                    });
+                }
+            }
+        }
+        messages.push(...agent.history);
+        if (prompt) {
+            messages.push({
+                role: 'user',
+                content: [{ type: 'text', text: prompt }],
+            });
+        }
+        let responseText;
+        try {
+            let response = await this.openai.chat.completions.create({
+                model: agent.modelName,
+                messages: messages,
+                store: false,
+            });
+            for (const choice of response.choices) {
+                if (choice.message.content)
+                    responseText = choice.message.content;
+            }
+            if (jsonSchema) {
+                responseText = this.trimToJson(responseText);
+                responseText = this.sanitizeJsonString(responseText);
+            }
+            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;
+    }
+    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();
+    }
+    computeMessageCost(agent, usage) {
+        const totalPromptTokens = usage.prompt_tokens || 0;
+        const cachedTokens = usage.prompt_tokens_details?.cached_tokens || 0;
+        const uncachedPromptTokens = totalPromptTokens - cachedTokens;
+        const completionTokens = usage.completion_tokens || 0;
+        let modelInfo = model_prices_1.default[agent.modelName];
+        if (!modelInfo && !agent.modelName.startsWith('xai/')) {
+            modelInfo = model_prices_1.default[`xai/${agent.modelName}`];
+        }
+        if (!modelInfo) {
+            console.error(`No price info found for model ${agent.modelName} or xai/${agent.modelName}`);
+            return;
+        }
+        const uncachedCost = uncachedPromptTokens * modelInfo.input_cost_per_token;
+        const cachedCost = cachedTokens *
+            (modelInfo.cache_read_input_token_cost || modelInfo.input_cost_per_token * 0.25);
+        const outputCost = completionTokens * modelInfo.output_cost_per_token;
+        const markup = agent.disableMarkup ? 0 : outputCost * agent.markupRate;
+        const cost = uncachedCost + cachedCost + outputCost + markup;
+        agent.totalInputTokens += totalPromptTokens;
+        agent.totalOutputTokens += completionTokens;
+        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=${uncachedPromptTokens}`);
+        }
+        if (agent.balanceService && cost > 0) {
+            agent.balanceService.decrementBalance(cost, markup);
+        }
+    }
+};
+exports.GrokAiService = GrokAiService;
+exports.GrokAiService = GrokAiService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [])
+], GrokAiService);

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

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

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

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

@@ -0,0 +1,13 @@
+import { BaseAiService } from './base-ai.service';
+import { Agent } from '../agent';
+import { ModelInfo } from '@shared/types/app.types';
+export declare class MockAiService extends BaseAiService {
+    constructor();
+    getServiceName(): string;
+    protected fetchModelsFromApi(): Promise<ModelInfo[]>;
+    preparedPrompt(agent: Agent, promptFileName: string, variables: any, saveResponse?: boolean, _cacheConfig?: any): Promise<any>;
+    getMockFile(promptFileName: string, prompt: string, variables: any): string;
+    instructedPrompt(agent: Agent, prompt: string, promptFileName: string, variables?: any, saveResponse?: boolean, cacheConfig?: any): Promise<any>;
+    textPrompt(agent: Agent, prompt: string, jsonSchema?: any, saveResponse?: boolean, _promptInstructions?: string, _cacheConfig?: any, maxOutputChars?: number): Promise<any>;
+    private trackMockCosts;
+}