@hashgraphonline/conversational-agent 0.1.217 → 0.1.219

package/src/types/content-reference.ts

@@ -1,6 +1,6 @@
 /**
  * Content Reference System Types
- * 
+ *
  * Shared interfaces for the Reference-Based Content System that handles
  * large content storage with unique reference IDs to optimize context window usage.
  */
@@ -14,17 +14,31 @@ export type ReferenceId = string;
 /**
  * Lifecycle state of a content reference
  */
-export type ReferenceLifecycleState = 'active' | 'expired' | 'cleanup_pending' | 'invalid';
+export type ReferenceLifecycleState =
+  | 'active'
+  | 'expired'
+  | 'cleanup_pending'
+  | 'invalid';
 
 /**
  * Content types supported by the reference system
  */
-export type ContentType = 'text' | 'json' | 'html' | 'markdown' | 'binary' | 'unknown';
+export type ContentType =
+  | 'text'
+  | 'json'
+  | 'html'
+  | 'markdown'
+  | 'binary'
+  | 'unknown';
 
 /**
  * Sources that created the content reference
  */
-export type ContentSource = 'mcp_tool' | 'user_upload' | 'agent_generated' | 'system';
+export type ContentSource =
+  | 'mcp_tool'
+  | 'user_upload'
+  | 'agent_generated'
+  | 'system';
 
 /**
  * Metadata associated with stored content
@@ -32,59 +46,62 @@ export type ContentSource = 'mcp_tool' | 'user_upload' | 'agent_generated' | 'sy
 export interface ContentMetadata {
   /** Content type classification */
   contentType: ContentType;
-  
+
   /** MIME type of the original content */
   mimeType?: string;
-  
+
   /** Size in bytes of the stored content */
   sizeBytes: number;
-  
+
   /** When the content was originally stored */
   createdAt: Date;
-  
+
   /** Last time the content was accessed via reference resolution */
   lastAccessedAt: Date;
-  
+
   /** Source that created this content reference */
   source: ContentSource;
-  
+
   /** Name of the MCP tool that generated the content (if applicable) */
   mcpToolName?: string;
-  
+
   /** Original filename or suggested name for the content */
   fileName?: string;
-  
+
   /** Number of times this reference has been resolved */
   accessCount: number;
-  
+
   /** Tags for categorization and cleanup policies */
   tags?: string[];
-  
+
   /** Custom metadata from the source */
   customMetadata?: Record<string, unknown>;
 }
 
 /**
  * Core content reference object passed through agent context
- * Designed to be lightweight (<100 tokens) while providing enough 
+ * Designed to be lightweight (<100 tokens) while providing enough
  * information for agent decision-making
  */
 export interface ContentReference {
   /** Unique identifier for resolving the content */
   referenceId: ReferenceId;
-  
+
   /** Current lifecycle state */
   state: ReferenceLifecycleState;
-  
+
   /** Brief description or preview of the content (max 200 chars) */
   preview: string;
-  
+
   /** Essential metadata for agent decision-making */
-  metadata: Pick<ContentMetadata, 'contentType' | 'sizeBytes' | 'source' | 'fileName' | 'mimeType'>;
-  
+  metadata: Pick<
+    ContentMetadata,
+    'contentType' | 'sizeBytes' | 'source' | 'fileName' | 'mimeType'
+  >;
+
   /** When this reference was created */
   createdAt: Date;
-  
+
   /** Special format indicator for reference IDs in content */
   readonly format: 'ref://{id}';
 }
@@ -95,19 +112,24 @@ export interface ContentReference {
 export interface ReferenceResolutionResult {
   /** Whether the resolution was successful */
   success: boolean;
-  
+
   /** The resolved content if successful */
   content?: Buffer;
-  
+
   /** Complete metadata if successful */
   metadata?: ContentMetadata;
-  
+
   /** Error message if resolution failed */
   error?: string;
-  
+
   /** Specific error type for targeted error handling */
-  errorType?: 'not_found' | 'expired' | 'corrupted' | 'access_denied' | 'system_error';
-  
+  errorType?:
+    | 'not_found'
+    | 'expired'
+    | 'corrupted'
+    | 'access_denied'
+    | 'system_error';
+
   /** Suggested actions for recovery */
   suggestedActions?: string[];
 }
@@ -118,39 +140,39 @@ export interface ReferenceResolutionResult {
 export interface ContentReferenceConfig {
   /** Size threshold above which content should be stored as references (default: 10KB) */
   sizeThresholdBytes: number;
-  
+
   /** Maximum age for unused references before cleanup (default: 1 hour) */
   maxAgeMs: number;
-  
+
   /** Maximum number of references to store simultaneously */
   maxReferences: number;
-  
+
   /** Maximum total storage size for all references */
   maxTotalStorageBytes: number;
-  
+
   /** Whether to enable automatic cleanup */
   enableAutoCleanup: boolean;
-  
+
   /** Interval for cleanup checks in milliseconds */
   cleanupIntervalMs: number;
-  
+
   /** Whether to persist references across restarts */
   enablePersistence: boolean;
-  
+
   /** Storage backend configuration */
   storageBackend: 'memory' | 'filesystem' | 'hybrid';
-  
+
   /** Cleanup policies for different content types */
   cleanupPolicies: {
     /** Policy for content marked as "recent" from MCP tools */
     recent: { maxAgeMs: number; priority: number };
-    
+
     /** Policy for user-uploaded content */
     userContent: { maxAgeMs: number; priority: number };
-    
+
     /** Policy for agent-generated content */
     agentGenerated: { maxAgeMs: number; priority: number };
-    
+
     /** Default policy for other content */
     default: { maxAgeMs: number; priority: number };
   };
@@ -172,8 +194,8 @@ export const DEFAULT_CONTENT_REFERENCE_CONFIG: ContentReferenceConfig = {
     recent: { maxAgeMs: 30 * 60 * 1000, priority: 1 },
     userContent: { maxAgeMs: 2 * 60 * 60 * 1000, priority: 2 },
     agentGenerated: { maxAgeMs: 60 * 60 * 1000, priority: 3 },
-    default: { maxAgeMs: 60 * 60 * 1000, priority: 4 }
-  }
+    default: { maxAgeMs: 60 * 60 * 1000, priority: 4 },
+  },
 };
 
 /**
@@ -182,36 +204,36 @@ export const DEFAULT_CONTENT_REFERENCE_CONFIG: ContentReferenceConfig = {
 export interface ContentReferenceStats {
   /** Total number of active references */
   activeReferences: number;
-  
+
   /** Total storage used by all references in bytes */
   totalStorageBytes: number;
-  
+
   /** Number of references cleaned up in last cleanup cycle */
   recentlyCleanedUp: number;
-  
+
   /** Number of successful reference resolutions since startup */
   totalResolutions: number;
-  
+
   /** Number of failed resolution attempts */
   failedResolutions: number;
-  
+
   /** Average content size in bytes */
   averageContentSize: number;
-  
+
   /** Most frequently accessed reference ID */
   mostAccessedReferenceId?: ReferenceId;
-  
+
   /** Storage utilization percentage */
   storageUtilization: number;
-  
+
   /** Performance metrics */
   performanceMetrics: {
     /** Average time to create a reference in milliseconds */
     averageCreationTimeMs: number;
-    
+
     /** Average time to resolve a reference in milliseconds */
     averageResolutionTimeMs: number;
-    
+
     /** Average cleanup time in milliseconds */
     averageCleanupTimeMs: number;
   };
@@ -241,41 +263,46 @@ export interface ContentReferenceStore {
    */
   storeContent(
     content: Buffer,
-    metadata: Omit<ContentMetadata, 'createdAt' | 'lastAccessedAt' | 'accessCount'>
+    metadata: Omit<
+      ContentMetadata,
+      'createdAt' | 'lastAccessedAt' | 'accessCount'
+    >
   ): Promise<ContentReference>;
-  
+
   /**
    * Resolve a reference to its content
    */
-  resolveReference(referenceId: ReferenceId): Promise<ReferenceResolutionResult>;
-  
+  resolveReference(
+    referenceId: ReferenceId
+  ): Promise<ReferenceResolutionResult>;
+
   /**
    * Check if a reference exists and is valid
    */
   hasReference(referenceId: ReferenceId): Promise<boolean>;
-  
+
   /**
    * Mark a reference for cleanup
    */
   cleanupReference(referenceId: ReferenceId): Promise<boolean>;
-  
+
   /**
    * Get current storage statistics
    */
   getStats(): Promise<ContentReferenceStats>;
-  
+
   /**
    * Update configuration
    */
   updateConfig(config: Partial<ContentReferenceConfig>): Promise<void>;
-  
+
   /**
    * Perform cleanup based on current policies
    */
   performCleanup(): Promise<{ cleanedUp: number; errors: string[] }>;
-  
+
   /**
    * Dispose of resources
    */
   dispose(): Promise<void>;
-}
+}

package/src/utils/index.ts

@@ -0,0 +1 @@
+export * from './response-formatter';

package/cli/dist/CLIApp.d.ts

@@ -1,9 +0,0 @@
-import React from 'react';
-interface Props {
-    accountId?: string;
-    privateKey?: string;
-    network?: 'testnet' | 'mainnet';
-    openAIApiKey?: string;
-}
-export declare const CLIApp: React.FC<Props>;
-export {};

package/cli/dist/CLIApp.js

@@ -1,127 +0,0 @@
-import React, { useState, useMemo, useCallback } from 'react';
-import { useApp } from 'ink';
-import { ScreenRouter } from './components/ScreenRouter.js';
-import { ConfigManager } from './managers/ConfigManager.js';
-import { AgentManager } from './managers/AgentManager.js';
-import { useStableState } from './hooks/useStableState.js';
-import { useInitializeAgent } from './hooks/useInitializeAgent.js';
-export const CLIApp = props => {
-    const { exit } = useApp();
-    const configManager = useMemo(() => ConfigManager.getInstance(), []);
-    const agentManager = useMemo(() => AgentManager.getInstance(), []);
-    const initialConfig = useMemo(() => configManager.getConfig(props), [
-        configManager,
-        props.accountId,
-        props.privateKey,
-        props.network,
-        props.openAIApiKey,
-    ]);
-    const initialMcpServers = useMemo(() => configManager.getMCPServers(), [configManager]);
-    const { state, actions } = useStableState(initialMcpServers);
-    const [currentConfig, setCurrentConfig] = useState(initialConfig);
-    const initializeAgent = useInitializeAgent({
-        configManager,
-        agentManager,
-        actions,
-    });
-    const handleInitializeAgent = useCallback(() => {
-        initializeAgent(currentConfig, state.mcpConfig);
-    }, [initializeAgent, currentConfig, state.mcpConfig]);
-    const sendMessage = useCallback(async (message) => {
-        if (!message.trim())
-            return;
-        const userMessage = {
-            role: 'user',
-            content: message,
-            timestamp: new Date(),
-        };
-        actions.addMessages([userMessage]);
-        actions.setInput('');
-        actions.setLoading(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 agentManager.sendMessage(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(),
-                    });
-                });
-            }
-            actions.addMessages(newMessages);
-        }
-        catch (err) {
-            actions.addMessages([
-                {
-                    role: 'system',
-                    content: `Error: ${err instanceof Error ? err.message : 'Unknown error'}`,
-                    timestamp: new Date(),
-                },
-            ]);
-        }
-        finally {
-            actions.setLoading(false);
-        }
-    }, [agentManager, state.messages, actions]);
-    const updateConfig = (field, value) => {
-        const updated = { ...currentConfig, [field]: value };
-        setCurrentConfig(updated);
-    };
-    const saveMCPConfig = () => {
-        const servers = [];
-        if (state.mcpConfig.enableFilesystem) {
-            const filesystemServer = {
-                name: 'filesystem',
-                command: 'npx',
-                args: [
-                    '-y',
-                    '@modelcontextprotocol/server-filesystem',
-                    state.mcpConfig.filesystemPath,
-                ],
-                transport: 'stdio',
-                autoConnect: true,
-            };
-            servers.push(filesystemServer);
-        }
-        servers.push(...state.mcpConfig.customServers);
-        configManager.saveMCPConfig(servers);
-    };
-    const stableHandlers = useMemo(() => ({
-        initializeAgent: handleInitializeAgent,
-        sendMessage,
-        updateConfig,
-        saveMCPConfig,
-        getMCPConfigPath: () => configManager.getMCPConfigPathForDisplay(),
-    }), [handleInitializeAgent, sendMessage]);
-    return (React.createElement(ScreenRouter, { state: state, currentConfig: currentConfig, actions: actions, stableHandlers: stableHandlers, exit: exit }));
-};

package/cli/dist/LocalConversationalAgent.d.ts

@@ -1,37 +0,0 @@
-/**
- * Minimal ConversationalAgent implementation for CLI use
- * This avoids complex dependencies while providing the core functionality
- *
- * For local development, this allows the CLI to work without needing to publish
- * the main package, while still providing a functional demo of the interface.
- */
-export interface ConversationalAgentOptions {
-    accountId: string;
-    privateKey: string;
-    network: 'testnet' | 'mainnet';
-    openAIApiKey: string;
-    openAIModelName?: string;
-    plugins?: any[];
-    verbose?: boolean;
-}
-export interface AgentResponse {
-    message?: string;
-    output?: string;
-    error?: string;
-    transactionId?: string;
-    scheduleId?: string;
-    notes?: string[];
-}
-export declare class ConversationalAgent {
-    private config;
-    private initialized;
-    constructor(config: ConversationalAgentOptions);
-    initialize(): Promise<void>;
-    processMessage(message: string, _chatHistory?: Array<{
-        type: 'human' | 'ai';
-        content: string;
-    }>): Promise<AgentResponse>;
-}
-export declare class OpenConvAIPlugin {
-    constructor();
-}

package/cli/dist/LocalConversationalAgent.js

@@ -1,58 +0,0 @@
-/**
- * Minimal ConversationalAgent implementation for CLI use
- * This avoids complex dependencies while providing the core functionality
- *
- * For local development, this allows the CLI to work without needing to publish
- * the main package, while still providing a functional demo of the interface.
- */
-export class ConversationalAgent {
-    constructor(config) {
-        Object.defineProperty(this, "config", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "initialized", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: false
-        });
-        this.config = config;
-    }
-    async initialize() {
-        if (!this.config.accountId || !this.config.privateKey || !this.config.openAIApiKey) {
-            throw new Error('Missing required configuration: accountId, privateKey, or openAIApiKey');
-        }
-        await new Promise(resolve => setTimeout(resolve, 500));
-        this.initialized = true;
-    }
-    async processMessage(message, _chatHistory) {
-        if (!this.initialized) {
-            throw new Error('Agent not initialized. Call initialize() first.');
-        }
-        const responses = [
-            "I'm a demo version of the Conversational Agent. In the full version, I would help you interact with the Hedera network.",
-            "This CLI demonstrates the interface for the Hashgraph Online Conversational Agent. Full functionality requires the complete implementation.",
-            "I understand you want to use Hedera network features. The production version would process this request using real network calls.",
-            "Demo mode: Your message has been received. The full agent would analyze this and execute appropriate Hedera operations.",
-            "This is a placeholder response. The actual Conversational Agent would provide real Hedera network functionality."
-        ];
-        const randomResponse = responses[Math.floor(Math.random() * responses.length)];
-        return {
-            message: randomResponse,
-            output: `Demo response for: ${message}`,
-            notes: [
-                `Connected to ${this.config.network}`,
-                `Using account ${this.config.accountId}`,
-                `Model: ${this.config.openAIModelName || 'gpt-4o-mini'}`,
-                'Running in CLI demo mode'
-            ]
-        };
-    }
-}
-export class OpenConvAIPlugin {
-    constructor() {
-    }
-}

package/cli/dist/app.d.ts

@@ -1,16 +0,0 @@
-import React from 'react';
-type Props = {
-    accountId?: string;
-    privateKey?: string;
-    network?: 'testnet' | 'mainnet';
-    openAIApiKey?: string;
-};
-/**
- * Main App component for the Hashgraph Online Conversational Agent CLI
- * @param accountId - Hedera account ID
- * @param privateKey - Hedera private key
- * @param network - Network to connect to (testnet or mainnet)
- * @param openAIApiKey - OpenAI API key for the conversational agent
- */
-export default function App({ accountId, privateKey, network, openAIApiKey, }: Props): React.JSX.Element;
-export {};

package/cli/dist/app.js

@@ -1,13 +0,0 @@
-import React from 'react';
-import { CLIApp } from './CLIApp.js';
-process.setMaxListeners(20);
-/**
- * Main App component for the Hashgraph Online Conversational Agent CLI
- * @param accountId - Hedera account ID
- * @param privateKey - Hedera private key
- * @param network - Network to connect to (testnet or mainnet)
- * @param openAIApiKey - OpenAI API key for the conversational agent
- */
-export default function App({ accountId, privateKey, network = 'testnet', openAIApiKey, }) {
-    return (React.createElement(CLIApp, { accountId: accountId, privateKey: privateKey, network: network, openAIApiKey: openAIApiKey }));
-}

package/cli/dist/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/cli/dist/cli.js

@@ -1,51 +0,0 @@
-#!/usr/bin/env node
-import React from 'react';
-import { render } from 'ink';
-import meow from 'meow';
-import App from './app.js';
-const cli = meow(`
-	Usage
-	  $ conversational-agent
-
-	Options
-		--account-id       Hedera account ID (e.g., 0.0.12345)
-		--private-key      Private key for the account
-		--network          Network to connect to (mainnet or testnet) [default: testnet]
-		--openai-api-key   OpenAI API key for the LLM
-
-	Examples
-	  $ conversational-agent
-	  Interactive mode - will prompt for configuration
-
-	  $ conversational-agent --account-id=0.0.12345 --private-key=... --openai-api-key=sk-...
-	  Start with provided configuration
-
-	  $ export HEDERA_ACCOUNT_ID=0.0.12345
-	  $ export HEDERA_PRIVATE_KEY=...
-	  $ export OPENAI_API_KEY=sk-...
-	  $ conversational-agent
-	  Uses environment variables for Hedera credentials
-`, {
-    importMeta: import.meta,
-    flags: {
-        accountId: {
-            type: 'string',
-            default: process.env['HEDERA_ACCOUNT_ID'] || '',
-        },
-        privateKey: {
-            type: 'string',
-            default: process.env['HEDERA_PRIVATE_KEY'] || '',
-        },
-        network: {
-            type: 'string',
-            default: process.env['HEDERA_NETWORK'] || 'testnet',
-            choices: ['testnet', 'mainnet'],
-        },
-        openaiApiKey: {
-            type: 'string',
-            default: process.env['OPENAI_API_KEY'] || '',
-        },
-    },
-});
-const { waitUntilExit } = render(React.createElement(App, { accountId: cli.flags.accountId, privateKey: cli.flags.privateKey, network: cli.flags.network, openAIApiKey: cli.flags.openaiApiKey }));
-waitUntilExit().then(() => process.exit(0));

package/cli/dist/components/AppContainer.d.ts

@@ -1,16 +0,0 @@
-import React from 'react';
-import { type Config } from '../types.js';
-import { type AppState } from '../hooks/useStableState.js';
-interface Props {
-    state: AppState;
-    currentConfig: Config;
-    actions: any;
-    stableHandlers: any;
-    exit: () => void;
-}
-/**
- * App container that keeps all screens mounted but only displays one
- * This prevents unmounting/remounting which causes double renders
- */
-export declare const AppContainer: React.FC<Props>;
-export {};

package/cli/dist/components/AppContainer.js

@@ -1,24 +0,0 @@
-import React from 'react';
-import { Box } from 'ink';
-import { WelcomeScreen } from './WelcomeScreen.js';
-import { ChatScreen } from './ChatScreen.js';
-import { LoadingScreen } from './LoadingScreen.js';
-import { SetupScreen } from './SetupScreen.js';
-import { MCPConfigScreen } from './MCPConfigScreen.js';
-/**
- * App container that keeps all screens mounted but only displays one
- * This prevents unmounting/remounting which causes double renders
- */
-export const AppContainer = ({ state, currentConfig, actions, stableHandlers, exit, }) => {
-    return (React.createElement(React.Fragment, null,
-        React.createElement(Box, { display: state.screen === 'welcome' ? 'flex' : 'none' },
-            React.createElement(WelcomeScreen, { config: currentConfig, onExit: exit, onInitializeAgent: stableHandlers.initializeAgent, onSetScreen: actions.setScreen })),
-        React.createElement(Box, { display: state.screen === 'loading' ? 'flex' : 'none' },
-            React.createElement(LoadingScreen, null)),
-        React.createElement(Box, { display: state.screen === 'setup' ? 'flex' : 'none' },
-            React.createElement(SetupScreen, { config: currentConfig, currentField: state.currentField, error: state.error, onUpdateConfig: stableHandlers.updateConfig, onSetCurrentField: actions.setCurrentField, onInitializeAgent: stableHandlers.initializeAgent })),
-        React.createElement(Box, { display: state.screen === 'mcp-config' ? 'flex' : 'none' },
-            React.createElement(MCPConfigScreen, { mcpConfig: state.mcpConfig, editingFilesystemPath: state.editingFilesystemPath, onSetMcpConfig: actions.setMcpConfig, onSetEditingFilesystemPath: actions.setEditingFilesystemPath, onSetScreen: actions.setScreen, onSaveMCPConfig: stableHandlers.saveMCPConfig, getMCPConfigPath: stableHandlers.getMCPConfigPath })),
-        React.createElement(Box, { display: state.screen === 'chat' ? 'flex' : 'none' },
-            React.createElement(ChatScreen, { config: currentConfig, messages: state.messages, input: state.input, isLoading: state.isLoading, setInput: actions.setInput, sendMessage: stableHandlers.sendMessage, showLogs: false, logs: state.logs }))));
-};