@hashgraphonline/conversational-agent 0.2.101 → 0.2.103

package/src/langchain/langchain-agent.ts

@@ -621,46 +621,56 @@ export class LangChainAgent extends BaseAgent {
       );
     }
 
-    const parsedSteps = result?.intermediateSteps?.[0]?.observation;
-    if (
-      parsedSteps &&
-      typeof parsedSteps === 'string' &&
-      this.isJSON(parsedSteps)
-    ) {
+    const steps = (result?.intermediateSteps as IntermediateStep[]) || [];
+    const lastJsonObservation = [...steps]
+      .reverse()
+      .find(
+        (s) => typeof s?.observation === 'string' && this.isJSON(s.observation as string)
+      )?.observation as string | undefined;
+
+    if (lastJsonObservation) {
       try {
-        const parsed = JSON.parse(parsedSteps);
+        const parsed = JSON.parse(lastJsonObservation);
 
         if (ResponseFormatter.isInscriptionResponse(parsed)) {
-          const formattedMessage =
-            ResponseFormatter.formatInscriptionResponse(parsed);
+          const formattedMessage = ResponseFormatter.formatInscriptionResponse(parsed);
           response.output = formattedMessage;
           response.message = formattedMessage;
-
           if (parsed.inscription) {
             response.inscription = parsed.inscription;
           }
           if (parsed.metadata) {
+            response.metadata = { ...response.metadata, ...parsed.metadata };
+          }
+        } else {
+          if (typeof parsed.message === 'string' && parsed.message.trim().length > 0) {
+            response.message = parsed.message;
+            response.output = parsed.message;
+          }
+          if (parsed.success === true) {
+            delete (response as { error?: string }).error;
+          }
+          if (typeof parsed.transactionBytes === 'string') {
             response.metadata = {
               ...response.metadata,
-              ...parsed.metadata,
+              transactionBytes: parsed.transactionBytes as string,
             };
           }
-        } else {
-          response = { ...response, ...parsed };
+          if (typeof parsed.scheduleId === 'string') {
+            (response as { scheduleId?: string }).scheduleId = parsed.scheduleId as string;
+          }
         }
 
         const blockMetadata = this.processHashLinkBlocks(parsed);
         if (blockMetadata.hashLinkBlock) {
-          response.metadata = {
-            ...response.metadata,
-            ...blockMetadata,
-          };
+          response.metadata = { ...response.metadata, ...blockMetadata };
         }
       } catch (error) {
         this.logger.error('Error parsing intermediate steps:', error);
       }
     }
 
+
     if (!response.output || response.output.trim() === '') {
       response.output = 'Agent action complete.';
     }

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);