@hashgraphonline/conversational-agent 0.1.210 → 0.1.213

package/cli/dist/context/AppContext.d.ts

@@ -0,0 +1,68 @@
+import React from 'react';
+import { ConversationalAgent, type MCPServerConfig } from '@hashgraphonline/conversational-agent';
+import { type Screen, type Message, type Config } from '../types.js';
+interface AppState {
+    screen: Screen;
+    agent: ConversationalAgent | null;
+    messages: Message[];
+    input: string;
+    isLoading: boolean;
+    error: string | null;
+    config: Config & {
+        mcpServers: MCPServerConfig[];
+    };
+    mcpConfig: {
+        enableFilesystem: boolean;
+        filesystemPath: string;
+        customServers: MCPServerConfig[];
+        addingCustom: boolean;
+        newServerName: string;
+        newServerCommand: string;
+        newServerArgs: string;
+        newServerEnv: string;
+        currentField: number;
+    };
+    editingFilesystemPath: boolean;
+    currentField: number;
+    logs: string[];
+}
+interface AppContextType {
+    state: AppState;
+    actions: {
+        setScreen: (screen: Screen) => void;
+        setAgent: (agent: ConversationalAgent | null) => void;
+        setMessages: (messages: Message[]) => void;
+        addMessages: (messages: Message[]) => void;
+        setInput: (input: string) => void;
+        setLoading: (loading: boolean) => void;
+        setError: (error: string | null) => void;
+        setConfig: (config: Config & {
+            mcpServers: MCPServerConfig[];
+        }) => void;
+        updateConfigField: (field: keyof Config, value: string) => void;
+        setMcpConfig: (config: Partial<AppState['mcpConfig']>) => void;
+        setEditingFilesystemPath: (editing: boolean) => void;
+        setCurrentField: (field: number) => void;
+        setLogs: (logs: string[]) => void;
+        initializeAgent: () => Promise<void>;
+        sendMessage: (message: string) => Promise<void>;
+    };
+}
+/**
+ * Get MCP config file path
+ */
+declare const getMCPConfigPath: () => string;
+/**
+ * Save MCP configuration to file
+ */
+declare const saveMCPConfig: (servers: MCPServerConfig[]) => void;
+interface AppProviderProps {
+    children: React.ReactNode;
+    accountId?: string;
+    privateKey?: string;
+    network?: 'testnet' | 'mainnet';
+    openAIApiKey?: string;
+}
+export declare const AppProvider: React.FC<AppProviderProps>;
+export declare const useAppContext: () => AppContextType;
+export { saveMCPConfig, getMCPConfigPath };

package/cli/dist/context/AppContext.js

@@ -0,0 +1,363 @@
+import React, { createContext, useContext, useReducer, useCallback, useRef, useEffect } from 'react';
+import { ConversationalAgent, MCPServers } from '@hashgraphonline/conversational-agent';
+import fs from 'fs';
+import path from 'path';
+const AppContext = createContext(null);
+/**
+ * Get MCP config file path
+ */
+const getMCPConfigPath = () => {
+    const projectRoot = process.env['CONVERSATIONAL_AGENT_ROOT'] || path.resolve('./../../');
+    return path.join(projectRoot, 'mcp-config.json');
+};
+/**
+ * Load MCP configuration from file
+ */
+const loadMCPConfig = () => {
+    const configPath = getMCPConfigPath();
+    try {
+        if (fs.existsSync(configPath)) {
+            const configContent = fs.readFileSync(configPath, 'utf-8');
+            const config = JSON.parse(configContent);
+            return Object.values(config.mcpServers || {});
+        }
+    }
+    catch (err) {
+        console.error('Failed to load MCP config:', err);
+    }
+    const defaultServers = [MCPServers.filesystem(process.cwd())];
+    saveMCPConfig(defaultServers);
+    return defaultServers;
+};
+/**
+ * Save MCP configuration to file
+ */
+const saveMCPConfig = (servers) => {
+    const configPath = getMCPConfigPath();
+    try {
+        const mcpServers = {};
+        servers.forEach(server => {
+            mcpServers[server.name] = server;
+        });
+        const config = { mcpServers };
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+    }
+    catch (err) {
+        console.error('Failed to save MCP config:', err);
+    }
+};
+/**
+ * Load config from .env file
+ */
+const 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'] || '',
+                mcpServers: envVars['MCP_SERVERS'] ? JSON.parse(envVars['MCP_SERVERS']) : [],
+            };
+        }
+    }
+    catch (err) { }
+    return {
+        accountId: '',
+        privateKey: '',
+        network: 'testnet',
+        openAIApiKey: '',
+        mcpServers: [],
+    };
+};
+/**
+ * Save config to .env file
+ */
+const 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);
+        updateEnvVar('MCP_SERVERS', JSON.stringify(configToSave.mcpServers || []));
+        fs.writeFileSync(envPath, envContent);
+    }
+    catch (err) { }
+};
+const appReducer = (state, action) => {
+    switch (action.type) {
+        case 'SET_SCREEN':
+            return { ...state, screen: action.payload };
+        case 'SET_AGENT':
+            return { ...state, agent: action.payload };
+        case 'SET_MESSAGES':
+            return { ...state, messages: action.payload };
+        case 'ADD_MESSAGES':
+            return { ...state, messages: [...state.messages, ...action.payload] };
+        case 'SET_INPUT':
+            return { ...state, input: action.payload };
+        case 'SET_LOADING':
+            return { ...state, isLoading: action.payload };
+        case 'SET_ERROR':
+            return { ...state, error: action.payload };
+        case 'SET_CONFIG':
+            return { ...state, config: action.payload };
+        case 'UPDATE_CONFIG_FIELD':
+            return {
+                ...state,
+                config: { ...state.config, [action.payload.field]: action.payload.value }
+            };
+        case 'SET_MCP_CONFIG':
+            return { ...state, mcpConfig: { ...state.mcpConfig, ...action.payload } };
+        case 'SET_EDITING_FILESYSTEM_PATH':
+            return { ...state, editingFilesystemPath: action.payload };
+        case 'SET_CURRENT_FIELD':
+            return { ...state, currentField: action.payload };
+        case 'SET_LOGS':
+            return { ...state, logs: action.payload };
+        default:
+            return state;
+    }
+};
+export const AppProvider = ({ children, accountId, privateKey, network = 'testnet', openAIApiKey, }) => {
+    const agentRef = useRef(null);
+    const initializingRef = useRef(false);
+    const autoInitialized = useRef(false);
+    const getInitialState = () => {
+        const envConfig = loadConfigFromEnv();
+        const loadedServers = loadMCPConfig();
+        const filesystemServer = loadedServers.find(s => s.name === 'filesystem');
+        const customServers = loadedServers.filter(s => s.name !== 'filesystem');
+        return {
+            screen: 'welcome',
+            agent: null,
+            messages: [],
+            input: '',
+            isLoading: false,
+            error: null,
+            config: {
+                accountId: accountId || envConfig.accountId,
+                privateKey: privateKey || envConfig.privateKey,
+                network: network || envConfig.network,
+                openAIApiKey: openAIApiKey || envConfig.openAIApiKey,
+                mcpServers: envConfig.mcpServers || [],
+            },
+            mcpConfig: {
+                enableFilesystem: !!filesystemServer,
+                filesystemPath: filesystemServer ? filesystemServer.args[2] || process.cwd() : process.cwd(),
+                customServers,
+                addingCustom: false,
+                newServerName: '',
+                newServerCommand: '',
+                newServerArgs: '',
+                newServerEnv: '',
+                currentField: 0,
+            },
+            editingFilesystemPath: false,
+            currentField: 0,
+            logs: [],
+        };
+    };
+    const [state, dispatch] = useReducer(appReducer, getInitialState());
+    const initializeAgent = useCallback(async () => {
+        if (agentRef.current) {
+            dispatch({ type: 'SET_AGENT', payload: agentRef.current });
+            dispatch({ type: 'SET_SCREEN', payload: 'chat' });
+            return;
+        }
+        if (initializingRef.current) {
+            return;
+        }
+        initializingRef.current = true;
+        dispatch({ type: 'SET_LOADING', payload: true });
+        dispatch({ type: 'SET_ERROR', payload: null });
+        try {
+            saveConfig(state.config);
+            const mcpServers = [];
+            if (state.mcpConfig.enableFilesystem && state.mcpConfig.filesystemPath) {
+                mcpServers.push(MCPServers.filesystem(state.mcpConfig.filesystemPath));
+            }
+            mcpServers.push(...state.mcpConfig.customServers);
+            const agentConfig = {
+                accountId: state.config.accountId,
+                privateKey: state.config.privateKey,
+                network: state.config.network,
+                openAIApiKey: state.config.openAIApiKey,
+                openAIModelName: 'gpt-4o-mini',
+                verbose: false,
+                disableLogging: true,
+                ...(mcpServers.length > 0 && { mcpServers }),
+            };
+            const conversationalAgent = new ConversationalAgent(agentConfig);
+            await conversationalAgent.initialize();
+            agentRef.current = conversationalAgent;
+            dispatch({ type: 'SET_AGENT', payload: conversationalAgent });
+            dispatch({ type: 'SET_SCREEN', payload: 'chat' });
+            const welcomeMessages = [
+                {
+                    role: 'system',
+                    content: `Connected to Hedera ${state.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 Hashgraph Consensus Standards Conversational Agent with extended MCP capabilities. I can help you manage HCS-10 agent registrations, HCS-11 profiles, send messages through HCS standards, interact with the Hedera network, and use external tools for file operations and more. How can I assist you today?"
+                    : "Hello! I'm your Hashgraph Consensus Standards Conversational Agent. I can help you manage HCS-10 agent registrations, HCS-11 profiles, send messages through HCS standards, and interact with the Hedera network. How can I assist you today?",
+                timestamp: new Date(),
+            });
+            dispatch({ type: 'SET_MESSAGES', payload: welcomeMessages });
+        }
+        catch (err) {
+            dispatch({
+                type: 'SET_ERROR',
+                payload: err instanceof Error ? err.message : 'Failed to initialize agent',
+            });
+            dispatch({ type: 'SET_SCREEN', payload: 'setup' });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+            initializingRef.current = false;
+        }
+    }, [state.config, state.mcpConfig]);
+    const sendMessage = useCallback(async (message) => {
+        const currentAgent = agentRef.current || state.agent;
+        if (!currentAgent || !message.trim())
+            return;
+        const userMessage = {
+            role: 'user',
+            content: message,
+            timestamp: new Date(),
+        };
+        dispatch({ type: 'ADD_MESSAGES', payload: [userMessage] });
+        dispatch({ type: 'SET_INPUT', payload: '' });
+        dispatch({ type: 'SET_LOADING', payload: true });
+        try {
+            const chatHistory = state.messages
+                .filter(m => m.role !== 'system')
+                .map(m => ({
+                type: m.role === 'user' ? 'human' : 'ai',
+                content: m.content,
+            }));
+            const response = await currentAgent.processMessage(message, chatHistory);
+            const assistantMessage = {
+                role: 'assistant',
+                content: response.message || response.output || response.error || 'No response received',
+                timestamp: new Date(),
+            };
+            const newMessages = [assistantMessage];
+            if (response.transactionId) {
+                newMessages.push({
+                    role: 'system',
+                    content: `Transaction ID: ${response.transactionId}`,
+                    timestamp: new Date(),
+                });
+            }
+            if (response.scheduleId) {
+                newMessages.push({
+                    role: 'system',
+                    content: `Schedule ID: ${response.scheduleId}`,
+                    timestamp: new Date(),
+                });
+            }
+            if (response.notes && response.notes.length > 0) {
+                response.notes.forEach((note) => {
+                    newMessages.push({
+                        role: 'system',
+                        content: note,
+                        timestamp: new Date(),
+                    });
+                });
+            }
+            dispatch({ type: 'ADD_MESSAGES', payload: newMessages });
+        }
+        catch (err) {
+            dispatch({
+                type: 'ADD_MESSAGES',
+                payload: [{
+                        role: 'system',
+                        content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`,
+                        timestamp: new Date(),
+                    }],
+            });
+        }
+        finally {
+            dispatch({ type: 'SET_LOADING', payload: false });
+        }
+    }, [state.agent, state.messages]);
+    const actions = {
+        setScreen: useCallback((screen) => dispatch({ type: 'SET_SCREEN', payload: screen }), []),
+        setAgent: useCallback((agent) => dispatch({ type: 'SET_AGENT', payload: agent }), []),
+        setMessages: useCallback((messages) => dispatch({ type: 'SET_MESSAGES', payload: messages }), []),
+        addMessages: useCallback((messages) => dispatch({ type: 'ADD_MESSAGES', payload: messages }), []),
+        setInput: useCallback((input) => dispatch({ type: 'SET_INPUT', payload: input }), []),
+        setLoading: useCallback((loading) => dispatch({ type: 'SET_LOADING', payload: loading }), []),
+        setError: useCallback((error) => dispatch({ type: 'SET_ERROR', payload: error }), []),
+        setConfig: useCallback((config) => dispatch({ type: 'SET_CONFIG', payload: config }), []),
+        updateConfigField: useCallback((field, value) => dispatch({ type: 'UPDATE_CONFIG_FIELD', payload: { field, value } }), []),
+        setMcpConfig: useCallback((config) => dispatch({ type: 'SET_MCP_CONFIG', payload: config }), []),
+        setEditingFilesystemPath: useCallback((editing) => dispatch({ type: 'SET_EDITING_FILESYSTEM_PATH', payload: editing }), []),
+        setCurrentField: useCallback((field) => dispatch({ type: 'SET_CURRENT_FIELD', payload: field }), []),
+        setLogs: useCallback((logs) => dispatch({ type: 'SET_LOGS', payload: logs }), []),
+        initializeAgent,
+        sendMessage,
+    };
+    useEffect(() => {
+        const hasRequiredConfig = state.config.accountId &&
+            state.config.privateKey &&
+            state.config.openAIApiKey;
+        if (hasRequiredConfig && !autoInitialized.current && !agentRef.current) {
+            autoInitialized.current = true;
+            initializeAgent();
+        }
+    }, [state.config.accountId, state.config.privateKey, state.config.openAIApiKey, initializeAgent]);
+    const contextValue = {
+        state,
+        actions,
+    };
+    return React.createElement(AppContext.Provider, { value: contextValue }, children);
+};
+export const useAppContext = () => {
+    const context = useContext(AppContext);
+    if (!context) {
+        throw new Error('useAppContext must be used within an AppProvider');
+    }
+    return context;
+};
+export { saveMCPConfig, getMCPConfigPath };

package/cli/dist/hooks/useInitializeAgent.d.ts

@@ -0,0 +1,19 @@
+import { ConfigManager } from '../managers/ConfigManager';
+import { AgentManager } from '../managers/AgentManager';
+import { type Config } from '../types';
+import { type MCPServerConfig } from '@hashgraphonline/conversational-agent';
+interface InitializeAgentProps {
+    configManager: ConfigManager;
+    agentManager: AgentManager;
+    actions: {
+        setScreen: (screen: any) => void;
+        setMessages: (messages: any[]) => void;
+        setError: (error: string | null) => void;
+    };
+}
+export declare const useInitializeAgent: ({ configManager, agentManager, actions, }: InitializeAgentProps) => (currentConfig: Config, mcpConfig: {
+    enableFilesystem: boolean;
+    filesystemPath: string;
+    customServers: MCPServerConfig[];
+}) => Promise<void>;
+export {};

package/cli/dist/hooks/useInitializeAgent.js

@@ -0,0 +1,28 @@
+import { useRef, useCallback } from 'react';
+export const useInitializeAgent = ({ configManager, agentManager, actions, }) => {
+    const initializingRef = useRef(false);
+    const initializeAgent = useCallback(async (currentConfig, mcpConfig) => {
+        if (agentManager.isInitialized() ||
+            agentManager.isInitializing() ||
+            initializingRef.current) {
+            return;
+        }
+        initializingRef.current = true;
+        actions.setScreen('loading');
+        try {
+            await configManager.saveConfig(currentConfig);
+            const { welcomeMessages } = await agentManager.initialize({ ...currentConfig, mcpServers: configManager.getMCPServers() }, mcpConfig);
+            actions.setMessages(welcomeMessages);
+            await new Promise(resolve => setTimeout(resolve, 100));
+            actions.setScreen('chat');
+        }
+        catch (err) {
+            actions.setError(err instanceof Error ? err.message : 'Failed to initialize agent');
+            actions.setScreen('setup');
+        }
+        finally {
+            initializingRef.current = false;
+        }
+    }, [configManager, agentManager, actions]);
+    return initializeAgent;
+};

package/cli/dist/hooks/useStableState.d.ts

@@ -0,0 +1,38 @@
+import { type Screen, type Message } from '../types';
+import { type MCPServerConfig } from '@hashgraphonline/conversational-agent';
+export interface AppState {
+    screen: Screen;
+    messages: Message[];
+    input: string;
+    isLoading: boolean;
+    error: string | null;
+    mcpConfig: {
+        enableFilesystem: boolean;
+        filesystemPath: string;
+        customServers: MCPServerConfig[];
+        addingCustom: boolean;
+        newServerName: string;
+        newServerCommand: string;
+        newServerArgs: string;
+        newServerEnv: string;
+        currentField: number;
+    };
+    editingFilesystemPath: boolean;
+    currentField: number;
+    logs: string[];
+}
+export declare const useStableState: (initialMcpServers: MCPServerConfig[]) => {
+    state: AppState;
+    actions: {
+        setScreen: (screen: Screen) => void;
+        setMessages: (messages: Message[]) => void;
+        addMessages: (messages: Message[]) => void;
+        setInput: (input: string) => void;
+        setLoading: (loading: boolean) => void;
+        setError: (error: string | null) => void;
+        setMcpConfig: (config: Partial<AppState["mcpConfig"]>) => void;
+        setEditingFilesystemPath: (editing: boolean) => void;
+        setCurrentField: (field: number) => void;
+        setLogs: (logs: string[]) => void;
+    };
+};

package/cli/dist/hooks/useStableState.js

@@ -0,0 +1,68 @@
+import { useReducer, useCallback, useMemo } from 'react';
+const appReducer = (state, action) => {
+    switch (action.type) {
+        case 'SET_SCREEN':
+            return { ...state, screen: action.payload };
+        case 'SET_MESSAGES':
+            return { ...state, messages: action.payload };
+        case 'ADD_MESSAGES':
+            return { ...state, messages: [...state.messages, ...action.payload] };
+        case 'SET_INPUT':
+            return { ...state, input: action.payload };
+        case 'SET_LOADING':
+            return { ...state, isLoading: action.payload };
+        case 'SET_ERROR':
+            return { ...state, error: action.payload };
+        case 'SET_MCP_CONFIG':
+            return { ...state, mcpConfig: { ...state.mcpConfig, ...action.payload } };
+        case 'SET_EDITING_FILESYSTEM_PATH':
+            return { ...state, editingFilesystemPath: action.payload };
+        case 'SET_CURRENT_FIELD':
+            return { ...state, currentField: action.payload };
+        case 'SET_LOGS':
+            return { ...state, logs: action.payload };
+        default:
+            return state;
+    }
+};
+export const useStableState = (initialMcpServers) => {
+    const getInitialState = useCallback(() => {
+        const filesystemServer = initialMcpServers.find(s => s.name === 'filesystem');
+        const customServers = initialMcpServers.filter(s => s.name !== 'filesystem');
+        return {
+            screen: 'welcome',
+            messages: [],
+            input: '',
+            isLoading: false,
+            error: null,
+            mcpConfig: {
+                enableFilesystem: !!filesystemServer,
+                filesystemPath: filesystemServer ? filesystemServer.args[2] || process.cwd() : process.cwd(),
+                customServers,
+                addingCustom: false,
+                newServerName: '',
+                newServerCommand: '',
+                newServerArgs: '',
+                newServerEnv: '',
+                currentField: 0,
+            },
+            editingFilesystemPath: false,
+            currentField: 0,
+            logs: [],
+        };
+    }, [initialMcpServers]);
+    const [state, dispatch] = useReducer(appReducer, null, getInitialState);
+    const actions = useMemo(() => ({
+        setScreen: (screen) => dispatch({ type: 'SET_SCREEN', payload: screen }),
+        setMessages: (messages) => dispatch({ type: 'SET_MESSAGES', payload: messages }),
+        addMessages: (messages) => dispatch({ type: 'ADD_MESSAGES', payload: messages }),
+        setInput: (input) => dispatch({ type: 'SET_INPUT', payload: input }),
+        setLoading: (loading) => dispatch({ type: 'SET_LOADING', payload: loading }),
+        setError: (error) => dispatch({ type: 'SET_ERROR', payload: error }),
+        setMcpConfig: (config) => dispatch({ type: 'SET_MCP_CONFIG', payload: config }),
+        setEditingFilesystemPath: (editing) => dispatch({ type: 'SET_EDITING_FILESYSTEM_PATH', payload: editing }),
+        setCurrentField: (field) => dispatch({ type: 'SET_CURRENT_FIELD', payload: field }),
+        setLogs: (logs) => dispatch({ type: 'SET_LOGS', payload: logs }),
+    }), [dispatch]);
+    return { state, actions };
+};

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

@@ -0,0 +1,57 @@
+import { ConversationalAgent, type MCPServerConfig } from '@hashgraphonline/conversational-agent';
+import { type Config, type Message } from '../types';
+export declare class AgentManager {
+    private static instance;
+    private agent;
+    private initializing;
+    private initialized;
+    private constructor();
+    static getInstance(): AgentManager;
+    /**
+     * Initialize the conversational agent
+     */
+    initialize(config: Config & {
+        mcpServers: MCPServerConfig[];
+    }, mcpConfig: {
+        enableFilesystem: boolean;
+        filesystemPath: string;
+        customServers: MCPServerConfig[];
+    }): Promise<{
+        agent: ConversationalAgent;
+        welcomeMessages: Message[];
+    }>;
+    /**
+     * Get welcome messages
+     */
+    private getWelcomeMessages;
+    /**
+     * Send message to agent
+     */
+    sendMessage(message: string, chatHistory: Array<{
+        type: 'human' | 'ai';
+        content: string;
+    }>): Promise<{
+        message?: string;
+        output?: string;
+        error?: string;
+        transactionId?: string;
+        scheduleId?: string;
+        notes?: string[];
+    }>;
+    /**
+     * Get current agent
+     */
+    getAgent(): ConversationalAgent | null;
+    /**
+     * Check if agent is initialized
+     */
+    isInitialized(): boolean;
+    /**
+     * Check if agent is initializing
+     */
+    isInitializing(): boolean;
+    /**
+     * Reset agent (for testing)
+     */
+    reset(): void;
+}