@hashgraphonline/standards-agent-kit 0.2.112 → 0.2.114

package/src/tools/hcs6/UpdateDynamicHashinalTool.ts

@@ -0,0 +1,74 @@
+import { z } from 'zod';
+import { BaseHCS6TransactionTool } from './base-hcs6-tools';
+import { HCS6TransactionToolParams } from './hcs6-tool-params';
+import type { TransactionResponse } from 'hedera-agent-kit';
+
+/**
+ * Schema for updating a dynamic hashinal
+ */
+const UpdateDynamicHashinalSchema = z.object({
+  registryTopicId: z.string()
+    .describe('The registry topic ID that tracks this dynamic hashinal'),
+  metadata: z.record(z.unknown())
+    .describe('Updated metadata object for the hashinal'),
+  data: z.object({
+    base64: z.string().optional().describe('Base64 encoded data for the updated hashinal'),
+    url: z.string().optional().describe('URL to fetch updated data from'),
+    mimeType: z.string().optional().describe('MIME type of the data'),
+  }).optional()
+    .describe('Updated data to inscribe'),
+  memo: z.string()
+    .optional()
+    .describe('Optional memo for the update (e.g., "Level up", "Version 2.0")'),
+  submitKey: z.string()
+    .describe('Submit key for the registry (required to update)'),
+});
+
+export type UpdateDynamicHashinalInput = z.infer<typeof UpdateDynamicHashinalSchema>;
+
+/**
+ * Tool for updating dynamic hashinals
+ */
+export class UpdateDynamicHashinalTool extends BaseHCS6TransactionTool<typeof UpdateDynamicHashinalSchema> {
+  name = 'updateDynamicHashinal';
+  description = 'Update an existing dynamic hashinal with new content while maintaining the same registry';
+  schema = UpdateDynamicHashinalSchema;
+
+  constructor(params: HCS6TransactionToolParams) {
+    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');
+      }
+
+      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',
+      };
+    }
+  }
+}

package/src/tools/hcs6/base-hcs6-tools.ts

@@ -0,0 +1,63 @@
+import {
+  BaseHederaTransactionTool,
+  BaseHederaQueryTool,
+  BaseServiceBuilder,
+} from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+import {
+  HCS6TransactionToolParams,
+  HCS6QueryToolParams,
+} from './hcs6-tool-params';
+import { z } from 'zod';
+
+/**
+ * Base class for HCS6 transaction tools
+ */
+export abstract class BaseHCS6TransactionTool<
+  T extends z.ZodObject<
+    z.ZodRawShape,
+    z.UnknownKeysParam,
+    z.ZodTypeAny
+  > = z.ZodObject<z.ZodRawShape>
+> extends BaseHederaTransactionTool<T> {
+  protected hcs6Builder: HCS6Builder;
+  namespace = 'hcs6' as const;
+
+  constructor(params: HCS6TransactionToolParams) {
+    super(params);
+    this.hcs6Builder = params.hcs6Builder;
+  }
+
+  /**
+   * Override to return the HCS6Builder
+   */
+  protected getServiceBuilder(): BaseServiceBuilder {
+    return this.hcs6Builder;
+  }
+}
+
+/**
+ * Base class for HCS6 query tools
+ */
+export abstract class BaseHCS6QueryTool<
+  T extends z.ZodObject<
+    z.ZodRawShape,
+    z.UnknownKeysParam,
+    z.ZodTypeAny
+  > = z.ZodObject<z.ZodRawShape>
+> extends BaseHederaQueryTool<T> {
+  protected hcs6Builder: HCS6Builder;
+  namespace = 'hcs6' as const;
+
+  constructor(params: HCS6QueryToolParams) {
+    super(params);
+    this.hcs6Builder = params.hcs6Builder;
+  }
+
+  /**
+   * Override to return the HCS6Builder
+   */
+  protected getServiceBuilder(): BaseServiceBuilder {
+    return this.hcs6Builder;
+  }
+}

package/src/tools/hcs6/hcs6-tool-params.ts

@@ -0,0 +1,21 @@
+import { HederaAgentKit } from 'hedera-agent-kit';
+import type { BasePluginContext } from 'hedera-agent-kit';
+import { HCS6Builder } from '../../builders/hcs6/hcs6-builder';
+
+/**
+ * Parameters for HCS6 transaction tools
+ */
+export interface HCS6TransactionToolParams {
+  hederaKit: HederaAgentKit;
+  hcs6Builder: HCS6Builder;
+  logger?: BasePluginContext['logger'];
+}
+
+/**
+ * Parameters for HCS6 query tools
+ */
+export interface HCS6QueryToolParams {
+  hederaKit: HederaAgentKit;
+  hcs6Builder: HCS6Builder;
+  logger?: BasePluginContext['logger'];
+}

package/src/tools/hcs6/index.ts

@@ -0,0 +1,6 @@
+export * from './base-hcs6-tools';
+export * from './hcs6-tool-params';
+export * from './CreateDynamicRegistryTool';
+export * from './RegisterDynamicHashinalTool';
+export * from './UpdateDynamicHashinalTool';
+export * from './QueryDynamicRegistryTool';

package/src/tools/index.ts

@@ -1,3 +1,4 @@
 export * from './hcs10';
 export * from './hcs2';
+export * from './hcs6';
 export * from './inscriber';

package/src/tools/inscriber/InscribeFromBufferTool.ts

@@ -53,7 +53,7 @@ const inscribeFromBufferSchema = z.object({
  */
 export class InscribeFromBufferTool extends BaseInscriberQueryTool<typeof inscribeFromBufferSchema> {
   name = 'inscribeFromBuffer';
-  description = 'Inscribe content that you already have (text, data, or files) to the Hedera network. Use this tool when you have content from: Wikipedia articles, MCP tool responses, text data, API responses, or any content you\'ve retrieved. Convert your content to base64 first. DO NOT use inscribeFromUrl for web page content - use this tool instead after retrieving the actual content.';
+  description = 'Use this for ANY web page, article, or content you retrieve. If user asks to inscribe a web page or article, FIRST retrieve it, THEN use this tool. This is the CORRECT tool for: web pages, news articles, blog posts, social media content, API responses, or any text content. Steps: 1) Retrieve content, 2) Convert to base64, 3) Use this tool. DO NOT use inscribeFromUrl for web content.';
 
   get specificInputSchema() {
     return inscribeFromBufferSchema;

package/src/tools/inscriber/InscribeFromUrlTool.ts

@@ -7,7 +7,7 @@ import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
  * Schema for inscribing from URL
  */
 const inscribeFromUrlSchema = z.object({
-  url: z.string().url().describe('The URL of the content to inscribe'),
+  url: z.string().url().describe('ONLY direct file download URLs ending in .pdf, .jpg, .png, .json, .zip etc. NOT for web pages or articles'),
   mode: z
     .enum(['file', 'hashinal'])
     .optional()
@@ -42,7 +42,7 @@ const inscribeFromUrlSchema = z.object({
  */
 export class InscribeFromUrlTool extends BaseInscriberQueryTool<typeof inscribeFromUrlSchema> {
   name = 'inscribeFromUrl';
-  description = 'Inscribe content directly from a URL that points to a downloadable file (PDF, image, JSON, etc). DO NOT use this for web pages like Wikipedia, Twitter, or GitHub pages. This tool is ONLY for direct file URLs like https://example.com/document.pdf or https://api.example.com/data.json. For content you already have (from Wikipedia, MCP tools, or text), use inscribeFromBuffer instead.';
+  description = 'DO NOT use this for web pages, articles, or HTML content - it will FAIL. ONLY use for direct file downloads like PDFs, images, JSON, ZIP files. If user asks to inscribe a web page article, DO NOT use this tool. Valid examples: .pdf, .jpg, .png, .json, .zip files. Invalid examples: any web page, news article, blog post, social media content. For those, retrieve the content first then use inscribeFromBuffer.';
 
   get specificInputSchema() {
     return inscribeFromUrlSchema;
@@ -76,18 +76,32 @@ export class InscribeFromUrlTool extends BaseInscriberQueryTool<typeof inscribeF
       const timeoutId = setTimeout(() => controller.abort(), 10000);
       
       try {
-        const response = await fetch(params.url, {
+        // First try HEAD request
+        const headResponse = await fetch(params.url, {
           method: 'HEAD',
           signal: controller.signal,
         });
         
         clearTimeout(timeoutId);
         
-        if (!response.ok) {
-          throw new Error(`URL returned error status ${response.status}: ${response.statusText}. Cannot inscribe content from inaccessible URLs.`);
+        if (!headResponse.ok) {
+          throw new Error(`URL returned error status ${headResponse.status}: ${headResponse.statusText}. Cannot inscribe content from inaccessible URLs.`);
         }
 
-        const contentLength = response.headers.get('content-length');
+        const contentType = headResponse.headers.get('content-type') || '';
+        const contentLength = headResponse.headers.get('content-length');
+        
+        // Check if content type indicates HTML/web page
+        const webPageContentTypes = [
+          'text/html',
+          'application/xhtml+xml',
+          'text/xml'
+        ];
+        
+        if (webPageContentTypes.some(type => contentType.toLowerCase().includes(type))) {
+          throw new Error(`URL returns HTML/web page content (Content-Type: ${contentType}). This tool only works with direct file URLs (PDFs, images, JSON, etc.). For web page content, first retrieve the content using the appropriate MCP tool or web scraper, then use inscribeFromBuffer to inscribe it.`);
+        }
+        
         if (contentLength && parseInt(contentLength) === 0) {
           throw new Error('URL returns empty content (Content-Length: 0). Cannot inscribe empty content.');
         }
@@ -95,8 +109,47 @@ export class InscribeFromUrlTool extends BaseInscriberQueryTool<typeof inscribeF
         if (contentLength && parseInt(contentLength) < 10) {
           throw new Error(`URL content is too small (${contentLength} bytes). Content must be at least 10 bytes.`);
         }
+        
+        // If HEAD doesn't provide content-type, do a partial GET to check
+        if (!contentType || contentType === 'application/octet-stream') {
+          console.log(`[InscribeFromUrlTool] Content-Type unclear, fetching first 1KB to verify...`);
+          
+          const getController = new AbortController();
+          const getTimeoutId = setTimeout(() => getController.abort(), 5000);
+          
+          try {
+            const getResponse = await fetch(params.url, {
+              signal: getController.signal,
+              headers: {
+                'Range': 'bytes=0-1023' // Get first 1KB
+              }
+            });
+            
+            clearTimeout(getTimeoutId);
+            
+            if (getResponse.ok || getResponse.status === 206) { // 206 is partial content
+              const buffer = await getResponse.arrayBuffer();
+              const bytes = new Uint8Array(buffer);
+              const text = new TextDecoder('utf-8', { fatal: false }).decode(bytes.slice(0, 512));
+              
+              // Check if it looks like HTML
+              if (text.toLowerCase().includes('<!doctype html') || 
+                  text.toLowerCase().includes('<html') ||
+                  text.match(/<meta\s+[^>]*>/i) ||
+                  text.match(/<title>/i)) {
+                throw new Error(`URL returns HTML content. This tool only works with direct file URLs. For web page content, first retrieve it using the appropriate tool, then use inscribeFromBuffer.`);
+              }
+            }
+          } catch (getError) {
+            clearTimeout(getTimeoutId);
+            if (getError instanceof Error && getError.message.includes('HTML content')) {
+              throw getError;
+            }
+            // If partial GET fails, continue anyway
+            console.log(`[InscribeFromUrlTool] Could not perform partial GET validation: ${getError instanceof Error ? getError.message : 'Unknown error'}`);
+          }
+        }
 
-        const contentType = response.headers.get('content-type');
         console.log(`[InscribeFromUrlTool] URL validation passed. Content-Type: ${contentType}, Content-Length: ${contentLength || 'unknown'}`);
       } catch (fetchError) {
         clearTimeout(timeoutId);
@@ -106,7 +159,7 @@ export class InscribeFromUrlTool extends BaseInscriberQueryTool<typeof inscribeF
       if (error instanceof Error) {
         if (error.name === 'AbortError') {
           console.log(`[InscribeFromUrlTool] Warning: URL validation timed out after 10 seconds. Proceeding with inscription attempt.`);
-        } else if (error.message.includes('URL returned error') || error.message.includes('empty content') || error.message.includes('too small')) {
+        } else if (error.message.includes('URL returned error') || error.message.includes('empty content') || error.message.includes('too small') || error.message.includes('HTML')) {
           throw error;
         } else {
           console.log(`[InscribeFromUrlTool] Warning: Could not validate URL with HEAD request: ${error.message}. Proceeding with inscription attempt.`);