@hashgraphonline/standards-agent-kit 0.2.132 → 0.2.135

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

@@ -1,205 +0,0 @@
-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');
-    });
-  });
-});

package/src/tools/hedera/HederaCreateNftTool.ts

@@ -1,294 +0,0 @@
-import { z } from 'zod';
-import { BaseHederaTransactionTool, BaseServiceBuilder } from 'hedera-agent-kit';
-import { extendZodSchema, renderConfigs } from '../../lib/zod-render/schema-extension';
-
-/**
- * Zod schema for a fixed fee input object with render configuration
- */
-const FixedFeeInputSchema = extendZodSchema(z.object({
-  type: z.enum(['FIXED', 'FIXED_FEE']),
-  feeCollectorAccountId: z.string().optional().describe('Fee collector account ID (defaults to treasury if not provided)'),
-  denominatingTokenId: z.string().optional().describe('Denominating token ID for the fee (if not HBAR)'),
-  amount: z.union([z.number(), z.string()]).describe('Fee amount (smallest unit for tokens, or tinybars for HBAR)'),
-})).withRender({
-  fieldType: 'object',
-  ui: {
-    label: 'Fixed Fee',
-    group: 'Custom Fees',
-    className: 'border rounded-lg p-4'
-  }
-});
-
-/**
- * Zod schema for a fractional fee input object with render configuration
- */
-const FractionalFeeInputSchema = extendZodSchema(z.object({
-  type: z.enum(['FRACTIONAL', 'FRACTIONAL_FEE']),
-  feeCollectorAccountId: z.string().optional().describe('Fee collector account ID (defaults to treasury if not provided)'),
-  numerator: z.number().int().describe('Numerator of the fractional fee'),
-  denominator: z.number().int().positive().describe('Denominator of the fractional fee'),
-  minAmount: z.union([z.number(), z.string()]).optional().describe('Minimum fractional fee amount'),
-  maxAmount: z.union([z.number(), z.string()]).optional().describe('Maximum fractional fee amount (0 for no max)'),
-  assessmentMethodInclusive: z.boolean().optional().describe('Fee is assessed on net amount (false) or gross (true)'),
-})).withRender({
-  fieldType: 'object',
-  ui: {
-    label: 'Fractional Fee',
-    group: 'Custom Fees',
-    className: 'border rounded-lg p-4'
-  }
-});
-
-/**
- * Zod schema for a royalty fee input object with render configuration
- */
-const RoyaltyFeeInputSchema = extendZodSchema(z.object({
-  type: z.enum(['ROYALTY', 'ROYALTY_FEE']),
-  feeCollectorAccountId: z.string().optional().describe('Fee collector account ID (defaults to treasury if not provided)'),
-  numerator: z.number().int().describe('Numerator of the royalty fee'),
-  denominator: z.number().int().positive().describe('Denominator of the royalty fee'),
-  fallbackFee: extendZodSchema(z.object({
-    feeCollectorAccountId: z.string().optional(),
-    denominatingTokenId: z.string().optional(),
-    amount: z.union([z.number(), z.string()])
-  })).optional().describe('Fallback fixed fee if royalty is not applicable'),
-})).withRender({
-  fieldType: 'object',
-  ui: {
-    label: 'Royalty Fee',
-    group: 'Custom Fees',
-    className: 'border rounded-lg p-4'
-  }
-});
-
-/**
- * Discriminated union of custom fee input types - simplified for compatibility
- */
-const CustomFeeInputUnionSchema = z.union([
-  FixedFeeInputSchema,
-  FractionalFeeInputSchema,
-  RoyaltyFeeInputSchema,
-]);
-
-/**
- * Enhanced NFT creation schema with render configurations
- */
-export const HederaCreateNftSchema = extendZodSchema(z.object({
-  tokenName: extendZodSchema(z.string().describe('The publicly visible name of the NFT collection'))
-    .withRender(renderConfigs.text('Token Name', 'Enter a unique name for your NFT collection')),
-
-  tokenSymbol: extendZodSchema(z.string().optional().describe('The publicly visible symbol of the NFT collection'))
-    .withRender(renderConfigs.text('Token Symbol', 'e.g., MYNFT, ART, GAME')),
-
-  treasuryAccountId: extendZodSchema(z.string().optional().describe('Treasury account ID (e.g., "0.0.xxxx")'))
-    .withRender(renderConfigs.text('Treasury Account', '0.0.xxxx format')),
-
-  adminKey: extendZodSchema(z.string().optional().describe('Admin key for token administration'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Admin Key (Optional)',
-        helpText: 'Serialized key for administrative operations',
-        group: 'Keys & Security'
-      }
-    }),
-
-  kycKey: extendZodSchema(z.string().optional().describe('KYC key for Know Your Customer operations'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'KYC Key (Optional)',
-        helpText: 'Key for KYC verification operations',
-        group: 'Keys & Security'
-      }
-    }),
-
-  freezeKey: extendZodSchema(z.string().optional().describe('Freeze key for freezing token operations'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Freeze Key (Optional)',
-        helpText: 'Key for freezing/unfreezing token operations',
-        group: 'Keys & Security'
-      }
-    }),
-
-  wipeKey: extendZodSchema(z.string().optional().describe('Wipe key for wiping tokens from accounts'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Wipe Key (Optional)',
-        helpText: 'Key for wiping tokens from accounts',
-        group: 'Keys & Security'
-      }
-    }),
-
-  supplyKey: extendZodSchema(z.string().optional().describe('Supply key for minting/burning operations'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Supply Key (Optional)',
-        helpText: 'Key for minting and burning NFTs',
-        group: 'Keys & Security'
-      }
-    }),
-
-  feeScheduleKey: extendZodSchema(z.string().optional().describe('Fee schedule key for updating custom fees'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Fee Schedule Key (Optional)',
-        helpText: 'Key for updating custom fee schedules',
-        group: 'Keys & Security'
-      }
-    }),
-
-  pauseKey: extendZodSchema(z.string().optional().describe('Pause key for pausing token operations'))
-    .withRender({
-      fieldType: 'textarea',
-      ui: {
-        label: 'Pause Key (Optional)',
-        helpText: 'Key for pausing/unpausing token operations',
-        group: 'Keys & Security'
-      }
-    }),
-
-  autoRenewAccountId: extendZodSchema(z.string().optional().describe('Auto-renew account ID (e.g., "0.0.xxxx")'))
-    .withRender(renderConfigs.text('Auto-Renew Account', '0.0.xxxx format')),
-
-  autoRenewPeriod: extendZodSchema(z.number().int().positive().optional().describe('Auto-renewal period in seconds'))
-    .withRender(renderConfigs.number('Auto-Renew Period (seconds)', 0)),
-
-  memo: extendZodSchema(z.string().optional().describe('Memo for the NFT collection'))
-    .withRender(renderConfigs.textarea('Memo (Optional)', 2)),
-
-  freezeDefault: extendZodSchema(z.boolean().optional().describe('Default freeze status for accounts'))
-    .withRender({
-      fieldType: 'checkbox',
-      ui: {
-        label: 'Freeze by Default',
-        helpText: 'New accounts will be frozen by default',
-        group: 'Token Settings'
-      }
-    }),
-
-  supplyType: extendZodSchema(z.enum(['FINITE', 'INFINITE']).optional().default('FINITE')
-    .describe('Supply type: FINITE or INFINITE. NFTs typically use FINITE'))
-    .withRender(renderConfigs.select('Supply Type', [
-      { value: 'FINITE', label: 'Finite Supply' },
-      { value: 'INFINITE', label: 'Infinite Supply' }
-    ])),
-
-  maxSupply: extendZodSchema(z.union([z.number(), z.string()]).optional()
-    .describe('Maximum supply if supplyType is FINITE'))
-    .withRender(renderConfigs.number('Maximum Supply', 1, 1000000000)),
-
-  customFees: extendZodSchema(z.array(CustomFeeInputUnionSchema).optional()
-    .describe('Array of custom fee objects for the token'))
-    .withRender(renderConfigs.array('Custom Fees (Optional)', 'Fee')),
-})).withRender({
-  fieldType: 'object',
-  ui: {
-    label: 'NFT Collection Configuration',
-    description: 'Configure your new NFT collection with all required and optional settings',
-    priority: 'essential'
-  },
-  progressive: {
-    priority: 'essential'
-  }
-});
-
-/**
- * Hedera Create NFT Tool with enhanced render configurations for form generation
- */
-export class HederaCreateNftTool extends BaseHederaTransactionTool<any> {
-  name = 'hedera-create-nft-collection';
-  description = 'Creates a new Hedera Non-Fungible Token (NFT) collection with comprehensive form generation support. Includes render configurations for UI components, field grouping, validation hints, and user-friendly form layouts.';
-  specificInputSchema = HederaCreateNftSchema as any;
-  namespace = 'hedera';
-
-  /**
-   * Returns the service builder for HTS operations
-   */
-  protected getServiceBuilder(): BaseServiceBuilder {
-    return this.hederaKit.hts();
-  }
-
-  /**
-   * Calls the builder method to create the NFT collection
-   */
-  protected async callBuilderMethod(
-    builder: BaseServiceBuilder,
-    specificArgs: z.infer<typeof HederaCreateNftSchema>
-  ): Promise<void> {
-    const htsBuilder = builder as any;
-
-    if (typeof htsBuilder.createNonFungibleToken === 'function') {
-      await htsBuilder.createNonFungibleToken(specificArgs);
-    } else {
-      throw new Error('HTS Builder does not support NFT creation');
-    }
-  }
-
-  /**
-   * Provides helpful notes for specific field values
-   */
-  protected override getNoteForKey(key: string, schemaDefaultValue: unknown, actualValue: unknown): string | undefined {
-    switch (key) {
-      case 'supplyType':
-        return `NFT collection supply type set to '${actualValue}'. Most NFT collections use FINITE supply.`;
-
-      case 'maxSupply':
-        if (actualValue !== undefined) {
-          try {
-            const num = BigInt(String(actualValue));
-            return `Maximum supply of '${num.toLocaleString()}' NFTs can be minted for this collection.`;
-          } catch {
-            return `Maximum supply set to '${actualValue}' NFTs for this collection.`;
-          }
-        }
-        break;
-
-      case 'customFees':
-        if (Array.isArray(actualValue) && actualValue.length > 0) {
-          return `${actualValue.length} custom fee(s) configured for this NFT collection.`;
-        }
-        break;
-
-      case 'treasuryAccountId':
-        if (actualValue) {
-          return `Treasury account '${actualValue}' will initially hold all minted NFTs.`;
-        }
-        break;
-
-      case 'tokenName':
-        if (actualValue) {
-          return `NFT collection '${actualValue}' will be created on Hedera network.`;
-        }
-        break;
-    }
-
-    return undefined;
-  }
-
-  /**
-   * Validates the configuration before execution
-   */
-  protected async validateInput(args: z.infer<typeof HederaCreateNftSchema>): Promise<void> {
-
-    if (args.supplyType === 'FINITE' && !args.maxSupply) {
-      throw new Error('maxSupply is required when supplyType is FINITE');
-    }
-
-    if (args.customFees && args.customFees.length > 0) {
-      for (const fee of args.customFees) {
-        if (fee.type === 'FRACTIONAL' && fee.denominator !== undefined && fee.denominator <= 0) {
-          throw new Error('Fractional fee denominator must be positive');
-        }
-        if (fee.type === 'ROYALTY' && fee.denominator !== undefined && fee.denominator <= 0) {
-          throw new Error('Royalty fee denominator must be positive');
-        }
-      }
-    }
-  }
-}

package/src/tools/hedera/index.ts

@@ -1 +0,0 @@
-export { HederaCreateNftTool, HederaCreateNftSchema } from './HederaCreateNftTool';