@hashgraphonline/conversational-agent 0.1.210 → 0.1.213

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/conversational-agent.d.ts

@@ -67,7 +67,7 @@ export declare class ConversationalAgent {
     stateManager: IStateManager;
     private options;
     logger: Logger;
-    protected contentStoreManager?: ContentStoreManager;
+    contentStoreManager?: ContentStoreManager;
     memoryManager?: SmartMemoryManager | undefined;
     private entityTools?;
     constructor(options: ConversationalAgentOptions);
@@ -184,14 +184,6 @@ export declare class ConversationalAgent {
      * Create a ConversationalAgent with MCP servers configured
      */
     static withMCP(options: ConversationalAgentOptions, mcpServers: MCPServerConfig[]): ConversationalAgent;
-    /**
-     * Detect the private key type by querying the account info from mirror node
-     * @param {string} accountId - The Hedera account ID
-     * @param {string} privateKey - The private key string
-     * @param {NetworkType} network - The Hedera Hashgraph
-     * @returns {Promise<PrivateKey>} The appropriate PrivateKey instance
-     */
-    private detectPrivateKeyType;
     /**
      * Resolve entity references using LLM-based resolver
      * @param content - Message content to resolve