@hashgraphonline/standards-agent-kit 0.2.119 → 0.2.121

package/dist/umd/tools/hcs6/CreateDynamicRegistryTool.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 /**
  * Schema for creating a dynamic hashinal registry
  */
@@ -22,10 +22,10 @@ export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySch
 /**
  * Tool for creating HCS-6 dynamic registries
  */
-export declare class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<typeof CreateDynamicRegistrySchema> {
+export declare class CreateDynamicRegistryTool extends BaseHCS6QueryTool<typeof CreateDynamicRegistrySchema> {
     name: string;
     description: string;
-    schema: z.ZodObject<{
+    get specificInputSchema(): z.ZodObject<{
         ttl: z.ZodDefault<z.ZodNumber>;
         adminKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
         submitKey: z.ZodOptional<z.ZodUnion<[z.ZodBoolean, z.ZodString]>>;
@@ -38,7 +38,7 @@ export declare class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<t
         adminKey?: string | boolean | undefined;
         submitKey?: string | boolean | undefined;
     }>;
-    constructor(params: HCS6TransactionToolParams);
-    protected _call(params: CreateDynamicRegistryInput): Promise<TransactionResponse>;
+    constructor(params: HCS6QueryToolParams);
+    protected executeQuery(params: CreateDynamicRegistryInput, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/umd/tools/hcs6/QueryDynamicRegistryTool.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS6QueryTool } from './base-hcs6-tools';
 import { HCS6QueryToolParams } from './hcs6-tool-params';
-import { TransactionResponse } from 'hedera-agent-kit';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 /**
  * Schema for querying a dynamic registry
  */
@@ -28,7 +28,7 @@ export type QueryDynamicRegistryInput = z.infer<typeof QueryDynamicRegistrySchem
 export declare class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof QueryDynamicRegistrySchema> {
     name: string;
     description: string;
-    schema: z.ZodObject<{
+    get specificInputSchema(): z.ZodObject<{
         topicId: z.ZodString;
         limit: z.ZodDefault<z.ZodOptional<z.ZodNumber>>;
         order: z.ZodDefault<z.ZodOptional<z.ZodEnum<["asc", "desc"]>>>;
@@ -45,6 +45,6 @@ export declare class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof Q
         skip?: number | undefined;
     }>;
     constructor(params: HCS6QueryToolParams);
-    protected _call(params: QueryDynamicRegistryInput): Promise<TransactionResponse>;
+    protected executeQuery(params: QueryDynamicRegistryInput, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/umd/tools/hcs6/RegisterDynamicHashinalTool.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 /**
  * Schema for registering a dynamic hashinal
  */
@@ -51,10 +51,10 @@ export type RegisterDynamicHashinalInput = z.infer<typeof RegisterDynamicHashina
 /**
  * Tool for registering (creating) dynamic hashinals
  */
-export declare class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool<typeof RegisterDynamicHashinalSchema> {
+export declare class RegisterDynamicHashinalTool extends BaseHCS6QueryTool<typeof RegisterDynamicHashinalSchema> {
     name: string;
     description: string;
-    schema: z.ZodObject<{
+    get specificInputSchema(): z.ZodObject<{
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         data: z.ZodOptional<z.ZodObject<{
             base64: z.ZodOptional<z.ZodString>;
@@ -96,7 +96,7 @@ export declare class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool
         submitKey?: string | undefined;
         registryTopicId?: string | undefined;
     }>;
-    constructor(params: HCS6TransactionToolParams);
-    protected _call(params: RegisterDynamicHashinalInput): Promise<TransactionResponse>;
+    constructor(params: HCS6QueryToolParams);
+    protected executeQuery(params: RegisterDynamicHashinalInput, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/umd/tools/hcs6/UpdateDynamicHashinalTool.d.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 /**
  * Schema for updating a dynamic hashinal
  */
@@ -48,10 +48,10 @@ export type UpdateDynamicHashinalInput = z.infer<typeof UpdateDynamicHashinalSch
 /**
  * Tool for updating dynamic hashinals
  */
-export declare class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<typeof UpdateDynamicHashinalSchema> {
+export declare class UpdateDynamicHashinalTool extends BaseHCS6QueryTool<typeof UpdateDynamicHashinalSchema> {
     name: string;
     description: string;
-    schema: z.ZodObject<{
+    get specificInputSchema(): z.ZodObject<{
         registryTopicId: z.ZodString;
         metadata: z.ZodRecord<z.ZodString, z.ZodUnknown>;
         data: z.ZodOptional<z.ZodObject<{
@@ -90,7 +90,7 @@ export declare class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<t
         } | undefined;
         memo?: string | undefined;
     }>;
-    constructor(params: HCS6TransactionToolParams);
-    protected _call(params: UpdateDynamicHashinalInput): Promise<TransactionResponse>;
+    constructor(params: HCS6QueryToolParams);
+    protected executeQuery(params: UpdateDynamicHashinalInput, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
 }
 export {};

package/dist/umd/tools/inscriber/InscribeFromBufferTool.d.ts

@@ -1,9 +1,6 @@
 import { z } from 'zod';
 import { BaseInscriberQueryTool } from './base-inscriber-tools';
 import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
-/**
- * Schema for inscribing from buffer
- */
 declare const inscribeFromBufferSchema: z.ZodObject<{
     base64Data: z.ZodString;
     fileName: z.ZodString;
@@ -38,12 +35,10 @@ declare const inscribeFromBufferSchema: z.ZodObject<{
     timeoutMs?: number | undefined;
     apiKey?: string | undefined;
 }>;
-/**
- * Tool for inscribing content from buffer
- */
 export declare class InscribeFromBufferTool extends BaseInscriberQueryTool<typeof inscribeFromBufferSchema> {
     name: string;
     description: string;
+    private config;
     get specificInputSchema(): z.ZodObject<{
         base64Data: z.ZodString;
         fileName: z.ZodString;
@@ -79,5 +74,11 @@ export declare class InscribeFromBufferTool extends BaseInscriberQueryTool<typeo
         apiKey?: string | undefined;
     }>;
     protected executeQuery(params: z.infer<typeof inscribeFromBufferSchema>, _runManager?: CallbackManagerForToolRun): Promise<unknown>;
+    private validateInput;
+    private validateContent;
+    private executeInscription;
+    private formatInscriptionResult;
+    private resolveContent;
+    private handleDirectContent;
 }
 export {};

package/dist/umd/tools/inscriber/base-inscriber-tools.d.ts

@@ -1,28 +1,39 @@
 import { BaseHederaTransactionTool, BaseHederaQueryTool, BaseServiceBuilder } from 'hedera-agent-kit';
 import { InscriberBuilder } from '../../builders/inscriber/inscriber-builder';
 import { InscriberTransactionToolParams, InscriberQueryToolParams } from './inscriber-tool-params';
+import { ContentResolverInterface } from '../../types/content-resolver';
 import { z } from 'zod';
 /**
  * Base class for Inscriber transaction tools
  */
 export declare abstract class BaseInscriberTransactionTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaTransactionTool<T> {
     protected inscriberBuilder: InscriberBuilder;
+    protected contentResolver: ContentResolverInterface | null;
     namespace: "inscriber";
     constructor(params: InscriberTransactionToolParams);
     /**
      * Override to return the InscriberBuilder
      */
     protected getServiceBuilder(): BaseServiceBuilder;
+    /**
+     * Get content resolver with fallback to registry
+     */
+    protected getContentResolver(): ContentResolverInterface | null;
 }
 /**
  * Base class for Inscriber query tools
  */
 export declare abstract class BaseInscriberQueryTool<T extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny> = z.ZodObject<z.ZodRawShape>> extends BaseHederaQueryTool<T> {
     protected inscriberBuilder: InscriberBuilder;
+    protected contentResolver: ContentResolverInterface | null;
     namespace: "inscriber";
     constructor(params: InscriberQueryToolParams);
     /**
      * Override to return the InscriberBuilder
      */
     protected getServiceBuilder(): BaseServiceBuilder;
+    /**
+     * Get content resolver with fallback to registry
+     */
+    protected getContentResolver(): ContentResolverInterface | null;
 }

package/dist/umd/tools/inscriber/inscriber-tool-params.d.ts

@@ -1,5 +1,6 @@
 import { HederaAgentKit, BasePluginContext } from 'hedera-agent-kit';
 import { InscriberBuilder } from '../../builders/inscriber/inscriber-builder';
+import { ContentResolverInterface } from '../../types/content-resolver';
 /**
  * Parameters for Inscriber transaction tools
  */
@@ -7,6 +8,7 @@ export interface InscriberTransactionToolParams {
     hederaKit: HederaAgentKit;
     inscriberBuilder: InscriberBuilder;
     logger?: BasePluginContext['logger'];
+    contentResolver?: ContentResolverInterface;
 }
 /**
  * Parameters for Inscriber query tools
@@ -15,4 +17,5 @@ export interface InscriberQueryToolParams {
     hederaKit: HederaAgentKit;
     inscriberBuilder: InscriberBuilder;
     logger?: BasePluginContext['logger'];
+    contentResolver?: ContentResolverInterface;
 }

package/dist/umd/types/content-resolver.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Content Resolver Types
+ *
+ * Re-export types from standards-sdk for content resolution.
+ */
+export type { ContentResolverInterface, ReferenceResolutionResult, ContentStoreInterface } from '@hashgraphonline/standards-sdk';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/standards-agent-kit",
-  "version": "0.2.119",
+  "version": "0.2.121",
   "description": "A modular SDK for building on-chain autonomous agents using Hashgraph Online Standards, including HCS-10 for agent discovery and communication.",
   "type": "module",
   "main": "./dist/cjs/standards-agent-kit.cjs",
@@ -63,7 +63,7 @@
   },
   "dependencies": {
     "@hashgraph/sdk": "^2.69.0",
-    "@hashgraphonline/standards-sdk": "0.0.167",
+    "@hashgraphonline/standards-sdk": "file:.yalc/@hashgraphonline/standards-sdk",
     "@langchain/community": "^0.3.49",
     "@langchain/core": "^0.3.66",
     "@langchain/openai": "^0.6.3",

package/src/builders/hcs10/hcs10-builder.ts

@@ -137,8 +137,8 @@ export class HCS10Builder extends BaseServiceBuilder {
   private standardClient: HCS10Client;
   private stateManager: IStateManager | undefined;
   private executeResult?: ExecuteResult & { rawResult?: unknown };
-  private useEncryption: boolean;
-  private guardedRegistryBaseUrl: string;
+  private useEncryption: boolean = false;
+  private guardedRegistryBaseUrl: string = '';
   private network: StandardNetworkType;
   private sdkLogger: SDKLogger;
 
@@ -175,7 +175,6 @@ export class HCS10Builder extends BaseServiceBuilder {
       network: this.network,
       operatorId: operatorId,
       operatorPrivateKey: operatorPrivateKey,
-      guardedRegistryBaseUrl: this.guardedRegistryBaseUrl,
       logLevel: options?.logLevel || 'info',
     });
 

package/src/config/ContentReferenceConfig.ts

@@ -0,0 +1,30 @@
+export interface ContentReferenceConfig {
+  maxInscriptionSize: number;
+  minContentSize: number;
+  logLevel: 'debug' | 'info' | 'warn' | 'error';
+  enableContentValidation: boolean;
+}
+
+export const DEFAULT_CONFIG: ContentReferenceConfig = {
+  maxInscriptionSize: 50 * 1024, // 50KB
+  minContentSize: 10,
+  logLevel: 'warn',
+  enableContentValidation: true,
+};
+
+export function loadConfig(): ContentReferenceConfig {
+  return {
+    maxInscriptionSize: parseInt(
+      process.env.REF_MAX_SIZE || DEFAULT_CONFIG.maxInscriptionSize.toString(),
+      10
+    ),
+    minContentSize: parseInt(
+      process.env.REF_MIN_SIZE || DEFAULT_CONFIG.minContentSize.toString(),
+      10
+    ),
+    logLevel:
+      (process.env.REF_LOG_LEVEL as ContentReferenceConfig['logLevel']) ||
+      DEFAULT_CONFIG.logLevel,
+    enableContentValidation: process.env.REF_ENABLE_VALIDATION !== 'false',
+  };
+}

package/src/index.ts

@@ -4,4 +4,6 @@ export * from './init';
 export * from './plugins';
 export { HCS10Builder, HCS2Builder, HCS6Builder, InscriberBuilder } from './builders';
 export type { ExecuteResult } from './builders';
-export { HCS10Client } from './hcs10';
+export { HCS10Client } from './hcs10';
+export type { ContentReferenceConfig } from './config/ContentReferenceConfig';
+export { loadConfig } from './config/ContentReferenceConfig';

package/src/tools/hcs6/CreateDynamicRegistryTool.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import type { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
 /**
  * Schema for creating a dynamic hashinal registry
@@ -24,43 +24,32 @@ export type CreateDynamicRegistryInput = z.infer<typeof CreateDynamicRegistrySch
 /**
  * Tool for creating HCS-6 dynamic registries
  */
-export class CreateDynamicRegistryTool extends BaseHCS6TransactionTool<typeof CreateDynamicRegistrySchema> {
+export class CreateDynamicRegistryTool extends BaseHCS6QueryTool<typeof CreateDynamicRegistrySchema> {
   name = 'createDynamicRegistry';
   description = 'Create a new HCS-6 dynamic registry for managing evolving content';
-  schema = CreateDynamicRegistrySchema;
+  
+  get specificInputSchema() {
+    return CreateDynamicRegistrySchema;
+  }
 
-  constructor(params: HCS6TransactionToolParams) {
+  constructor(params: HCS6QueryToolParams) {
     super(params);
   }
 
-  protected async _call(
-    params: CreateDynamicRegistryInput
-  ): Promise<TransactionResponse> {
-    try {
-      const result = await this.hcs6Builder.createRegistry({
-        ttl: params.ttl,
-        adminKey: params.adminKey,
-        submitKey: params.submitKey,
-      });
-
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to create dynamic registry');
-      }
+  protected async executeQuery(
+    params: CreateDynamicRegistryInput,
+    _runManager?: CallbackManagerForToolRun
+  ): Promise<unknown> {
+    const result = await this.hcs6Builder.createRegistry({
+      ttl: params.ttl,
+      adminKey: params.adminKey,
+      submitKey: params.submitKey,
+    });
 
-      return {
-        status: 'success',
-        data: {
-          topicId: result.topicId,
-          transactionId: result.transactionId,
-          ttl: params.ttl,
-          memo: `hcs-6:1:${params.ttl}`,
-        },
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        message: error instanceof Error ? error.message : 'Unknown error',
-      };
+    if (!result.success) {
+      throw new Error(result.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.`;
   }
 }

package/src/tools/hcs6/QueryDynamicRegistryTool.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { BaseHCS6QueryTool } from './base-hcs6-tools';
 import { HCS6QueryToolParams } from './hcs6-tool-params';
-import type { TransactionResponse } from 'hedera-agent-kit';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
 /**
  * Schema for querying a dynamic registry
@@ -30,43 +30,33 @@ export type QueryDynamicRegistryInput = z.infer<typeof QueryDynamicRegistrySchem
 export class QueryDynamicRegistryTool extends BaseHCS6QueryTool<typeof QueryDynamicRegistrySchema> {
   name = 'queryDynamicRegistry';
   description = 'Query a dynamic registry to get the current state of a dynamic hashinal';
-  schema = QueryDynamicRegistrySchema;
+  
+  get specificInputSchema() {
+    return QueryDynamicRegistrySchema;
+  }
 
   constructor(params: HCS6QueryToolParams) {
     super(params);
   }
 
-  protected async _call(
-    params: QueryDynamicRegistryInput
-  ): Promise<TransactionResponse> {
-    try {
-      const registry = await this.hcs6Builder.getRegistry(params.topicId, {
-        limit: params.limit,
-        order: params.order,
-        skip: params.skip,
-      });
+  protected async executeQuery(
+    params: QueryDynamicRegistryInput,
+    _runManager?: CallbackManagerForToolRun
+  ): Promise<unknown> {
+    const registry = await this.hcs6Builder.getRegistry(params.topicId, {
+      limit: params.limit,
+      order: params.order,
+      skip: params.skip,
+    });
+
+    const latestEntry = registry.latestEntry ? {
+      topicId: registry.latestEntry.message.t_id,
+      timestamp: registry.latestEntry.timestamp,
+      memo: registry.latestEntry.message.m,
+      sequence: registry.latestEntry.sequence,
+      payer: registry.latestEntry.payer,
+    } : null;
 
-      return {
-        status: 'success',
-        data: {
-          topicId: registry.topicId,
-          registryType: 'NON_INDEXED',
-          ttl: registry.ttl,
-          latestEntry: registry.latestEntry ? {
-            topicId: registry.latestEntry.message.t_id,
-            timestamp: registry.latestEntry.timestamp,
-            memo: registry.latestEntry.message.m,
-            sequence: registry.latestEntry.sequence,
-            payer: registry.latestEntry.payer,
-          } : null,
-          totalEntries: registry.entries.length,
-        },
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        message: error instanceof Error ? error.message : 'Unknown error',
-      };
-    }
+    return `Successfully queried dynamic registry!\n\nRegistry Topic: ${registry.topicId}\nRegistry Type: NON_INDEXED\nTTL: ${registry.ttl} seconds\nTotal Entries: ${registry.entries.length}${latestEntry ? `\n\nLatest Entry:\n- Topic ID: ${latestEntry.topicId}\n- Timestamp: ${latestEntry.timestamp}\n- Memo: ${latestEntry.memo || 'N/A'}\n- Sequence: ${latestEntry.sequence}` : '\n\nNo entries found in registry.'}`;
   }
 }

package/src/tools/hcs6/RegisterDynamicHashinalTool.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import type { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
 /**
  * Schema for registering a dynamic hashinal
@@ -35,45 +35,35 @@ export type RegisterDynamicHashinalInput = z.infer<typeof RegisterDynamicHashina
 /**
  * Tool for registering (creating) dynamic hashinals
  */
-export class RegisterDynamicHashinalTool extends BaseHCS6TransactionTool<typeof RegisterDynamicHashinalSchema> {
+export class RegisterDynamicHashinalTool extends BaseHCS6QueryTool<typeof RegisterDynamicHashinalSchema> {
   name = 'registerDynamicHashinal';
   description = 'Create and register a new dynamic hashinal that can be updated over time';
-  schema = RegisterDynamicHashinalSchema;
+  
+  get specificInputSchema() {
+    return RegisterDynamicHashinalSchema;
+  }
 
-  constructor(params: HCS6TransactionToolParams) {
+  constructor(params: HCS6QueryToolParams) {
     super(params);
   }
 
-  protected async _call(
-    params: RegisterDynamicHashinalInput
-  ): Promise<TransactionResponse> {
-    try {
-      const result = await this.hcs6Builder.register({
-        metadata: params.metadata,
-        data: params.data,
-        memo: params.memo,
-        ttl: params.ttl,
-        registryTopicId: params.registryTopicId,
-        submitKey: params.submitKey,
-      });
-
-      if (!result.success || !result.registryTopicId || !result.inscriptionTopicId) {
-        throw new Error(result.error || 'Failed to register dynamic hashinal');
-      }
+  protected async executeQuery(
+    params: RegisterDynamicHashinalInput,
+    _runManager?: CallbackManagerForToolRun
+  ): Promise<unknown> {
+    const result = await this.hcs6Builder.register({
+      metadata: params.metadata,
+      data: params.data,
+      memo: params.memo,
+      ttl: params.ttl,
+      registryTopicId: params.registryTopicId,
+      submitKey: params.submitKey,
+    });
 
-      return {
-        status: 'success',
-        data: {
-          registryTopicId: result.registryTopicId,
-          inscriptionTopicId: result.inscriptionTopicId,
-          transactionId: result.transactionId,
-        },
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        message: error instanceof Error ? error.message : 'Unknown error',
-      };
+    if (!result.success) {
+      throw new Error(result.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.`;
   }
 }

package/src/tools/hcs6/UpdateDynamicHashinalTool.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod';
-import { BaseHCS6TransactionTool } from './base-hcs6-tools';
-import { HCS6TransactionToolParams } from './hcs6-tool-params';
-import type { TransactionResponse } from 'hedera-agent-kit';
+import { BaseHCS6QueryTool } from './base-hcs6-tools';
+import { HCS6QueryToolParams } from './hcs6-tool-params';
+import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
 
 /**
  * Schema for updating a dynamic hashinal
@@ -29,46 +29,35 @@ export type UpdateDynamicHashinalInput = z.infer<typeof UpdateDynamicHashinalSch
 /**
  * Tool for updating dynamic hashinals
  */
-export class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<typeof UpdateDynamicHashinalSchema> {
+export class UpdateDynamicHashinalTool extends BaseHCS6QueryTool<typeof UpdateDynamicHashinalSchema> {
   name = 'updateDynamicHashinal';
   description = 'Update an existing dynamic hashinal with new content while maintaining the same registry';
-  schema = UpdateDynamicHashinalSchema;
+  
+  get specificInputSchema() {
+    return UpdateDynamicHashinalSchema;
+  }
 
-  constructor(params: HCS6TransactionToolParams) {
+  constructor(params: HCS6QueryToolParams) {
     super(params);
   }
 
-  protected async _call(
-    params: UpdateDynamicHashinalInput
-  ): Promise<TransactionResponse> {
-    try {
-      // Use the register method with the existing registry ID
-      const result = await this.hcs6Builder.register({
-        metadata: params.metadata,
-        data: params.data,
-        memo: params.memo,
-        registryTopicId: params.registryTopicId,
-        submitKey: params.submitKey,
-      });
-
-      if (!result.success) {
-        throw new Error(result.error || 'Failed to update dynamic hashinal');
-      }
+  protected async executeQuery(
+    params: UpdateDynamicHashinalInput,
+    _runManager?: CallbackManagerForToolRun
+  ): Promise<unknown> {
+    // Use the register method with the existing registry ID to update
+    const result = await this.hcs6Builder.register({
+      metadata: params.metadata,
+      data: params.data,
+      memo: params.memo,
+      registryTopicId: params.registryTopicId,
+      submitKey: params.submitKey,
+    });
 
-      return {
-        status: 'success',
-        data: {
-          registryTopicId: result.registryTopicId,
-          newInscriptionTopicId: result.inscriptionTopicId,
-          transactionId: result.transactionId,
-          updateMemo: params.memo,
-        },
-      };
-    } catch (error) {
-      return {
-        status: 'error',
-        message: error instanceof Error ? error.message : 'Unknown error',
-      };
+    if (!result.success) {
+      throw new Error(result.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.`;
   }
 }