@hashgraphonline/standards-agent-kit 0.2.136 → 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

@@ -1,23 +1,54 @@
 import { z } from 'zod';
 import { BaseInscriberQueryTool } from './base-inscriber-tools';
-import { InscriptionOptions } from '@hashgraphonline/standards-sdk';
+import {
+  InscriptionOptions,
+  InscriptionResponse,
+  InscriptionResult,
+} from '@hashgraphonline/standards-sdk';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 import { resolveContent } from '../../utils/content-resolver';
 import { contentRefSchema } from '../../validation/content-ref-schemas';
 import { loadConfig } from '../../config/ContentReferenceConfig';
+import {
+  extractTopicIds,
+  buildInscriptionLinks,
+} from '../../utils/inscription-utils';
 
 const inscribeFromBufferSchema = z.object({
-  base64Data: z.union([z.string(), contentRefSchema])
-    .describe('Content to inscribe as base64 data, plain text, or content reference'),
+  base64Data: z
+    .union([z.string(), contentRefSchema])
+    .describe(
+      'Content to inscribe as base64 data, plain text, or content reference'
+    ),
   fileName: z.string().min(1).describe('Name for the inscribed content'),
   mimeType: z.string().optional().describe('MIME type of the content'),
   metadata: z.record(z.unknown()).optional().describe('Metadata to attach'),
-  tags: z.array(z.string()).optional().describe('Tags to categorize the inscription'),
-  chunkSize: z.number().int().positive().optional().describe('Chunk size for large files'),
-  waitForConfirmation: z.boolean().optional().describe('Wait for inscription confirmation'),
-  timeoutMs: z.number().int().positive().optional().describe('Timeout in milliseconds'),
+  tags: z
+    .array(z.string())
+    .optional()
+    .describe('Tags to categorize the inscription'),
+  chunkSize: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Chunk size for large files'),
+  waitForConfirmation: z
+    .boolean()
+    .optional()
+    .describe('Wait for inscription confirmation'),
+  timeoutMs: z
+    .number()
+    .int()
+    .positive()
+    .optional()
+    .describe('Timeout in milliseconds'),
   apiKey: z.string().optional().describe('API key for inscription service'),
-  quoteOnly: z.boolean().optional().default(false).describe('Return cost quote only'),
+  quoteOnly: z
+    .boolean()
+    .optional()
+    .default(false)
+    .describe('Return cost quote only'),
 });
 
 export class InscribeFromBufferTool extends BaseInscriberQueryTool<
@@ -33,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;
@@ -108,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,
@@ -115,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
@@ -218,27 +325,25 @@ export class InscribeFromBufferTool extends BaseInscriberQueryTool<
     result: Awaited<ReturnType<typeof this.inscriberBuilder.inscribe>>,
     options: InscriptionOptions
   ): string {
-    if (result.confirmed && !result.quote) {
-      const topicId =
-        result.inscription?.topic_id || (result.result as any).topicId;
-      const network = options.network || 'testnet';
-      const cdnUrl = topicId
-        ? `https://kiloscribe.com/api/inscription-cdn/${topicId}?network=${network}`
-        : null;
+    const typed = result as InscriptionResponse;
+
+    if (typed.confirmed && !typed.quote) {
+      const ids = extractTopicIds(typed.inscription, typed.result);
+      const network = (options.network || 'testnet') as 'mainnet' | 'testnet';
+      const { topicId, cdnUrl } = buildInscriptionLinks(ids, network, '1');
       return `Successfully inscribed and confirmed content on the Hedera network!\n\nTransaction ID: ${
-        (result.result as any).transactionId
+        (typed.result as InscriptionResult)?.transactionId ?? 'unknown'
       }\nTopic ID: ${topicId || 'N/A'}${
         cdnUrl ? `\nView inscription: ${cdnUrl}` : ''
       }\n\nThe inscription is now available.`;
     }
 
-    if (!result.quote && !result.confirmed) {
+    if (!typed.quote && !typed.confirmed) {
       return `Successfully submitted inscription to the Hedera network!\n\nTransaction ID: ${
-        (result.result as any).transactionId
+        (typed.result as InscriptionResult)?.transactionId ?? 'unknown'
       }\n\nThe inscription is processing and will be confirmed shortly.`;
     }
 
     return 'Inscription operation completed.';
   }
-
 }

package/src/tools/inscriber/InscribeFromFileTool.ts

@@ -1,9 +1,10 @@
 import { z } from 'zod';
 import { BaseInscriberQueryTool } from './base-inscriber-tools';
-import { InscriptionOptions } from '@hashgraphonline/standards-sdk';
+import { InscriptionOptions, InscriptionResponse } from '@hashgraphonline/standards-sdk';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import { extractTopicIds, buildInscriptionLinks } from '../../utils/inscription-utils';
 
 /**
  * Schema for inscribing from file
@@ -206,10 +207,10 @@ export class InscribeFromFileTool extends BaseInscriberQueryTool<
     }
 
     try {
-      let result: unknown;
+      let result: Awaited<ReturnType<typeof this.inscriberBuilder.inscribe>>;
 
       if (params.timeoutMs) {
-        const timeoutPromise = new Promise((_, reject) => {
+        const timeoutPromise = new Promise<never>((_, reject) => {
           setTimeout(
             () =>
               reject(
@@ -243,22 +244,18 @@ export class InscribeFromFileTool extends BaseInscriberQueryTool<
         );
       }
 
-      const inscriptionResult = result as any;
+      const inscriptionResult = result as InscriptionResponse;
       if (inscriptionResult.confirmed && !inscriptionResult.quote) {
-        const topicId =
-          inscriptionResult.inscription?.topic_id ||
-          inscriptionResult.result.topicId;
-        const network = options.network || 'testnet';
-        const cdnUrl = topicId
-          ? `https://kiloscribe.com/api/inscription-cdn/${topicId}?network=${network}`
-          : null;
+        const ids = extractTopicIds(inscriptionResult.inscription, inscriptionResult.result);
+        const network = (options.network || 'testnet') as 'mainnet' | 'testnet';
+        const { topicId, cdnUrl } = buildInscriptionLinks(ids, network, '1');
         return `Successfully inscribed and confirmed content on the Hedera network!\n\nTransaction ID: ${
-          inscriptionResult.result.transactionId
+          (inscriptionResult.result as { transactionId?: string })?.transactionId ?? 'unknown'
         }\nTopic ID: ${topicId || 'N/A'}${
           cdnUrl ? `\nView inscription: ${cdnUrl}` : ''
         }\n\nThe inscription is now available.`;
       } else if (!inscriptionResult.quote && !inscriptionResult.confirmed) {
-        return `Successfully submitted inscription to the Hedera network!\n\nTransaction ID: ${inscriptionResult.result.transactionId}\n\nThe inscription is processing and will be confirmed shortly.`;
+        return `Successfully submitted inscription to the Hedera network!\n\nTransaction ID: ${(inscriptionResult.result as { transactionId?: string })?.transactionId ?? 'unknown'}\n\nThe inscription is processing and will be confirmed shortly.`;
       } else {
         return 'Inscription operation completed.';
       }

package/src/tools/inscriber/InscribeFromUrlTool.ts

@@ -1,7 +1,8 @@
 import { z } from 'zod';
 import { BaseInscriberQueryTool } from './base-inscriber-tools';
-import { InscriptionOptions, Logger } from '@hashgraphonline/standards-sdk';
+import { InscriptionOptions, Logger, InscriptionResponse } from '@hashgraphonline/standards-sdk';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
+import { extractTopicIds, buildInscriptionLinks } from '../../utils/inscription-utils';
 
 const logger = new Logger({ module: 'InscribeFromUrlTool' });
 
@@ -309,21 +310,24 @@ export class InscribeFromUrlTool extends BaseInscriberQueryTool<
         );
       }
 
-      if (result.confirmed && !result.quote) {
-        const topicId =
-          result.inscription?.topic_id || (result.result as any).topicId;
-        const network = options.network || 'testnet';
-        const cdnUrl = topicId
-          ? `https://kiloscribe.com/api/inscription-cdn/${topicId}?network=${network}`
-          : null;
+      const typed = result as InscriptionResponse;
+
+      if (typed.confirmed && !typed.quote) {
+        const ids = extractTopicIds(typed.inscription, typed.result);
+        const network = (options.network || 'testnet') as 'mainnet' | 'testnet';
+        const { topicId, cdnUrl } = buildInscriptionLinks(
+          ids,
+          network,
+          '1'
+        );
         return `Successfully inscribed and confirmed content on the Hedera network!\n\nTransaction ID: ${
-          (result.result as any).transactionId
+          (typed.result as { transactionId?: string })?.transactionId ?? 'unknown'
         }\nTopic ID: ${topicId || 'N/A'}${
           cdnUrl ? `\nView inscription: ${cdnUrl}` : ''
         }\n\nThe inscription is now available.`;
-      } else if (!result.quote && !result.confirmed) {
+      } else if (!typed.quote && !typed.confirmed) {
         return `Successfully submitted inscription to the Hedera network!\n\nTransaction ID: ${
-          (result.result as any).transactionId
+          (typed.result as { transactionId?: string })?.transactionId ?? 'unknown'
         }\n\nThe inscription is processing and will be confirmed shortly.`;
       } else {
         return 'Inscription operation completed.';