@hashgraphonline/conversational-agent 0.2.1 → 0.2.103

package/src/memory/smart-memory-manager.ts

@@ -19,6 +19,8 @@ export interface EntityAssociation {
   createdAt: Date;
   /** Transaction ID that created this entity */
   transactionId?: string;
+  /** Optional session identifier to scope associations */
+  sessionId?: string;
 }
 
 /**
@@ -381,7 +383,8 @@ export class SmartMemoryManager {
     entityId: string,
     entityName: string,
     entityType: string,
-    transactionId?: string
+    transactionId?: string,
+    sessionId?: string
   ): void {
     try {
       if (
@@ -410,7 +413,7 @@ export class SmartMemoryManager {
 
       const sanitizedEntityId = entityId.trim();
       const sanitizedEntityName = entityName.trim().substring(0, 100);
-      const sanitizedEntityType = entityType.trim().toLowerCase();
+      const sanitizedEntityType = this.normalizeEntityType(entityType);
 
       let usageHint = '';
       if (sanitizedEntityType === 'tokenid') {
@@ -433,7 +436,7 @@ export class SmartMemoryManager {
         createdAt: new Date(),
         isEntityAssociation: true,
         ...(usageHint ? { usage: usageHint } : {}),
-        ...(sanitizedEntityType === 'topicid'
+        ...(sanitizedEntityType === 'topicId'
           ? { hrl: `hcs://1/${sanitizedEntityId}` }
           : {}),
         ...(transactionId !== undefined &&
@@ -441,6 +444,7 @@ export class SmartMemoryManager {
         transactionId.trim() !== ''
           ? { transactionId: transactionId.trim() }
           : {}),
+        ...(sessionId && sessionId.trim() !== '' ? { sessionId: sessionId.trim() } : {}),
       };
 
       const content = JSON.stringify(association);
@@ -462,6 +466,7 @@ export class SmartMemoryManager {
           entityName: sanitizedEntityName,
           entityType: sanitizedEntityType,
           isEntityAssociation: true,
+          ...(sessionId && sessionId.trim() !== '' ? { sessionId: sessionId.trim() } : {}),
         },
       };
 
@@ -480,6 +485,43 @@ export class SmartMemoryManager {
     }
   }
 
+  /**
+   * Normalize various type aliases to canonical EntityFormat strings using a registry.
+   */
+  private normalizeEntityType(input: string): string {
+    const raw = (input || '').trim();
+    if (raw.length === 0) {
+      return '';
+    }
+
+    const key = raw.replace(/[^a-z]/gi, '').toLowerCase();
+
+    const REGISTRY: Record<string, string> = {
+      topic: 'topicId',
+      topicid: 'topicId',
+      token: 'tokenId',
+      tokenid: 'tokenId',
+      account: 'accountId',
+      accountid: 'accountId',
+      contract: 'contractId',
+      contractid: 'contractId',
+      file: 'fileId',
+      fileid: 'fileId',
+      schedule: 'scheduleId',
+      scheduleid: 'scheduleId',
+    };
+
+    if (Object.prototype.hasOwnProperty.call(REGISTRY, key)) {
+      return REGISTRY[key];
+    }
+
+    if (/^[a-z]+Id$/.test(raw)) {
+      return raw;
+    }
+
+    return raw;
+  }
+
   /**
    * Resolve entity references from natural language queries
    * @param query - Search query (entity name or natural language reference)
@@ -611,19 +653,15 @@ export class SmartMemoryManager {
    */
   getEntityAssociations(entityType?: string): EntityAssociation[] {
     try {
-      const sanitizedEntityType = entityType
-        ? entityType.trim().toLowerCase()
-        : undefined;
+      const rawFilter = entityType ? entityType.trim() : undefined;
+      const filterCanonical = rawFilter ? this.normalizeEntityType(rawFilter) : undefined;
 
-      if (
-        entityType &&
-        (!sanitizedEntityType || sanitizedEntityType.length === 0)
-      ) {
+      if (entityType && (!rawFilter || rawFilter.length === 0)) {
         return [];
       }
 
       const SEARCH_ANY_ENTITY = 'entityId';
-      const searchQuery = sanitizedEntityType || SEARCH_ANY_ENTITY;
+      const searchQuery = filterCanonical || SEARCH_ANY_ENTITY;
       const searchResults = this._contentStorage.searchMessages(searchQuery, {
         caseSensitive: false,
         limit: 100,
@@ -638,10 +676,7 @@ export class SmartMemoryManager {
             const parsed = JSON.parse(content);
 
             if (parsed.entityId && parsed.entityName && parsed.entityType) {
-              if (
-                sanitizedEntityType &&
-                parsed.entityType !== sanitizedEntityType
-              ) {
+              if (filterCanonical && parsed.entityType !== filterCanonical) {
                 continue;
               }
 
@@ -667,18 +702,36 @@ export class SmartMemoryManager {
         }
       }
 
-      const results = associations
-        .filter(
-          (assoc, index, arr) =>
-            arr.findIndex((a) => a.entityId === assoc.entityId) === index
-        )
-        .sort((a, b): number => {
-          const getTime = (d: Date | string): number =>
-            d instanceof Date ? d.getTime() : new Date(d).getTime();
-          const aTime = getTime(a.createdAt);
-          const bTime = getTime(b.createdAt);
-          return bTime - aTime;
-        });
+      // Merge duplicates by entityId, preferring the newest and one that carries transactionId
+      const mergedById = new Map<string, EntityAssociation>();
+      const getTime = (d: Date | string): number =>
+        d instanceof Date ? d.getTime() : new Date(d).getTime();
+
+      for (const assoc of associations) {
+        const existing = mergedById.get(assoc.entityId);
+        if (!existing) {
+          mergedById.set(assoc.entityId, assoc);
+          continue;
+        }
+
+        const existingTime = getTime(existing.createdAt);
+        const currentTime = getTime(assoc.createdAt);
+
+        const preferCurrent =
+          currentTime > existingTime ||
+          (!!assoc.transactionId && !existing.transactionId);
+
+        if (preferCurrent) {
+          mergedById.set(assoc.entityId, {
+            ...existing,
+            ...assoc,
+          });
+        }
+      }
+
+      const results = Array.from(mergedById.values()).sort((a, b) =>
+        getTime(b.createdAt) - getTime(a.createdAt)
+      );
 
       return results;
     } catch (error) {

package/src/scripts/test-inscribe-form-generation.ts

@@ -69,9 +69,9 @@ async function createTestAgent(): Promise<ConversationalAgent> {
     network: (process.env.HEDERA_NETWORK as 'testnet' | 'mainnet') || 'testnet',
     openAIApiKey: process.env.OPENAI_API_KEY!,
     openAIModelName: 'gpt-4o-mini',
-    verbose: true, // Enable verbose for debugging
-    disableLogging: false, // Enable logging for debugging
-    entityMemoryEnabled: false, // Disable for testing
+    verbose: true,
+    disableLogging: false,
+    entityMemoryEnabled: false,
   };
 
   const agent = new ConversationalAgent(options);

package/src/scripts/test-inscribe-wrapper-verification.ts

@@ -64,9 +64,9 @@ async function createTestAgent(): Promise<ConversationalAgent> {
     network: (process.env.HEDERA_NETWORK as 'testnet' | 'mainnet') || 'testnet',
     openAIApiKey: process.env.OPENAI_API_KEY!,
     openAIModelName: 'gpt-4o-mini',
-    verbose: false, // Reduce verbosity
-    disableLogging: true, // Disable logs
-    entityMemoryEnabled: false, // Disable for testing
+    verbose: false,
+    disableLogging: true,
+    entityMemoryEnabled: false,
   };
 
   const agent = new ConversationalAgent(options);

package/src/services/attachment-processor.ts

@@ -0,0 +1,163 @@
+import { Logger } from '@hashgraphonline/standards-sdk';
+import type { ContentStoreManager as PackageContentStoreManager } from './content-store-manager';
+
+export interface AttachmentData {
+  name: string;
+  data: string;
+  type: string;
+  size: number;
+}
+
+type ContentStoreManager = PackageContentStoreManager;
+
+/**
+ * Utility for processing file attachments and content references
+ */
+export class AttachmentProcessor {
+  private logger: Logger;
+
+  constructor() {
+    this.logger = new Logger({ module: 'AttachmentProcessor' });
+  }
+
+  /**
+   * Process attachments and create content references
+   */
+  async processAttachments(
+    content: string,
+    attachments: AttachmentData[],
+    contentStoreManager?: ContentStoreManager
+  ): Promise<string> {
+    if (attachments.length === 0) {
+      return content;
+    }
+
+    this.logger.info('Processing attachments with content reference system:', {
+      attachmentCount: attachments.length,
+      totalSize: attachments.reduce((sum, att) => sum + att.size, 0),
+    });
+
+    if (contentStoreManager && contentStoreManager.isInitialized()) {
+      return this.processWithContentStore(content, attachments, contentStoreManager);
+    } else {
+      this.logger.warn('Content storage not available, creating simple file references');
+      return this.processWithSimpleReferences(content, attachments);
+    }
+  }
+
+  /**
+   * Process attachments using content store manager
+   */
+  private async processWithContentStore(
+    content: string,
+    attachments: AttachmentData[],
+    contentStoreManager: ContentStoreManager
+  ): Promise<string> {
+    const contentReferences: string[] = [];
+
+    for (const attachment of attachments) {
+      try {
+        const base64Data = attachment.data.includes('base64,')
+          ? attachment.data.split('base64,')[1]
+          : attachment.data;
+        const buffer = Buffer.from(base64Data, 'base64');
+
+        const contentRef = await contentStoreManager.storeContentIfLarge(
+          buffer,
+          {
+            mimeType: attachment.type,
+            source: 'user_upload',
+            fileName: attachment.name,
+            tags: ['attachment', 'user_file'],
+          }
+        );
+
+        if (contentRef) {
+          if (attachment.type.startsWith('image/')) {
+            contentReferences.push(
+              `[Image File: ${attachment.name}] (content-ref:${contentRef.referenceId})`
+            );
+          } else {
+            contentReferences.push(
+              `[File: ${attachment.name}] (content-ref:${contentRef.referenceId})`
+            );
+          }
+        } else {
+          contentReferences.push(
+            this.createInlineReference(attachment, base64Data)
+          );
+        }
+      } catch (error) {
+        this.logger.error('Failed to process attachment:', {
+          fileName: attachment.name,
+          error: error instanceof Error ? error.message : 'Unknown error',
+        });
+        contentReferences.push(
+          `[File: ${attachment.name} - Error processing file: ${
+            error instanceof Error ? error.message : 'Unknown error'
+          }]`
+        );
+      }
+    }
+
+    const fileList = this.createFileList(attachments);
+    return content
+      ? `${content}\n\nAttached files:\n${fileList}\n\n${contentReferences.join('\n')}`
+      : `Attached files:\n${fileList}\n\n${contentReferences.join('\n')}`;
+  }
+
+  /**
+   * Process attachments with simple file references
+   */
+  private processWithSimpleReferences(content: string, attachments: AttachmentData[]): string {
+    const fileReferences = attachments.map((attachment) => {
+      const sizeStr = this.formatFileSize(attachment.size);
+
+      if (attachment.type.startsWith('image/')) {
+        return `📎 Image: ${attachment.name} (${sizeStr}, ${attachment.type})`;
+      } else {
+        return `📎 File: ${attachment.name} (${sizeStr}, ${attachment.type})`;
+      }
+    });
+
+    return content
+      ? `${content}\n\nAttached files:\n${fileReferences.join('\n')}`
+      : `Attached files:\n${fileReferences.join('\n')}`;
+  }
+
+  /**
+   * Create inline reference for small files
+   */
+  private createInlineReference(attachment: AttachmentData, base64Data: string): string {
+    if (attachment.size < 50000) {
+      if (attachment.type.startsWith('image/')) {
+        return `![${attachment.name}](data:${attachment.type};base64,${base64Data})`;
+      } else {
+        return `[File: ${attachment.name} (${this.formatFileSize(attachment.size)})]\nContent: ${base64Data}`;
+      }
+    } else {
+      return `[File: ${attachment.name} (${this.formatFileSize(attachment.size)}) - Content too large to include inline]`;
+    }
+  }
+
+  /**
+   * Create formatted file list
+   */
+  private createFileList(attachments: AttachmentData[]): string {
+    return attachments
+      .map((file) => {
+        const sizeStr = this.formatFileSize(file.size);
+        return `📎 ${file.name} (${sizeStr})`;
+      })
+      .join('\n');
+  }
+
+  /**
+   * Format file size for display
+   */
+  private formatFileSize(size: number): string {
+    return size >= 1024 * 1024
+      ? `${(size / (1024 * 1024)).toFixed(1)}MB`
+      : `${(size / 1024).toFixed(1)}KB`;
+  }
+}

package/src/services/content-store-manager.ts

@@ -165,8 +165,26 @@ export class ContentStoreManager {
     }
 
     try {
-      await ContentStoreService.setInstance(this.adapter);
-      ContentResolverRegistry.register(this.resolver);
+      if (
+        ContentStoreService &&
+        typeof (ContentStoreService as unknown as { setInstance?: Function }).setInstance === 'function'
+      ) {
+        await (ContentStoreService as unknown as { setInstance: (adapter: unknown) => Promise<void> }).setInstance(
+          this.adapter
+        );
+      } else {
+        this.logger.warn('ContentStoreService.setInstance is unavailable; skipping registration');
+      }
+      if (
+        ContentResolverRegistry &&
+        typeof (ContentResolverRegistry as unknown as { register?: Function }).register === 'function'
+      ) {
+        (ContentResolverRegistry as unknown as { register: (resolver: unknown) => void }).register(
+          this.resolver
+        );
+      } else {
+        this.logger.warn('ContentResolverRegistry.register is unavailable; skipping registration');
+      }
       this.isRegistered = true;
       this.logger.info(
         'ContentStoreManager initialized and registered for cross-package access'
@@ -236,8 +254,18 @@ export class ContentStoreManager {
   async dispose(): Promise<void> {
     if (this.isRegistered) {
       this.contentStorage.dispose();
-      ContentStoreService.dispose();
-      ContentResolverRegistry.unregister();
+      if (
+        ContentStoreService &&
+        typeof (ContentStoreService as unknown as { dispose?: Function }).dispose === 'function'
+      ) {
+        (ContentStoreService as unknown as { dispose: () => void }).dispose();
+      }
+      if (
+        ContentResolverRegistry &&
+        typeof (ContentResolverRegistry as unknown as { unregister?: Function }).unregister === 'function'
+      ) {
+        (ContentResolverRegistry as unknown as { unregister: () => void }).unregister();
+      }
       this.isRegistered = false;
       this.logger.info('ContentStoreManager disposed and unregistered');
     }

package/src/services/index.ts

@@ -1,3 +1,5 @@
 export * from './entity-resolver';
 export * from './content-store-manager';
 export * from './formatters';
+export * from './parameter-service';
+export * from './attachment-processor';