@hashgraphonline/conversational-agent 0.1.217 → 0.1.218

package/src/memory/{ContentStorage.ts → content-storage.ts}

@@ -1,5 +1,5 @@
 import type { BaseMessage } from '@langchain/core/messages';
-import { ReferenceIdGenerator } from './ReferenceIdGenerator';
+import { ReferenceIdGenerator } from './reference-id-generator';
 import {
   ReferenceId,
   ContentReference,
@@ -12,7 +12,7 @@ import {
   ContentType,
   ContentSource,
   ReferenceLifecycleState,
-  DEFAULT_CONTENT_REFERENCE_CONFIG
+  DEFAULT_CONTENT_REFERENCE_CONFIG,
 } from '../types/content-reference';
 
 /**
@@ -68,13 +68,13 @@ export interface StorageStats {
 interface StoredContent {
   /** The actual content buffer */
   content: Buffer;
-  
+
   /** Complete metadata */
   metadata: ContentMetadata;
-  
+
   /** Current lifecycle state */
   state: ReferenceLifecycleState;
-  
+
   /** When this reference expires (if applicable) */
   expiresAt?: Date;
 }
@@ -82,7 +82,7 @@ interface StoredContent {
 /**
  * Content storage for managing pruned conversation messages and large content references
  * Provides searchable storage with time-based querying and automatic cleanup.
- * 
+ *
  * Extended to support reference-based storage for large content to optimize context window usage.
  */
 export class ContentStorage implements ContentReferenceStore {
@@ -108,8 +108,11 @@ export class ContentStorage implements ContentReferenceStore {
     referenceConfig?: Partial<ContentReferenceConfig>
   ) {
     this.maxStorage = maxStorage;
-    
-    this.referenceConfig = { ...DEFAULT_CONTENT_REFERENCE_CONFIG, ...referenceConfig };
+
+    this.referenceConfig = {
+      ...DEFAULT_CONTENT_REFERENCE_CONFIG,
+      ...referenceConfig,
+    };
     this.referenceStats = {
       activeReferences: 0,
       totalStorageBytes: 0,
@@ -124,10 +127,10 @@ export class ContentStorage implements ContentReferenceStore {
         averageCleanupTimeMs: 0,
         creationTimes: [],
         resolutionTimes: [],
-        cleanupTimes: []
-      }
+        cleanupTimes: [],
+      },
     };
-    
+
     if (this.referenceConfig.enableAutoCleanup) {
       this.startReferenceCleanupTimer();
     }
@@ -147,10 +150,10 @@ export class ContentStorage implements ContentReferenceStore {
     const now = new Date();
     let dropped = 0;
 
-    const storedMessages: StoredMessage[] = messages.map(message => ({
+    const storedMessages: StoredMessage[] = messages.map((message) => ({
       message,
       storedAt: now,
-      id: this.generateId()
+      id: this.generateId(),
     }));
 
     this.messages.push(...storedMessages);
@@ -162,7 +165,7 @@ export class ContentStorage implements ContentReferenceStore {
 
     return {
       stored: storedMessages.length,
-      dropped
+      dropped,
     };
   }
 
@@ -177,9 +180,7 @@ export class ContentStorage implements ContentReferenceStore {
     }
 
     const startIndex = Math.max(0, this.messages.length - count);
-    return this.messages
-      .slice(startIndex)
-      .map(stored => stored.message);
+    return this.messages.slice(startIndex).map((stored) => stored.message);
   }
 
   /**
@@ -193,11 +194,7 @@ export class ContentStorage implements ContentReferenceStore {
       return [];
     }
 
-    const {
-      caseSensitive = false,
-      limit,
-      useRegex = false
-    } = options;
+    const { caseSensitive = false, limit, useRegex = false } = options;
 
     let matches: BaseMessage[] = [];
 
@@ -205,20 +202,20 @@ export class ContentStorage implements ContentReferenceStore {
       try {
         const regex = new RegExp(query, caseSensitive ? 'g' : 'gi');
         matches = this.messages
-          .filter(stored => regex.test(stored.message.content as string))
-          .map(stored => stored.message);
+          .filter((stored) => regex.test(stored.message.content as string))
+          .map((stored) => stored.message);
       } catch {
         return [];
       }
     } else {
       const searchTerm = caseSensitive ? query : query.toLowerCase();
       matches = this.messages
-        .filter(stored => {
+        .filter((stored) => {
           const content = stored.message.content as string;
           const searchContent = caseSensitive ? content : content.toLowerCase();
           return searchContent.includes(searchTerm);
         })
-        .map(stored => stored.message);
+        .map((stored) => stored.message);
     }
 
     return limit ? matches.slice(0, limit) : matches;
@@ -236,10 +233,10 @@ export class ContentStorage implements ContentReferenceStore {
     }
 
     return this.messages
-      .filter(stored => 
-        stored.storedAt >= startTime && stored.storedAt <= endTime
+      .filter(
+        (stored) => stored.storedAt >= startTime && stored.storedAt <= endTime
       )
-      .map(stored => stored.message);
+      .map((stored) => stored.message);
   }
 
   /**
@@ -248,9 +245,10 @@ export class ContentStorage implements ContentReferenceStore {
    */
   getStorageStats(): StorageStats {
     const totalMessages = this.messages.length;
-    const usagePercentage = totalMessages > 0 
-      ? Math.round((totalMessages / this.maxStorage) * 100)
-      : 0;
+    const usagePercentage =
+      totalMessages > 0
+        ? Math.round((totalMessages / this.maxStorage) * 100)
+        : 0;
 
     let oldestMessageTime: Date | undefined;
     let newestMessageTime: Date | undefined;
@@ -265,7 +263,7 @@ export class ContentStorage implements ContentReferenceStore {
       maxStorageLimit: this.maxStorage,
       usagePercentage,
       oldestMessageTime,
-      newestMessageTime
+      newestMessageTime,
     };
   }
 
@@ -309,8 +307,8 @@ export class ContentStorage implements ContentReferenceStore {
    */
   getMessagesByType(messageType: string, limit?: number): BaseMessage[] {
     const filtered = this.messages
-      .filter(stored => stored.message._getType() === messageType)
-      .map(stored => stored.message);
+      .filter((stored) => stored.message._getType() === messageType)
+      .map((stored) => stored.message);
 
     return limit ? filtered.slice(0, limit) : filtered;
   }
@@ -319,11 +317,11 @@ export class ContentStorage implements ContentReferenceStore {
    * Get the current storage configuration
    * @returns Storage configuration object
    */
-  getConfig() {
+  getConfig(): { maxStorage: number; currentUsage: number; utilizationPercentage: number } {
     return {
       maxStorage: this.maxStorage,
       currentUsage: this.messages.length,
-      utilizationPercentage: (this.messages.length / this.maxStorage) * 100
+      utilizationPercentage: (this.messages.length / this.maxStorage) * 100,
     };
   }
 
@@ -345,23 +343,23 @@ export class ContentStorage implements ContentReferenceStore {
       return [];
     }
 
-    const cutoffTime = new Date(Date.now() - (minutes * 60 * 1000));
-    
+    const cutoffTime = new Date(Date.now() - minutes * 60 * 1000);
+
     return this.messages
-      .filter(stored => stored.storedAt >= cutoffTime)
-      .map(stored => stored.message);
+      .filter((stored) => stored.storedAt >= cutoffTime)
+      .map((stored) => stored.message);
   }
 
   /**
    * Export messages to a JSON-serializable format
    * @returns Serializable representation of stored messages
    */
-  exportMessages() {
-    return this.messages.map(stored => ({
+  exportMessages(): Array<{ content: string; type: string; storedAt: string; id: string }> {
+    return this.messages.map((stored) => ({
       content: stored.message.content,
       type: stored.message._getType(),
       storedAt: stored.storedAt.toISOString(),
-      id: stored.id
+      id: stored.id,
     }));
   }
 
@@ -369,14 +367,16 @@ export class ContentStorage implements ContentReferenceStore {
    * Determine if content should be stored as a reference based on size
    */
   shouldUseReference(content: Buffer | string): boolean {
-    const size = Buffer.isBuffer(content) ? content.length : Buffer.byteLength(content, 'utf8');
+    const size = Buffer.isBuffer(content)
+      ? content.length
+      : Buffer.byteLength(content, 'utf8');
     return size > this.referenceConfig.sizeThresholdBytes;
   }
 
   /**
    * Store content and return a reference if it exceeds the size threshold
    * Otherwise returns null to indicate direct content should be used
-   * 
+   *
    * Special case: Image files are ALWAYS stored as references regardless of size
    * because they need special handling for inscription tools
    */
@@ -392,21 +392,31 @@ export class ContentStorage implements ContentReferenceStore {
       customMetadata?: Record<string, unknown>;
     }
   ): Promise<ContentReference | null> {
-    const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
-    
-    const isImageFile = this.isImageContent(metadata.mimeType, metadata.fileName);
-    
+    const buffer = Buffer.isBuffer(content)
+      ? content
+      : Buffer.from(content, 'utf8');
+
+    const isImageFile = this.isImageContent(
+      metadata.mimeType,
+      metadata.fileName
+    );
+
     if (!isImageFile && !this.shouldUseReference(buffer)) {
       return null;
     }
-    
-    const storeMetadata: Omit<ContentMetadata, 'createdAt' | 'lastAccessedAt' | 'accessCount'> = {
-      contentType: metadata.contentType || this.detectContentType(buffer, metadata.mimeType),
+
+    const storeMetadata: Omit<
+      ContentMetadata,
+      'createdAt' | 'lastAccessedAt' | 'accessCount'
+    > = {
+      contentType:
+        metadata.contentType ||
+        this.detectContentType(buffer, metadata.mimeType),
       sizeBytes: buffer.length,
       source: metadata.source,
-      tags: []
+      tags: [],
     };
-    
+
     if (metadata.mimeType !== undefined) {
       storeMetadata.mimeType = metadata.mimeType;
     }
@@ -422,7 +432,7 @@ export class ContentStorage implements ContentReferenceStore {
     if (metadata.customMetadata !== undefined) {
       storeMetadata.customMetadata = metadata.customMetadata;
     }
-    
+
     return await this.storeContent(buffer, storeMetadata);
   }
 
@@ -431,72 +441,83 @@ export class ContentStorage implements ContentReferenceStore {
    */
   async storeContent(
     content: Buffer,
-    metadata: Omit<ContentMetadata, 'createdAt' | 'lastAccessedAt' | 'accessCount'>
+    metadata: Omit<
+      ContentMetadata,
+      'createdAt' | 'lastAccessedAt' | 'accessCount'
+    >
   ): Promise<ContentReference> {
     const startTime = Date.now();
-    
+
     try {
       const now = new Date();
       const referenceId = ReferenceIdGenerator.generateId(content);
-      
+
       const fullMetadata: ContentMetadata = {
         ...metadata,
         createdAt: now,
         lastAccessedAt: now,
-        accessCount: 0
+        accessCount: 0,
       };
-      
+
       const storedContent: StoredContent = {
         content,
         metadata: fullMetadata,
-        state: 'active'
+        state: 'active',
       };
-      
+
       const expirationTime = this.calculateExpirationTime(metadata.source);
       if (expirationTime !== undefined) {
         storedContent.expiresAt = expirationTime;
       }
-      
+
       this.contentStore.set(referenceId, storedContent);
-      
+
       this.updateStatsAfterStore(content.length);
-      
+
       await this.enforceReferenceStorageLimits();
-      
-      const preview = this.createContentPreview(content, fullMetadata.contentType);
-      
-      const referenceMetadata: Pick<ContentMetadata, 'contentType' | 'sizeBytes' | 'source' | 'fileName' | 'mimeType'> = {
+
+      const preview = this.createContentPreview(
+        content,
+        fullMetadata.contentType
+      );
+
+      const referenceMetadata: Pick<
+        ContentMetadata,
+        'contentType' | 'sizeBytes' | 'source' | 'fileName' | 'mimeType'
+      > = {
         contentType: fullMetadata.contentType,
         sizeBytes: fullMetadata.sizeBytes,
-        source: fullMetadata.source
+        source: fullMetadata.source,
       };
-      
+
       if (fullMetadata.fileName !== undefined) {
         referenceMetadata.fileName = fullMetadata.fileName;
       }
       if (fullMetadata.mimeType !== undefined) {
         referenceMetadata.mimeType = fullMetadata.mimeType;
       }
-      
+
       const reference: ContentReference = {
         referenceId,
         state: 'active',
         preview,
         metadata: referenceMetadata,
         createdAt: now,
-        format: 'ref://{id}' as const
+        format: 'ref://{id}' as const,
       };
-      
+
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('creation', duration);
-      
+
       return reference;
     } catch (error) {
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('creation', duration);
-      
+
       throw new ContentReferenceError(
-        `Failed to store content: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        `Failed to store content: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
         'system_error',
         undefined,
         ['Try again', 'Check storage limits', 'Contact administrator']
@@ -507,9 +528,11 @@ export class ContentStorage implements ContentReferenceStore {
   /**
    * Resolve a reference to its content (implements ContentReferenceStore)
    */
-  async resolveReference(referenceId: ReferenceId): Promise<ReferenceResolutionResult> {
+  async resolveReference(
+    referenceId: ReferenceId
+  ): Promise<ReferenceResolutionResult> {
     const startTime = Date.now();
-    
+
     try {
       if (!ReferenceIdGenerator.isValidReferenceId(referenceId)) {
         this.referenceStats.failedResolutions++;
@@ -517,22 +540,29 @@ export class ContentStorage implements ContentReferenceStore {
           success: false,
           error: 'Invalid reference ID format',
           errorType: 'not_found',
-          suggestedActions: ['Check the reference ID format', 'Ensure the reference ID is complete']
+          suggestedActions: [
+            'Check the reference ID format',
+            'Ensure the reference ID is complete',
+          ],
         };
       }
-      
+
       const storedContent = this.contentStore.get(referenceId);
-      
+
       if (!storedContent) {
         this.referenceStats.failedResolutions++;
         return {
           success: false,
           error: 'Reference not found',
           errorType: 'not_found',
-          suggestedActions: ['Verify the reference ID', 'Check if the content has expired', 'Request fresh content']
+          suggestedActions: [
+            'Verify the reference ID',
+            'Check if the content has expired',
+            'Request fresh content',
+          ],
         };
       }
-      
+
       if (storedContent.expiresAt && storedContent.expiresAt < new Date()) {
         storedContent.state = 'expired';
         this.referenceStats.failedResolutions++;
@@ -540,44 +570,53 @@ export class ContentStorage implements ContentReferenceStore {
           success: false,
           error: 'Reference has expired',
           errorType: 'expired',
-          suggestedActions: ['Request fresh content', 'Use alternative content source']
+          suggestedActions: [
+            'Request fresh content',
+            'Use alternative content source',
+          ],
         };
       }
-      
+
       if (storedContent.state !== 'active') {
         this.referenceStats.failedResolutions++;
         return {
           success: false,
           error: `Reference is ${storedContent.state}`,
-          errorType: storedContent.state === 'expired' ? 'expired' : 'corrupted',
-          suggestedActions: ['Request fresh content', 'Check reference validity']
+          errorType:
+            storedContent.state === 'expired' ? 'expired' : 'corrupted',
+          suggestedActions: [
+            'Request fresh content',
+            'Check reference validity',
+          ],
         };
       }
-      
+
       storedContent.metadata.lastAccessedAt = new Date();
       storedContent.metadata.accessCount++;
-      
+
       this.referenceStats.totalResolutions++;
-      
+
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('resolution', duration);
-      
+
       return {
         success: true,
         content: storedContent.content,
-        metadata: storedContent.metadata
+        metadata: storedContent.metadata,
       };
     } catch (error) {
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('resolution', duration);
-      
+
       this.referenceStats.failedResolutions++;
-      
+
       return {
         success: false,
-        error: `System error resolving reference: ${error instanceof Error ? error.message : 'Unknown error'}`,
+        error: `System error resolving reference: ${
+          error instanceof Error ? error.message : 'Unknown error'
+        }`,
         errorType: 'system_error',
-        suggestedActions: ['Try again', 'Contact administrator']
+        suggestedActions: ['Try again', 'Contact administrator'],
       };
     }
   }
@@ -589,17 +628,17 @@ export class ContentStorage implements ContentReferenceStore {
     if (!ReferenceIdGenerator.isValidReferenceId(referenceId)) {
       return false;
     }
-    
+
     const storedContent = this.contentStore.get(referenceId);
     if (!storedContent) {
       return false;
     }
-    
+
     if (storedContent.expiresAt && storedContent.expiresAt < new Date()) {
       storedContent.state = 'expired';
       return false;
     }
-    
+
     return storedContent.state === 'active';
   }
 
@@ -611,13 +650,13 @@ export class ContentStorage implements ContentReferenceStore {
     if (!storedContent) {
       return false;
     }
-    
+
     this.referenceStats.totalStorageBytes -= storedContent.content.length;
     this.referenceStats.activeReferences--;
     this.referenceStats.recentlyCleanedUp++;
-    
+
     this.contentStore.delete(referenceId);
-    
+
     return true;
   }
 
@@ -626,14 +665,20 @@ export class ContentStorage implements ContentReferenceStore {
    */
   async getStats(): Promise<ContentReferenceStats> {
     this.updateReferenceStorageStats();
-    
+
     return {
       ...this.referenceStats,
       performanceMetrics: {
-        averageCreationTimeMs: this.calculateAverage(this.referenceStats.performanceMetrics.creationTimes),
-        averageResolutionTimeMs: this.calculateAverage(this.referenceStats.performanceMetrics.resolutionTimes),
-        averageCleanupTimeMs: this.calculateAverage(this.referenceStats.performanceMetrics.cleanupTimes)
-      }
+        averageCreationTimeMs: this.calculateAverage(
+          this.referenceStats.performanceMetrics.creationTimes
+        ),
+        averageResolutionTimeMs: this.calculateAverage(
+          this.referenceStats.performanceMetrics.resolutionTimes
+        ),
+        averageCleanupTimeMs: this.calculateAverage(
+          this.referenceStats.performanceMetrics.cleanupTimes
+        ),
+      },
     };
   }
 
@@ -642,12 +687,12 @@ export class ContentStorage implements ContentReferenceStore {
    */
   async updateConfig(config: Partial<ContentReferenceConfig>): Promise<void> {
     this.referenceConfig = { ...this.referenceConfig, ...config };
-    
+
     if (this.cleanupTimer) {
       clearInterval(this.cleanupTimer);
       delete this.cleanupTimer;
     }
-    
+
     if (this.referenceConfig.enableAutoCleanup) {
       this.startReferenceCleanupTimer();
     }
@@ -660,43 +705,48 @@ export class ContentStorage implements ContentReferenceStore {
     const startTime = Date.now();
     const errors: string[] = [];
     let cleanedUp = 0;
-    
+
     try {
       const now = new Date();
       const toCleanup: ReferenceId[] = [];
-      
+
       for (const [referenceId, storedContent] of this.contentStore.entries()) {
         let shouldCleanup = false;
-        
+
         if (storedContent.expiresAt && storedContent.expiresAt < now) {
           shouldCleanup = true;
           storedContent.state = 'expired';
         }
-        
-        const ageMs = now.getTime() - storedContent.metadata.createdAt.getTime();
+
+        const ageMs =
+          now.getTime() - storedContent.metadata.createdAt.getTime();
         const policy = this.getCleanupPolicy(storedContent.metadata.source);
-        
+
         if (ageMs > policy.maxAgeMs) {
           shouldCleanup = true;
         }
-        
+
         if (storedContent.state === 'cleanup_pending') {
           shouldCleanup = true;
         }
-        
+
         if (shouldCleanup) {
           toCleanup.push(referenceId);
         }
       }
-      
+
       toCleanup.sort((a, b) => {
         const aContent = this.contentStore.get(a)!;
         const bContent = this.contentStore.get(b)!;
-        const aPriority = this.getCleanupPolicy(aContent.metadata.source).priority;
-        const bPriority = this.getCleanupPolicy(bContent.metadata.source).priority;
+        const aPriority = this.getCleanupPolicy(
+          aContent.metadata.source
+        ).priority;
+        const bPriority = this.getCleanupPolicy(
+          bContent.metadata.source
+        ).priority;
         return bPriority - aPriority;
       });
-      
+
       for (const referenceId of toCleanup) {
         try {
           const success = await this.cleanupReference(referenceId);
@@ -704,15 +754,23 @@ export class ContentStorage implements ContentReferenceStore {
             cleanedUp++;
           }
         } catch (error) {
-          errors.push(`Failed to cleanup ${referenceId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+          errors.push(
+            `Failed to cleanup ${referenceId}: ${
+              error instanceof Error ? error.message : 'Unknown error'
+            }`
+          );
         }
       }
-      
+
       if (this.contentStore.size > this.referenceConfig.maxReferences) {
-        const sortedByAge = Array.from(this.contentStore.entries())
-          .sort(([, a], [, b]) => a.metadata.lastAccessedAt.getTime() - b.metadata.lastAccessedAt.getTime());
-        
-        const excessCount = this.contentStore.size - this.referenceConfig.maxReferences;
+        const sortedByAge = Array.from(this.contentStore.entries()).sort(
+          ([, a], [, b]) =>
+            a.metadata.lastAccessedAt.getTime() -
+            b.metadata.lastAccessedAt.getTime()
+        );
+
+        const excessCount =
+          this.contentStore.size - this.referenceConfig.maxReferences;
         for (let i = 0; i < excessCount && i < sortedByAge.length; i++) {
           const [referenceId] = sortedByAge[i];
           try {
@@ -721,22 +779,28 @@ export class ContentStorage implements ContentReferenceStore {
               cleanedUp++;
             }
           } catch (error) {
-            errors.push(`Failed to cleanup excess reference ${referenceId}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+            errors.push(
+              `Failed to cleanup excess reference ${referenceId}: ${
+                error instanceof Error ? error.message : 'Unknown error'
+              }`
+            );
           }
         }
       }
-      
+
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('cleanup', duration);
-      
+
       return { cleanedUp, errors };
     } catch (error) {
       const duration = Date.now() - startTime;
       this.recordPerformanceMetric('cleanup', duration);
-      
-      const errorMessage = `Cleanup process failed: ${error instanceof Error ? error.message : 'Unknown error'}`;
+
+      const errorMessage = `Cleanup process failed: ${
+        error instanceof Error ? error.message : 'Unknown error'
+      }`;
       errors.push(errorMessage);
-      
+
       return { cleanedUp, errors };
     }
   }
@@ -752,8 +816,11 @@ export class ContentStorage implements ContentReferenceStore {
     if (this.contentStore.size >= this.referenceConfig.maxReferences) {
       await this.performCleanup();
     }
-    
-    if (this.referenceStats.totalStorageBytes >= this.referenceConfig.maxTotalStorageBytes) {
+
+    if (
+      this.referenceStats.totalStorageBytes >=
+      this.referenceConfig.maxTotalStorageBytes
+    ) {
       await this.performCleanup();
     }
   }
@@ -763,7 +830,7 @@ export class ContentStorage implements ContentReferenceStore {
     return new Date(Date.now() + policy.maxAgeMs);
   }
 
-  private getCleanupPolicy(source: ContentSource) {
+  private getCleanupPolicy(source: ContentSource): { maxAgeMs: number; priority: number } {
     switch (source) {
       case 'mcp_tool':
         return this.referenceConfig.cleanupPolicies.recent;
@@ -784,19 +851,32 @@ export class ContentStorage implements ContentReferenceStore {
       if (mimeType.startsWith('text/')) return 'text';
       return 'binary';
     }
-    
-    const contentStr = content.toString('utf8', 0, Math.min(content.length, 1000));
+
+    const contentStr = content.toString(
+      'utf8',
+      0,
+      Math.min(content.length, 1000)
+    );
     if (contentStr.startsWith('{') || contentStr.startsWith('[')) return 'json';
-    if (contentStr.includes('<html>') || contentStr.includes('<!DOCTYPE')) return 'html';
-    if (contentStr.includes('#') && contentStr.includes('\n')) return 'markdown';
-    
+    if (contentStr.includes('<html>') || contentStr.includes('<!DOCTYPE'))
+      return 'html';
+    if (contentStr.includes('#') && contentStr.includes('\n'))
+      return 'markdown';
+
     return 'text';
   }
 
-  private createContentPreview(content: Buffer, contentType: ContentType): string {
+  private createContentPreview(
+    content: Buffer,
+    contentType: ContentType
+  ): string {
     const maxLength = 200;
-    let preview = content.toString('utf8', 0, Math.min(content.length, maxLength * 2));
-    
+    let preview = content.toString(
+      'utf8',
+      0,
+      Math.min(content.length, maxLength * 2)
+    );
+
     if (contentType === 'html') {
       preview = preview
         .replace(/<[^>]*>/g, '')
@@ -806,15 +886,14 @@ export class ContentStorage implements ContentReferenceStore {
       try {
         const parsed = JSON.parse(preview);
         preview = JSON.stringify(parsed, null, 0);
-      } catch {
-      }
+      } catch {}
     }
-    
+
     preview = preview.trim();
     if (preview.length > maxLength) {
       preview = preview.substring(0, maxLength) + '...';
     }
-    
+
     return preview || '[Binary content]';
   }
 
@@ -826,21 +905,26 @@ export class ContentStorage implements ContentReferenceStore {
 
   private updateReferenceStorageStats(): void {
     if (this.referenceStats.activeReferences > 0) {
-      this.referenceStats.averageContentSize = this.referenceStats.totalStorageBytes / this.referenceStats.activeReferences;
+      this.referenceStats.averageContentSize =
+        this.referenceStats.totalStorageBytes /
+        this.referenceStats.activeReferences;
     }
-    
-    this.referenceStats.storageUtilization = (this.referenceStats.totalStorageBytes / this.referenceConfig.maxTotalStorageBytes) * 100;
-    
+
+    this.referenceStats.storageUtilization =
+      (this.referenceStats.totalStorageBytes /
+        this.referenceConfig.maxTotalStorageBytes) *
+      100;
+
     let mostAccessedId: ReferenceId | undefined;
     let maxAccess = 0;
-    
+
     for (const [referenceId, storedContent] of this.contentStore.entries()) {
       if (storedContent.metadata.accessCount > maxAccess) {
         maxAccess = storedContent.metadata.accessCount;
         mostAccessedId = referenceId;
       }
     }
-    
+
     if (mostAccessedId !== undefined) {
       this.referenceStats.mostAccessedReferenceId = mostAccessedId;
     } else {
@@ -855,20 +939,33 @@ export class ContentStorage implements ContentReferenceStore {
     if (mimeType && mimeType.startsWith('image/')) {
       return true;
     }
-    
+
     if (fileName) {
       const lowerFileName = fileName.toLowerCase();
-      const imageExtensions = ['.png', '.jpg', '.jpeg', '.gif', '.bmp', '.webp', '.svg', '.tiff', '.ico'];
-      return imageExtensions.some(ext => lowerFileName.endsWith(ext));
+      const imageExtensions = [
+        '.png',
+        '.jpg',
+        '.jpeg',
+        '.gif',
+        '.bmp',
+        '.webp',
+        '.svg',
+        '.tiff',
+        '.ico',
+      ];
+      return imageExtensions.some((ext) => lowerFileName.endsWith(ext));
     }
-    
+
     return false;
   }
 
-  private recordPerformanceMetric(type: 'creation' | 'resolution' | 'cleanup', timeMs: number): void {
+  private recordPerformanceMetric(
+    type: 'creation' | 'resolution' | 'cleanup',
+    timeMs: number
+  ): void {
     const metrics = this.referenceStats.performanceMetrics;
     const maxRecords = 100;
-    
+
     switch (type) {
       case 'creation':
         metrics.creationTimes.push(timeMs);
@@ -900,8 +997,7 @@ export class ContentStorage implements ContentReferenceStore {
     this.cleanupTimer = setInterval(async () => {
       try {
         await this.performCleanup();
-      } catch {
-      }
+      } catch {}
     }, this.referenceConfig.cleanupIntervalMs);
   }
 
@@ -913,9 +1009,9 @@ export class ContentStorage implements ContentReferenceStore {
       clearInterval(this.cleanupTimer);
       delete this.cleanupTimer;
     }
-    
+
     this.contentStore.clear();
-    
+
     this.clear();
   }
-}
+}