dexto 1.1.10 → 1.2.0

package/dist/cli/tool-confirmation/cli-confirmation-handler.js

@@ -1,10 +1,10 @@
-import { logger } from '@dexto/core';
+import { logger, ApprovalType, ApprovalStatus } from '@dexto/core';
 import * as readline from 'readline';
 import chalk from 'chalk';
 import boxen from 'boxen';
 /**
- * CLI-specific subscriber for tool confirmation events
- * Implements EventSubscriber pattern to listen to AgentEventBus for tool confirmation requests
+ * CLI-specific subscriber for approval events
+ * Implements EventSubscriber pattern to listen to AgentEventBus for approval requests
  */
 export class CLIToolConfirmationSubscriber {
     agentEventBus;
@@ -12,54 +12,334 @@ export class CLIToolConfirmationSubscriber {
         // No configuration needed - CLI always shows interactive prompts
     }
     /**
-     * Subscribe to tool confirmation events on the AgentEventBus
+     * Subscribe to approval events on the AgentEventBus
      */
     subscribe(eventBus) {
         this.agentEventBus = eventBus;
-        this.agentEventBus.on('dexto:toolConfirmationRequest', this.handleConfirmationRequest.bind(this));
+        this.agentEventBus.on('dexto:approvalRequest', this.handleApprovalRequest.bind(this));
     }
     /**
-     * Handle tool confirmation request events from the AgentEventBus
+     * Handle approval request events from the AgentEventBus
      */
-    async handleConfirmationRequest(event) {
+    async handleApprovalRequest(event) {
         try {
-            logger.info(`Handling tool confirmation request for ${event.toolName}, executionId: ${event.executionId}`);
-            // Display tool call using the logger's built-in method
-            logger.toolCall(event.toolName, event.args);
-            // Collect user input with arrow key navigation
-            const approved = await this.collectArrowKeyInput();
-            // Send response back via AgentEventBus
-            const response = {
-                executionId: event.executionId,
-                approved,
-                rememberChoice: false, // CLI won't persist choice
-                ...(event.sessionId && { sessionId: event.sessionId }),
-            };
-            this.sendConfirmationResponse(response);
-            if (!approved) {
-                logger.warn(`Tool '${event.toolName}' execution denied`);
+            if (event.type === ApprovalType.TOOL_CONFIRMATION) {
+                await this.handleToolConfirmation(event);
+            }
+            else if (event.type === ApprovalType.ELICITATION) {
+                await this.handleElicitation(event);
+            }
+            else {
+                logger.debug(`[CLI] Ignoring unsupported approval type: ${event.type}`);
             }
         }
         catch (error) {
-            logger.error(`Error handling tool confirmation request: ${error}`);
+            // Use structured logging to preserve error stack and metadata
+            logger.error(`Error handling approval request: ${error instanceof Error ? error.message : String(error)}`, error instanceof Error ? { error } : undefined);
             // Send denial response on error
-            this.sendConfirmationResponse({
-                executionId: event.executionId,
-                approved: false,
-                ...(event.sessionId && { sessionId: event.sessionId }),
-            });
+            const errorResponse = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.DENIED,
+            };
+            if (event.sessionId !== undefined) {
+                errorResponse.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(errorResponse);
+        }
+    }
+    /**
+     * Handle tool confirmation approval
+     */
+    async handleToolConfirmation(event) {
+        const toolMetadata = event.metadata;
+        logger.info(`Handling tool confirmation request for ${toolMetadata.toolName}, approvalId: ${event.approvalId}`);
+        // Display tool call using the logger's built-in method
+        logger.toolCall(toolMetadata.toolName, toolMetadata.args);
+        // Collect user input with arrow key navigation
+        const approved = await this.collectArrowKeyInput();
+        // Send response back via AgentEventBus
+        const response = {
+            approvalId: event.approvalId,
+            status: approved ? ApprovalStatus.APPROVED : ApprovalStatus.DENIED,
+            data: {
+                rememberChoice: false, // CLI won't persist choice
+            },
+        };
+        if (event.sessionId !== undefined) {
+            response.sessionId = event.sessionId;
+        }
+        this.sendApprovalResponse(response);
+        if (!approved) {
+            logger.warn(`Tool '${toolMetadata.toolName}' execution denied`);
+        }
+    }
+    /**
+     * Handle elicitation approval (form-based input from MCP servers)
+     */
+    async handleElicitation(event) {
+        const elicitationMetadata = event.metadata;
+        logger.info(`Handling elicitation request from MCP server '${elicitationMetadata.serverName}', approvalId: ${event.approvalId}`);
+        // Display the elicitation prompt
+        console.log('\n' +
+            boxen(chalk.cyan.bold('📝 Information Request from MCP Server'), {
+                padding: 1,
+                margin: 1,
+                borderStyle: 'round',
+                borderColor: 'cyan',
+            }));
+        console.log(chalk.white(`Server: ${chalk.yellow(elicitationMetadata.serverName)}`));
+        console.log(chalk.white(`Message: ${chalk.white(elicitationMetadata.prompt)}\n`));
+        // Collect form data based on schema
+        const formData = await this.collectFormData(elicitationMetadata.schema);
+        if (formData === null) {
+            // User cancelled
+            const cancelResponse = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.CANCELLED,
+            };
+            if (event.sessionId !== undefined) {
+                cancelResponse.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(cancelResponse);
+            logger.info('Elicitation cancelled by user');
         }
+        else {
+            // User provided data
+            const response = {
+                approvalId: event.approvalId,
+                status: ApprovalStatus.APPROVED,
+                data: { formData },
+            };
+            if (event.sessionId !== undefined) {
+                response.sessionId = event.sessionId;
+            }
+            this.sendApprovalResponse(response);
+            logger.info('Elicitation completed successfully');
+        }
+    }
+    /**
+     * Collect form data based on JSON Schema
+     * Returns null if user cancels
+     */
+    async collectFormData(schema) {
+        const formData = {};
+        if (!schema.properties || typeof schema.properties !== 'object') {
+            logger.warn('Invalid schema: no properties found');
+            return null;
+        }
+        const properties = schema.properties;
+        const required = schema.required || [];
+        for (const [fieldName, fieldSchema] of Object.entries(properties)) {
+            const field = fieldSchema;
+            const isRequired = required.includes(fieldName);
+            const fieldType = field.type || 'string';
+            // Display field prompt
+            const requiredLabel = isRequired ? chalk.red('*') : '';
+            console.log(chalk.cyan(`${fieldName}${requiredLabel}`) +
+                (field.description ? chalk.gray(` - ${field.description}`) : ''));
+            // Collect input based on field type
+            let value;
+            if (fieldType === 'boolean') {
+                value = await this.collectBooleanInput(fieldName, isRequired);
+            }
+            else if (fieldType === 'number' || fieldType === 'integer') {
+                value = await this.collectNumberInput(fieldName, fieldType === 'integer', isRequired);
+            }
+            else if (field.enum && Array.isArray(field.enum)) {
+                value = await this.collectEnumInput(fieldName, field.enum, isRequired);
+            }
+            else {
+                // Default to string input
+                value = await this.collectStringInput(fieldName, isRequired);
+            }
+            if (value === null) {
+                // User cancelled
+                return null;
+            }
+            // Only assign if value is not undefined (allows skipping optional fields)
+            if (value !== undefined) {
+                formData[fieldName] = value;
+            }
+        }
+        return formData;
+    }
+    /**
+     * Collect string input from user
+     */
+    collectStringInput(fieldName, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName}: `
+                : `${fieldName} (optional, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                if (!answer && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectStringInput(fieldName, required));
+                    return;
+                }
+                // Return undefined for optional skipped fields, empty string for provided empty input
+                if (!answer && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                resolve(answer);
+            });
+        });
+    }
+    /**
+     * Collect boolean input from user (yes/no)
+     */
+    collectBooleanInput(fieldName, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName} (yes/no): `
+                : `${fieldName} (yes/no, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                const normalized = answer.toLowerCase().trim();
+                // Allow skipping optional fields
+                if (!normalized && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!normalized && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectBooleanInput(fieldName, required));
+                    return;
+                }
+                if (normalized === 'yes' || normalized === 'y' || normalized === 'true') {
+                    resolve(true);
+                }
+                else if (normalized === 'no' || normalized === 'n' || normalized === 'false') {
+                    resolve(false);
+                }
+                else {
+                    console.log(chalk.red('Please answer yes or no'));
+                    resolve(this.collectBooleanInput(fieldName, required));
+                }
+            });
+        });
+    }
+    /**
+     * Collect number input from user
+     */
+    collectNumberInput(fieldName, integer, required) {
+        return new Promise((resolve) => {
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const type = integer ? 'integer' : 'number';
+            const prompt = required
+                ? `${fieldName} (${type}): `
+                : `${fieldName} (${type}, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                // Allow skipping optional fields
+                if (!answer.trim() && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!answer.trim() && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                const num = Number(answer);
+                if (isNaN(num)) {
+                    console.log(chalk.red(`Please enter a valid ${type}`));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                if (integer && !Number.isInteger(num)) {
+                    console.log(chalk.red('Please enter an integer'));
+                    resolve(this.collectNumberInput(fieldName, integer, required));
+                    return;
+                }
+                resolve(num);
+            });
+        });
+    }
+    /**
+     * Collect enum input from user (select from list)
+     */
+    collectEnumInput(fieldName, options, required) {
+        return new Promise((resolve) => {
+            console.log(chalk.gray('Available options:'));
+            options.forEach((option, index) => {
+                console.log(chalk.gray(`  ${index + 1}. ${option}`));
+            });
+            const rl = readline.createInterface({
+                input: process.stdin,
+                output: process.stdout,
+            });
+            const prompt = required
+                ? `${fieldName} (enter number or value): `
+                : `${fieldName} (enter number or value, press Enter to skip): `;
+            rl.question(prompt, (answer) => {
+                rl.close();
+                if (answer.toLowerCase() === 'cancel') {
+                    resolve(null);
+                    return;
+                }
+                // Allow skipping optional fields
+                if (!answer.trim() && !required) {
+                    resolve(undefined);
+                    return;
+                }
+                if (!answer.trim() && required) {
+                    console.log(chalk.red('This field is required'));
+                    resolve(this.collectEnumInput(fieldName, options, required));
+                    return;
+                }
+                // Try as index first
+                const index = parseInt(answer) - 1;
+                if (!isNaN(index) && index >= 0 && index < options.length) {
+                    resolve(options[index]);
+                    return;
+                }
+                // Try as direct value
+                const directMatch = options.find((opt) => String(opt) === answer);
+                if (directMatch !== undefined) {
+                    resolve(directMatch);
+                    return;
+                }
+                console.log(chalk.red('Invalid selection'));
+                resolve(this.collectEnumInput(fieldName, options, required));
+            });
+        });
     }
     /**
-     * Send confirmation response via AgentEventBus
+     * Send approval response via AgentEventBus
      */
-    sendConfirmationResponse(response) {
+    sendApprovalResponse(response) {
         if (!this.agentEventBus) {
-            logger.error('AgentEventBus not available for sending confirmation response');
+            logger.error('AgentEventBus not available for sending approval response');
             return;
         }
-        logger.debug(`CLI sending toolConfirmationResponse for executionId ${response.executionId}, approved=${response.approved}, sessionId=${response.sessionId}`);
-        this.agentEventBus.emit('dexto:toolConfirmationResponse', response);
+        logger.debug(`CLI sending approvalResponse for approvalId ${response.approvalId}, status=${response.status}, sessionId=${response.sessionId ?? 'global'}`);
+        this.agentEventBus.emit('dexto:approvalResponse', response);
     }
     /**
      * Collect user input with arrow key navigation
@@ -155,7 +435,7 @@ export class CLIToolConfirmationSubscriber {
      */
     cleanup() {
         if (this.agentEventBus) {
-            this.agentEventBus.removeAllListeners('dexto:toolConfirmationRequest');
+            this.agentEventBus.removeAllListeners('dexto:approvalRequest');
         }
     }
 }

package/dist/cli/utils/options.js

@@ -13,9 +13,9 @@ export function validateCliOptions(opts) {
         agent: z.string().min(1, 'Agent name or path must not be empty').optional(),
         strict: z.boolean().optional().default(false),
         verbose: z.boolean().optional().default(true),
-        mode: z.enum(['cli', 'web', 'server', 'discord', 'telegram', 'mcp'], {
+        mode: z.enum(['web', 'cli', 'server', 'discord', 'telegram', 'mcp'], {
             errorMap: () => ({
-                message: 'Mode must be one of "cli", "web", "server", "discord", "telegram", or "mcp"',
+                message: 'Mode must be one of "web", "cli", "server", "discord", "telegram", or "mcp"',
             }),
         }),
         webPort: z.string().refine((val) => {