@hashgraphonline/standards-agent-kit 0.2.130 → 0.2.132

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/standards-agent-kit",
-  "version": "0.2.130",
+  "version": "0.2.132",
   "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",
@@ -21,33 +21,6 @@
     "LICENSE",
     "README.md"
   ],
-  "scripts": {
-    "clean": "rimraf dist",
-    "build:es": "BUILD_FORMAT=es vite build",
-    "build:cjs": "BUILD_FORMAT=cjs vite build",
-    "build:umd": "BUILD_FORMAT=umd vite build",
-    "build": "pnpm run clean && pnpm run build:es && pnpm run build:cjs && pnpm run build:umd",
-    "test": "jest",
-    "lint": "eslint . --ext .ts",
-    "lint:fix": "eslint . --ext .ts --fix",
-    "prepare": "pnpm run build",
-    "prepublishOnly": "pnpm run build",
-    "release": "pnpm publish --access public",
-    "release:canary": "pnpm run prepublishOnly && pnpm publish --tag canary --access public",
-    "version:canary": "pnpm version prerelease --preid canary --no-git-tag-version",
-    "publish:canary": "pnpm run version:canary && pnpm run release:canary",
-    "demo:cli": "tsx examples/cli-demo.ts",
-    "demo:interactive": "tsx examples/interactive-demo.ts",
-    "demo:langchain": "tsx examples/langchain-demo.ts",
-    "demo:plugin": "tsx examples/plugin-system-example.ts",
-    "demo:plugin:weather": "tsx examples/plugins/weather/index.ts",
-    "demo:plugin:defi": "tsx examples/plugins/defi/index.ts",
-    "demo:plugin:openconvai": "tsx examples/openconvai-plugin-example.ts",
-    "demo:inscription-quotes": "tsx examples/inscription-quote-demo.ts",
-    "standards-agent:start": "tsx examples/standards-expert/cli.ts -- start",
-    "standards-agent:process-docs": "tsx examples/standards-expert/cli.ts -- process-docs --all-repos",
-    "typecheck": "tsc --noEmit"
-  },
   "keywords": [
     "hedera",
     "hcs10",
@@ -90,9 +63,9 @@
   },
   "dependencies": {
     "@hashgraph/sdk": "^2.69.0",
-    "@hashgraphonline/standards-sdk": "0.0.181",
+    "@hashgraphonline/standards-sdk": "0.0.182",
     "@langchain/community": "^0.3.5",
-    "@langchain/core": "^0.3.7",
+    "@langchain/core": "^0.3.71",
     "@langchain/openai": "^0.6.7",
     "@octokit/rest": "^21.1.1",
     "axios": "^1.11.0",
@@ -128,5 +101,29 @@
     "vite-plugin-node-polyfills": "^0.23.0",
     "vite-plugin-string-replace": "^1.1.3"
   },
-  "packageManager": "pnpm@10.11.1+sha512.e519b9f7639869dc8d5c3c5dfef73b3f091094b0a006d7317353c72b124e80e1afd429732e28705ad6bfa1ee879c1fce46c128ccebd3192101f43dd67c667912"
-}
+  "scripts": {
+    "clean": "rimraf dist",
+    "build:es": "BUILD_FORMAT=es vite build",
+    "build:cjs": "BUILD_FORMAT=cjs vite build",
+    "build:umd": "BUILD_FORMAT=umd vite build",
+    "build": "pnpm run clean && pnpm run build:es && pnpm run build:cjs && pnpm run build:umd",
+    "test": "jest",
+    "lint": "eslint . --ext .ts",
+    "lint:fix": "eslint . --ext .ts --fix",
+    "release": "pnpm publish --access public",
+    "release:canary": "pnpm run prepublishOnly && pnpm publish --tag canary --access public",
+    "version:canary": "pnpm version prerelease --preid canary --no-git-tag-version",
+    "publish:canary": "pnpm run version:canary && pnpm run release:canary",
+    "demo:cli": "tsx examples/cli-demo.ts",
+    "demo:interactive": "tsx examples/interactive-demo.ts",
+    "demo:langchain": "tsx examples/langchain-demo.ts",
+    "demo:plugin": "tsx examples/plugin-system-example.ts",
+    "demo:plugin:weather": "tsx examples/plugins/weather/index.ts",
+    "demo:plugin:defi": "tsx examples/plugins/defi/index.ts",
+    "demo:plugin:openconvai": "tsx examples/openconvai-plugin-example.ts",
+    "demo:inscription-quotes": "tsx examples/inscription-quote-demo.ts",
+    "standards-agent:start": "tsx examples/standards-expert/cli.ts -- start",
+    "standards-agent:process-docs": "tsx examples/standards-expert/cli.ts -- process-docs --all-repos",
+    "typecheck": "tsc --noEmit"
+  }
+}

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

@@ -13,19 +13,55 @@ import {
 } from '@hashgraphonline/standards-sdk';
 
 /**
- * Type definition for DAppSigner since we don't have the actual package
+ * Type definition for DAppSigner from hedera-wallet-connect
  */
 interface DAppSigner {
   getAccountId(): { toString(): string };
+  [key: string]: unknown;
+}
+
+/**
+ * Type definition for inscription request parameters
+ */
+interface InscriptionRequest {
+  [key: string]: unknown;
+}
+
+/**
+ * Type definition for inscription configuration
+ */
+interface InscriptionConfig {
+  [key: string]: unknown;
+}
+
+/**
+ * Type definition for inscription execution result
+ */
+interface InscriptionExecutionResult {
+  [key: string]: unknown;
+}
+
+/**
+ * Type definition for inscription result
+ */
+interface InscriptionResult {
+  [key: string]: unknown;
+}
+
+/**
+ * Type definition for wait for inscription result
+ */
+interface WaitForInscriptionResult {
+  [key: string]: unknown;
 }
 
 /**
  * Type definition for InscriptionSDK since we don't have the actual package
  */
 interface InscriptionSDK {
-  inscribeAndExecute(request: any, config: any): Promise<any>;
-  inscribe(request: any, signer: any): Promise<any>;
-  waitForInscription(txId: string, maxAttempts: number, intervalMs: number, checkCompletion: boolean, progressCallback?: Function): Promise<any>;
+  inscribeAndExecute(request: InscriptionRequest, config: InscriptionConfig): Promise<InscriptionExecutionResult>;
+  inscribe(request: InscriptionRequest, signer: DAppSigner): Promise<InscriptionResult>;
+  waitForInscription(txId: string, maxAttempts: number, intervalMs: number, checkCompletion: boolean, progressCallback?: (...args: unknown[]) => void): Promise<WaitForInscriptionResult>;
 }
 
 /**
@@ -42,7 +78,7 @@ export class InscriberBuilder extends BaseServiceBuilder {
    * Get or create Inscription SDK - temporarily returns null since we don't have the actual SDK
    */
   protected async getInscriptionSDK(
-    options: InscriptionOptions
+    _options: InscriptionOptions
   ): Promise<InscriptionSDK | null> {
     return null;
   }
@@ -81,7 +117,7 @@ export class InscriberBuilder extends BaseServiceBuilder {
     signer: DAppSigner,
     options: InscriptionOptions
   ): Promise<InscriptionResponse> {
-    return await inscribeWithSigner(input, signer as any, options);
+    return await inscribeWithSigner(input, signer as unknown as Parameters<typeof inscribeWithSigner>[1], options);
   }
 
   /**

package/src/hcs10/HCS10Client.ts

@@ -17,7 +17,6 @@ import { AgentMetadata, AgentChannels } from './types';
 import { encryptMessage } from '../utils/Encryption';
 import { IStateManager } from '../state/state-types';
 
-// Keep type alias as they were removed accidentally
 type StandardHandleConnectionRequest = InstanceType<
   typeof StandardSDKClient
 >['handleConnectionRequest'];
@@ -444,13 +443,11 @@ export class HCS10Client {
     error?: string;
   }> {
     try {
-      // Set up client with provided operator details
+
       this.setClient(options.accountId, options.privateKey);
 
-      // Check if we can retrieve the operator ID
       const operatorId = this.getOperatorId();
 
-      // If we got this far, basic validation passed
       return {
         isValid: true,
         operator: { accountId: operatorId },
@@ -472,7 +469,7 @@ export class HCS10Client {
     const validationResult = await this.validateOperator(options);
 
     if (validationResult.isValid) {
-      // If we have access to the state manager, initialize its connections manager
+
       if (options.stateManager) {
         options.stateManager.initializeConnectionsManager(this.standardClient);
       }

package/src/hcs10/types.ts

@@ -1,4 +1,3 @@
-// src/hcs10/types.ts
 
 import { FeeConfigBuilderInterface } from '@hashgraphonline/standards-sdk';
 
@@ -25,7 +24,7 @@ export interface AgentMetadata {
 export interface AgentChannels {
     inboundTopicId: string;
     outboundTopicId: string;
-    // Future: additional connection topics can be added.
+
 }
 
 /**
@@ -39,16 +38,3 @@ export interface HCS10Message {
     messageId: string;
     metadata?: Record<string, unknown>;
 }
-
-// export interface AgentRegistration {
-//     id: string;
-//     name: string;
-//     capabilities: string[];
-//     createdAt: number;
-//     publicKey: string;
-// }
-
-// export interface HCS10Config {
-//     topicId: string;
-//     network: 'mainnet' | 'testnet' | 'previewnet';
-// }

package/src/index.ts

@@ -2,6 +2,8 @@ export * from './tools';
 export * from './state';
 export * from './init';
 export * from './plugins';
+export * from './lib';
+export * from './interfaces';
 export { HCS10Builder, HCS2Builder, HCS6Builder, InscriberBuilder } from './builders';
 export type { ExecuteResult } from './builders';
 export { HCS10Client } from './hcs10';

package/src/init/init.ts

@@ -73,13 +73,19 @@ export const initializeStandardsAgentKit = async (
 
   const networkEnv = config.network || process.env.HEDERA_NETWORK || 'testnet';
 
+  const shouldSilence = process.env.DISABLE_LOGGING === 'true';
+  const logger = Logger.getInstance({
+    level: config.logLevel || 'info',
+    silent: shouldSilence,
+  });
+
   let network: 'mainnet' | 'testnet';
   if (networkEnv === 'mainnet') {
     network = 'mainnet';
   } else if (networkEnv === 'testnet') {
     network = 'testnet';
   } else {
-    console.warn(
+    logger.warn(
       `Unsupported network specified: '${networkEnv}'. Defaulting to 'testnet'.`
     );
     network = 'testnet';
@@ -91,12 +97,6 @@ export const initializeStandardsAgentKit = async (
     );
   }
 
-  const shouldSilence = process.env.DISABLE_LOGGING === 'true';
-  const logger = Logger.getInstance({
-    level: config.logLevel || 'info',
-    silent: shouldSilence,
-  });
-
   const stateManager =
     options?.stateManager ||
     new OpenConvaiState({
@@ -105,13 +105,11 @@ export const initializeStandardsAgentKit = async (
     });
   logger.info('State manager initialized');
 
-  // Create HederaAgentKit
   const signer = new ServerSigner(operatorId, operatorPrivateKey, network);
   const hederaKit = new HederaAgentKit(signer);
   await hederaKit.initialize();
   logger.info(`HederaAgentKit initialized for ${operatorId} on ${network}`);
 
-  // Create HCS10Builder
   const hcs10Builder = new HCS10Builder(hederaKit, stateManager, {
     useEncryption: config.useEncryption,
     registryUrl: config.registryUrl,
@@ -135,7 +133,6 @@ export const initializeStandardsAgentKit = async (
 
   const tools: Partial<HCS10Tools> = {};
 
-  // Always create RegisterAgentTool
   tools.registerAgentTool = new RegisterAgentTool({
     hederaKit,
     hcs10Builder,

package/src/interfaces/FormValidatable.ts

@@ -0,0 +1,57 @@
+import { z } from 'zod';
+
+/**
+ * Interface for tools that can provide custom form validation logic
+ */
+export interface FormValidatable {
+  /**
+   * Determines if a form should be generated for the given input
+   * @param input The input data to validate
+   * @returns true if a form should be generated, false if the tool can execute
+   */
+  shouldGenerateForm(input: unknown): boolean;
+
+  /**
+   * Returns the schema to use for form generation
+   * This allows tools to provide a focused schema for forms
+   * @returns The schema to use for generating forms
+   */
+  getFormSchema(): z.ZodSchema;
+
+  /**
+   * Optional method to validate metadata quality and provide detailed feedback
+   * @param input The input data to analyze
+   * @returns Object indicating if form is needed and the reason
+   */
+  validateMetadataQuality?(input: unknown): { needsForm: boolean; reason: string };
+
+  /**
+   * Optional method to define which fields are essential for this tool
+   * Essential fields are always shown in forms even if marked as optional
+   * @returns Array of field names that are essential for user experience
+   */
+  getEssentialFields?(): string[];
+
+  /**
+   * Optional method to determine if a field value should be considered empty
+   * Allows tools to define custom empty logic for their specific data types
+   * @param fieldName The name of the field
+   * @param value The value to check
+   * @returns true if the field should be considered empty
+   */
+  isFieldEmpty?(fieldName: string, value: unknown): boolean;
+}
+
+/**
+ * Type guard to check if a tool implements FormValidatable
+ */
+export function isFormValidatable(tool: unknown): tool is FormValidatable {
+  return (
+    tool !== null &&
+    typeof tool === 'object' &&
+    'shouldGenerateForm' in tool &&
+    'getFormSchema' in tool &&
+    typeof (tool as FormValidatable).shouldGenerateForm === 'function' &&
+    typeof (tool as FormValidatable).getFormSchema === 'function'
+  );
+}

package/src/interfaces/index.ts

@@ -0,0 +1 @@
+export * from './FormValidatable';

package/src/lib/index.ts

@@ -0,0 +1 @@
+export * from './zod-render';

package/src/lib/zod-render/__tests__/withRender.test.ts

@@ -0,0 +1,205 @@
+import { z } from 'zod';
+import {
+  extendZodSchema,
+  hasRenderConfig,
+  getRenderConfig,
+  renderConfigs,
+  installZodRenderExtensions,
+  createProgressiveSchema,
+  extractProgressiveInfo,
+  enhanceRenderConfig
+} from '../schema-extension';
+import { EnhancedRenderConfig } from '../types';
+
+describe('withRender Schema Extensions', () => {
+  beforeEach(() => {
+
+    installZodRenderExtensions();
+  });
+
+  describe('Basic withRender functionality', () => {
+    it('should extend a schema with render configuration', () => {
+      const schema = z.string();
+      const extendedSchema = extendZodSchema(schema);
+
+      expect(typeof extendedSchema.withRender).toBe('function');
+      expect(typeof extendedSchema.withProgressive).toBe('function');
+      expect(typeof extendedSchema.withBlock).toBe('function');
+    });
+
+    it('should store render configuration in schema', () => {
+      const config: EnhancedRenderConfig = {
+        fieldType: 'text',
+        ui: { label: 'Test Field', priority: 'essential' },
+        progressive: { priority: 'essential' }
+      };
+
+      const schema = extendZodSchema(z.string()).withRender(config);
+
+      expect(hasRenderConfig(schema)).toBe(true);
+      expect(getRenderConfig(schema)).toEqual(config);
+    });
+
+    it('should support progressive disclosure configuration', () => {
+      const schema = extendZodSchema(z.string()).withProgressive('essential', 'Basic Info');
+
+      const progressiveInfo = extractProgressiveInfo(schema);
+      expect(progressiveInfo.priority).toBe('essential');
+      expect(progressiveInfo.group).toBe('Basic Info');
+    });
+
+    it('should support block configuration', () => {
+      const schema = extendZodSchema(z.string()).withBlock('account-input');
+
+      const config = getRenderConfig(schema);
+      expect(config?.block?.id).toBe('account-input');
+      expect(config?.block?.type).toBe('field');
+      expect(config?.block?.reusable).toBe(true);
+    });
+  });
+
+  describe('Progressive disclosure helpers', () => {
+    it('should create essential field configurations', () => {
+      const config = renderConfigs.essential.text('Name', 'Enter your name');
+
+      expect(config.fieldType).toBe('text');
+      expect(config.ui?.label).toBe('Name');
+      expect(config.ui?.placeholder).toBe('Enter your name');
+      expect(config.ui?.priority).toBe('essential');
+      expect(config.progressive?.priority).toBe('essential');
+    });
+
+    it('should create advanced field configurations', () => {
+      const config = renderConfigs.advanced.number('Batch Size', 1, 100);
+
+      expect(config.fieldType).toBe('number');
+      expect(config.ui?.label).toBe('Batch Size');
+      expect(config.ui?.priority).toBe('advanced');
+      expect(config.progressive?.priority).toBe('advanced');
+      expect(config.constraints?.min).toBe(1);
+      expect(config.constraints?.max).toBe(100);
+    });
+
+    it('should create expert field configurations', () => {
+      const config = renderConfigs.expert.textarea('Debug Info', 5);
+
+      expect(config.fieldType).toBe('textarea');
+      expect(config.ui?.label).toBe('Debug Info');
+      expect(config.ui?.priority).toBe('expert');
+      expect(config.progressive?.priority).toBe('expert');
+      expect(config.props?.rows).toBe(5);
+    });
+  });
+
+  describe('Global prototype extension', () => {
+    it('should add withRender to all Zod schemas', () => {
+      const stringSchema = z.string();
+      const numberSchema = z.number();
+      const objectSchema = z.object({ name: z.string() });
+
+      expect(typeof (stringSchema as any).withRender).toBe('function');
+      expect(typeof (numberSchema as any).withProgressive).toBe('function');
+      expect(typeof (objectSchema as any).withBlock).toBe('function');
+    });
+
+    it('should work with chained configurations', () => {
+      const schema = (z.string() as any)
+        .withProgressive('essential', 'Basic Info')
+        .withRender({ ui: { helpText: 'This is required' } });
+
+      const config = getRenderConfig(schema);
+      expect(config?.progressive?.priority).toBe('essential');
+      expect(config?.progressive?.group).toBe('Basic Info');
+      expect(config?.ui?.helpText).toBe('This is required');
+    });
+  });
+
+  describe('Progressive schema creation', () => {
+    it('should create schemas with grouped fields', () => {
+      const baseSchema = z.object({
+        name: z.string(),
+        symbol: z.string(),
+        batchSize: z.number().optional(),
+        adminKey: z.string().optional()
+      });
+
+      const groups = {
+        'Basic Info': { priority: 'essential' as const, fields: ['name', 'symbol'] },
+        'Advanced': { priority: 'advanced' as const, fields: ['batchSize', 'adminKey'] }
+      };
+
+      const progressiveSchema = createProgressiveSchema(baseSchema, groups);
+
+      expect(hasRenderConfig(progressiveSchema)).toBe(true);
+    });
+  });
+
+  describe('Legacy compatibility', () => {
+    it('should enhance legacy render configs', () => {
+      const legacyConfig = {
+        fieldType: 'text' as const,
+        ui: { label: 'Test', priority: 'advanced' as const }
+      };
+
+      const enhanced = enhanceRenderConfig(legacyConfig);
+
+      expect(enhanced.progressive?.priority).toBe('advanced');
+      expect(enhanced.ui?.label).toBe('Test');
+    });
+
+    it('should handle configs without priority', () => {
+      const legacyConfig = {
+        fieldType: 'text' as const,
+        ui: { label: 'Test' }
+      };
+
+      const enhanced = enhanceRenderConfig(legacyConfig);
+
+      expect(enhanced.progressive?.priority).toBe('common');
+    });
+  });
+
+  describe('Real-world usage patterns', () => {
+    it('should support individual field progressive disclosure', () => {
+
+      const tokenIdField = (z.string() as any).withProgressive('essential', 'Basic Info');
+      const batchSizeField = (z.number().optional() as any).withProgressive('advanced', 'Performance');
+      const timeoutField = (z.number().optional() as any).withProgressive('expert', 'Technical');
+
+      const tokenIdInfo = extractProgressiveInfo(tokenIdField);
+      expect(tokenIdInfo.priority).toBe('essential');
+      expect(tokenIdInfo.group).toBe('Basic Info');
+
+      const batchSizeInfo = extractProgressiveInfo(batchSizeField);
+      expect(batchSizeInfo.priority).toBe('advanced');
+      expect(batchSizeInfo.group).toBe('Performance');
+
+      const timeoutInfo = extractProgressiveInfo(timeoutField);
+      expect(timeoutInfo.priority).toBe('expert');
+      expect(timeoutInfo.group).toBe('Technical');
+    });
+
+    it('should support complex NFT schema configuration', () => {
+      const nftSchema = z.object({
+        tokenId: z.string(),
+        name: z.string(),
+        description: z.string().optional(),
+        batchSize: z.number().optional(),
+        timeoutMs: z.number().optional()
+      });
+
+      const enhancedSchema = (nftSchema as any).withRender({
+        fieldType: 'object',
+        progressive: {
+          priority: 'common',
+          group: 'NFT Creation'
+        }
+      });
+
+      expect(hasRenderConfig(enhancedSchema)).toBe(true);
+      const config = getRenderConfig(enhancedSchema);
+      expect(config?.progressive?.priority).toBe('common');
+      expect(config?.progressive?.group).toBe('NFT Creation');
+    });
+  });
+});