@hashgraphonline/standards-agent-kit 0.2.131 → 0.2.134

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

@@ -11,21 +11,14 @@ import {
   HederaClientConfig,
   NetworkType,
 } from '@hashgraphonline/standards-sdk';
+import { InscriptionSDK } from '@kiloscribe/inscription-sdk';
 
 /**
- * Type definition for DAppSigner since we don't have the actual package
+ * Type definition for DAppSigner interface compatible with inscription SDK
  */
 interface DAppSigner {
   getAccountId(): { toString(): string };
-}
-
-/**
- * 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>;
+  [key: string]: unknown;
 }
 
 /**
@@ -42,7 +35,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 +74,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/config-extractor.ts

@@ -0,0 +1,351 @@
+import { ZodType } from 'zod';
+
+/**
+ * Type definitions for Zod internal structures
+ */
+interface ZodDef {
+  typeName: string;
+  type?: ZodType<unknown>;
+}
+
+/**
+ * Type definition for Zod object schema with shape property
+ */
+interface ZodObjectSchema {
+  _def: ZodDef;
+  shape: Record<string, ZodType<unknown>>;
+}
+
+/**
+ * Type definition for Zod array schema with element type
+ */
+interface ZodArraySchema {
+  _def: ZodDef & {
+    type: ZodType<unknown>;
+  };
+}
+
+/**
+ * Type definition for field config map entries
+ */
+interface FieldConfigMapEntry {
+  renderConfig: RenderConfigSchema;
+  metadata: FieldMetadata;
+  path: string[];
+}
+
+
+/**
+ * Type definition for simple field configuration
+ */
+interface SimpleFieldConfig {
+  name: string;
+  type: FormFieldType;
+  label: string;
+  required: boolean;
+  placeholder?: string;
+  options?: Array<{ value: unknown; label: string }>;
+}
+import {
+  RenderConfigSchema,
+  ExtractedRenderConfig,
+  FieldMetadata,
+  FormFieldType
+} from './types';
+import {
+  hasRenderConfig,
+  getRenderConfig,
+  extractFieldMetadata,
+  getInnerSchema
+} from './schema-extension';
+
+/**
+ * Extracts render configurations from a Zod schema and all nested schemas
+ */
+export function extractRenderConfigs(schema: ZodType<unknown>): ExtractedRenderConfig {
+  const fields: Record<string, RenderConfigSchema> = {};
+  const groups: Record<string, string[]> = {};
+  const order: string[] = [];
+  const metadata: Record<string, FieldMetadata> = {};
+
+  extractFromSchema(schema, '', fields, groups, order, metadata);
+
+  return {
+    fields,
+    groups: organizeFieldGroups(groups),
+    order: orderFields(order, fields),
+    metadata
+  };
+}
+
+/**
+ * Recursively extracts render configurations from schema and nested schemas
+ */
+function extractFromSchema(
+  schema: ZodType<unknown>,
+  pathPrefix: string,
+  fields: Record<string, RenderConfigSchema>,
+  groups: Record<string, string[]>,
+  order: string[],
+  metadata: Record<string, FieldMetadata>
+): void {
+  const innerSchema = getInnerSchema(schema);
+  const typeName = (innerSchema._def as ZodDef)?.typeName;
+
+  if (typeName === 'ZodObject') {
+    extractFromObjectSchema(innerSchema as unknown as ZodObjectSchema, pathPrefix, fields, groups, order, metadata);
+  } else if (typeName === 'ZodArray') {
+    extractFromArraySchema(innerSchema as unknown as ZodArraySchema, pathPrefix, fields, groups, order, metadata);
+  } else {
+    extractFromPrimitiveSchema(schema, pathPrefix, fields, groups, order, metadata);
+  }
+}
+
+/**
+ * Extracts configurations from ZodObject schemas
+ */
+function extractFromObjectSchema(
+  schema: ZodObjectSchema,
+  pathPrefix: string,
+  fields: Record<string, RenderConfigSchema>,
+  groups: Record<string, string[]>,
+  order: string[],
+  metadata: Record<string, FieldMetadata>
+): void {
+  const shape = schema.shape;
+
+  if (hasRenderConfig(schema)) {
+    const config = getRenderConfig(schema);
+    if (config && pathPrefix) {
+      fields[pathPrefix] = config;
+      addToGroup(groups, config.ui?.group || 'default', pathPrefix);
+      addToOrder(order, pathPrefix, config.ui?.order);
+    }
+  }
+
+  for (const [key, fieldSchema] of Object.entries(shape)) {
+    const fieldPath = pathPrefix ? `${pathPrefix}.${key}` : key;
+    extractFromSchema(fieldSchema as ZodType<unknown>, fieldPath, fields, groups, order, metadata);
+  }
+}
+
+/**
+ * Extracts configurations from ZodArray schemas
+ */
+function extractFromArraySchema(
+  schema: ZodArraySchema,
+  pathPrefix: string,
+  fields: Record<string, RenderConfigSchema>,
+  groups: Record<string, string[]>,
+  order: string[],
+  metadata: Record<string, FieldMetadata>
+): void {
+  if (hasRenderConfig(schema)) {
+    const config = getRenderConfig(schema);
+    if (config) {
+      fields[pathPrefix] = config;
+      addToGroup(groups, config.ui?.group || 'default', pathPrefix);
+      addToOrder(order, pathPrefix, config.ui?.order);
+      metadata[pathPrefix] = extractFieldMetadata(schema);
+    }
+  }
+
+  const elementSchema = schema._def.type;
+  if (elementSchema) {
+    const itemPath = `${pathPrefix}[]`;
+    extractFromSchema(elementSchema, itemPath, fields, groups, order, metadata);
+  }
+}
+
+/**
+ * Extracts configurations from primitive schemas
+ */
+function extractFromPrimitiveSchema(
+  schema: ZodType<unknown>,
+  pathPrefix: string,
+  fields: Record<string, RenderConfigSchema>,
+  groups: Record<string, string[]>,
+  order: string[],
+  metadata: Record<string, FieldMetadata>
+): void {
+  if (hasRenderConfig(schema)) {
+    const config = getRenderConfig(schema);
+    if (config) {
+      fields[pathPrefix] = config;
+      addToGroup(groups, config.ui?.group || 'default', pathPrefix);
+      addToOrder(order, pathPrefix, config.ui?.order);
+    }
+  }
+
+  metadata[pathPrefix] = extractFieldMetadata(schema);
+}
+
+/**
+ * Adds a field to a group
+ */
+function addToGroup(groups: Record<string, string[]>, groupName: string, fieldPath: string): void {
+  if (!groups[groupName]) {
+    groups[groupName] = [];
+  }
+  groups[groupName].push(fieldPath);
+}
+
+/**
+ * Adds a field to the order array considering explicit order values
+ */
+function addToOrder(order: string[], fieldPath: string, explicitOrder?: number): void {
+  if (explicitOrder !== undefined) {
+    order.splice(explicitOrder, 0, fieldPath);
+  } else {
+    order.push(fieldPath);
+  }
+}
+
+/**
+ * Organizes field groups with proper ordering
+ */
+function organizeFieldGroups(groups: Record<string, string[]>): Record<string, string[]> {
+  const organized: Record<string, string[]> = {};
+  const groupPriority = ['default', 'Keys & Security', 'Token Settings', 'Custom Fees'];
+
+  for (const groupName of groupPriority) {
+    if (groups[groupName]) {
+      organized[groupName] = groups[groupName];
+    }
+  }
+
+  for (const [groupName, fields] of Object.entries(groups)) {
+    if (!groupPriority.includes(groupName)) {
+      organized[groupName] = fields;
+    }
+  }
+
+  return organized;
+}
+
+/**
+ * Orders fields based on explicit order values and logical grouping
+ */
+function orderFields(order: string[], fields: Record<string, RenderConfigSchema>): string[] {
+  const fieldPriority: Record<string, number> = {
+    'tokenName': 1,
+    'tokenSymbol': 2,
+    'maxSupply': 3,
+    'supplyType': 4,
+    'treasuryAccountId': 5,
+    'memo': 6,
+  };
+
+  return order.sort((a, b) => {
+    const aConfig = fields[a];
+    const bConfig = fields[b];
+
+    if (aConfig?.ui?.order !== undefined && bConfig?.ui?.order !== undefined) {
+      return aConfig.ui.order - bConfig.ui.order;
+    }
+
+    if (aConfig?.ui?.order !== undefined) {
+      return -1;
+    }
+    if (bConfig?.ui?.order !== undefined) {
+      return 1;
+    }
+
+    const aPriority = fieldPriority[a] || 1000;
+    const bPriority = fieldPriority[b] || 1000;
+
+    if (aPriority !== bPriority) {
+      return aPriority - bPriority;
+    }
+
+    return a.localeCompare(b);
+  });
+}
+
+/**
+ * Generates field ordering metadata for complex forms
+ */
+export function generateFieldOrdering(schema: ZodType<unknown>): {
+  sections: Record<string, { title: string; fields: string[]; order: number }>;
+  fieldOrder: string[];
+} {
+  const extracted = extractRenderConfigs(schema);
+  const sections: Record<string, { title: string; fields: string[]; order: number }> = {};
+
+  const sectionOrder: Record<string, number> = {
+    'default': 0,
+    'Basic Information': 1,
+    'Token Settings': 2,
+    'Keys & Security': 3,
+    'Custom Fees': 4,
+    'Advanced Settings': 5
+  };
+
+  for (const [groupName, fields] of Object.entries(extracted.groups)) {
+    const displayName = groupName === 'default' ? 'Basic Information' : groupName;
+    sections[displayName] = {
+      title: displayName,
+      fields,
+      order: sectionOrder[displayName] || 10
+    };
+  }
+
+  return {
+    sections,
+    fieldOrder: extracted.order
+  };
+}
+
+/**
+ * Creates a field configuration map for form builders
+ */
+export function createFieldConfigMap(schema: ZodType<unknown>): Record<string, FieldConfigMapEntry> {
+  const extracted = extractRenderConfigs(schema);
+  const configMap: Record<string, FieldConfigMapEntry> = {};
+
+  for (const [fieldPath, renderConfig] of Object.entries(extracted.fields)) {
+    const metadata = extracted.metadata[fieldPath];
+    const path = fieldPath.split('.');
+
+    configMap[fieldPath] = {
+      renderConfig,
+      metadata,
+      path
+    };
+  }
+
+  return configMap;
+}
+
+
+
+
+/**
+ * Creates a simplified configuration for basic form rendering
+ */
+export function createSimpleConfig(schema: ZodType<unknown>): {
+  fields: Array<SimpleFieldConfig>;
+} {
+  const extracted = extractRenderConfigs(schema);
+  const fields = [];
+
+  for (const fieldPath of extracted.order) {
+    const renderConfig = extracted.fields[fieldPath];
+    const metadata = extracted.metadata[fieldPath];
+
+    if (!renderConfig || !metadata) {
+      continue;
+    }
+
+    fields.push({
+      name: fieldPath,
+      type: metadata.type,
+      label: renderConfig.ui?.label || fieldPath,
+      required: metadata.required,
+      placeholder: renderConfig.ui?.placeholder,
+      options: renderConfig.options || metadata.options
+    });
+  }
+
+  return { fields };
+}

package/src/lib/zod-render/index.ts

@@ -0,0 +1,36 @@
+export * from './types';
+export * from './schema-extension';
+export * from './config-extractor';
+
+export {
+  extendZodSchema,
+  hasRenderConfig,
+  getRenderConfig,
+  renderConfigs
+} from './schema-extension';
+
+export {
+  extractRenderConfigs,
+  generateFieldOrdering,
+  createFieldConfigMap,
+  createSimpleConfig
+} from './config-extractor';
+
+export type {
+  FormFieldType,
+  RenderContext,
+  RenderFunction,
+  RenderConfigSchema,
+  ZodSchemaWithRender,
+  FormGenerationOptions,
+  ValidationError,
+  FormState,
+  FormActions,
+  UseFormReturn,
+  ComponentRegistry,
+  FieldComponentProps,
+  SelectOption,
+  FileUploadResult,
+  FieldMetadata,
+  ExtractedRenderConfig
+} from './types';