briyah 1.1.8 → 1.2.1

package/dist-sdk/server/src/ai/LLM/openai.service.js

@@ -161,20 +161,20 @@ let OpenAiService = class OpenAiService extends base_ai_service_1.BaseAiService
                 type: 'text',
             };
         let instructions = promptInstructions || agent.systemInstruction;
+        const requestParams = {
+            model: agent.modelName,
+            reasoning: { effort: agent.reasoningEffort },
+            input: messages,
+            instructions: instructions,
+            store: false,
+            text: { format: format },
+            tools: tools,
+        };
+        this.debugLogRequest(agent.agentName, requestParams);
         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,
-            });
+            response = await this.openai.responses.create(requestParams);
             if (jsonSchema) {
                 responseText = this.trimToJson(response.output_text);
                 responseText = this.sanitizeJsonString(responseText);
@@ -182,6 +182,7 @@ let OpenAiService = class OpenAiService extends base_ai_service_1.BaseAiService
             else {
                 responseText = response.output_text;
             }
+            this.debugLogResponse(agent.agentName, responseText);
             if (response.usage) {
                 this.computeMessageCost(agent, response.usage);
             }

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

@@ -120,14 +120,16 @@ let TogetherAiService = class TogetherAiService extends base_ai_service_1.BaseAi
                 },
             }
             : undefined;
+        const requestParams = {
+            model: agent.modelName,
+            messages: messages,
+            temperature: 0,
+            response_format: responseFormat,
+        };
+        this.debugLogRequest(agent.agentName, requestParams);
         let responseText;
         try {
-            const response = await this.togetherClient.chat.completions.create({
-                model: agent.modelName,
-                messages: messages,
-                temperature: 0,
-                response_format: responseFormat,
-            });
+            const response = await this.togetherClient.chat.completions.create(requestParams);
             if (response.choices && response.choices[0]?.message?.content) {
                 responseText = response.choices[0].message.content;
             }
@@ -141,6 +143,7 @@ let TogetherAiService = class TogetherAiService extends base_ai_service_1.BaseAi
             else {
                 responseText = this.trimResponseText(responseText);
             }
+            this.debugLogResponse(agent.agentName, responseText);
             if (response.usage) {
                 this.computeMessageCost(agent, response.usage);
             }

package/dist-sdk/server/src/ai/agent-factory.d.ts

@@ -1,15 +1,17 @@
 import { AiFactoryService } from './ai-factory.service';
 import { AgentStoreService } from './agent-store.service';
 import { ArtifactService } from './artifact.service';
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
+import { IConfigService } from '../config/env-config';
 import { BalanceService } from '../app/balance.service';
 import { Agent } from './agent';
 export declare class AgentFactory {
     private readonly aiFactoryService;
     private readonly agentStoreService;
-    private readonly configService;
+    private readonly userPaths;
     private readonly balanceService;
     private readonly artifactService;
-    constructor(aiFactoryService: AiFactoryService, agentStoreService: AgentStoreService, configService: ConfigurationService, balanceService: BalanceService, artifactService: ArtifactService);
+    private readonly configService;
+    constructor(aiFactoryService: AiFactoryService, agentStoreService: AgentStoreService, userPaths: UserPathsService, balanceService: BalanceService, artifactService: ArtifactService, configService: IConfigService);
     createAgent(aiServiceName: string, agentName: string, agentNickname: string, description: string, promptFolder: string, modelName: string, storageDir?: string, artifactService?: ArtifactService): Agent;
 }

package/dist-sdk/server/src/ai/agent-factory.js

@@ -4,21 +4,23 @@ exports.AgentFactory = void 0;
 class AgentFactory {
     aiFactoryService;
     agentStoreService;
-    configService;
+    userPaths;
     balanceService;
     artifactService;
-    constructor(aiFactoryService, agentStoreService, configService, balanceService, artifactService) {
+    configService;
+    constructor(aiFactoryService, agentStoreService, userPaths, balanceService, artifactService, configService) {
         this.aiFactoryService = aiFactoryService;
         this.agentStoreService = agentStoreService;
-        this.configService = configService;
+        this.userPaths = userPaths;
         this.balanceService = balanceService;
         this.artifactService = artifactService;
+        this.configService = configService;
     }
     createAgent(aiServiceName, agentName, agentNickname, description, promptFolder, modelName, storageDir = '', artifactService) {
         const aiService = this.aiFactoryService.createAiService(aiServiceName);
         const finalStorageDir = storageDir || this.agentStoreService.getDefaultStorageDir();
         const finalArtifactService = artifactService || this.artifactService;
-        return aiService.createAgent(this.configService, this.agentStoreService, this.balanceService, finalArtifactService, agentName, agentNickname, description, promptFolder, modelName, finalStorageDir);
+        return aiService.createAgent(this.userPaths, this.configService, this.agentStoreService, this.balanceService, finalArtifactService, agentName, agentNickname, description, promptFolder, modelName, finalStorageDir);
     }
 }
 exports.AgentFactory = AgentFactory;

package/dist-sdk/server/src/ai/agent-store.service.d.ts

@@ -1,20 +1,22 @@
 import { Agent } from './agent';
 import { AiFactoryService } from './ai-factory.service';
 import { ArtifactService } from './artifact.service';
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
+import { IConfigService } from '../config/env-config';
 import { AttachedFileService } from './attached-file.service';
 import { BalanceService } from '../app/balance.service';
 export declare class AgentStoreService {
     private readonly aiFactoryService;
-    private readonly configService;
+    private readonly userPaths;
     private readonly attachedFileService;
     private readonly balanceService;
     private readonly artifactService;
+    private readonly configService;
     private agents;
     private readonly defaultStorageDir;
     private loaded;
     private loadPromise;
-    constructor(aiFactoryService: AiFactoryService, configService: ConfigurationService, attachedFileService: AttachedFileService, balanceService: BalanceService, artifactService: ArtifactService);
+    constructor(aiFactoryService: AiFactoryService, userPaths: UserPathsService, attachedFileService: AttachedFileService, balanceService: BalanceService, artifactService: ArtifactService, configService: IConfigService);
     getDefaultStorageDir(): string;
     registerAgent(agent: Agent): void;
     storeAgent(agent: Agent, storageDir?: string): string;

package/dist-sdk/server/src/ai/agent-store.service.js

@@ -50,27 +50,29 @@ const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const ai_factory_service_1 = require("./ai-factory.service");
 const artifact_service_1 = require("./artifact.service");
-const configuration_service_1 = require("../config/configuration.service");
+const user_paths_service_1 = require("../config/user-paths.service");
 const attached_file_service_1 = require("./attached-file.service");
 const balance_service_1 = require("../app/balance.service");
 const logger_1 = require("../common/logger");
 let AgentStoreService = class AgentStoreService {
     aiFactoryService;
-    configService;
+    userPaths;
     attachedFileService;
     balanceService;
     artifactService;
+    configService;
     agents = new Map();
     defaultStorageDir;
     loaded = false;
     loadPromise = null;
-    constructor(aiFactoryService, configService, attachedFileService, balanceService, artifactService) {
+    constructor(aiFactoryService, userPaths, attachedFileService, balanceService, artifactService, configService) {
         this.aiFactoryService = aiFactoryService;
-        this.configService = configService;
+        this.userPaths = userPaths;
         this.attachedFileService = attachedFileService;
         this.balanceService = balanceService;
         this.artifactService = artifactService;
-        this.defaultStorageDir = path.join(this.configService.getUserDataDir(), 'agents');
+        this.configService = configService;
+        this.defaultStorageDir = path.join(this.userPaths.getUserDataDir(), 'agents');
     }
     getDefaultStorageDir() {
         return this.defaultStorageDir;
@@ -130,7 +132,7 @@ let AgentStoreService = class AgentStoreService {
         }
         const instanceId = (0, crypto_1.randomUUID)();
         const aiService = this.aiFactoryService.createAiService(template.serviceName);
-        const instance = new agent_1.Agent(instanceId, this.configService, this, this.balanceService, this.artifactService, publishedName, template.agentNickname || template.agentName, template.description, template.promptFolder, template.systemInstruction, [], template.modelName, template.serviceName, aiService, template.reasoningEffort, template.allowSearch, template.maxOutputTokens, template.beginInstruction, this.defaultStorageDir);
+        const instance = new agent_1.Agent(instanceId, this.userPaths, this.configService, this, this.balanceService, this.artifactService, publishedName, template.agentNickname || template.agentName, template.description, template.promptFolder, template.systemInstruction, [], template.modelName, template.serviceName, aiService, template.reasoningEffort, template.allowSearch, template.maxOutputTokens, template.beginInstruction, this.defaultStorageDir);
         instance.templateAgentId = templateId;
         instance.isPublished = true;
         instance.createdAt = new Date();
@@ -233,19 +235,17 @@ let AgentStoreService = class AgentStoreService {
                     }
                     const aiService = this.aiFactoryService.createAiService(config.serviceName);
                     const finalArtifactService = artifactService || this.artifactService;
-                    const agent = new agent_1.Agent(config.id, this.configService, this, this.balanceService, finalArtifactService, config.agentName, config.agentNickname || config.agentName, config.description, config.promptFolder, config.systemInstruction, config.history || [], config.modelName, config.serviceName, aiService, config.reasoningEffort, config.allowSearch, config.maxOutputTokens, config.beginInstruction || '', storageDir);
+                    const agent = new agent_1.Agent(config.id, this.userPaths, this.configService, this, this.balanceService, finalArtifactService, config.agentName, config.agentNickname || config.agentName, config.description, config.promptFolder, config.systemInstruction, config.history || [], config.modelName, config.serviceName, aiService, config.reasoningEffort, config.allowSearch, config.maxOutputTokens, config.beginInstruction || '', storageDir);
                     agent.createdAt = new Date(config.createdAt);
-                    agent.configService = this.configService;
+                    agent.userPaths = this.userPaths;
                     agent.smallModelName = config.smallModelName;
                     agent.totalInputTokens = config.totalInputTokens || 0;
                     agent.totalOutputTokens = config.totalOutputTokens || 0;
                     agent.totalCost = config.totalCost || 0;
                     agent.totalMarkup = config.totalMarkup || 0;
-                    agent.markupRate =
-                        config.markupRate ??
-                            (process.env.DEFAULT_MARKUP_RATE
-                                ? parseFloat(process.env.DEFAULT_MARKUP_RATE)
-                                : 2);
+                    if (config.markupRate !== undefined) {
+                        agent.markupRate = config.markupRate;
+                    }
                     agent.isControlledByHuman = config.isControlledByHuman || false;
                     agent.disableMarkup = config.disableMarkup || false;
                     agent.disableBalanceCheck = config.disableBalanceCheck || false;
@@ -356,8 +356,8 @@ exports.AgentStoreService = AgentStoreService;
 exports.AgentStoreService = AgentStoreService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [ai_factory_service_1.AiFactoryService,
-        configuration_service_1.ConfigurationService,
+        user_paths_service_1.UserPathsService,
         attached_file_service_1.AttachedFileService,
         balance_service_1.BalanceService,
-        artifact_service_1.ArtifactService])
+        artifact_service_1.ArtifactService, Object])
 ], AgentStoreService);

package/dist-sdk/server/src/ai/agent.d.ts

@@ -5,7 +5,8 @@ import { Message } from '../../../shared/types/app.types';
 import { BaseAiService } from './LLM/base-ai.service';
 import { FileMetadata } from './attached-file.service';
 import { ArtifactService } from './artifact.service';
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
+import { IConfigService } from '../config/env-config';
 import { BalanceService } from '../app/balance.service';
 import { AgentStoreService } from './agent-store.service';
 export declare class Agent {
@@ -31,7 +32,8 @@ export declare class Agent {
     vectorStore?: VectorStore;
     aiService: BaseAiService;
     artifactService: ArtifactService;
-    configService: ConfigurationService;
+    userPaths: UserPathsService;
+    configService: IConfigService;
     balanceService?: BalanceService;
     description: string;
     promptFolder: string;
@@ -40,7 +42,6 @@ export declare class Agent {
     modelName: string;
     smallModelName?: string;
     serviceName: string;
-    imageProperties?: Record<string, any>;
     reasoningEffort: 'low' | 'medium' | 'high' | null;
     allowSearch: boolean;
     maxOutputTokens: number;
@@ -52,7 +53,7 @@ export declare class Agent {
     private onStateChange;
     storageDir: string;
     private agentStoreService;
-    constructor(id: string | null, configService: ConfigurationService, agentStoreService: AgentStoreService, balanceService: BalanceService, artifactService: ArtifactService, agentName: string, agentNickname: string, description: string, promptFolder: string, systemInstruction: string, history: any[], modelName: string, serviceName: string, aiService: BaseAiService, reasoningEffort: 'low' | 'medium' | 'high' | null, allowSearch: boolean, maxOutputTokens: number, beginInstruction: string, storageDir: string);
+    constructor(id: string | null, userPaths: UserPathsService, configService: IConfigService, agentStoreService: AgentStoreService, balanceService: BalanceService, artifactService: ArtifactService, agentName: string, agentNickname: string, description: string, promptFolder: string, systemInstruction: string, history: any[], modelName: string, serviceName: string, aiService: BaseAiService, reasoningEffort: 'low' | 'medium' | 'high' | null, allowSearch: boolean, maxOutputTokens: number, beginInstruction: string, storageDir: string);
     attachDocument(fileName: string, fileData: Uint8Array): Promise<string>;
     attachArtifact(artifactId: string): void;
     detachArtifact(artifactId: string): void;
@@ -74,15 +75,17 @@ export declare class Agent {
         success: boolean;
         originalLength: number;
         newLength: number;
+        originalChars: number;
+        newChars: number;
         message: string;
         summary?: string;
     }>;
     textPrompt(prompt: string, jsonSchema?: any, saveResponse?: boolean, promptInstructions?: string, cacheMessage?: boolean, maxOutputChars?: number): Promise<any>;
-    generateImage(prompt: string): Promise<{
+    generateImage(prompt: string, imageProperties?: Record<string, any>): Promise<{
         artifactId?: string;
         error?: any;
     }>;
-    editImage(prompt: string, referenceImageArtifactIds?: string[]): Promise<{
+    editImage(prompt: string, imageProperties?: Record<string, any>, referenceImageArtifactIds?: string[]): Promise<{
         artifactId?: string;
         error?: any;
     }>;

package/dist-sdk/server/src/ai/agent.js

@@ -2,6 +2,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.Agent = void 0;
 const app_types_1 = require("../../../shared/types/app.types");
+const logger_1 = require("../common/logger");
 const crypto_1 = require("crypto");
 class Agent {
     id;
@@ -29,6 +30,7 @@ class Agent {
     vectorStore;
     aiService;
     artifactService;
+    userPaths;
     configService;
     balanceService;
     description;
@@ -38,7 +40,6 @@ class Agent {
     modelName;
     smallModelName;
     serviceName;
-    imageProperties;
     reasoningEffort;
     allowSearch;
     maxOutputTokens = 0;
@@ -50,7 +51,7 @@ class Agent {
     onStateChange = null;
     storageDir;
     agentStoreService;
-    constructor(id, configService, agentStoreService, balanceService, artifactService, agentName = '', agentNickname = '', description = '', promptFolder = '', systemInstruction = '', history = [], modelName = '', serviceName = '', aiService, reasoningEffort = null, allowSearch = false, maxOutputTokens = 0, beginInstruction = '', storageDir) {
+    constructor(id, userPaths, configService, agentStoreService, balanceService, artifactService, agentName = '', agentNickname = '', description = '', promptFolder = '', systemInstruction = '', history = [], modelName = '', serviceName = '', aiService, reasoningEffort = null, allowSearch = false, maxOutputTokens = 0, beginInstruction = '', storageDir) {
         this.agentName = agentName;
         this.agentNickname = agentNickname || Agent.generateNickname(agentName);
         this.description = description;
@@ -70,10 +71,18 @@ class Agent {
         this.maxOutputTokens = maxOutputTokens;
         this.beginInstruction = beginInstruction;
         this.storageDir = storageDir;
+        this.userPaths = userPaths;
         this.configService = configService;
         this.agentStoreService = agentStoreService;
         this.balanceService = balanceService;
         this.artifactService = artifactService;
+        const configuredMarkupRate = configService?.get('DEFAULT_MARKUP_RATE');
+        if (configuredMarkupRate !== undefined && configuredMarkupRate !== null) {
+            const parsed = parseFloat(String(configuredMarkupRate));
+            if (!isNaN(parsed)) {
+                this.markupRate = parsed;
+            }
+        }
         this.id = id ? id : (0, crypto_1.randomUUID)();
     }
     async attachDocument(fileName, fileData) {
@@ -182,11 +191,14 @@ class Agent {
     async compact() {
         const originalHistory = [...(this.history || [])];
         const originalLength = originalHistory.length;
+        const originalChars = originalHistory.reduce((sum, m) => sum + (m?.content?.length || 0), 0);
         if (originalLength === 0) {
             return {
                 success: true,
                 originalLength,
                 newLength: originalLength,
+                originalChars,
+                newChars: 0,
                 message: 'No conversation history to compact',
             };
         }
@@ -197,11 +209,15 @@ class Agent {
             const summary = summaryResponse?.summary || summaryResponse;
             this.addToConversationHistory(`[CONVERSATION HISTORY SUMMARY]\n\n${summary}`, true);
             const newLength = this.history.length;
+            const newChars = this.history.reduce((sum, m) => sum + (m?.content?.length || 0), 0);
+            logger_1.logger.log(`Compacted ${this.agentName}: ${originalChars} -> ${newChars} characters (${originalLength} -> ${newLength} messages)`);
             this.save();
             return {
                 success: true,
                 originalLength,
                 newLength,
+                originalChars,
+                newChars,
                 message: `${originalLength} messages -> ${newLength} messages`,
                 summary,
             };
@@ -214,11 +230,11 @@ class Agent {
     async textPrompt(prompt, jsonSchema = null, saveResponse = true, promptInstructions = null, cacheMessage = false, maxOutputChars = 0) {
         return await this.aiService.textPrompt(this, prompt, jsonSchema, saveResponse, promptInstructions, this.aiService.getCacheConfig(this, cacheMessage), maxOutputChars);
     }
-    async generateImage(prompt) {
-        return await this.aiService.generateImage(this, prompt, this.imageProperties);
+    async generateImage(prompt, imageProperties) {
+        return await this.aiService.generateImage(this, prompt, imageProperties);
     }
-    async editImage(prompt, referenceImageArtifactIds) {
-        return await this.aiService.editImage(this, prompt, this.imageProperties, referenceImageArtifactIds);
+    async editImage(prompt, imageProperties, referenceImageArtifactIds) {
+        return await this.aiService.editImage(this, prompt, imageProperties, referenceImageArtifactIds);
     }
 }
 exports.Agent = Agent;

package/dist-sdk/server/src/ai/ai-debug-logger.d.ts

@@ -0,0 +1,10 @@
+export declare class AiDebugLogger {
+    static isEnabled(): boolean;
+    private static getLogDir;
+    private static timestamp;
+    private static sanitize;
+    private static write;
+    static writeRequest(agentName: string, content: unknown): void;
+    static writeThinking(agentName: string, content: string): void;
+    static writeResponse(agentName: string, content: string): void;
+}

package/dist-sdk/server/src/ai/ai-debug-logger.js

@@ -0,0 +1,82 @@
+"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 __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;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AiDebugLogger = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class AiDebugLogger {
+    static isEnabled() {
+        return process.env.AI_DEBUG === 'true';
+    }
+    static getLogDir() {
+        const dataPath = process.env.BRIYAH_DATA_PATH || path.resolve(process.cwd(), 'server', 'data');
+        const dir = path.resolve(dataPath, 'logs', 'ai-debug');
+        fs.mkdirSync(dir, { recursive: true });
+        return dir;
+    }
+    static timestamp() {
+        const now = new Date();
+        const pad = (n, len = 2) => String(n).padStart(len, '0');
+        return (`${now.getFullYear()}-${pad(now.getMonth() + 1)}-${pad(now.getDate())}` +
+            `_${pad(now.getHours())}-${pad(now.getMinutes())}-${pad(now.getSeconds())}` +
+            `-${pad(now.getMilliseconds(), 3)}`);
+    }
+    static sanitize(name) {
+        return name.replace(/[<>:"/\\|?*\s]+/g, '_').substring(0, 80);
+    }
+    static write(agentName, suffix, content) {
+        if (!this.isEnabled())
+            return;
+        try {
+            const filename = `${this.timestamp()}_${this.sanitize(agentName)}_${suffix}.txt`;
+            fs.writeFileSync(path.join(this.getLogDir(), filename), content, 'utf8');
+        }
+        catch {
+        }
+    }
+    static writeRequest(agentName, content) {
+        const text = typeof content === 'string' ? content : JSON.stringify(content, null, 2);
+        this.write(agentName, 'REQUEST', text);
+    }
+    static writeThinking(agentName, content) {
+        if (!content)
+            return;
+        this.write(agentName, 'THINKING', content);
+    }
+    static writeResponse(agentName, content) {
+        this.write(agentName, 'RESPONSE', content ?? '');
+    }
+}
+exports.AiDebugLogger = AiDebugLogger;

package/dist-sdk/server/src/ai/artifact.module.js

@@ -9,13 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.ArtifactModule = void 0;
 const common_1 = require("@nestjs/common");
 const artifact_service_1 = require("./artifact.service");
-const configuration_module_1 = require("../config/configuration.module");
+const user_paths_module_1 = require("../config/user-paths.module");
 let ArtifactModule = class ArtifactModule {
 };
 exports.ArtifactModule = ArtifactModule;
 exports.ArtifactModule = ArtifactModule = __decorate([
     (0, common_1.Module)({
-        imports: [configuration_module_1.ConfigurationModule],
+        imports: [user_paths_module_1.UserPathsModule],
         providers: [artifact_service_1.ArtifactService],
         exports: [artifact_service_1.ArtifactService],
     })

package/dist-sdk/server/src/ai/artifact.service.d.ts

@@ -1,9 +1,9 @@
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
 import { ArtifactMetadata } from '../../../shared/types/app.types';
 export declare class ArtifactService {
-    private readonly configService;
+    private readonly userPaths;
     private readonly artifactsDir;
-    constructor(configService: ConfigurationService, storageDir?: string);
+    constructor(userPaths: UserPathsService, storageDir?: string);
     private getMetadataPath;
     private loadMetadata;
     private saveMetadata;

package/dist-sdk/server/src/ai/artifact.service.js

@@ -47,18 +47,18 @@ const common_1 = require("@nestjs/common");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
-const configuration_service_1 = require("../config/configuration.service");
+const user_paths_service_1 = require("../config/user-paths.service");
 const logger_1 = require("../common/logger");
 let ArtifactService = class ArtifactService {
-    configService;
+    userPaths;
     artifactsDir;
-    constructor(configService, storageDir) {
-        this.configService = configService;
+    constructor(userPaths, storageDir) {
+        this.userPaths = userPaths;
         if (storageDir) {
             this.artifactsDir = storageDir;
         }
         else {
-            const userDataDir = this.configService.getUserDataDir();
+            const userDataDir = this.userPaths.getUserDataDir();
             this.artifactsDir = path.join(userDataDir, 'artifacts');
         }
         if (!fs.existsSync(this.artifactsDir)) {
@@ -236,5 +236,5 @@ let ArtifactService = class ArtifactService {
 exports.ArtifactService = ArtifactService;
 exports.ArtifactService = ArtifactService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService, String])
+    __metadata("design:paramtypes", [user_paths_service_1.UserPathsService, String])
 ], ArtifactService);

package/dist-sdk/server/src/ai/attached-file.module.js

@@ -9,13 +9,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.AttachedFileModule = void 0;
 const common_1 = require("@nestjs/common");
 const attached_file_service_1 = require("./attached-file.service");
-const configuration_module_1 = require("../config/configuration.module");
+const user_paths_module_1 = require("../config/user-paths.module");
 let AttachedFileModule = class AttachedFileModule {
 };
 exports.AttachedFileModule = AttachedFileModule;
 exports.AttachedFileModule = AttachedFileModule = __decorate([
     (0, common_1.Module)({
-        imports: [configuration_module_1.ConfigurationModule],
+        imports: [user_paths_module_1.UserPathsModule],
         providers: [attached_file_service_1.AttachedFileService],
         exports: [attached_file_service_1.AttachedFileService],
     })

package/dist-sdk/server/src/ai/attached-file.service.d.ts

@@ -1,4 +1,4 @@
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
 export interface FileMetadata {
     fileName: string;
     fileId: string;
@@ -14,9 +14,9 @@ export interface FileMetadata {
     };
 }
 export declare class AttachedFileService {
-    private readonly configService;
+    private readonly userPaths;
     private readonly attachedFilesDir;
-    constructor(configService: ConfigurationService);
+    constructor(userPaths: UserPathsService);
     private getMetadataPath;
     storeFile(ownerId: string, fileName: string, fileData: Uint8Array, additionalMetadata?: Partial<FileMetadata>): string;
     getFile(ownerId: string, fileId: string): Uint8Array | null;

package/dist-sdk/server/src/ai/attached-file.service.js

@@ -47,14 +47,14 @@ const common_1 = require("@nestjs/common");
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
 const crypto_1 = require("crypto");
-const configuration_service_1 = require("../config/configuration.service");
+const user_paths_service_1 = require("../config/user-paths.service");
 const logger_1 = require("../common/logger");
 let AttachedFileService = class AttachedFileService {
-    configService;
+    userPaths;
     attachedFilesDir;
-    constructor(configService) {
-        this.configService = configService;
-        this.attachedFilesDir = this.configService.getUploadDir();
+    constructor(userPaths) {
+        this.userPaths = userPaths;
+        this.attachedFilesDir = this.userPaths.getUploadDir();
         if (!fs.existsSync(this.attachedFilesDir)) {
             fs.mkdirSync(this.attachedFilesDir, { recursive: true });
         }
@@ -250,5 +250,5 @@ let AttachedFileService = class AttachedFileService {
 exports.AttachedFileService = AttachedFileService;
 exports.AttachedFileService = AttachedFileService = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [configuration_service_1.ConfigurationService])
+    __metadata("design:paramtypes", [user_paths_service_1.UserPathsService])
 ], AttachedFileService);

package/dist-sdk/server/src/app/balance.service.d.ts

@@ -1,13 +1,13 @@
-import { ConfigurationService } from '../config/configuration.service';
+import { UserPathsService } from '../config/user-paths.service';
 import { BalanceMessageService } from './balance-message.service';
 export declare class BalanceService {
     private userId;
-    private configService;
+    private userPaths;
     private balanceFilePath;
     private markupFilePath;
     private startingBalance;
     private balanceMessageService?;
-    constructor(userId: string, configService: ConfigurationService, balanceMessageService?: BalanceMessageService);
+    constructor(userId: string, userPaths: UserPathsService, balanceMessageService?: BalanceMessageService);
     getBalance(): number;
     getMarkup(): number;
     hasSufficientBalance(): boolean;