@hashgraphonline/standards-agent-kit 0.2.137 → 0.2.138

package/src/tools/hcs2/DeleteEntryTool.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS2QueryTool } from './base-hcs2-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { isWalletBytesResponse, type RegistryOperationResult } from '../../types/tx-results';
 
 /**
  * Schema for deleting an entry from HCS-2
@@ -37,7 +38,7 @@ export class DeleteEntryTool extends BaseHCS2QueryTool<typeof deleteEntrySchema>
     _runManager?: CallbackManagerForToolRun
   ): Promise<unknown> {
     try {
-      const result = await this.hcs2Builder.deleteEntry(
+      const result: RegistryOperationResult = await this.hcs2Builder.deleteEntry(
         params.registryTopicId,
         {
           uid: params.uid,
@@ -45,10 +46,23 @@ export class DeleteEntryTool extends BaseHCS2QueryTool<typeof deleteEntrySchema>
         }
       );
 
-      if (!result.success) {
+      if (!('success' in result) || !result.success) {
         throw new Error(result.error || 'Failed to delete entry');
       }
 
+      if (isWalletBytesResponse(result)) {
+        const txBytes = result.transactionBytes;
+        return {
+          message: 'I prepared an unsigned transaction to delete the HCS-2 registry entry. Please review and approve to submit.',
+          transactionBytes: txBytes,
+          metadata: {
+            transactionBytes: txBytes,
+            pendingApproval: true,
+            description: `Delete HCS-2 entry (registry ${params.registryTopicId}, uid ${params.uid})`,
+          },
+        };
+      }
+
       return `Successfully deleted entry from HCS-2 registry!\n\nRegistry Topic: ${params.registryTopicId}\nUID: ${params.uid}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe entry has been removed from the registry.`;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to delete entry';

package/src/tools/hcs2/MigrateRegistryTool.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS2QueryTool } from './base-hcs2-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { isWalletBytesResponse, type RegistryOperationResult } from '../../types/tx-results';
 
 /**
  * Schema for migrating an HCS-2 registry
@@ -42,7 +43,7 @@ export class MigrateRegistryTool extends BaseHCS2QueryTool<typeof migrateRegistr
     _runManager?: CallbackManagerForToolRun
   ): Promise<unknown> {
     try {
-      const result = await this.hcs2Builder.migrateRegistry(
+      const result: RegistryOperationResult = await this.hcs2Builder.migrateRegistry(
         params.registryTopicId,
         {
           targetTopicId: params.targetTopicId,
@@ -51,10 +52,23 @@ export class MigrateRegistryTool extends BaseHCS2QueryTool<typeof migrateRegistr
         }
       );
 
-      if (!result.success) {
+      if (!('success' in result) || !result.success) {
         throw new Error(result.error || 'Failed to migrate registry');
       }
 
+      if (isWalletBytesResponse(result)) {
+        const txBytes = result.transactionBytes;
+        return {
+          message: 'I prepared an unsigned transaction to migrate the HCS-2 registry. Please review and approve to submit.',
+          transactionBytes: txBytes,
+          metadata: {
+            transactionBytes: txBytes,
+            pendingApproval: true,
+            description: `Migrate HCS-2 registry (from ${params.registryTopicId} to ${params.targetTopicId})`,
+          },
+        };
+      }
+
       return `Successfully migrated HCS-2 registry!\n\nFrom Registry Topic: ${params.registryTopicId}\nTo Target Topic: ${params.targetTopicId}${params.metadata ? `\nMetadata: ${params.metadata}` : ''}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe registry has been migrated to the new topic.`;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to migrate registry';

package/src/tools/hcs2/QueryRegistryTool.ts

@@ -34,7 +34,7 @@ const queryRegistrySchema = z.object({
  */
 export class QueryRegistryTool extends BaseHCS2QueryTool<typeof queryRegistrySchema> {
   name = 'queryHCS2Registry';
-  description = 'Query entries from an HCS-2 registry';
+  description = 'Query entries from an HCS-2 registry (standard HCS-2). Retrieves indexed or latest entries and returns a structured summary.'
 
   get specificInputSchema() {
     return queryRegistrySchema;
@@ -50,9 +50,18 @@ export class QueryRegistryTool extends BaseHCS2QueryTool<typeof queryRegistrySch
       skip: params.skip,
     });
 
+    const typeVal = (registry as unknown as { registryType: unknown }).registryType;
+    const isIndexed =
+      typeVal === 0 ||
+      typeVal === '0' ||
+      String(typeVal).toLowerCase() === 'indexed' ||
+      String(typeVal).toLowerCase() === 'index' ||
+      String(typeVal).toLowerCase() === 'index_topic' ||
+      String(typeVal).toLowerCase() === 'indexed_registry';
+
     return {
       topicId: registry.topicId,
-      registryType: registry.registryType === 0 ? 'indexed' : 'non-indexed',
+      registryType: isIndexed ? 'indexed' : 'non-indexed',
       ttl: registry.ttl,
       totalEntries: registry.entries.length,
       entries: registry.entries.map(entry => ({

package/src/tools/hcs2/RegisterEntryTool.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS2QueryTool } from './base-hcs2-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { isWalletBytesResponse, type RegistryOperationResult } from '../../types/tx-results';
 
 /**
  * Schema for registering an entry in HCS-2
@@ -30,7 +31,7 @@ const registerEntrySchema = z.object({
  */
 export class RegisterEntryTool extends BaseHCS2QueryTool<typeof registerEntrySchema> {
   name = 'registerHCS2Entry';
-  description = 'Register a new entry in an HCS-2 registry';
+  description = 'Register an entry in an HCS-2 registry (standard HCS-2). Use this to add a target topic to an existing HCS-2 registry.'
 
   get specificInputSchema(): typeof registerEntrySchema {
     return registerEntrySchema;
@@ -41,7 +42,7 @@ export class RegisterEntryTool extends BaseHCS2QueryTool<typeof registerEntrySch
     _runManager?: CallbackManagerForToolRun
   ): Promise<unknown> {
     try {
-      const result = await this.hcs2Builder.registerEntry(
+      const result: RegistryOperationResult = await this.hcs2Builder.registerEntry(
         params.registryTopicId,
         {
           targetTopicId: params.targetTopicId,
@@ -50,10 +51,23 @@ export class RegisterEntryTool extends BaseHCS2QueryTool<typeof registerEntrySch
         }
       );
 
-      if (!result.success) {
+      if (!('success' in result) || !result.success) {
         throw new Error(result.error || 'Failed to register entry');
       }
 
+      if (isWalletBytesResponse(result)) {
+        const txBytes = result.transactionBytes;
+        return {
+          message: 'I prepared an unsigned transaction to register the entry in the HCS-2 registry. Please review and approve to submit.',
+          transactionBytes: txBytes,
+          metadata: {
+            transactionBytes: txBytes,
+            pendingApproval: true,
+            description: `Register HCS-2 entry (registry ${params.registryTopicId} -> target ${params.targetTopicId})`,
+          },
+        };
+      }
+
       return `Successfully registered entry in HCS-2 registry!\n\nRegistry Topic: ${params.registryTopicId}\nTarget Topic ID: ${params.targetTopicId}${params.metadata ? `\nMetadata: ${params.metadata}` : ''}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe entry has been added to the registry.`;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to register entry';

package/src/tools/hcs2/UpdateEntryTool.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS2QueryTool } from './base-hcs2-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { isWalletBytesResponse, type RegistryOperationResult } from '../../types/tx-results';
 
 /**
  * Schema for updating an entry in HCS-2
@@ -45,7 +46,7 @@ export class UpdateEntryTool extends BaseHCS2QueryTool<typeof updateEntrySchema>
     _runManager?: CallbackManagerForToolRun
   ): Promise<unknown> {
     try {
-      const result = await this.hcs2Builder.updateEntry(
+      const result: RegistryOperationResult = await this.hcs2Builder.updateEntry(
         params.registryTopicId,
         {
           targetTopicId: params.targetTopicId,
@@ -55,10 +56,23 @@ export class UpdateEntryTool extends BaseHCS2QueryTool<typeof updateEntrySchema>
         }
       );
 
-      if (!result.success) {
+      if (!('success' in result) || !result.success) {
         throw new Error(result.error || 'Failed to update entry');
       }
 
+      if (isWalletBytesResponse(result)) {
+        const txBytes = result.transactionBytes;
+        return {
+          message: 'I prepared an unsigned transaction to update the HCS-2 registry entry. Please review and approve to submit.',
+          transactionBytes: txBytes,
+          metadata: {
+            transactionBytes: txBytes,
+            pendingApproval: true,
+            description: `Update HCS-2 entry (registry ${params.registryTopicId}, uid ${params.uid} -> ${params.targetTopicId})`,
+          },
+        };
+      }
+
       return `Successfully updated entry in HCS-2 registry!\n\nRegistry Topic: ${params.registryTopicId}\nUID: ${params.uid}\nNew Target Topic ID: ${params.targetTopicId}${params.metadata ? `\nMetadata: ${params.metadata}` : ''}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe entry has been updated in the registry.`;
     } catch (error) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to update entry';

package/src/tools/hcs6/CreateDynamicRegistryTool.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { isWalletBytesResponse } from '../../types/tx-results';
 import { HCS6QueryToolParams } from './hcs6-tool-params';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
@@ -44,10 +45,23 @@ export class CreateDynamicRegistryTool extends BaseHCS6QueryTool<typeof CreateDy
       submitKey: params.submitKey,
     });
 
-    if (!result.success) {
-      throw new Error(result.error || 'Failed to create dynamic registry');
+    if (!('success' in result) || !result.success) {
+      throw new Error((result as any).error || 'Failed to create dynamic registry');
     }
 
-    return `Successfully created HCS-6 dynamic registry!\n\nTopic ID: ${result.topicId}\nTTL: ${params.ttl} seconds\n\nYou can now register dynamic hashinals to this registry using the topic ID.`;
+    if (isWalletBytesResponse(result)) {
+      const txBytes = result.transactionBytes;
+      return {
+        message: 'I prepared an unsigned transaction to create your HCS-6 dynamic registry. Please review and approve to submit.',
+        transactionBytes: txBytes,
+        metadata: {
+          transactionBytes: txBytes,
+          pendingApproval: true,
+          description: `Create HCS-6 dynamic registry (TTL: ${params.ttl}s)`,
+        },
+      };
+    }
+
+    return `Successfully created HCS-6 dynamic registry!\n\nTopic ID: ${(result as any).topicId}\nTTL: ${params.ttl} seconds\n\nYou can now register dynamic hashinals to this registry using the topic ID.`;
   }
 }

package/src/tools/hcs6/RegisterDynamicHashinalTool.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { isWalletBytesResponse } from '../../types/tx-results';
 import { HCS6QueryToolParams } from './hcs6-tool-params';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
@@ -60,10 +61,23 @@ export class RegisterDynamicHashinalTool extends BaseHCS6QueryTool<typeof Regist
       submitKey: params.submitKey,
     });
 
-    if (!result.success) {
-      throw new Error(result.error || 'Failed to register dynamic hashinal');
+    if (!('success' in result) || !result.success) {
+      throw new Error((result as any).error || 'Failed to register dynamic hashinal');
     }
 
-    return `Successfully registered dynamic hashinal!\n\nRegistry Topic ID: ${result.registryTopicId}\nInscription Topic ID: ${result.inscriptionTopicId}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe dynamic hashinal has been created and can be updated using the registry topic ID.`;
+    if (isWalletBytesResponse(result as any)) {
+      const txBytes = (result as any).transactionBytes as string;
+      return {
+        message: 'I prepared an unsigned transaction to register a dynamic hashinal. Please review and approve to submit.',
+        transactionBytes: txBytes,
+        metadata: {
+          transactionBytes: txBytes,
+          pendingApproval: true,
+          description: `Register dynamic hashinal${params.memo ? ` (Memo: ${params.memo})` : ''}`,
+        },
+      };
+    }
+
+    return `Successfully registered dynamic hashinal!\n\nRegistry Topic ID: ${(result as any).registryTopicId}\nInscription Topic ID: ${(result as any).inscriptionTopicId}${params.memo ? `\nMemo: ${params.memo}` : ''}\n\nThe dynamic hashinal has been created and can be updated using the registry topic ID.`;
   }
 }

package/src/tools/hcs6/UpdateDynamicHashinalTool.ts

@@ -1,5 +1,6 @@
 import { z } from 'zod';
 import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { isWalletBytesResponse } from '../../types/tx-results';
 import { HCS6QueryToolParams } from './hcs6-tool-params';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
@@ -54,10 +55,23 @@ export class UpdateDynamicHashinalTool extends BaseHCS6QueryTool<typeof UpdateDy
       submitKey: params.submitKey,
     });
 
-    if (!result.success) {
-      throw new Error(result.error || 'Failed to update dynamic hashinal');
+    if (!('success' in result) || !result.success) {
+      throw new Error((result as any).error || 'Failed to update dynamic hashinal');
     }
 
-    return `Successfully updated dynamic hashinal!\n\nRegistry Topic ID: ${params.registryTopicId}\nInscription Topic ID: ${result.inscriptionTopicId}${params.memo ? `\nUpdate Memo: ${params.memo}` : ''}\n\nThe dynamic hashinal has been updated with new content.`;
+    if (isWalletBytesResponse(result as any)) {
+      const txBytes = (result as any).transactionBytes as string;
+      return {
+        message: 'I prepared an unsigned transaction to update a dynamic hashinal. Please review and approve to submit.',
+        transactionBytes: txBytes,
+        metadata: {
+          transactionBytes: txBytes,
+          pendingApproval: true,
+          description: `Update dynamic hashinal (registry ${params.registryTopicId})${params.memo ? ` (Memo: ${params.memo})` : ''}`,
+        },
+      };
+    }
+
+    return `Successfully updated dynamic hashinal!\n\nRegistry Topic ID: ${params.registryTopicId}\nInscription Topic ID: ${(result as any).inscriptionTopicId}${params.memo ? `\nUpdate Memo: ${params.memo}` : ''}\n\nThe dynamic hashinal has been updated with new content.`;
   }
 }

package/src/tools/inscriber/InscribeFromBufferTool.ts

@@ -64,19 +64,92 @@ export class InscribeFromBufferTool extends BaseInscriberQueryTool<
     return inscribeFromBufferSchema;
   }
 
+  protected override async _call(
+    args: z.infer<typeof inscribeFromBufferSchema>,
+    _runManager?: CallbackManagerForToolRun
+  ): Promise<string> {
+    try {
+      const input = typeof args.base64Data === 'string' ? args.base64Data : '';
+      const buffer = /^[A-Za-z0-9+/]*={0,2}$/.test(input)
+        ? Buffer.from(input, 'base64')
+        : Buffer.from(input, 'utf8');
+
+      const fileName = args.fileName;
+      const mimeType = args.mimeType;
+
+      const network = this.inscriberBuilder['hederaKit'].client.network
+        .toString()
+        .includes('mainnet')
+        ? 'mainnet'
+        : 'testnet';
+
+      const options: InscriptionOptions = {
+        mode: 'file',
+        metadata: args.metadata,
+        tags: args.tags,
+        chunkSize: args.chunkSize,
+        waitForConfirmation: args.quoteOnly ? false : args.waitForConfirmation ?? true,
+        waitMaxAttempts: 60,
+        waitIntervalMs: 5000,
+        apiKey: args.apiKey,
+        network,
+        quoteOnly: args.quoteOnly,
+      };
+
+      const result = await this.inscriberBuilder.inscribe(
+        { type: 'buffer', buffer, fileName, mimeType },
+        options
+      );
+
+      const typed = result as InscriptionResponse;
+      if (typed.confirmed && !typed.quote) {
+        const ids = extractTopicIds(typed.inscription, typed.result);
+        const { topicId, cdnUrl } = buildInscriptionLinks(ids, network, '1');
+        return JSON.stringify({
+          success: true,
+          data: `Successfully inscribed and confirmed content on the Hedera network!\n\nTransaction ID: ${
+            (typed.result as InscriptionResult)?.transactionId ?? 'unknown'
+          }\nTopic ID: ${topicId || 'N/A'}${
+            cdnUrl ? `\nView inscription: ${cdnUrl}` : ''
+          }\n\nThe inscription is now available.`,
+        });
+      }
+
+      return JSON.stringify({
+        success: true,
+        data: `Successfully submitted inscription to the Hedera network!\n\nTransaction ID: ${
+          (typed.result as InscriptionResult)?.transactionId ?? 'unknown'
+        }\n\nThe inscription is processing and will be confirmed shortly.`,
+      });
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      return JSON.stringify({ success: false, error: `Inscription failed: ${errorMessage}` });
+    }
+  }
+
   protected async executeQuery(
     params: z.infer<typeof inscribeFromBufferSchema>,
     _runManager?: CallbackManagerForToolRun
   ): Promise<unknown> {
-    this.validateInput(params);
 
     const resolvedContent = await resolveContent(
       params.base64Data,
       params.mimeType,
       params.fileName
     );
+    console.log('[InscribeFromBufferTool] Resolved content bytes:', resolvedContent.buffer?.length ?? -1);
 
-    this.validateContent(resolvedContent.buffer);
+    try {
+      this.validateContent(resolvedContent.buffer);
+    } catch (validationError) {
+      this.logger?.warn(
+        `Content validation warning: ${
+          validationError instanceof Error
+            ? validationError.message
+            : String(validationError)
+        }`
+      );
+    }
 
     const buffer = resolvedContent.buffer;
     const resolvedMimeType = resolvedContent.mimeType || params.mimeType;
@@ -139,6 +212,7 @@ export class InscribeFromBufferTool extends BaseInscriberQueryTool<
     }
 
     try {
+      console.log('[InscribeFromBufferTool] Calling inscribe with fileName:', resolvedFileName, 'mime:', resolvedMimeType);
       const result = await this.executeInscription(
         buffer,
         resolvedFileName,
@@ -146,8 +220,10 @@ export class InscribeFromBufferTool extends BaseInscriberQueryTool<
         options,
         params.timeoutMs
       );
+      console.log('[InscribeFromBufferTool] Inscribe result (confirmed):', Boolean((result as any)?.confirmed));
       return this.formatInscriptionResult(result, options);
     } catch (error) {
+      console.warn('[InscribeFromBufferTool] Error during inscription:', error);
       const errorMessage =
         error instanceof Error
           ? error.message

package/src/tools/inscriber/InscribeHashinalTool.ts

@@ -51,7 +51,9 @@ const HASHLINK_BLOCK_CONFIG = {
  * @param network The network type to get configuration for
  * @returns Network-specific block configuration with blockId, hashLink, and template
  */
-function getHashLinkBlockId(network) {
+function getHashLinkBlockId(
+  network: 'mainnet' | 'testnet',
+): { blockId: string; hashLink: string; template: string } {
   const config =
     network === 'mainnet'
       ? HASHLINK_BLOCK_CONFIG.mainnet
@@ -534,143 +536,41 @@ export class InscribeHashinalTool
 
       if (result.confirmed && !result.quote) {
         const ids = extractTopicIds(result.inscription, result.result);
-        const network = options.network || 'testnet';
+        const network = (options.network || 'testnet') as 'mainnet' | 'testnet';
         const fileStandard = params.fileStandard || '1';
-        const { hrl, cdnUrl, topicId } = buildInscriptionLinks(
+        const { hrl, topicId, cdnUrl } = buildInscriptionLinks(
           ids,
           network,
           fileStandard
         );
-        const standardType = fileStandard === '6' ? 'Dynamic' : 'Static';
-
-        if (!hrl) {
-          return createInscriptionError({
-            code: 'MISSING_TOPIC_ID',
-            details: 'Inscription completed but topic ID is missing',
-            suggestions: [
-              'Try the inscription again',
-              'Contact support if the issue persists',
-            ],
-          });
-        }
-
-        const inscriptionResponse = createInscriptionSuccess({
-          hrl,
+
+        const txId = (result.result as InscriptionResult)?.transactionId ?? 'unknown';
+        return createInscriptionSuccess({
+          hrl: hrl || 'hcs://1/unknown',
           topicId: topicId || 'unknown',
-          standard: standardType as 'Static' | 'Dynamic',
-          cdnUrl: cdnUrl || undefined,
-          transactionId: (result.result as InscriptionResult)?.transactionId,
+          standard: fileStandard === '6' ? 'Dynamic' : 'Static',
+          cdnUrl,
+          transactionId: txId,
           metadata: {
             name: params.name,
             creator: params.creator,
             description: params.description,
             type: params.type,
-            attributes: params.attributes,
+            attributes: Array.isArray(params.attributes) ? params.attributes : [],
           },
         });
-
-        this.onEntityCreated?.({
-          entityId: topicId || 'unknown',
-          entityName: params.name || 'Unnamed Inscription',
-          entityType: 'topicId',
-          transactionId: (result.result as InscriptionResult)?.transactionId,
-        });
-
-        if (params.withHashLinkBlocks) {
-          try {
-            const blockData = await this.createHashLinkBlock(
-              inscriptionResponse,
-              inscriptionData.type === 'buffer'
-                ? inscriptionData.mimeType
-                : undefined
-            );
-
-            inscriptionResponse.hashLinkBlock = blockData;
-          } catch (blockError) {
-            const logger = new Logger({ module: 'InscribeHashinalTool' });
-            logger.error('Failed to create HashLink block', {
-              error: blockError,
-            });
-          }
-        }
-
-        return inscriptionResponse;
       } else if (!result.quote && !result.confirmed) {
-        const ids = extractTopicIds(result.inscription, result.result);
-        if (ids.jsonTopicId || ids.topicId) {
-          const network = options.network || 'testnet';
-          const fileStandard = params.fileStandard || '1';
-          const { hrl, cdnUrl, topicId } = buildInscriptionLinks(
-            ids,
-            network,
-            fileStandard
-          );
-          const standardType = fileStandard === '6' ? 'Dynamic' : 'Static';
-
-          if (hrl) {
-            const inscriptionResponse = createInscriptionSuccess({
-              hrl,
-              topicId: topicId || 'unknown',
-              standard: standardType as 'Static' | 'Dynamic',
-              cdnUrl: cdnUrl || undefined,
-              transactionId: (result.result as InscriptionResult)
-                ?.transactionId,
-              metadata: {
-                name: params.name,
-                creator: params.creator,
-                description: params.description,
-                type: params.type,
-                attributes: params.attributes,
-              },
-            });
-
-            this.onEntityCreated?.({
-              entityId: topicId || 'unknown',
-              entityName: params.name || 'Unnamed Inscription',
-              entityType: 'topicId',
-              transactionId: (result.result as InscriptionResult)
-                ?.transactionId,
-            });
-
-            if (params.withHashLinkBlocks) {
-              try {
-                const blockData = await this.createHashLinkBlock(
-                  inscriptionResponse,
-                  inscriptionData.type === 'buffer'
-                    ? inscriptionData.mimeType
-                    : undefined
-                );
-
-                inscriptionResponse.hashLinkBlock = blockData;
-              } catch (blockError) {
-                const logger = new Logger({ module: 'InscribeHashinalTool' });
-                logger.error('Failed to create HashLink block', {
-                  error: blockError,
-                });
-              }
-            }
-
-            return inscriptionResponse;
-          }
-        }
-
-        const transactionId =
-          (result.result as InscriptionResult)?.transactionId || 'unknown';
-        const pending = createInscriptionPending({
-          transactionId,
+        const txId = (result.result as InscriptionResult)?.transactionId ?? 'unknown';
+        return createInscriptionPending({
+          transactionId: txId,
+          details:
+            'Successfully submitted Hashinal inscription. Waiting for network confirmation...'
         });
-        return {
-          ...pending,
-          metadata: { transactionId },
-        } as unknown as InscriptionResponse;
       } else {
         return createInscriptionError({
-          code: 'UNKNOWN_STATE',
-          details: 'Inscription completed but result state is unclear',
-          suggestions: [
-            'Check if the inscription was successful manually',
-            'Try the inscription again',
-          ],
+          code: 'UNEXPECTED_RESULT',
+          details: 'Received an unexpected inscription result state',
+          suggestions: ['Try again or verify network status']
         });
       }
     } catch (error) {
@@ -678,16 +578,7 @@ export class InscribeHashinalTool
         error instanceof Error
           ? error.message
           : 'Failed to inscribe Hashinal NFT';
-      return createInscriptionError({
-        code: 'INSCRIPTION_FAILED',
-        details: `Inscription failed: ${errorMessage}`,
-        suggestions: [
-          'Check network connectivity',
-          'Verify you have sufficient HBAR balance',
-          'Ensure content is accessible and valid',
-          'Try again in a moment',
-        ],
-      });
+      throw new Error(`Inscription failed: ${errorMessage}`);
     }
   }
 

package/src/types/tx-results.ts

@@ -0,0 +1,18 @@
+import type { TopicRegistrationResponse, RegistryOperationResponse, HCS6TopicRegistrationResponse, HCS6RegistryOperationResponse, HCS6CreateHashinalResponse } from '@hashgraphonline/standards-sdk';
+
+export interface WalletBytesResponse {
+  success: true;
+  transactionBytes: string;
+}
+
+export function isWalletBytesResponse(value: unknown): value is WalletBytesResponse {
+  return !!value && typeof (value as any).transactionBytes === 'string';
+}
+
+export type TopicRegistrationResult = TopicRegistrationResponse | WalletBytesResponse;
+export type RegistryOperationResult = RegistryOperationResponse | WalletBytesResponse;
+export type SubmitMessageResult = { success: true; transactionId?: string } | WalletBytesResponse;
+
+export type HCS6TopicRegistrationResult = HCS6TopicRegistrationResponse | WalletBytesResponse;
+export type HCS6RegistryOperationResult = HCS6RegistryOperationResponse | WalletBytesResponse;
+export type HCS6CreateHashinalResult = HCS6CreateHashinalResponse | WalletBytesResponse;

package/src/utils/CodedError.ts

@@ -0,0 +1,8 @@
+export class CodedError extends Error {
+  code: string;
+  constructor(code: string, message: string) {
+    super(message);
+    this.code = code;
+    Object.setPrototypeOf(this, CodedError.prototype);
+  }
+}

package/src/utils/Encryption.ts

@@ -6,11 +6,9 @@
  */
 
 export function encryptMessage(message: string): string {
-    // TODO: Add encryption logic here if useEncryption flag is true.
     return message; // currently returns plaintext.
 }
 
 export function decryptMessage(encryptedMessage: string): string {
-    // TODO: Add decryption logic here.
     return encryptedMessage;
 }