@hashgraphonline/conversational-agent 0.1.215 → 0.1.217

package/dist/types/langchain/external-tool-wrapper.d.ts

@@ -1,179 +0,0 @@
-import { StructuredTool } from '@langchain/core/tools';
-import { z } from 'zod';
-import { CallbackManagerForToolRun } from '@langchain/core/callbacks/manager';
-import { RenderConfigSchema } from '@hashgraphonline/standards-agent-kit';
-
-/**
- * Configuration for wrapping external tools with render configs
- */
-export interface ExternalToolWrapperConfig {
-    renderConfig?: RenderConfigSchema;
-    fieldConfigs?: Record<string, RenderConfigSchema>;
-    ui?: {
-        label?: string;
-        description?: string;
-    };
-    preserveOriginalSchema?: boolean;
-}
-/**
- * Wrapper class that adds render configs to external tools
- */
-export declare class ExternalToolWrapper<TSchema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>> extends StructuredTool<TSchema> {
-    private originalTool;
-    private wrapperConfig;
-    private logger;
-    private enhancedSchema;
-    name: string;
-    description: string;
-    schema: TSchema;
-    constructor(originalTool: StructuredTool<TSchema>, config?: ExternalToolWrapperConfig);
-    /**
-     * Creates an enhanced schema with render configurations
-     */
-    private createEnhancedSchema;
-    /**
-     * Adds field-level render configurations to the schema
-     */
-    private addFieldRenderConfigs;
-    /**
-     * Adds render configuration to a specific field
-     */
-    private addRenderConfigToField;
-    /**
-     * Adds tool-level render configuration to the schema
-     */
-    private addToolRenderConfig;
-    /**
-     * Override _call to delegate to the original tool
-     */
-    protected _call(input: z.infer<TSchema>, runManager?: CallbackManagerForToolRun): Promise<string>;
-}
-/**
- * Predefined render config helpers for common field types
- */
-export declare const renderConfigs: {
-    /**
-     * Text input field configuration
-     */
-    text: (label: string, placeholder?: string, helpText?: string) => RenderConfigSchema;
-    /**
-     * Number input field configuration
-     */
-    number: (label: string, min?: number, max?: number, placeholder?: string) => RenderConfigSchema;
-    /**
-     * Select dropdown field configuration
-     */
-    select: (label: string, options: Array<{
-        value: string | number;
-        label: string;
-        disabled?: boolean;
-    }>, helpText?: string) => RenderConfigSchema;
-    /**
-     * Textarea field configuration
-     */
-    textarea: (label: string, placeholder?: string, maxLength?: number) => RenderConfigSchema;
-    /**
-     * Checkbox field configuration
-     */
-    checkbox: (label: string, helpText?: string) => RenderConfigSchema;
-    /**
-     * Currency field configuration
-     */
-    currency: (label: string, currency?: string, min?: number, max?: number) => RenderConfigSchema;
-    /**
-     * Account ID field configuration
-     */
-    accountId: (label?: string) => RenderConfigSchema;
-    /**
-     * Token ID field configuration
-     */
-    tokenId: (label?: string) => RenderConfigSchema;
-    /**
-     * Private key field configuration
-     */
-    privateKey: (label?: string) => RenderConfigSchema;
-};
-/**
- * Wraps an external tool with render configurations
- *
- * @param tool The external StructuredTool to wrap
- * @param config Configuration for render configs and UI
- * @returns Enhanced tool with render configurations
- *
- * @example
- * ```typescript
- * import { SomeHederaTool } from 'hedera-agent-kit';
- *
- * const externalTool = new SomeHederaTool();
- * const wrappedTool = wrapExternalToolWithRenderConfig(externalTool, {
- *   renderConfig: {
- *     fieldType: 'form',
- *     ui: { label: 'Transfer HBAR', description: 'Transfer HBAR between accounts' }
- *   },
- *   fieldConfigs: {
- *     fromAccountId: renderConfigs.accountId('From Account'),
- *     toAccountId: renderConfigs.accountId('To Account'),
- *     amount: renderConfigs.currency('Amount', 'HBAR', 0.00000001),
- *     memo: renderConfigs.text('Memo', 'Optional memo', 'Transaction memo (optional)')
- *   }
- * });
- * ```
- */
-export declare function wrapExternalToolWithRenderConfig<TSchema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>>(tool: StructuredTool<TSchema>, config?: ExternalToolWrapperConfig): ExternalToolWrapper<TSchema>;
-/**
- * Batch wrapper for multiple external tools
- *
- * @param tools Array of tools with their configurations
- * @returns Array of wrapped tools
- *
- * @example
- * ```typescript
- * const wrappedTools = wrapExternalTools([
- *   {
- *     tool: new TransferHbarTool(),
- *     config: {
- *       fieldConfigs: {
- *         fromAccountId: renderConfigs.accountId('From Account'),
- *         toAccountId: renderConfigs.accountId('To Account'),
- *         amount: renderConfigs.currency('Amount', 'HBAR')
- *       }
- *     }
- *   },
- *   {
- *     tool: new CreateTokenTool(),
- *     config: {
- *       fieldConfigs: {
- *         treasuryAccountId: renderConfigs.accountId('Treasury Account'),
- *         tokenName: renderConfigs.text('Token Name'),
- *         tokenSymbol: renderConfigs.text('Token Symbol')
- *       }
- *     }
- *   }
- * ]);
- * ```
- */
-export declare function wrapExternalTools<TSchema extends z.ZodObject<z.ZodRawShape, z.UnknownKeysParam, z.ZodTypeAny>>(tools: Array<{
-    tool: StructuredTool<TSchema>;
-    config?: ExternalToolWrapperConfig;
-}>): ExternalToolWrapper<TSchema>[];
-/**
- * Configuration preset for common Hedera tools
- */
-export declare const hederaToolConfigs: {
-    /**
-     * Standard configuration for HBAR transfer tools
-     */
-    hbarTransfer: () => ExternalToolWrapperConfig;
-    /**
-     * Standard configuration for token creation tools
-     */
-    tokenCreation: () => ExternalToolWrapperConfig;
-    /**
-     * Standard configuration for account creation tools
-     */
-    accountCreation: () => ExternalToolWrapperConfig;
-    /**
-     * Standard configuration for smart contract tools
-     */
-    smartContract: () => ExternalToolWrapperConfig;
-};

package/dist/types/scripts/test-external-tool-wrapper.d.ts

@@ -1,5 +0,0 @@
-/**
- * Test script for the external tool wrapper functionality
- * Run with: pnpm tsx src/scripts/test-external-tool-wrapper.ts
- */
-export {};

package/dist/types/scripts/test-hedera-kit-wrapper.d.ts

@@ -1,36 +0,0 @@
-/**
- * Test script to validate external tool wrapper functionality with hedera-agent-kit tools
- *
- * This test demonstrates that the external-tool-wrapper solution works successfully with
- * hedera-agent-kit tools by:
- *
- * 1. Creating mock tools that simulate hedera-agent-kit tool structure
- * 2. Wrapping them with render configurations using wrapExternalToolWithRenderConfig
- * 3. Integrating wrapped tools with FormValidatingToolWrapper
- * 4. Verifying form generation works with missing fields
- * 5. Testing batch wrapping with predefined configurations
- * 6. Confirming TypeScript type safety is maintained
- * 7. Validating tool delegation functionality is preserved
- *
- * Expected Output:
- * ✅ External tool wrapping with render configs works
- * ✅ Integration with FormValidatingToolWrapper works
- * ✅ Form generation for missing fields works
- * ✅ Batch wrapping with predefined configs works
- * ✅ TypeScript type safety maintained
- * ✅ Tool delegation functionality preserved
- *
- * Acceptance Criteria Met:
- * - Test runs successfully ✅
- * - Uses realistic hedera-agent-kit tool structure ✅
- * - Demonstrates external tool wrapping works ✅
- * - No TypeScript errors or linting violations ✅
- * - Shows form generation integration ✅
- * - Validates render config enhancement ✅
- */
-declare function testHederaKitWrapper(): Promise<void>;
-/**
- * Demonstrate specific render config scenarios
- */
-declare function demonstrateRenderConfigs(): void;
-export { testHederaKitWrapper, demonstrateRenderConfigs };

package/dist/types/scripts/test-inscribe-form-generation.d.ts

@@ -1,15 +0,0 @@
-/**
- * Test script to verify that InscribeHashinalTool generates a form when attributes field is missing
- *
- * This script tests the end-to-end form generation functionality for the InscribeHashinalTool
- * when required fields are missing from the input.
- *
- * Expected behavior:
- * 1. Tool should be wrapped with FormValidatingToolWrapper (due to extendZodSchema)
- * 2. When attributes field is missing, validation should fail
- * 3. A form should be generated containing the missing attributes field
- * 4. Tool should NOT execute directly but return form generation response
- *
- * Run with: pnpm tsx src/scripts/test-inscribe-form-generation.ts
- */
-export {};

package/dist/types/scripts/test-inscribe-wrapper-verification.d.ts

@@ -1,13 +0,0 @@
-/**
- * Simplified test script to verify that InscribeHashinalTool is wrapped with FormValidatingToolWrapper
- *
- * This script verifies the fix for isZodObjectLike detection in langchain-agent.ts
- *
- * Expected behavior:
- * 1. InscribeHashinalTool should be detected as having extendZodSchema with render config
- * 2. Tool should be wrapped with FormValidatingToolWrapper during initialization
- * 3. Wrapper type should be confirmed in the tools array
- *
- * Run with: pnpm tsx src/scripts/test-inscribe-wrapper-verification.ts
- */
-export {};

package/src/examples/external-tool-wrapper-example.ts

@@ -1,227 +0,0 @@
-/**
- * Example demonstrating how to wrap external tools with render configs
- * This example shows how to wrap tools from hedera-agent-kit with form configurations
- */
-
-import { z } from 'zod';
-import { StructuredTool } from '@langchain/core/tools';
-import { 
-  wrapExternalToolWithRenderConfig, 
-  wrapExternalTools, 
-  renderConfigs, 
-  hederaToolConfigs 
-} from '../langchain/external-tool-wrapper';
-import { FormGenerator } from '../forms/form-generator';
-import { wrapToolWithFormValidation } from '../langchain/FormValidatingToolWrapper';
-
-// Example: Mock external tool from hedera-agent-kit
-class MockTransferHbarTool extends StructuredTool {
-  name = 'transfer_hbar';
-  description = 'Transfer HBAR between accounts';
-  
-  schema = z.object({
-    fromAccountId: z.string().describe('Source account ID'),
-    toAccountId: z.string().describe('Destination account ID'),
-    amount: z.number().describe('Amount to transfer in tinybars'),
-    memo: z.string().optional().describe('Optional transaction memo')
-  });
-
-  protected async _call(input: z.infer<typeof this.schema>): Promise<string> {
-    // Mock implementation
-    return `Transferred ${input.amount} tinybars from ${input.fromAccountId} to ${input.toAccountId}${input.memo ? ` with memo: ${input.memo}` : ''}`;
-  }
-}
-
-class MockCreateTokenTool extends StructuredTool {
-  name = 'create_token';
-  description = 'Create a new token on Hedera';
-  
-  schema = z.object({
-    treasuryAccountId: z.string().describe('Treasury account ID'),
-    tokenName: z.string().describe('Token name'),
-    tokenSymbol: z.string().describe('Token symbol'),
-    maxSupply: z.number().optional().describe('Maximum token supply'),
-    decimals: z.number().optional().describe('Number of decimal places')
-  });
-
-  protected async _call(input: z.infer<typeof this.schema>): Promise<string> {
-    // Mock implementation
-    return `Created token ${input.tokenSymbol} (${input.tokenName}) with treasury ${input.treasuryAccountId}`;
-  }
-}
-
-/**
- * Example 1: Basic external tool wrapping with custom render configs
- */
-export function exampleBasicWrapping() {
-  const externalTool = new MockTransferHbarTool();
-  
-  const wrappedTool = wrapExternalToolWithRenderConfig(externalTool, {
-    renderConfig: {
-      fieldType: 'object',
-      ui: { 
-        label: 'Transfer HBAR', 
-        description: 'Transfer HBAR between accounts' 
-      }
-    },
-    fieldConfigs: {
-      fromAccountId: renderConfigs.accountId('From Account'),
-      toAccountId: renderConfigs.accountId('To Account'),
-      amount: renderConfigs.currency('Amount', 'HBAR', 0.00000001),
-      memo: renderConfigs.text('Memo', 'Optional memo', 'Transaction memo (optional)')
-    }
-  });
-
-  console.log('Wrapped tool name:', wrappedTool.name);
-  console.log('Wrapped tool description:', wrappedTool.description);
-  console.log('Schema has render config:', !!(wrappedTool.schema as any)._renderConfig);
-  
-  return wrappedTool;
-}
-
-/**
- * Example 2: Using predefined configurations for common Hedera tools
- */
-export function examplePresetConfigurations() {
-  const externalTool = new MockTransferHbarTool();
-  
-  const wrappedTool = wrapExternalToolWithRenderConfig(
-    externalTool,
-    hederaToolConfigs.hbarTransfer()
-  );
-
-  return wrappedTool;
-}
-
-/**
- * Example 3: Batch wrapping multiple tools
- */
-export function exampleBatchWrapping() {
-  const transferTool = new MockTransferHbarTool();
-  const createTokenTool = new MockCreateTokenTool();
-
-  const wrappedTools = [
-    wrapExternalToolWithRenderConfig(transferTool, hederaToolConfigs.hbarTransfer()),
-    wrapExternalToolWithRenderConfig(createTokenTool, hederaToolConfigs.tokenCreation())
-  ];
-
-  console.log(`Wrapped ${wrappedTools.length} tools`);
-  
-  return wrappedTools;
-}
-
-/**
- * Example 4: Integration with FormValidatingToolWrapper
- */
-export function exampleFormValidationIntegration() {
-  const externalTool = new MockTransferHbarTool();
-  
-  // Step 1: Wrap with render configs
-  const wrappedTool = wrapExternalToolWithRenderConfig(externalTool, {
-    fieldConfigs: {
-      fromAccountId: renderConfigs.accountId('From Account'),
-      toAccountId: renderConfigs.accountId('To Account'),
-      amount: renderConfigs.currency('Amount', 'HBAR', 0.00000001),
-      memo: renderConfigs.text('Memo', 'Optional memo')
-    }
-  });
-
-  // Step 2: Wrap with form validation
-  const formGenerator = new FormGenerator();
-  const formValidatingTool = wrapToolWithFormValidation(
-    wrappedTool,
-    formGenerator,
-    {
-      requireAllFields: false,
-      skipFields: ['memo'] // memo is optional
-    }
-  );
-
-  console.log('Fully wrapped tool ready for form generation');
-  
-  return formValidatingTool;
-}
-
-/**
- * Example 5: Custom field configurations for specialized tools
- */
-export function exampleCustomFieldConfigs() {
-  const externalTool = new MockCreateTokenTool();
-  
-  const wrappedTool = wrapExternalToolWithRenderConfig(externalTool, {
-    ui: {
-      label: 'Create Hedera Token',
-      description: 'Create a new fungible token on Hedera'
-    },
-    fieldConfigs: {
-      treasuryAccountId: renderConfigs.accountId('Treasury Account'),
-      tokenName: renderConfigs.text('Token Name', 'My Awesome Token'),
-      tokenSymbol: renderConfigs.text('Symbol', 'MAT', '3-6 characters recommended'),
-      maxSupply: renderConfigs.number('Max Supply', 1, 9223372036854775807, 'Leave blank for infinite'),
-      decimals: renderConfigs.select(
-        'Decimals',
-        [
-          { value: 0, label: '0 (whole numbers only)' },
-          { value: 2, label: '2 (like USD cents)' },
-          { value: 8, label: '8 (like Bitcoin)' },
-          { value: 18, label: '18 (like Ethereum)' }
-        ],
-        'Number of decimal places for the token'
-      )
-    }
-  });
-
-  return wrappedTool;
-}
-
-/**
- * Example 6: Working with actual hedera-agent-kit tools
- * This example shows how you would wrap real tools from the hedera-agent-kit package
- */
-export function exampleRealHederaAgentKitTools() {
-  // This is how you would import and wrap real tools from hedera-agent-kit:
-  
-  /*
-  import { 
-    HederaCreateAccountTool,
-    HederaTransferTool,
-    HederaCreateTokenTool 
-  } from 'hedera-agent-kit';
-
-  const createAccountTool = new HederaCreateAccountTool();
-  const transferTool = new HederaTransferTool();
-  const createTokenTool = new HederaCreateTokenTool();
-
-  const wrappedTools = wrapExternalTools([
-    {
-      tool: createAccountTool,
-      config: hederaToolConfigs.accountCreation()
-    },
-    {
-      tool: transferTool,
-      config: hederaToolConfigs.hbarTransfer()
-    },
-    {
-      tool: createTokenTool,
-      config: hederaToolConfigs.tokenCreation()
-    }
-  ]);
-
-  return wrappedTools;
-  */
-  
-  console.log('This example shows how to wrap real hedera-agent-kit tools');
-  console.log('Uncomment the code above to use with actual hedera-agent-kit tools');
-  
-  return [];
-}
-
-// Export all examples for easy testing
-export const examples = {
-  basicWrapping: exampleBasicWrapping,
-  presetConfigurations: examplePresetConfigurations,
-  batchWrapping: exampleBatchWrapping,
-  formValidationIntegration: exampleFormValidationIntegration,
-  customFieldConfigs: exampleCustomFieldConfigs,
-  realHederaAgentKitTools: exampleRealHederaAgentKitTools
-};

package/src/langchain/ContentAwareAgentExecutor.ts

@@ -1,19 +0,0 @@
-import { AgentExecutor } from 'langchain/agents';
-import { Logger } from '@hashgraphonline/standards-sdk';
-
-/**
- * Custom AgentExecutor that intercepts large tool outputs and converts them to content references
- * before they are sent to the LLM to avoid token limit issues.
- * 
- * Note: The content reference conversion is already handled in the MCP adapter,
- * so this class currently just extends AgentExecutor without modifications.
- * We keep it as a placeholder for future enhancements.
- */
-export class ContentAwareAgentExecutor extends AgentExecutor {
-  private logger: Logger;
-
-  constructor(config: any) {
-    super(config);
-    this.logger = new Logger({ module: 'ContentAwareAgentExecutor' });
-  }
-}