@hashgraphonline/standards-agent-kit 0.2.130 → 0.2.132

package/dist/cjs/builders/inscriber/inscriber-builder.d.ts

@@ -1,20 +1,51 @@
 import { BaseServiceBuilder, HederaAgentKit } from 'hedera-agent-kit';
 import { InscriptionInput, InscriptionOptions, InscriptionResponse, RetrievedInscriptionResult } 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>;
 }
 /**
  * Builder for Inscription operations
@@ -25,7 +56,7 @@ export declare class InscriberBuilder extends BaseServiceBuilder {
     /**
      * Get or create Inscription SDK - temporarily returns null since we don't have the actual SDK
      */
-    protected getInscriptionSDK(options: InscriptionOptions): Promise<InscriptionSDK | null>;
+    protected getInscriptionSDK(_options: InscriptionOptions): Promise<InscriptionSDK | null>;
     /**
      * Inscribe content using server-side authentication
      */

package/dist/cjs/index.d.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/dist/cjs/interfaces/FormValidatable.d.ts

@@ -0,0 +1,45 @@
+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 declare function isFormValidatable(tool: unknown): tool is FormValidatable;

package/dist/cjs/interfaces/index.d.ts

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

package/dist/cjs/lib/index.d.ts

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

package/dist/cjs/lib/zod-render/__tests__/withRender.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cjs/lib/zod-render/config-extractor.d.ts

@@ -0,0 +1,71 @@
+import { ZodType } from 'zod';
+import { RenderConfigSchema, ExtractedRenderConfig, FieldMetadata, FormFieldType } from './types';
+/**
+ * Type definition for field config map entries
+ */
+interface FieldConfigMapEntry {
+    renderConfig: RenderConfigSchema;
+    metadata: FieldMetadata;
+    path: string[];
+}
+/**
+ * Type definition for validation rules entries
+ */
+interface ValidationRulesEntry {
+    required: boolean;
+    type: FormFieldType;
+    constraints: Record<string, unknown>;
+    customMessages?: Record<string, 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;
+    }>;
+}
+/**
+ * Extracts render configurations from a Zod schema and all nested schemas
+ */
+export declare function extractRenderConfigs(schema: ZodType<unknown>): ExtractedRenderConfig;
+/**
+ * Generates field ordering metadata for complex forms
+ */
+export declare function generateFieldOrdering(schema: ZodType<unknown>): {
+    sections: Record<string, {
+        title: string;
+        fields: string[];
+        order: number;
+    }>;
+    fieldOrder: string[];
+};
+/**
+ * Creates a field configuration map for form builders
+ */
+export declare function createFieldConfigMap(schema: ZodType<unknown>): Record<string, FieldConfigMapEntry>;
+/**
+ * Generates validation rules from schema and render configs
+ */
+export declare function extractValidationRules(schema: ZodType<unknown>): Record<string, ValidationRulesEntry>;
+/**
+ * Merges render configurations from multiple schemas
+ */
+export declare function mergeRenderConfigs(...configs: ExtractedRenderConfig[]): ExtractedRenderConfig;
+/**
+ * Filters render configurations based on conditions
+ */
+export declare function filterRenderConfigs(config: ExtractedRenderConfig, filter: (fieldPath: string, renderConfig: RenderConfigSchema) => boolean): ExtractedRenderConfig;
+/**
+ * Creates a simplified configuration for basic form rendering
+ */
+export declare function createSimpleConfig(schema: ZodType<unknown>): {
+    fields: Array<SimpleFieldConfig>;
+};
+export {};

package/dist/cjs/lib/zod-render/index.d.ts

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

package/dist/cjs/lib/zod-render/schema-extension.d.ts

@@ -0,0 +1,102 @@
+import { ZodType } from 'zod';
+import { RenderConfigSchema, EnhancedRenderConfig, ZodSchemaWithRender, FormFieldType, FieldMetadata, SelectOption, SchemaComposer } from './types';
+/**
+ * Extends a Zod schema with render configuration capabilities
+ */
+export declare function extendZodSchema<TSchema>(schema: ZodType<TSchema>): ZodSchemaWithRender<TSchema>;
+/**
+ * Checks if a schema has render configuration
+ */
+export declare function hasRenderConfig(schema: unknown): schema is ZodSchemaWithRender;
+/**
+ * Extracts render configuration from a schema
+ */
+export declare function getRenderConfig(schema: ZodType<unknown>): EnhancedRenderConfig | undefined;
+/**
+ * Infers form field type from Zod schema type with enhanced field detection
+ */
+export declare function inferFieldTypeFromSchema(schema: ZodType<unknown>): FormFieldType;
+/**
+ * Extracts options from enum, union, or literal schemas
+ */
+export declare function extractOptionsFromSchema(schema: ZodType<unknown>): SelectOption[] | undefined;
+/**
+ * Checks if a schema is optional
+ */
+export declare function isOptionalSchema(schema: ZodType<unknown>): boolean;
+/**
+ * Gets the inner schema from optional/default wrappers
+ */
+export declare function getInnerSchema(schema: ZodType<unknown>): ZodType<unknown>;
+/**
+ * Extracts validation constraints from a schema with enhanced support
+ */
+export declare function extractValidationConstraints(schema: ZodType<unknown>): Record<string, unknown>;
+/**
+ * Gets default value from schema with comprehensive type support
+ */
+export declare function getDefaultValue(schema: ZodType<unknown>): unknown;
+/**
+ * Extracts field metadata from schema including render configuration
+ */
+export declare function extractFieldMetadata(schema: ZodType<unknown>): FieldMetadata;
+/**
+ * Schema composition utilities for building complex forms
+ */
+export declare const schemaComposer: SchemaComposer;
+/**
+ * Creates render configuration with sensible defaults
+ */
+export declare function createRenderConfig(overrides?: Partial<EnhancedRenderConfig>): EnhancedRenderConfig;
+/**
+ * Helper function to create common render configurations
+ */
+export declare const renderConfigs: {
+    text: (label: string, placeholder?: string, priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    number: (label: string, min?: number, max?: number, priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    select: (label: string, options: SelectOption[], priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    textarea: (label: string, rows?: number, priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    currency: (label: string, symbol?: string, priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    array: (label: string, itemLabel?: string, priority?: "essential" | "common" | "advanced" | "expert") => EnhancedRenderConfig;
+    essential: {
+        text: (label: string, placeholder?: string) => EnhancedRenderConfig;
+        number: (label: string, min?: number, max?: number) => EnhancedRenderConfig;
+        select: (label: string, options: SelectOption[]) => EnhancedRenderConfig;
+        textarea: (label: string, rows?: number) => EnhancedRenderConfig;
+    };
+    advanced: {
+        text: (label: string, placeholder?: string) => EnhancedRenderConfig;
+        number: (label: string, min?: number, max?: number) => EnhancedRenderConfig;
+        select: (label: string, options: SelectOption[]) => EnhancedRenderConfig;
+        textarea: (label: string, rows?: number) => EnhancedRenderConfig;
+        array: (label: string, itemLabel?: string) => EnhancedRenderConfig;
+    };
+    expert: {
+        text: (label: string, placeholder?: string) => EnhancedRenderConfig;
+        number: (label: string, min?: number, max?: number) => EnhancedRenderConfig;
+        select: (label: string, options: SelectOption[]) => EnhancedRenderConfig;
+        textarea: (label: string, rows?: number) => EnhancedRenderConfig;
+    };
+};
+/**
+ * Extends Zod prototype to add withRender functionality globally
+ */
+export declare function installZodRenderExtensions(): void;
+/**
+ * Creates a progressive form schema with grouped fields
+ */
+export declare function createProgressiveSchema<TSchema>(baseSchema: ZodType<TSchema>, groups: Record<string, {
+    priority: 'essential' | 'common' | 'advanced' | 'expert';
+    fields: string[];
+}>): ZodSchemaWithRender<TSchema>;
+/**
+ * Utility to convert legacy render configs to enhanced configs
+ */
+export declare function enhanceRenderConfig(config: RenderConfigSchema): EnhancedRenderConfig;
+/**
+ * Helper to extract progressive disclosure information from schema
+ */
+export declare function extractProgressiveInfo(schema: ZodType<unknown>): {
+    priority: 'essential' | 'common' | 'advanced' | 'expert';
+    group?: string;
+};

package/dist/cjs/lib/zod-render/types.d.ts

@@ -0,0 +1,286 @@
+import { ZodType } from 'zod';
+export type ReactNode = unknown;
+export type ReactElement = unknown;
+export type ComponentType<_TProps = Record<string, unknown>> = unknown;
+/**
+ * Core form field types supported by the render system
+ */
+export type FormFieldType = 'text' | 'number' | 'select' | 'checkbox' | 'textarea' | 'file' | 'array' | 'object' | 'currency' | 'percentage';
+/**
+ * Context provided to render functions containing field state and callbacks
+ */
+export type RenderContext = {
+    path: string[];
+    value: unknown;
+    setValue: (value: unknown) => void;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+};
+/**
+ * Function that renders a field component for a Zod schema
+ */
+export type RenderFunction<TSchema = unknown> = (schema: ZodType<TSchema>, context: RenderContext) => ReactNode;
+/**
+ * Configuration for rendering a form field
+ */
+export type RenderConfigSchema = {
+    fieldType: FormFieldType;
+    component?: ComponentType<Record<string, unknown>>;
+    props?: Record<string, unknown>;
+    wrapper?: ComponentType<{
+        children: ReactNode;
+    }>;
+    validation?: {
+        customMessages?: Record<string, string>;
+    };
+    ui?: {
+        label?: string;
+        placeholder?: string;
+        helpText?: string;
+        group?: string;
+        order?: number;
+        hidden?: boolean;
+        readonly?: boolean;
+        width?: 'full' | 'half' | 'third' | 'quarter';
+        className?: string;
+        priority?: 'essential' | 'common' | 'advanced' | 'expert';
+        collapsible?: boolean;
+        expanded?: boolean;
+        icon?: string;
+        description?: string;
+    };
+    options?: Array<{
+        value: unknown;
+        label: string;
+        disabled?: boolean;
+    }>;
+    constraints?: {
+        min?: number;
+        max?: number;
+        step?: number;
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        accept?: string;
+        multiple?: boolean;
+    };
+};
+/**
+ * Extended Zod schema with render configuration
+ */
+export interface ZodSchemaWithRender<TSchema = unknown> extends ZodType<TSchema> {
+    _renderConfig?: EnhancedRenderConfig;
+    withRender: (config: EnhancedRenderConfig | RenderConfigSchema) => ZodSchemaWithRender<TSchema>;
+    withProgressive: (priority: 'essential' | 'common' | 'advanced' | 'expert', group?: string) => ZodSchemaWithRender<TSchema>;
+    withBlock: (blockId: string) => ZodSchemaWithRender<TSchema>;
+}
+/**
+ * Progressive disclosure configuration
+ */
+export type ProgressiveDisclosureConfig = {
+    enabled?: boolean;
+    groups?: FormGroup[];
+    defaultExpanded?: string[];
+    showFieldCount?: boolean;
+    adaptiveLayout?: boolean;
+    essentialOnly?: boolean;
+};
+/**
+ * Form group configuration for progressive disclosure
+ */
+export type FormGroup = {
+    name: string;
+    priority: 'essential' | 'common' | 'advanced' | 'expert';
+    collapsible?: boolean;
+    description?: string;
+    icon?: string;
+    defaultExpanded?: boolean;
+};
+/**
+ * Options for generating forms from schemas
+ */
+export type FormGenerationOptions = {
+    fieldOrder?: string[];
+    fieldConfigs?: Record<string, RenderConfigSchema>;
+    onSubmit?: (values: Record<string, unknown>) => void | Promise<void>;
+    onValueChange?: (path: string[], value: unknown) => void;
+    className?: string;
+    disabled?: boolean;
+    showSubmitButton?: boolean;
+    submitButtonText?: string;
+    resetButtonText?: string;
+    showResetButton?: boolean;
+    groupBy?: 'none' | 'group' | 'section';
+    layout?: 'vertical' | 'horizontal' | 'grid';
+    progressiveDisclosure?: ProgressiveDisclosureConfig;
+};
+/**
+ * Form validation error
+ */
+export type ValidationError = {
+    path: string[];
+    message: string;
+    code: string;
+};
+/**
+ * Form state management
+ */
+export type FormState<TValues = Record<string, unknown>> = {
+    values: TValues;
+    errors: ValidationError[];
+    isValidating: boolean;
+    isSubmitting: boolean;
+    isDirty: boolean;
+    touchedFields: Set<string>;
+};
+/**
+ * Form action handlers
+ */
+export type FormActions<TValues = Record<string, unknown>> = {
+    setValue: (path: string[], value: unknown) => void;
+    setValues: (values: Partial<TValues>) => void;
+    setError: (path: string[], error: string) => void;
+    clearError: (path: string[]) => void;
+    clearErrors: () => void;
+    reset: () => void;
+    submit: () => Promise<void>;
+    validate: () => Promise<boolean>;
+    touchField: (path: string[]) => void;
+};
+/**
+ * Complete form hook return type
+ */
+export type UseFormReturn<TValues = Record<string, unknown>> = {
+    state: FormState<TValues>;
+    actions: FormActions<TValues>;
+};
+/**
+ * Registry mapping field types to React components
+ */
+export type ComponentRegistry = Record<FormFieldType, ComponentType<FieldComponentProps>>;
+/**
+ * Props passed to field components
+ */
+export type FieldComponentProps = {
+    value: unknown;
+    onChange: (value: unknown) => void;
+    error?: string;
+    disabled?: boolean;
+    required?: boolean;
+    placeholder?: string;
+    options?: Array<{
+        value: unknown;
+        label: string;
+        disabled?: boolean;
+    }>;
+    multiple?: boolean;
+    accept?: string;
+    rows?: number;
+    min?: number;
+    max?: number;
+    step?: number;
+    className?: string;
+};
+/**
+ * Option for select fields
+ */
+export type SelectOption = {
+    value: unknown;
+    label: string;
+    disabled?: boolean;
+};
+/**
+ * File upload result
+ */
+export type FileUploadResult = {
+    name: string;
+    data: string;
+    type: string;
+    size: number;
+};
+/**
+ * Field metadata extracted from schema
+ */
+export type FieldMetadata = {
+    type: FormFieldType;
+    required: boolean;
+    optional: boolean;
+    default?: unknown;
+    options?: SelectOption[];
+    constraints?: Record<string, unknown>;
+    description?: string;
+    validation?: {
+        minLength?: number;
+        maxLength?: number;
+        min?: number;
+        max?: number;
+        pattern?: RegExp;
+    };
+};
+/**
+ * Schema composition utilities
+ */
+export type SchemaComposer = {
+    merge: <TSchema1, TSchema2>(schema1: ZodType<TSchema1>, schema2: ZodType<TSchema2>) => ZodType<TSchema1 & TSchema2>;
+    extend: <TSchema>(schema: ZodType<TSchema>, extensions: Record<string, ZodType<unknown>>) => ZodType<TSchema>;
+    pick: <TSchema>(schema: ZodType<TSchema>, keys: string[]) => ZodType<Partial<TSchema>>;
+    omit: <TSchema>(schema: ZodType<TSchema>, keys: string[]) => ZodType<Omit<TSchema, string>>;
+};
+/**
+ * Render config extraction result
+ */
+export type ExtractedRenderConfig = {
+    fields: Record<string, RenderConfigSchema>;
+    groups: Record<string, string[]>;
+    order: string[];
+    metadata: Record<string, FieldMetadata>;
+    progressiveDisclosure?: ProgressiveDisclosureConfig;
+};
+/**
+ * Block-based form architecture types
+ */
+export type FormBlock<TSchema = unknown> = {
+    id: string;
+    name: string;
+    schema: ZodType<TSchema>;
+    renderConfig?: RenderConfigSchema;
+    validate?: (data: unknown) => ValidationError[];
+    getDefaultValue?: () => unknown;
+    metadata?: {
+        category?: string;
+        reusable?: boolean;
+        description?: string;
+        version?: string;
+    };
+};
+/**
+ * Block registry for reusable form components
+ */
+export type BlockRegistry = {
+    register: <TSchema>(block: FormBlock<TSchema>) => void;
+    get: <TSchema>(id: string) => FormBlock<TSchema> | undefined;
+    list: () => FormBlock[];
+    listByCategory: (category: string) => FormBlock[];
+    unregister: (id: string) => void;
+};
+/**
+ * Enhanced render configuration with block support
+ */
+export type EnhancedRenderConfig = RenderConfigSchema & {
+    block?: {
+        id?: string;
+        type?: 'field' | 'group' | 'section' | 'array-item' | 'union-variant';
+        reusable?: boolean;
+        composition?: {
+            blocks?: string[];
+            layout?: 'stack' | 'grid' | 'flex';
+        };
+    };
+    progressive?: {
+        priority: 'essential' | 'common' | 'advanced' | 'expert';
+        group?: string;
+        showWhen?: (values: Record<string, unknown>) => boolean;
+        hideWhen?: (values: Record<string, unknown>) => boolean;
+    };
+};