@hashgraphonline/conversational-agent 0.1.219 → 0.1.220

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hashgraphonline/conversational-agent",
-  "version": "0.1.219",
+  "version": "0.1.220",
   "type": "module",
   "main": "./dist/cjs/index.cjs",
   "module": "./dist/esm/index.js",
@@ -95,7 +95,7 @@
   },
   "dependencies": {
     "@hashgraph/sdk": "^2.69.0",
-    "@hashgraphonline/standards-agent-kit": "file:.yalc/@hashgraphonline/standards-agent-kit",
+    "@hashgraphonline/standards-agent-kit": "0.2.135",
     "@hashgraphonline/standards-sdk": "0.0.187",
     "@langchain/anthropic": "^0.3.26",
     "@langchain/core": "^0.3.71",

package/src/base-agent.ts

@@ -12,6 +12,7 @@ import type { CostCalculation } from 'hedera-agent-kit';
 import type { AIProvider, VercelAIProvider, BAMLProvider } from './providers';
 import { Logger } from '@hashgraphonline/standards-sdk';
 import type { MCPServerConfig, MCPConnectionStatus } from './mcp/types';
+import type { FormSubmission } from './forms/types';
 
 export interface ToolFilterConfig {
   namespaceWhitelist?: string[];
@@ -112,6 +113,9 @@ export abstract class BaseAgent {
     message: string,
     context?: ConversationContext
   ): Promise<ChatResponse>;
+  abstract processFormSubmission(
+    submission: FormSubmission
+  ): Promise<ChatResponse>;
   abstract shutdown(): Promise<void>;
   abstract switchMode(mode: OperationalMode): void;
   abstract getUsageStats(): UsageStats;

package/src/conversational-agent.ts

@@ -89,7 +89,8 @@ export interface ConversationalAgentOptions {
  * @returns A new instance of the ConversationalAgent class.
  */
 export class ConversationalAgent {
-  private static readonly NOT_INITIALIZED_ERROR = 'Agent not initialized. Call initialize() first.';
+  private static readonly NOT_INITIALIZED_ERROR =
+    'Agent not initialized. Call initialize() first.';
   protected agent?: AgentInstance;
   public hcs10Plugin: HCS10Plugin;
   public hcs2Plugin: HCS2Plugin;
@@ -333,18 +334,6 @@ export class ConversationalAgent {
       throw new Error(ConversationalAgent.NOT_INITIALIZED_ERROR);
     }
 
-    const internalAgent = this.agent as {
-      processFormSubmission?: (
-        submission: FormSubmission
-      ) => Promise<ChatResponse>;
-    };
-    if (
-      !internalAgent.processFormSubmission ||
-      typeof internalAgent.processFormSubmission !== 'function'
-    ) {
-      throw new Error('processFormSubmission not available on internal agent');
-    }
-
     try {
       this.logger.info('Processing form submission:', {
         formId: submission.formId,
@@ -352,7 +341,7 @@ export class ConversationalAgent {
         parameterKeys: Object.keys(submission.parameters || {}),
         hasContext: !!submission.context,
       });
-      const response = await internalAgent.processFormSubmission(submission);
+      const response = await this.agent.processFormSubmission(submission);
       this.logger.info('Form submission processed successfully');
       return response;
     } catch (error) {

package/src/langchain/form-aware-agent-executor.ts

@@ -29,15 +29,54 @@ interface HashLinkResponse {
   message: string;
 }
 
+interface ToolWithOriginal {
+  originalTool?: {
+    call?: (args: Record<string, unknown>) => Promise<string>;
+  };
+}
+
+interface ActionWithToolInput {
+  toolInput?: Record<string, unknown>;
+}
+
+interface ZodSchemaDefinition {
+  _def?: {
+    typeName?: string;
+    shape?: (() => Record<string, z.ZodTypeAny>) | Record<string, z.ZodTypeAny>;
+    innerType?: z.ZodTypeAny;
+    defaultValue?: unknown;
+  };
+}
+
+interface ToolWrapper {
+  executeOriginal?: (args: Record<string, unknown>) => Promise<string>;
+  getOriginalTool?: () => {
+    _call?: (args: Record<string, unknown>) => Promise<string>;
+    call?: (args: Record<string, unknown>) => Promise<string>;
+  };
+  originalTool?: {
+    _call?: (args: Record<string, unknown>) => Promise<string>;
+    call?: (args: Record<string, unknown>) => Promise<string>;
+  };
+  call?: (args: Record<string, unknown>) => Promise<string>;
+}
+
+interface CallableTool {
+  _call?: (args: Record<string, unknown>) => Promise<string>;
+  call?: (args: Record<string, unknown>) => Promise<string>;
+}
+
+interface ToolWithSchema {
+  schema?: Record<string, unknown>;
+}
+
 interface PendingFormData {
   toolName: string;
   originalInput: unknown;
   originalToolInput?: unknown;
   schema: unknown;
   toolRef?: ToolInterface | undefined;
-  originalToolRef?:
-    | { call?: (args: Record<string, unknown>) => Promise<string> }
-    | undefined;
+  originalToolRef?: ToolWithOriginal['originalTool'];
 }
 
 interface ToolResponse {
@@ -368,13 +407,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
           originalToolInput: toolInput,
           schema: schemaToUse,
           toolRef: tool as ToolInterface | undefined,
-          originalToolRef: (
-            tool as unknown as {
-              originalTool?: {
-                call?: (args: Record<string, unknown>) => Promise<string>;
-              };
-            }
-          ).originalTool,
+          originalToolRef: (tool as ToolWithOriginal).originalTool,
         };
         this.pendingForms.set(formMessage.id, formData);
         globalPendingForms.set(formMessage.id, formData);
@@ -416,7 +449,8 @@ export class FormAwareAgentExecutor extends AgentExecutor {
           typeof preprocessedInput === 'object' &&
           '__requestForm' in (preprocessedInput as Record<string, unknown>)
         ) {
-          const rf = (preprocessedInput as Record<string, unknown>).__requestForm as {
+          const rf = (preprocessedInput as Record<string, unknown>)
+            .__requestForm as {
             id?: string;
             title?: string;
             description?: string;
@@ -430,7 +464,9 @@ export class FormAwareAgentExecutor extends AgentExecutor {
             submitLabel?: string;
           };
 
-          const formId = rf.id || `form_${Date.now()}_${Math.random().toString(36).slice(2)}`;
+          const formId =
+            rf.id ||
+            `form_${Date.now()}_${Math.random().toString(36).slice(2)}`;
           const formMessage = {
             type: 'form',
             id: formId,
@@ -484,9 +520,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
             originalToolInput: toolInput,
             schema: resolvedSchema,
             toolRef: tool as ToolInterface | undefined,
-            originalToolRef: (
-              tool as unknown as { originalTool?: { call?: (a: Record<string, unknown>) => Promise<string> } }
-            ).originalTool,
+            originalToolRef: (tool as ToolWithOriginal).originalTool,
           });
           globalPendingForms.set(formId, {
             toolName,
@@ -511,8 +545,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
           });
 
           try {
-            (action as unknown as { toolInput?: Record<string, unknown> }).toolInput =
-              preprocessedInput as Record<string, unknown>;
+            (action as ActionWithToolInput).toolInput = preprocessedInput;
           } catch {}
         } else {
           this.formLogger.debug(`No parameter changes needed for ${toolName}`);
@@ -543,15 +576,13 @@ export class FormAwareAgentExecutor extends AgentExecutor {
     }
 
     try {
-      const obj = schema as { _def?: { typeName?: string; shape?: unknown } };
+      const obj = schema as ZodSchemaDefinition;
       const def = obj._def;
       if (!def || def.typeName !== 'ZodObject') {
         return false;
       }
       const rawShape: unknown =
-        typeof (def as { shape?: unknown }).shape === 'function'
-          ? (def as { shape: () => Record<string, z.ZodTypeAny> }).shape()
-          : (def as { shape?: Record<string, z.ZodTypeAny> }).shape;
+        typeof def.shape === 'function' ? def.shape() : def.shape;
       if (!rawShape || typeof rawShape !== 'object') {
         return false;
       }
@@ -561,22 +592,14 @@ export class FormAwareAgentExecutor extends AgentExecutor {
         return false;
       }
       const unwrapOptional = (s: z.ZodTypeAny): z.ZodTypeAny => {
-        const inner = (
-          s as unknown as {
-            _def?: { typeName?: string; innerType?: z.ZodTypeAny };
-          }
-        )._def;
+        const inner = (s as ZodSchemaDefinition)._def;
         if (inner && inner.typeName === 'ZodOptional' && inner.innerType) {
           return inner.innerType;
         }
         return s;
       };
       const unwrapped = unwrapOptional(fieldSchema);
-      const fdef = (
-        unwrapped as unknown as {
-          _def?: { typeName?: string; defaultValue?: unknown };
-        }
-      )._def;
+      const fdef = (unwrapped as ZodSchemaDefinition)._def;
       if (!fdef) {
         return true;
       }
@@ -626,11 +649,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
                   (t) => t.name === actionToolName
                 ) as ToolInterface | undefined;
                 const originalToolCandidate =
-                  (toolInstance as unknown as {
-                    originalTool?: {
-                      call?: (args: Record<string, unknown>) => Promise<string>;
-                    };
-                  }) || {};
+                  (toolInstance as ToolWithOriginal) || {};
                 const pf: PendingFormData = {
                   toolName: actionToolName,
                   originalInput: inputs,
@@ -901,35 +920,19 @@ export class FormAwareAgentExecutor extends AgentExecutor {
     }
 
     try {
-      const maybeWrapper = tool as unknown as {
-        executeOriginal?: (args: Record<string, unknown>) => Promise<string>;
-        getOriginalTool?: () => {
-          _call?: (args: Record<string, unknown>) => Promise<string>;
-          call?: (args: Record<string, unknown>) => Promise<string>;
-        };
-        originalTool?: {
-          _call?: (args: Record<string, unknown>) => Promise<string>;
-          call?: (args: Record<string, unknown>) => Promise<string>;
-        };
-        call?: (args: Record<string, unknown>) => Promise<string>;
-      };
+      const maybeWrapper = tool as ToolWrapper;
       let toolOutput: string;
       if (typeof maybeWrapper.executeOriginal === 'function') {
         toolOutput = await maybeWrapper.executeOriginal(mergedToolInput);
       } else if (typeof maybeWrapper.getOriginalTool === 'function') {
         const ot = maybeWrapper.getOriginalTool();
-        const otCall = ot as unknown as {
-          _call?: (a: Record<string, unknown>) => Promise<string>;
-          call?: (a: Record<string, unknown>) => Promise<string>;
-        };
+        const otCall = ot as CallableTool;
         if (ot && typeof otCall._call === 'function') {
           toolOutput = await otCall._call(mergedToolInput);
         } else if (ot && typeof otCall.call === 'function') {
           toolOutput = await otCall.call(mergedToolInput);
         } else {
-          const tcall = tool as unknown as {
-            call?: (a: Record<string, unknown>) => Promise<string>;
-          };
+          const tcall = tool as CallableTool;
           if (typeof tcall.call === 'function') {
             toolOutput = await tcall.call(mergedToolInput);
           } else {
@@ -948,18 +951,8 @@ export class FormAwareAgentExecutor extends AgentExecutor {
         typeof maybeWrapper.originalTool.call === 'function'
       ) {
         toolOutput = await maybeWrapper.originalTool.call(mergedToolInput);
-      } else if (
-        typeof (
-          tool as unknown as {
-            call?: (a: Record<string, unknown>) => Promise<string>;
-          }
-        ).call === 'function'
-      ) {
-        toolOutput = await (
-          tool as unknown as {
-            call: (a: Record<string, unknown>) => Promise<string>;
-          }
-        ).call(mergedToolInput);
+      } else if (typeof (tool as CallableTool).call === 'function') {
+        toolOutput = await (tool as CallableTool).call!(mergedToolInput);
       } else {
         throw new Error(
           'No callable tool implementation found for form submission'
@@ -969,16 +962,6 @@ export class FormAwareAgentExecutor extends AgentExecutor {
       let responseMetadata: Record<string, unknown> = {};
       let formattedOutput: string;
 
-      this.formLogger.info('🔍 METADATA EXTRACTION: Analyzing tool output', {
-        outputType: typeof toolOutput,
-        outputLength: toolOutput?.length || 0,
-        isString: typeof toolOutput === 'string',
-        firstChars:
-          typeof toolOutput === 'string'
-            ? toolOutput.substring(0, 100)
-            : 'not-string',
-      });
-
       try {
         const parsed = JSON.parse(toolOutput);
         this.formLogger.info(
@@ -1077,7 +1060,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
             );
             return {
               toolName: lastStep.action.tool,
-              schema: (tool as unknown as Record<string, unknown>).schema,
+              schema: (tool as ToolWithSchema).schema,
             };
           }
         }
@@ -1102,7 +1085,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
             this.formLogger.info('Found tool from input steps:', action.tool);
             return {
               toolName: action.tool,
-              schema: (tool as unknown as Record<string, unknown>).schema,
+              schema: (tool as ToolWithSchema).schema,
             };
           }
         }
@@ -1144,7 +1127,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
         if ('schema' in tool) {
           return {
             toolName: tool.name,
-            schema: (tool as unknown as Record<string, unknown>).schema,
+            schema: (tool as ToolWithSchema).schema,
           };
         }
       }
@@ -1163,7 +1146,7 @@ export class FormAwareAgentExecutor extends AgentExecutor {
 
     for (const tool of this.tools) {
       if ('schema' in tool) {
-        const toolSchema = (tool as unknown as Record<string, unknown>).schema;
+        const toolSchema = (tool as ToolWithSchema).schema;
         if (this.schemaMatchesErrorPaths(toolSchema, errorPaths)) {
           this.formLogger.info(
             'Detected tool from error path analysis:',

package/src/langchain/langchain-agent.ts

@@ -54,6 +54,21 @@ interface ToolExecutionData {
   type: string;
   formId?: string;
   parameters?: Record<string, unknown>;
+  toolName?: string;
+}
+
+interface ToolWithOriginal {
+  originalTool?: {
+    call?: (args: Record<string, unknown>) => Promise<string>;
+  };
+}
+
+interface ExecutorWithRestore {
+  restorePendingForms?: (p: Map<string, unknown>) => void;
+}
+
+interface ResultWithToolName {
+  toolName?: string;
 }
 
 interface IntermediateStep {
@@ -289,11 +304,7 @@ export class LangChainAgent extends BaseAgent {
     const mergedArgs = { ...processedParameters, renderForm: false };
 
     if (entry.wrapper) {
-      const maybeWrapper = entry.tool as unknown as {
-        originalTool?: {
-          call?: (a: Record<string, unknown>) => Promise<string>;
-        };
-      };
+      const maybeWrapper = entry.tool as ToolWithOriginal;
       if (maybeWrapper.originalTool?.call) {
         return await maybeWrapper.originalTool.call(mergedArgs);
       }
@@ -342,8 +353,7 @@ export class LangChainAgent extends BaseAgent {
         string,
         unknown
       >;
-      const toolName = (toolExecutionData as unknown as { toolName?: string })
-        .toolName;
+      const toolName = toolExecutionData.toolName;
 
       if (toolName) {
         const toolOutput = await this.executeToolDirect(toolName, params);
@@ -359,8 +369,7 @@ export class LangChainAgent extends BaseAgent {
 
     const formSubmission: FormSubmission = {
       formId: toolExecutionData.formId,
-      toolName:
-        (toolExecutionData as unknown as { toolName?: string }).toolName || '',
+      toolName: toolExecutionData.toolName || '',
       parameters: toolExecutionData.parameters || {},
       timestamp: Date.now(),
     };
@@ -511,7 +520,7 @@ export class LangChainAgent extends BaseAgent {
         parsed =
           typeof toolOutput === 'string'
             ? (JSON.parse(toolOutput) as Record<string, unknown>)
-            : (toolOutput as unknown as Record<string, unknown>);
+            : (toolOutput as Record<string, unknown>);
       } catch {}
 
       if (parsed && parsed['requiresForm'] && parsed['formMessage']) {
@@ -538,16 +547,10 @@ export class LangChainAgent extends BaseAgent {
           schema: null,
         });
 
-        const maybeRestore = this.executor as unknown as {
-          restorePendingForms?: (p: Map<string, unknown>) => void;
-        };
+        const maybeRestore = this.executor as ExecutorWithRestore;
 
         if (typeof maybeRestore.restorePendingForms === 'function') {
-          (
-            maybeRestore.restorePendingForms as unknown as (
-              p: Map<string, unknown>
-            ) => void
-          )(pending as unknown as Map<string, unknown>);
+          maybeRestore.restorePendingForms!(pending);
         }
 
         const outputMsg =
@@ -559,7 +562,7 @@ export class LangChainAgent extends BaseAgent {
           message: outputMsg,
           notes: [],
           requiresForm: true,
-          formMessage: formMessage as unknown as ChatResponse['formMessage'],
+          formMessage: formMessage as ChatResponse['formMessage'],
         } as ChatResponse;
       }
     } catch {}
@@ -1079,39 +1082,11 @@ export class LangChainAgent extends BaseAgent {
     submission: FormSubmission,
     context?: ConversationContext
   ): Promise<ChatResponse> {
-    this.logger.info('🔥 LangChainAgent.processFormSubmission START');
-
     if (!this.initialized || !this.executor || !this.smartMemory) {
-      this.logger.error(
-        '🔥 LangChainAgent.processFormSubmission - Agent not initialized'
-      );
       throw new Error('Agent not initialized. Call boot() first.');
     }
 
-    this.logger.info(
-      '🔥 LangChainAgent.processFormSubmission - After initialization check'
-    );
-
     try {
-      this.logger.info(
-        '🔥 LangChainAgent.processFormSubmission - About to log submission info'
-      );
-
-      this.logger.info('Processing form submission:', {
-        formId: submission.formId,
-        toolName: submission.toolName,
-        parameterKeys: Object.keys(submission.parameters || {}),
-        hasParameters: !!submission.parameters,
-        parametersType: typeof submission.parameters,
-        parametersIsNull: submission.parameters === null,
-        parametersIsUndefined: submission.parameters === undefined,
-        hasContext: !!submission.context,
-      });
-
-      this.logger.info(
-        '🔥 LangChainAgent.processFormSubmission - After submission info logged'
-      );
-
       if (!submission.parameters || typeof submission.parameters !== 'object') {
         this.logger.error('Invalid form submission parameters:', {
           parameters: submission.parameters,
@@ -1123,70 +1098,17 @@ export class LangChainAgent extends BaseAgent {
         );
       }
 
-      this.logger.info(
-        '🔥 LangChainAgent.processFormSubmission - Parameters validated'
-      );
-
       this.loadContextMessages(context);
 
-      this.logger.info(
-        '🔥 LangChainAgent.processFormSubmission - Context loaded'
-      );
-
-      try {
-        const currentMessages = this.smartMemory.getMessages();
-        this.logger.info('Current messages in memory (form path):', {
-          count: currentMessages.length,
-          messages: currentMessages.map((m) => m.content),
-        });
-      } catch {}
-
       const safeSubmission = {
         ...submission,
         parameters: submission.parameters || {},
       };
 
-      this.logger.info(
-        '🔥 LangChainAgent.processFormSubmission - Safe submission created'
-      );
-
-      this.logger.info('About to call executor.processFormSubmission with:', {
-        formId: safeSubmission.formId,
-        toolName: safeSubmission.toolName,
-        parameterKeys: Object.keys(safeSubmission.parameters),
-        parameterCount: Object.keys(safeSubmission.parameters).length,
-      });
-
       const result = await this.executor.processFormSubmission(safeSubmission);
 
-      this.logger.info('🔍 DEBUG: Raw result from FormAwareAgentExecutor:', {
-        hasResult: !!result,
-        resultKeys: result ? Object.keys(result) : [],
-        hasMetadata: !!result?.metadata,
-        metadataKeys: result?.metadata ? Object.keys(result.metadata) : [],
-        hasHashLinkBlock: hasHashLinkBlock(result?.metadata),
-        hashLinkBlockContent: hasHashLinkBlock(result?.metadata)
-          ? result.metadata.hashLinkBlock
-          : undefined,
-      });
-
-      if (result?.metadata) {
-        this.logger.info(
-          '🔍 DEBUG: Full metadata from executor:',
-          JSON.stringify(result.metadata)
-        );
-      }
-
       const preservedMetadata = result?.metadata ? { ...result.metadata } : {};
 
-      this.logger.info('Executor processFormSubmission result:', {
-        hasResult: !!result,
-        hasOutput: !!result.output,
-        hasError: !!result.error,
-        hasMetadata: !!result.metadata,
-        outputType: typeof result.output,
-      });
-
       try {
         const maybeRaw = (
           result as unknown as {
@@ -1194,8 +1116,7 @@ export class LangChainAgent extends BaseAgent {
             toolName?: string;
           }
         ).rawToolOutput;
-        const toolName =
-          (result as unknown as { toolName?: string }).toolName || 'unknown';
+        const toolName = (result as ResultWithToolName).toolName || 'unknown';
         if (typeof maybeRaw === 'string' && maybeRaw.trim().length > 0) {
           const payload = this.isJSON(maybeRaw)
             ? maybeRaw
@@ -1235,7 +1156,6 @@ export class LangChainAgent extends BaseAgent {
             ? response.metadata.hashLinkBlock
             : undefined,
         });
-
       }
 
       if (result.requiresForm && result.formMessage) {
@@ -1422,7 +1342,7 @@ export class LangChainAgent extends BaseAgent {
       new MessagesPlaceholder('agent_scratchpad'),
     ]);
 
-    const langchainTools = this.tools as unknown as StructuredTool[];
+    const langchainTools = this.tools as StructuredTool[];
 
     const inscriptionTool = this.getInscriptionTool();
     if (inscriptionTool) {

package/src/services/formatters/format-converter-registry.ts

@@ -124,11 +124,6 @@ export class FormatConverterRegistry {
     const networkType = (context.networkType as NetworkType) || 'testnet';
     const mirrorNode = new HederaMirrorNode(networkType, this.logger);
 
-    mirrorNode.configureRetry({
-      maxRetries: 3,
-      maxDelayMs: 1000,
-    });
-
     const checks = await Promise.allSettled([
       mirrorNode
         .getAccountBalance(entity)