@hashgraphonline/conversational-agent 0.1.214 → 0.1.217

package/cli/dist/managers/AgentManager.js

@@ -0,0 +1,119 @@
+import { ConversationalAgent, MCPServers, } from '@hashgraphonline/conversational-agent';
+export class AgentManager {
+    static instance;
+    agent = null;
+    initializing = false;
+    initialized = false;
+    constructor() { }
+    static getInstance() {
+        if (!AgentManager.instance) {
+            AgentManager.instance = new AgentManager();
+        }
+        return AgentManager.instance;
+    }
+    /**
+     * Initialize the conversational agent
+     */
+    async initialize(config, mcpConfig) {
+        if (this.agent && this.initialized) {
+            return {
+                agent: this.agent,
+                welcomeMessages: this.getWelcomeMessages(config, []),
+            };
+        }
+        if (this.initializing) {
+            throw new Error('Agent is already initializing');
+        }
+        this.initializing = true;
+        try {
+            const mcpServers = [];
+            if (mcpConfig.enableFilesystem && mcpConfig.filesystemPath) {
+                mcpServers.push(MCPServers.filesystem(mcpConfig.filesystemPath));
+            }
+            mcpServers.push(...mcpConfig.customServers);
+            const agentConfig = {
+                accountId: config.accountId,
+                privateKey: config.privateKey,
+                network: config.network,
+                openAIApiKey: config.openAIApiKey,
+                openAIModelName: 'gpt-4o-mini',
+                verbose: false,
+                disableLogging: true,
+                ...(mcpServers.length > 0 && { mcpServers }),
+            };
+            const conversationalAgent = new ConversationalAgent(agentConfig);
+            await conversationalAgent.initialize();
+            this.agent = conversationalAgent;
+            this.initialized = true;
+            const welcomeMessages = this.getWelcomeMessages(config, mcpServers);
+            return { agent: conversationalAgent, welcomeMessages };
+        }
+        finally {
+            this.initializing = false;
+        }
+    }
+    /**
+     * Get welcome messages
+     */
+    getWelcomeMessages(config, mcpServers) {
+        const welcomeMessages = [
+            {
+                role: 'system',
+                content: `Connected to Hedera ${config.network}`,
+                timestamp: new Date(),
+            },
+        ];
+        if (mcpServers.length > 0) {
+            welcomeMessages.push({
+                role: 'system',
+                content: `MCP servers enabled: ${mcpServers
+                    .map(s => s.name)
+                    .join(', ')}`,
+                timestamp: new Date(),
+            });
+        }
+        welcomeMessages.push({
+            role: 'assistant',
+            content: mcpServers.length > 0
+                ? "Hello! I'm your Conversational Agent powered by Hashgraph Online, with extended MCP capabilities. I can help you with:\n\n• HCS-10 agent registrations and HCS-11 profiles\n• Sending messages through HCS standards\n• Creating accounts, transferring HBAR, and managing tokens\n• Deploying smart contracts and interacting with them\n• Managing NFTs, token swaps, and staking operations\n• Scheduling transactions and consensus submissions\n• File operations and external tool integration\n\nHow can I assist you today?"
+                : "Hello! I'm your Conversational Agent powered by Hashgraph Online. I can help you with:\n\n• HCS-10 agent registrations and HCS-11 profiles\n• Sending messages through HCS standards\n• Creating accounts, transferring HBAR, and managing tokens\n• Deploying smart contracts and interacting with them\n• Managing NFTs, token swaps, and staking operations\n• Scheduling transactions and consensus submissions\n\nHow can I assist you today?",
+            timestamp: new Date(),
+        });
+        return welcomeMessages;
+    }
+    /**
+     * Send message to agent
+     */
+    async sendMessage(message, chatHistory) {
+        if (!this.agent) {
+            throw new Error('Agent not initialized');
+        }
+        return this.agent.processMessage(message, chatHistory);
+    }
+    /**
+     * Get current agent
+     */
+    getAgent() {
+        return this.agent;
+    }
+    /**
+     * Check if agent is initialized
+     */
+    isInitialized() {
+        return this.initialized;
+    }
+    /**
+     * Check if agent is initializing
+     */
+    isInitializing() {
+        return this.initializing;
+    }
+    /**
+     * Reset agent (for testing)
+     */
+    reset() {
+        this.agent = null;
+        this.initialized = false;
+        this.initializing = false;
+    }
+}

package/cli/dist/managers/ConfigManager.d.ts

@@ -0,0 +1,53 @@
+import { type MCPServerConfig } from '@hashgraphonline/conversational-agent';
+import { type Config } from '../types';
+export declare class ConfigManager {
+    private static instance;
+    private _config;
+    private _mcpServers;
+    private constructor();
+    static getInstance(): ConfigManager;
+    /**
+     * Get MCP config file path
+     */
+    private getMCPConfigPath;
+    /**
+     * Load MCP configuration from file
+     */
+    private loadMCPConfig;
+    /**
+     * Save MCP configuration to file
+     */
+    saveMCPConfig(servers: MCPServerConfig[]): void;
+    /**
+     * Load config from .env file
+     */
+    private loadConfigFromEnv;
+    /**
+     * Save config to .env file
+     */
+    saveConfig(configToSave: Config): void;
+    /**
+     * Get complete config (cached)
+     */
+    getConfig(props?: Partial<Config>): Config & {
+        mcpServers: MCPServerConfig[];
+    };
+    /**
+     * Update config and save
+     */
+    updateConfig(updates: Partial<Config>): Config & {
+        mcpServers: MCPServerConfig[];
+    };
+    /**
+     * Get MCP servers
+     */
+    getMCPServers(): MCPServerConfig[];
+    /**
+     * Get MCP config path for display
+     */
+    getMCPConfigPathForDisplay(): string;
+    /**
+     * Reset cache (for testing)
+     */
+    resetCache(): void;
+}

package/cli/dist/managers/ConfigManager.js

@@ -0,0 +1,173 @@
+import fs from 'fs';
+import path from 'path';
+import { MCPServers } from '@hashgraphonline/conversational-agent';
+export class ConfigManager {
+    static instance;
+    _config = null;
+    _mcpServers = null;
+    constructor() { }
+    static getInstance() {
+        if (!ConfigManager.instance) {
+            ConfigManager.instance = new ConfigManager();
+        }
+        return ConfigManager.instance;
+    }
+    /**
+     * Get MCP config file path
+     */
+    getMCPConfigPath() {
+        const projectRoot = process.env['CONVERSATIONAL_AGENT_ROOT'] || path.resolve('./../../');
+        return path.join(projectRoot, 'mcp-config.json');
+    }
+    /**
+     * Load MCP configuration from file
+     */
+    loadMCPConfig() {
+        if (this._mcpServers)
+            return this._mcpServers;
+        const configPath = this.getMCPConfigPath();
+        try {
+            if (fs.existsSync(configPath)) {
+                const configContent = fs.readFileSync(configPath, 'utf-8');
+                const config = JSON.parse(configContent);
+                this._mcpServers = Object.values(config.mcpServers || {});
+                return this._mcpServers;
+            }
+        }
+        catch (err) {
+            console.error('Failed to load MCP config:', err);
+        }
+        const defaultServers = [MCPServers.filesystem(process.cwd())];
+        this.saveMCPConfig(defaultServers);
+        this._mcpServers = defaultServers;
+        return defaultServers;
+    }
+    /**
+     * Save MCP configuration to file
+     */
+    saveMCPConfig(servers) {
+        const configPath = this.getMCPConfigPath();
+        try {
+            const mcpServers = {};
+            servers.forEach(server => {
+                mcpServers[server.name] = server;
+            });
+            const config = { mcpServers };
+            fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+            this._mcpServers = servers;
+        }
+        catch (err) {
+            console.error('Failed to save MCP config:', err);
+        }
+    }
+    /**
+     * Load config from .env file
+     */
+    loadConfigFromEnv() {
+        const projectRoot = process.env['CONVERSATIONAL_AGENT_ROOT'] || path.resolve('./../../');
+        const envPath = path.join(projectRoot, '.env');
+        try {
+            if (fs.existsSync(envPath)) {
+                const envContent = fs.readFileSync(envPath, 'utf-8');
+                const envVars = {};
+                envContent.split('\n').forEach(line => {
+                    const trimmedLine = line.trim();
+                    if (trimmedLine && !trimmedLine.startsWith('#')) {
+                        const [key, ...valueParts] = trimmedLine.split('=');
+                        if (key && valueParts.length > 0) {
+                            envVars[key] = valueParts.join('=');
+                        }
+                    }
+                });
+                return {
+                    accountId: envVars['HEDERA_ACCOUNT_ID'] || '',
+                    privateKey: envVars['HEDERA_PRIVATE_KEY'] || '',
+                    network: envVars['HEDERA_NETWORK'] || 'testnet',
+                    openAIApiKey: envVars['OPENAI_API_KEY'] || '',
+                };
+            }
+        }
+        catch (err) { }
+        return {
+            accountId: '',
+            privateKey: '',
+            network: 'testnet',
+            openAIApiKey: '',
+        };
+    }
+    /**
+     * Save config to .env file
+     */
+    saveConfig(configToSave) {
+        const projectRoot = process.env['CONVERSATIONAL_AGENT_ROOT'] || path.resolve('./../../');
+        const envPath = path.join(projectRoot, '.env');
+        try {
+            let envContent = '';
+            if (fs.existsSync(envPath)) {
+                envContent = fs.readFileSync(envPath, 'utf-8');
+            }
+            const updateEnvVar = (key, value) => {
+                const regex = new RegExp(`^${key}=.*$`, 'gm');
+                if (regex.test(envContent)) {
+                    envContent = envContent.replace(regex, `${key}=${value}`);
+                }
+                else {
+                    envContent += `${envContent ? '\n' : ''}${key}=${value}`;
+                }
+            };
+            updateEnvVar('HEDERA_ACCOUNT_ID', configToSave.accountId);
+            updateEnvVar('HEDERA_PRIVATE_KEY', configToSave.privateKey);
+            updateEnvVar('HEDERA_NETWORK', configToSave.network);
+            updateEnvVar('OPENAI_API_KEY', configToSave.openAIApiKey);
+            fs.writeFileSync(envPath, envContent);
+            this._config = null;
+        }
+        catch (err) { }
+    }
+    /**
+     * Get complete config (cached)
+     */
+    getConfig(props = {}) {
+        if (!this._config) {
+            const envConfig = this.loadConfigFromEnv();
+            const mcpServers = this.loadMCPConfig();
+            this._config = {
+                accountId: props.accountId || envConfig.accountId,
+                privateKey: props.privateKey || envConfig.privateKey,
+                network: props.network || envConfig.network,
+                openAIApiKey: props.openAIApiKey || envConfig.openAIApiKey,
+                mcpServers,
+            };
+        }
+        return this._config;
+    }
+    /**
+     * Update config and save
+     */
+    updateConfig(updates) {
+        const current = this.getConfig();
+        const updated = { ...current, ...updates };
+        this.saveConfig(updated);
+        this._config = updated;
+        return updated;
+    }
+    /**
+     * Get MCP servers
+     */
+    getMCPServers() {
+        return this.loadMCPConfig();
+    }
+    /**
+     * Get MCP config path for display
+     */
+    getMCPConfigPathForDisplay() {
+        return this.getMCPConfigPath();
+    }
+    /**
+     * Reset cache (for testing)
+     */
+    resetCache() {
+        this._config = null;
+        this._mcpServers = null;
+    }
+}

package/cli/dist/types.d.ts

@@ -0,0 +1,31 @@
+export type Screen = 'welcome' | 'setup' | 'mcp-config' | 'chat' | 'loading';
+export interface Message {
+    role: 'user' | 'assistant' | 'system';
+    content: string;
+    timestamp: Date;
+}
+export interface Config {
+    accountId: string;
+    privateKey: string;
+    network: string;
+    openAIApiKey: string;
+}
+export declare const BRAND_COLORS: {
+    blue: string;
+    green: string;
+    purple: string;
+    dark: string;
+    white: string;
+    hedera: {
+        purple: string;
+        blue: string;
+        green: string;
+        charcoal: string;
+        smoke: string;
+    };
+    keywords: string;
+    functions: string;
+    strings: string;
+    variables: string;
+    comments: string;
+};

package/cli/dist/types.js

@@ -0,0 +1,19 @@
+export const BRAND_COLORS = {
+    blue: '#5599fe',
+    green: '#48df7b',
+    purple: '#b56cff',
+    dark: '#3f4174',
+    white: '#ffffff',
+    hedera: {
+        purple: '#8259ef',
+        blue: '#2d84eb',
+        green: '#3ec878',
+        charcoal: '#464646',
+        smoke: '#8c8c8c',
+    },
+    keywords: '#3f4174',
+    functions: '#5599fe',
+    strings: '#48df7b',
+    variables: '#b56cff',
+    comments: '#6b7280',
+};

package/dist/cjs/base-agent.d.ts

@@ -73,6 +73,8 @@ export interface ChatResponse {
         args: Record<string, unknown>;
         output?: string;
     }>;
+    formMessage?: unknown;
+    requiresForm?: boolean;
     [key: string]: unknown;
 }
 export interface UsageStats extends TokenUsage {

package/dist/cjs/conversational-agent.d.ts

@@ -10,6 +10,7 @@ import { IStateManager } from '@hashgraphonline/standards-agent-kit';
 import { MCPServerConfig, MCPConnectionStatus } from './mcp/types';
 import { ContentStoreManager } from './services/ContentStoreManager';
 import { SmartMemoryManager, SmartMemoryConfig } from './memory';
+import { FormSubmission } from './forms/types';
 
 export type ToolDescriptor = {
     name: string;
@@ -107,6 +108,13 @@ export declare class ConversationalAgent {
      * @throws {Error} If agent is not initialized
      */
     processMessage(message: string, chatHistory?: ChatHistoryItem[]): Promise<ChatResponse>;
+    /**
+     * Process form submission through the conversational agent
+     * @param {FormSubmission} submission - The form submission data
+     * @returns {Promise<ChatResponse>} The agent's response after processing the form
+     * @throws {Error} If agent is not initialized or doesn't support form processing
+     */
+    processFormSubmission(submission: FormSubmission): Promise<ChatResponse>;
     /**
      * Validates initialization options and throws if required fields are missing.
      *

package/dist/cjs/core/ToolRegistry.d.ts

@@ -0,0 +1,130 @@
+import { StructuredTool } from '@langchain/core/tools';
+import { z } from 'zod';
+import { Logger } from '@hashgraphonline/standards-sdk';
+import { FormValidatingToolWrapper } from '../langchain/FormValidatingToolWrapper';
+
+/**
+ * Tool capabilities configuration for registry entries
+ */
+export interface ToolCapabilities {
+    supportsFormValidation: boolean;
+    requiresWrapper: boolean;
+    priority: 'low' | 'medium' | 'high' | 'critical';
+    category: 'core' | 'extension' | 'mcp';
+}
+/**
+ * Tool metadata for comprehensive tool information
+ */
+export interface ToolMetadata {
+    name: string;
+    version: string;
+    category: ToolCapabilities['category'];
+    description: string;
+    capabilities: ToolCapabilities;
+    dependencies: string[];
+    schema: unknown;
+}
+/**
+ * Registry entry containing tool instance and metadata
+ */
+export interface ToolRegistryEntry {
+    tool: StructuredTool;
+    metadata: ToolMetadata;
+    wrapper?: FormValidatingToolWrapper<z.ZodObject<z.ZodRawShape>> | undefined;
+    originalTool: StructuredTool;
+}
+/**
+ * Options for tool registration
+ */
+export interface ToolRegistrationOptions {
+    forceWrapper?: boolean;
+    skipWrapper?: boolean;
+    wrapperConfig?: {
+        requireAllFields?: boolean;
+        skipFields?: string[];
+    };
+    metadata?: Partial<ToolMetadata>;
+}
+/**
+ * Query interface for finding tools
+ */
+export interface ToolQuery {
+    name?: string;
+    category?: ToolMetadata['category'];
+    capabilities?: Partial<ToolCapabilities>;
+}
+/**
+ * Centralized tool registry for managing tool lifecycle
+ */
+export declare class ToolRegistry {
+    private tools;
+    private formGenerator;
+    private logger;
+    constructor(logger?: Logger);
+    /**
+     * Register a tool with the registry
+     */
+    registerTool(tool: StructuredTool, options?: ToolRegistrationOptions): void;
+    /**
+     * Get a tool by name
+     */
+    getTool(name: string): ToolRegistryEntry | null;
+    /**
+     * Get tools by capability
+     */
+    getToolsByCapability(capability: keyof ToolCapabilities, value?: unknown): ToolRegistryEntry[];
+    /**
+     * Get tools by query
+     */
+    getToolsByQuery(query: ToolQuery): ToolRegistryEntry[];
+    /**
+     * Get all registered tools
+     */
+    getAllTools(): StructuredTool[];
+    /**
+     * Get all registry entries
+     */
+    getAllRegistryEntries(): ToolRegistryEntry[];
+    /**
+     * Get all tool names
+     */
+    getToolNames(): string[];
+    /**
+     * Check if a tool is registered
+     */
+    hasTool(name: string): boolean;
+    /**
+     * Unregister a tool
+     */
+    unregisterTool(name: string): boolean;
+    /**
+     * Clear all tools
+     */
+    clear(): void;
+    /**
+     * Analyze tool capabilities
+     */
+    private analyzeToolCapabilities;
+    /**
+     * Check if tool has render configuration
+     */
+    private hasRenderConfig;
+    /**
+     * Determine if tool should be wrapped
+     */
+    private shouldWrapTool;
+    /**
+     * Check if schema is ZodObject-like
+     */
+    private isZodObjectLike;
+    /**
+     * Get statistics about the registry
+     */
+    getStatistics(): {
+        totalTools: number;
+        wrappedTools: number;
+        unwrappedTools: number;
+        categoryCounts: Record<ToolCapabilities['category'], number>;
+        priorityCounts: Record<ToolCapabilities['priority'], number>;
+    };
+}

package/dist/cjs/execution/ExecutionPipeline.d.ts

@@ -0,0 +1,81 @@
+import { Logger } from '@hashgraphonline/standards-sdk';
+import { SmartMemoryManager } from '../memory/SmartMemoryManager';
+import { FormEngine, ToolExecutionResult } from '../forms/FormEngine';
+import { ToolRegistry, ToolRegistryEntry } from '../core/ToolRegistry';
+
+/**
+ * Session context for tool execution
+ */
+export interface SessionContext {
+    sessionId: string;
+    userId?: string;
+    timestamp: number;
+    conversationId?: string;
+}
+/**
+ * Context passed through execution pipeline
+ */
+export interface ExecutionContext {
+    toolName: string;
+    input: unknown;
+    session: SessionContext;
+    memory: SmartMemoryManager;
+    traceId: string;
+    toolEntry: ToolRegistryEntry;
+}
+/**
+ * Result of tool execution with metadata
+ */
+export interface ExecutionResult extends ToolExecutionResult {
+    traceId: string;
+    executionTime: number;
+}
+/**
+ * ExecutionPipeline handles tool execution coordination
+ */
+export declare class ExecutionPipeline {
+    private logger;
+    private toolRegistry;
+    private formEngine;
+    private memory;
+    constructor(toolRegistry: ToolRegistry, formEngine: FormEngine, memory: SmartMemoryManager, logger?: Logger);
+    /**
+     * Execute a tool through the pipeline
+     */
+    execute(toolName: string, input: unknown, sessionContext?: SessionContext): Promise<ExecutionResult>;
+    /**
+     * Execute tool with validation
+     */
+    executeWithValidation(toolName: string, input: unknown, sessionContext?: SessionContext): Promise<ExecutionResult>;
+    /**
+     * Process form submission
+     */
+    processFormSubmission(toolName: string, formId: string, parameters: Record<string, unknown>, sessionContext?: SessionContext): Promise<ExecutionResult>;
+    /**
+     * Check if form generation is required
+     */
+    private checkFormGeneration;
+    /**
+     * Execute tool directly
+     */
+    private executeToolDirect;
+    /**
+     * Execute wrapped tool
+     */
+    private executeWrappedTool;
+    /**
+     * Handle execution error
+     */
+    private handleExecutionError;
+    /**
+     * Build default session context
+     */
+    private buildDefaultSession;
+    /**
+     * Get statistics about the pipeline
+     */
+    getStatistics(): {
+        totalMiddleware: number;
+        registeredMiddleware: string[];
+    };
+}