@hashgraphonline/conversational-agent 0.1.215 → 0.1.217

package/src/mcp/ContentProcessor.ts

@@ -18,6 +18,19 @@ export interface ProcessedResponse {
   errors?: string[];
 }
 
+/**
+ * Content reference interface
+ */
+interface ContentReference {
+  referenceId: string;
+  preview?: string;
+  metadata: {
+    sizeBytes: number;
+    contentType?: string;
+    [key: string]: unknown;
+  };
+}
+
 export interface ContentAnalysis {
   shouldProcess: boolean;
   contents: MCPResponseContent[];
@@ -226,7 +239,7 @@ export class MCPContentProcessor {
     return result;
   }
 
-  private createLightweightReference(reference: any): Record<string, unknown> {
+  private createLightweightReference(reference: ContentReference): Record<string, unknown> {
     return {
       type: 'content_reference',
       referenceId: reference.referenceId,
@@ -238,7 +251,7 @@ export class MCPContentProcessor {
     };
   }
 
-  private replaceContentInResponse(obj: unknown, oldContent: unknown, newContent: any): void {
+  private replaceContentInResponse(obj: unknown, oldContent: unknown, newContent: unknown): void {
     if (obj === null || obj === undefined) {
       return;
     }
@@ -260,8 +273,11 @@ export class MCPContentProcessor {
         for (const key of Object.keys(record)) {
           delete record[key];
         }
-        for (const key of Object.keys(newContent)) {
-          record[key] = newContent[key];
+        if (typeof newContent === 'object' && newContent !== null) {
+          const newContentRecord = newContent as Record<string, unknown>;
+          for (const key of Object.keys(newContentRecord)) {
+            record[key] = newContentRecord[key];
+          }
         }
         return;
       }

package/src/mcp/MCPClientManager.ts

@@ -3,7 +3,7 @@ import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js'
 import type { MCPServerConfig, MCPToolInfo, MCPConnectionStatus } from './types';
 import { Logger } from '@hashgraphonline/standards-sdk';
 import type { ContentStorage } from '../memory/ContentStorage';
-import { MCPContentProcessor, ProcessedResponse } from './ContentProcessor';
+import { MCPContentProcessor } from './ContentProcessor';
 
 /**
  * Manages connections to MCP servers and tool discovery

package/src/mcp/adapters/langchain.ts

@@ -87,7 +87,7 @@ export function convertMCPToolToLangChain(
                 originalSize: responseBuffer.length
               });
               return `content-ref:${referenceId}`;
-            } catch (storeError) {
+            } catch {
             }
           }
         }

package/src/memory/ContentStorage.ts

@@ -207,7 +207,7 @@ export class ContentStorage implements ContentReferenceStore {
         matches = this.messages
           .filter(stored => regex.test(stored.message.content as string))
           .map(stored => stored.message);
-      } catch (error) {
+      } catch {
         return [];
       }
     } else {
@@ -365,7 +365,6 @@ export class ContentStorage implements ContentReferenceStore {
     }));
   }
 
-
   /**
    * Determine if content should be stored as a reference based on size
    */
@@ -377,6 +376,9 @@ export class ContentStorage implements ContentReferenceStore {
   /**
    * 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
    */
   async storeContentIfLarge(
     content: Buffer | string,
@@ -392,7 +394,9 @@ export class ContentStorage implements ContentReferenceStore {
   ): Promise<ContentReference | null> {
     const buffer = Buffer.isBuffer(content) ? content : Buffer.from(content, 'utf8');
     
-    if (!this.shouldUseReference(buffer)) {
+    const isImageFile = this.isImageContent(metadata.mimeType, metadata.fileName);
+    
+    if (!isImageFile && !this.shouldUseReference(buffer)) {
       return null;
     }
     
@@ -744,7 +748,6 @@ export class ContentStorage implements ContentReferenceStore {
     return { ...this.referenceConfig };
   }
 
-
   private async enforceReferenceStorageLimits(): Promise<void> {
     if (this.contentStore.size >= this.referenceConfig.maxReferences) {
       await this.performCleanup();
@@ -845,6 +848,23 @@ export class ContentStorage implements ContentReferenceStore {
     }
   }
 
+  /**
+   * Check if content is an image file based on MIME type or filename
+   */
+  private isImageContent(mimeType?: string, fileName?: string): boolean {
+    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));
+    }
+    
+    return false;
+  }
+
   private recordPerformanceMetric(type: 'creation' | 'resolution' | 'cleanup', timeMs: number): void {
     const metrics = this.referenceStats.performanceMetrics;
     const maxRecords = 100;
@@ -880,7 +900,7 @@ export class ContentStorage implements ContentReferenceStore {
     this.cleanupTimer = setInterval(async () => {
       try {
         await this.performCleanup();
-      } catch (error) {
+      } catch {
       }
     }, this.referenceConfig.cleanupIntervalMs);
   }

package/src/memory/SmartMemoryManager.ts

@@ -1,4 +1,5 @@
 import type { BaseMessage } from '@langchain/core/messages';
+import { Logger } from '@hashgraphonline/standards-sdk';
 import { MemoryWindow } from './MemoryWindow';
 import { ContentStorage } from './ContentStorage';
 import { TokenCounter } from './TokenCounter';
@@ -88,6 +89,7 @@ export class SmartMemoryManager {
   private _contentStorage: ContentStorage;
   private tokenCounter: TokenCounter;
   private config: Required<SmartMemoryConfig>;
+  private logger: Logger;
 
   private static readonly DEFAULT_CONFIG: Required<SmartMemoryConfig> = {
     maxTokens: 8000,
@@ -98,6 +100,7 @@ export class SmartMemoryManager {
 
   constructor(config: SmartMemoryConfig = {}) {
     this.config = { ...SmartMemoryManager.DEFAULT_CONFIG, ...config };
+    this.logger = new Logger({ module: 'SmartMemoryManager' });
 
     this.tokenCounter = new TokenCounter(this.config.modelName);
     this._contentStorage = new ContentStorage(this.config.storageLimit);
@@ -446,7 +449,14 @@ export class SmartMemoryManager {
       };
 
       this._contentStorage.storeMessages([entityMessage as BaseMessage]);
-    } catch (_error) {}
+    } catch (error) {
+      this.logger.error('Failed to store entity association', {
+        entityId,
+        entityName,
+        entityType,
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
   }
 
   /**
@@ -563,7 +573,12 @@ export class SmartMemoryManager {
       const results = uniqueAssociations.slice(0, safeLimit);
 
       return results;
-    } catch (_error) {
+    } catch (error) {
+      this.logger.error('Failed to resolve entity reference', {
+        query,
+        options,
+        error: error instanceof Error ? error.message : String(error)
+      });
       return [];
     }
   }
@@ -616,7 +631,11 @@ export class SmartMemoryManager {
               associations.push(parsed as EntityAssociation);
             }
           }
-        } catch (_parseError) {
+        } catch (parseError) {
+          this.logger.warn('Failed to parse entity association from message', {
+            messageContent: typeof message.content === 'string' ? message.content.substring(0, 100) : 'non-string',
+            error: parseError instanceof Error ? parseError.message : String(parseError)
+          });
           continue;
         }
       }
@@ -635,7 +654,11 @@ export class SmartMemoryManager {
         });
 
       return results;
-    } catch (_error) {
+    } catch (error) {
+      this.logger.error('Failed to get entity associations', {
+        entityType,
+        error: error instanceof Error ? error.message : String(error)
+      });
       return [];
     }
   }

package/src/memory/TokenCounter.ts

@@ -36,7 +36,7 @@ export class TokenCounter {
     try {
       const tokens = this.encoding.encode(text);
       return tokens.length;
-    } catch (error) {
+    } catch {
       return Math.ceil(text.split(/\s+/).length * 1.3);
     }
   }

package/src/plugins/hbar/HbarPlugin.ts

@@ -76,7 +76,6 @@ export class HbarPlugin extends BasePlugin {
   }
 
   override getTools(): HederaTool[] {
-    // @ts-ignore
     return this.tools;
   }
 

package/src/scripts/test-external-tool-wrapper.ts

@@ -9,14 +9,13 @@ async function testExternalToolWrapper() {
   console.log('🧪 Testing External Tool Wrapper\n');
 
   try {
-    // Test 1: Basic wrapping
+
     console.log('📝 Test 1: Basic external tool wrapping');
     const basicTool = examples.basicWrapping();
     console.log(`✅ Tool "${basicTool.name}" wrapped successfully`);
     console.log(`   Description: ${basicTool.description}`);
     console.log(`   Schema type: ${basicTool.schema.constructor.name}`);
     
-    // Test the wrapped tool execution
     const testInput = {
       fromAccountId: '0.0.123',
       toAccountId: '0.0.456',
@@ -27,13 +26,11 @@ async function testExternalToolWrapper() {
     const result = await (basicTool as any)._call(testInput);
     console.log(`   Execution result: ${result}\n`);
 
-    // Test 2: Preset configurations
     console.log('📝 Test 2: Preset configurations');
     const presetTool = examples.presetConfigurations();
     console.log(`✅ Tool "${presetTool.name}" wrapped with preset config`);
     console.log(`   Description: ${presetTool.description}\n`);
 
-    // Test 3: Batch wrapping
     console.log('📝 Test 3: Batch wrapping multiple tools');
     const batchTools = examples.batchWrapping();
     console.log(`✅ Wrapped ${batchTools.length} tools in batch`);
@@ -42,16 +39,14 @@ async function testExternalToolWrapper() {
     });
     console.log();
 
-    // Test 4: Form validation integration
     console.log('📝 Test 4: Form validation integration');
     const formTool = examples.formValidationIntegration();
     console.log(`✅ Tool "${formTool.name}" wrapped with form validation`);
     console.log(`   Tool type: ${formTool.constructor.name}`);
     
-    // Test with incomplete input to trigger form generation
     const incompleteInput = {
       fromAccountId: '0.0.123'
-      // Missing required fields: toAccountId, amount
+
     } as any;
     
     try {
@@ -68,17 +63,15 @@ async function testExternalToolWrapper() {
     }
     console.log();
 
-    // Test 5: Custom field configurations
     console.log('📝 Test 5: Custom field configurations');
     const customTool = examples.customFieldConfigs();
     console.log(`✅ Tool "${customTool.name}" wrapped with custom configs`);
     console.log(`   Description: ${customTool.description}`);
     
-    // Check if schema has render configs attached
     const schema = customTool.schema as any;
     const shape = schema._def.shape();
     let fieldConfigCount = 0;
-    for (const [fieldName, fieldSchema] of Object.entries(shape)) {
+    for (const [, fieldSchema] of Object.entries(shape)) {
       if ((fieldSchema as any)._renderConfig) {
         fieldConfigCount++;
       }
@@ -86,7 +79,6 @@ async function testExternalToolWrapper() {
     console.log(`   Fields with render configs: ${fieldConfigCount}`);
     console.log();
 
-    // Test 6: Render config helpers
     console.log('📝 Test 6: Render config helpers');
     const { renderConfigs } = await import('../langchain/external-tool-wrapper');
     
@@ -108,5 +100,4 @@ async function testExternalToolWrapper() {
   }
 }
 
-// Run the tests
 testExternalToolWrapper().catch(console.error);

package/src/scripts/test-hedera-kit-wrapper.ts

@@ -27,7 +27,7 @@ class MockHederaGetAccountInfoTool extends StructuredTool {
   protected async _call(
     input: z.infer<typeof this.schema>
   ): Promise<string> {
-    // Simulate hedera-agent-kit tool behavior
+
     return JSON.stringify({
       success: true,
       accountId: input.accountId,
@@ -104,13 +104,11 @@ async function testHederaKitWrapper(): Promise<void> {
   try {
     logger.info('🚀 Starting Hedera Agent Kit external tool wrapper test');
 
-    // Create mock tools that simulate hedera-agent-kit tool structure
     const originalTool = new MockHederaGetAccountInfoTool();
     const transferTool = new MockHederaTransferHbarTool();
     logger.info(`📋 Testing with tool: ${originalTool.name}`);
     logger.info(`📝 Original tool description: ${originalTool.description}`);
 
-    // Test 1: Basic external tool wrapping with render configs
     logger.info('\n🔧 Test 1: Wrapping external tool with render configs');
     
     const wrappedTool = wrapExternalToolWithRenderConfig(originalTool, {
@@ -129,12 +127,10 @@ async function testHederaKitWrapper(): Promise<void> {
     logger.info(`✅ Wrapped tool description: ${wrappedTool.description}`);
     logger.info(`✅ Wrapped tool type: ${wrappedTool.constructor.name}`);
     
-    // Verify the wrapped tool has enhanced schema
     const enhancedSchema = wrappedTool.schema;
     const hasRenderConfig = !!((enhancedSchema as unknown as { _renderConfig?: unknown })._renderConfig);
     logger.info(`✅ Has tool-level render config: ${hasRenderConfig}`);
 
-    // Test 2: Integration with FormValidatingToolWrapper
     logger.info('\n🔧 Test 2: Integration with FormValidatingToolWrapper');
     
     const formGenerator = new FormGenerator();
@@ -150,16 +146,15 @@ async function testHederaKitWrapper(): Promise<void> {
     logger.info(`✅ Form validating tool created: ${formValidatingTool.name}`);
     logger.info(`✅ Form validating tool type: ${formValidatingTool.constructor.name}`);
 
-    // Test 3: Form generation with missing fields
     logger.info('\n🔧 Test 3: Testing form generation with incomplete input');
     
     const incompleteInput = {
-      // Missing required accountId field
+
       includeBalances: true
     };
 
     try {
-      const result = await formValidatingTool._call(incompleteInput as z.infer<typeof originalTool.schema>);
+      const result = await (formValidatingTool as any)._call(incompleteInput as z.infer<typeof originalTool.schema>);
       const parsedResult = JSON.parse(result);
       
       if (parsedResult.requiresForm) {
@@ -174,7 +169,6 @@ async function testHederaKitWrapper(): Promise<void> {
       logger.error('❌ Form generation test failed:', error);
     }
 
-    // Test 4: Batch wrapping with predefined configs
     logger.info('\n🔧 Test 4: Testing batch wrapping with predefined configs');
     
     const batchWrappedTools = [
@@ -187,10 +181,8 @@ async function testHederaKitWrapper(): Promise<void> {
     logger.info(`✅ Batch wrapped ${batchWrappedTools.length} tools`);
     logger.info(`✅ Batch wrapped tool: ${batchWrappedTools[0].name}`);
 
-    // Test 5: Verify external tool wrapper type safety
     logger.info('\n🔧 Test 5: Testing TypeScript type safety');
     
-    // This should compile without type errors
     const typedWrapper: ExternalToolWrapper<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>> = wrappedTool;
     const typedFormWrapper: FormValidatingToolWrapper<z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>> = formValidatingTool;
     
@@ -198,17 +190,14 @@ async function testHederaKitWrapper(): Promise<void> {
     logger.info(`✅ External wrapper type: ${typedWrapper.constructor.name}`);
     logger.info(`✅ Form wrapper type: ${typedFormWrapper.constructor.name}`);
 
-    // Test 6: Verify tool delegation works
     logger.info('\n🔧 Test 6: Testing tool delegation');
     
-    // Test that the wrapper correctly delegates to the original tool
-    logger.info(`✅ Original tool callable: ${typeof originalTool._call === 'function'}`);
-    logger.info(`✅ Wrapped tool callable: ${typeof wrappedTool._call === 'function'}`);
-    logger.info(`✅ Form tool callable: ${typeof formValidatingTool._call === 'function'}`);
+    logger.info(`✅ Original tool callable: ${typeof (originalTool as any)._call === 'function'}`);
+    logger.info(`✅ Wrapped tool callable: ${typeof (wrappedTool as any)._call === 'function'}`);
+    logger.info(`✅ Form tool callable: ${typeof (formValidatingTool as any)._call === 'function'}`);
 
     logger.info('\n🎉 All external tool wrapper tests completed successfully!');
     
-    // Summary
     logger.info('\n📊 Test Summary:');
     logger.info('✅ External tool wrapping with render configs works');
     logger.info('✅ Integration with FormValidatingToolWrapper works');
@@ -236,22 +225,18 @@ function demonstrateRenderConfigs(): void {
   
   logger.info('\n🎨 Demonstrating available render configurations:');
   
-  // Account-related configs
   logger.info('\n👤 Account Configurations:');
   const accountConfig = renderConfigs.accountId('Target Account');
   logger.info(`- Account ID: ${JSON.stringify(accountConfig, null, 2)}`);
   
-  // Currency configs
   logger.info('\n💰 Currency Configurations:');
   const currencyConfig = renderConfigs.currency('Transfer Amount', 'HBAR', 0.00000001, 1000);
   logger.info(`- Currency: ${JSON.stringify(currencyConfig, null, 2)}`);
   
-  // Token configs
   logger.info('\n🪙 Token Configurations:');
   const tokenConfig = renderConfigs.tokenId('Token to Transfer');
   logger.info(`- Token ID: ${JSON.stringify(tokenConfig, null, 2)}`);
   
-  // Form control configs
   logger.info('\n📝 Form Control Configurations:');
   const textConfig = renderConfigs.text('Transaction Memo', 'Enter memo', 'Optional transaction memo');
   const selectConfig = renderConfigs.select('Network', [
@@ -265,7 +250,6 @@ function demonstrateRenderConfigs(): void {
   logger.info('\n✨ These configurations enhance hedera-agent-kit tools with rich UI metadata!');
 }
 
-// Run the test if this file is executed directly
 if (import.meta.url === `file://${process.argv[1]}`) {
   testHederaKitWrapper()
     .then(() => {