prompt-language-shell 0.9.2 → 0.9.6

package/dist/execution/handlers.js

@@ -7,7 +7,7 @@ import { getTotalElapsed } from './utils.js';
  */
 export function handleTaskCompletion(index, elapsed, context) {
     const { tasks, message, summary } = context;
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
+    const updatedTasks = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Success, elapsed } : task);
     if (index < tasks.length - 1) {
         // More tasks to execute
         return {
@@ -18,7 +18,7 @@ export function handleTaskCompletion(index, elapsed, context) {
             finalState: {
                 message,
                 summary,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
                 completionMessage: null,
                 error: null,
             },
@@ -27,17 +27,17 @@ export function handleTaskCompletion(index, elapsed, context) {
     }
     // All tasks complete
     const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
+    const totalElapsed = getTotalElapsed(updatedTasks);
     const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
     return {
         action: {
-            type: ExecuteActionType.AllTasksComplete,
+            type: ExecuteActionType.ExecutionComplete,
             payload: { index, elapsed, summaryText },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
+            tasks: updatedTasks,
             completionMessage: completion,
             error: null,
         },
@@ -47,63 +47,29 @@ export function handleTaskCompletion(index, elapsed, context) {
 /**
  * Handles task error logic and returns the appropriate action and state.
  */
-export function handleTaskFailure(index, error, elapsed, context) {
+export function handleTaskFailure(index, error, context) {
     const { tasks, message, summary } = context;
-    const task = tasks[index];
-    const isCritical = task.command.critical !== false; // Default to true
-    const updatedTaskInfos = tasks.map((task, i) => i === index ? { ...task, status: ExecutionStatus.Failed, elapsed } : task);
-    if (isCritical) {
-        // Critical failure - stop execution
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorCritical,
-                payload: { index, error },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: true,
-        };
-    }
-    // Non-critical failure - continue to next task
-    if (index < tasks.length - 1) {
-        return {
-            action: {
-                type: ExecuteActionType.TaskErrorContinue,
-                payload: { index, elapsed },
-            },
-            finalState: {
-                message,
-                summary,
-                tasks: updatedTaskInfos,
-                completionMessage: null,
-                error: null,
-            },
-            shouldComplete: false,
-        };
-    }
-    // Last task failed (non-critical), complete execution
-    // Non-critical failures still show completion message with summary
-    const summaryText = summary.trim() || 'Execution completed';
-    const totalElapsed = getTotalElapsed(updatedTaskInfos);
-    const completion = `${summaryText} in ${formatDuration(totalElapsed)}.`;
+    const updatedTasks = tasks.map((task, i) => {
+        if (i === index) {
+            return { ...task, status: ExecutionStatus.Failed, elapsed: 0 };
+        }
+        else if (i > index && task.status === ExecutionStatus.Pending) {
+            return { ...task, status: ExecutionStatus.Cancelled };
+        }
+        return task;
+    });
     return {
         action: {
-            type: ExecuteActionType.LastTaskError,
-            payload: { index, elapsed, summaryText },
+            type: ExecuteActionType.TaskError,
+            payload: { index, error },
         },
         finalState: {
             message,
             summary,
-            tasks: updatedTaskInfos,
-            completionMessage: completion,
+            tasks: updatedTasks,
+            completionMessage: null,
             error: null,
         },
-        shouldComplete: true,
     };
 }
 /**

package/dist/execution/reducer.js

@@ -33,84 +33,72 @@ export function executeReducer(state, action) {
             };
         case ExecuteActionType.TaskStarted: {
             const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Running }
+                ? {
+                    ...task,
+                    status: ExecutionStatus.Running,
+                    startTime: action.payload.startTime,
+                }
                 : task);
             return {
                 ...state,
                 tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.TaskComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskProgress: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
+                    output: action.payload.output,
                 }
                 : task);
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.AllTasksComplete: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.TaskComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
                     status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completionMessage: completion,
-            };
-        }
-        case ExecuteActionType.TaskErrorCritical: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
-                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
-                : task);
-            return {
-                ...state,
-                tasks: updatedTaskInfos,
-                error: action.payload.error,
+                tasks: updatedTasks,
             };
         }
-        case ExecuteActionType.TaskErrorContinue: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
+        case ExecuteActionType.ExecutionComplete: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
                 ? {
                     ...task,
-                    status: ExecutionStatus.Failed,
+                    status: ExecutionStatus.Success,
                     elapsed: action.payload.elapsed,
                 }
                 : task);
+            const totalElapsed = getTotalElapsed(updatedTasks);
+            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
+                completionMessage: completion,
             };
         }
-        case ExecuteActionType.LastTaskError: {
-            const updatedTaskInfos = state.tasks.map((task, i) => i === action.payload.index
-                ? {
-                    ...task,
-                    status: ExecutionStatus.Failed,
-                    elapsed: action.payload.elapsed,
-                }
+        case ExecuteActionType.TaskError: {
+            const updatedTasks = state.tasks.map((task, i) => i === action.payload.index
+                ? { ...task, status: ExecutionStatus.Failed, elapsed: 0 }
                 : task);
-            const totalElapsed = getTotalElapsed(updatedTaskInfos);
-            const completion = `${action.payload.summaryText} in ${formatDuration(totalElapsed)}.`;
             return {
                 ...state,
-                tasks: updatedTaskInfos,
-                completionMessage: completion,
+                tasks: updatedTasks,
+                error: action.payload.error,
             };
         }
         case ExecuteActionType.CancelExecution: {
             // Mark running task as aborted, pending tasks as cancelled
-            const updatedTaskInfos = state.tasks.map((task) => {
+            const updatedTasks = state.tasks.map((task) => {
                 if (task.status === ExecutionStatus.Running) {
                     return { ...task, status: ExecutionStatus.Aborted };
                 }
@@ -121,7 +109,7 @@ export function executeReducer(state, action) {
             });
             return {
                 ...state,
-                tasks: updatedTaskInfos,
+                tasks: updatedTasks,
             };
         }
         default:

package/dist/execution/runner.js

@@ -1,5 +1,14 @@
 import { ExecutionResult, ExecutionStatus, executeCommand, setOutputCallback, } from '../services/shell.js';
 import { calculateElapsed } from '../services/utils.js';
+// Maximum number of output lines to keep in memory
+const MAX_OUTPUT_LINES = 128;
+/**
+ * Limit output to last MAX_OUTPUT_LINES lines to prevent memory exhaustion
+ */
+function limitLines(output) {
+    const lines = output.split('\n');
+    return lines.slice(-MAX_OUTPUT_LINES).join('\n');
+}
 /**
  * Execute a single task and track its progress.
  * All execution logic is contained here, outside of React components.
@@ -17,21 +26,38 @@ export async function executeTask(command, index, callbacks) {
         error,
         workdir,
     });
+    // Throttle updates to avoid excessive re-renders (100ms minimum interval)
+    let lastUpdateTime = 0;
+    let pendingTimeout;
+    const throttledUpdate = () => {
+        const now = Date.now();
+        if (now - lastUpdateTime >= 100) {
+            lastUpdateTime = now;
+            callbacks.onUpdate(createOutput());
+        }
+        else if (!pendingTimeout) {
+            pendingTimeout = setTimeout(() => {
+                pendingTimeout = undefined;
+                lastUpdateTime = Date.now();
+                callbacks.onUpdate(createOutput());
+            }, 100 - (now - lastUpdateTime));
+        }
+    };
     // Set up output streaming callback
     setOutputCallback((data, stream) => {
         if (stream === 'stdout') {
-            stdout += data;
+            stdout = limitLines(stdout + data);
         }
         else {
-            stderr += data;
+            stderr = limitLines(stderr + data);
         }
-        callbacks.onOutputChange?.(createOutput());
+        throttledUpdate();
     });
-    callbacks.onStart?.();
     try {
         const result = await executeCommand(command, undefined, index);
-        // Clear callback
+        // Clear callback and pending timeout
         setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
         const elapsed = calculateElapsed(startTime);
         // Update final output from result
         stdout = result.output;
@@ -39,42 +65,34 @@ export async function executeTask(command, index, callbacks) {
         workdir = result.workdir;
         if (result.result === ExecutionResult.Success) {
             const output = createOutput();
-            callbacks.onComplete?.(elapsed, output);
-            return {
-                status: ExecutionStatus.Success,
-                elapsed,
-                output,
-            };
+            callbacks.onUpdate(output);
+            callbacks.onComplete(elapsed, output);
+            return { status: ExecutionStatus.Success, elapsed, output };
         }
         else {
             const errorMsg = result.errors || result.error || 'Command failed';
             error = errorMsg;
             const output = createOutput();
-            callbacks.onError?.(errorMsg, elapsed, output);
-            return {
-                status: ExecutionStatus.Failed,
-                elapsed,
-                output,
-            };
+            callbacks.onUpdate(output);
+            callbacks.onError(errorMsg, output);
+            return { status: ExecutionStatus.Failed, elapsed, output };
         }
     }
     catch (err) {
-        // Clear callback
+        // Clear callback and pending timeout
         setOutputCallback(undefined);
+        clearTimeout(pendingTimeout);
         const elapsed = calculateElapsed(startTime);
         const errorMsg = err instanceof Error ? err.message : 'Unknown error';
         error = errorMsg;
         const output = createOutput();
-        callbacks.onError?.(errorMsg, elapsed, output);
-        return {
-            status: ExecutionStatus.Failed,
-            elapsed,
-            output,
-        };
+        callbacks.onUpdate(output);
+        callbacks.onError(errorMsg, output);
+        return { status: ExecutionStatus.Failed, elapsed, output };
     }
 }
 /**
- * Create an empty task output
+ * Create an empty execution output
  */
 export function createEmptyOutput() {
     return { stdout: '', stderr: '', error: '' };

package/dist/execution/types.js

@@ -4,10 +4,9 @@ export var ExecuteActionType;
     ExecuteActionType["CommandsReady"] = "COMMANDS_READY";
     ExecuteActionType["ProcessingError"] = "PROCESSING_ERROR";
     ExecuteActionType["TaskStarted"] = "TASK_STARTED";
+    ExecuteActionType["TaskProgress"] = "TASK_PROGRESS";
     ExecuteActionType["TaskComplete"] = "TASK_COMPLETE";
-    ExecuteActionType["AllTasksComplete"] = "ALL_TASKS_COMPLETE";
-    ExecuteActionType["TaskErrorCritical"] = "TASK_ERROR_CRITICAL";
-    ExecuteActionType["TaskErrorContinue"] = "TASK_ERROR_CONTINUE";
-    ExecuteActionType["LastTaskError"] = "LAST_TASK_ERROR";
+    ExecuteActionType["ExecutionComplete"] = "EXECUTION_COMPLETE";
+    ExecuteActionType["TaskError"] = "TASK_ERROR";
     ExecuteActionType["CancelExecution"] = "CANCEL_EXECUTION";
 })(ExecuteActionType || (ExecuteActionType = {}));

package/dist/execution/utils.js

@@ -1,6 +1,6 @@
 import { ExecutionStatus } from '../services/shell.js';
 /**
- * Calculate total elapsed time from task infos
+ * Calculate total elapsed time from task data
  */
 export function getTotalElapsed(tasks) {
     return tasks.reduce((sum, task) => sum + task.elapsed, 0);

package/dist/index.js

@@ -5,7 +5,7 @@ import { dirname, join } from 'path';
 import { fileURLToPath } from 'url';
 import { render } from 'ink';
 import { DebugLevel } from './configuration/types.js';
-import { Main } from './ui/Main.js';
+import { Main } from './Main.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Get package info

package/dist/services/anthropic.js

@@ -1,7 +1,7 @@
 import Anthropic from '@anthropic-ai/sdk';
 import { getAvailableConfigStructure, getConfiguredKeys, } from '../configuration/schema.js';
 import { logPrompt, logResponse } from './logger.js';
-import { formatSkillsForPrompt, loadSkillsWithValidation } from './skills.js';
+import { loadSkillsForPrompt } from './skills.js';
 import { toolRegistry } from './registry.js';
 import { CommandResultSchema, IntrospectResultSchema, } from '../types/schemas.js';
 /**
@@ -69,36 +69,32 @@ export class AnthropicService {
     async processWithTool(command, toolName, customInstructions) {
         // Load tool from registry
         const tool = toolRegistry.getSchema(toolName);
-        // Use custom instructions if provided, otherwise load from registry
-        let systemPrompt;
-        if (customInstructions) {
-            // Custom instructions provided (typically for testing)
-            systemPrompt = customInstructions;
+        // Check if this tool uses skills
+        const usesSkills = toolName === 'schedule' ||
+            toolName === 'introspect' ||
+            toolName === 'execute' ||
+            toolName === 'validate';
+        // Load base instructions and skills
+        const baseInstructions = customInstructions || toolRegistry.getInstructions(toolName);
+        let formattedSkills = '';
+        let skillDefinitions = [];
+        let systemPrompt = baseInstructions;
+        if (!customInstructions && usesSkills) {
+            const skillsResult = loadSkillsForPrompt();
+            formattedSkills = skillsResult.formatted;
+            skillDefinitions = skillsResult.definitions;
+            systemPrompt += formattedSkills;
         }
-        else {
-            // Load and build system prompt automatically (production)
-            const instructions = toolRegistry.getInstructions(toolName);
-            systemPrompt = instructions;
-            // Add skills section for applicable tools
-            if (toolName === 'schedule' ||
-                toolName === 'introspect' ||
-                toolName === 'execute' ||
-                toolName === 'validate') {
-                const skills = loadSkillsWithValidation();
-                const skillsSection = formatSkillsForPrompt(skills);
-                systemPrompt += skillsSection;
-            }
-            // Add config structure for configure tool only
-            if (toolName === 'configure') {
-                const configStructure = getAvailableConfigStructure();
-                const configuredKeys = getConfiguredKeys();
-                const configSection = '\n## Available Configuration\n\n' +
-                    'Config structure (key: description):\n' +
-                    JSON.stringify(configStructure, null, 2) +
-                    '\n\nConfigured keys (keys that exist in config file):\n' +
-                    JSON.stringify(configuredKeys, null, 2);
-                systemPrompt += configSection;
-            }
+        // Add config structure for configure tool only
+        if (!customInstructions && toolName === 'configure') {
+            const configStructure = getAvailableConfigStructure();
+            const configuredKeys = getConfiguredKeys();
+            const configSection = '\n## Available Configuration\n\n' +
+                'Config structure (key: description):\n' +
+                JSON.stringify(configStructure, null, 2) +
+                '\n\nConfigured keys (keys that exist in config file):\n' +
+                JSON.stringify(configuredKeys, null, 2);
+            systemPrompt += configSection;
         }
         // Build tools array - add web search for answer tool
         const tools = [tool];
@@ -111,7 +107,7 @@ export class AnthropicService {
         // Collect debug components
         const debug = [];
         // Log prompt at Verbose level
-        const promptDebug = logPrompt(toolName, command, systemPrompt);
+        const promptDebug = logPrompt(toolName, command, baseInstructions, formattedSkills, skillDefinitions);
         if (promptDebug) {
             debug.push(promptDebug);
         }

package/dist/services/colors.js

@@ -20,6 +20,7 @@ export const Palette = {
     Yellow: '#cccc5c',
     Orange: '#f48c80',
     MediumOrange: '#d07560',
+    WarmOrange: '#ce985e',
     DarkOrange: '#ab5e40',
     BurntOrange: '#cc7a5c',
     Red: '#cc5c5c',
@@ -132,7 +133,7 @@ const taskColors = {
  */
 const feedbackColors = {
     [FeedbackType.Info]: Colors.Status.Info,
-    [FeedbackType.Warning]: Palette.Yellow,
+    [FeedbackType.Warning]: Palette.WarmOrange,
     [FeedbackType.Succeeded]: Colors.Status.Success,
     [FeedbackType.Aborted]: Palette.MediumOrange,
     [FeedbackType.Failed]: Colors.Status.Error,

package/dist/services/logger.js

@@ -1,7 +1,19 @@
 import { DebugLevel } from '../configuration/types.js';
-import { createDebug } from './components.js';
 import { loadDebugSetting } from '../configuration/io.js';
 import { Palette } from './colors.js';
+import { createDebug } from './components.js';
+/**
+ * Enum controlling what content is shown in debug prompt output
+ * - LLM: Exact prompt as sent to LLM (no display formatting)
+ * - Skills: Same content with visual separators for readability
+ * - Summary: Condensed view (Name, Steps, Execution only)
+ */
+export var PromptDisplay;
+(function (PromptDisplay) {
+    PromptDisplay["LLM"] = "llm";
+    PromptDisplay["Skills"] = "skills";
+    PromptDisplay["Summary"] = "summary";
+})(PromptDisplay || (PromptDisplay = {}));
 /**
  * Debug logger for the application
  * Logs information based on the current debug level setting
@@ -49,24 +61,125 @@ export function getWarnings() {
     warnings.length = 0;
     return result;
 }
+/**
+ * Content width for debug display (matches Debug component)
+ * Box width 80 - 2 borders - 4 padding = 74 chars
+ */
+const DISPLAY_CONTENT_WIDTH = 74;
+/**
+ * Join sections with separators matching display width
+ */
+function joinWithSeparators(sections) {
+    const separator = '-'.repeat(DISPLAY_CONTENT_WIDTH);
+    return sections.join('\n\n' + separator + '\n\n');
+}
+/**
+ * Format a single skill definition as summary markdown
+ */
+function formatSkillSummary(skill) {
+    const lines = [];
+    lines.push(`### Name`);
+    lines.push(skill.name);
+    lines.push('');
+    if (skill.steps.length > 0) {
+        lines.push(`### Steps`);
+        for (const step of skill.steps) {
+            lines.push(`- ${step}`);
+        }
+        lines.push('');
+    }
+    if (skill.execution.length > 0) {
+        lines.push(`### Execution`);
+        for (const cmd of skill.execution) {
+            lines.push(`- ${cmd}`);
+        }
+    }
+    return lines.join('\n').trim();
+}
+/**
+ * Format skill definitions as summary for debug display
+ * Shows only Name, Steps, and Execution with visual separators
+ */
+export function formatSkillsSummary(definitions) {
+    if (definitions.length === 0) {
+        return '(no skills)';
+    }
+    const header = '## Available Skills';
+    const skillSummaries = definitions.map(formatSkillSummary);
+    return joinWithSeparators([header, ...skillSummaries]);
+}
+/**
+ * Format skills section with visual separators for debug display
+ * Layout: Header description -> separator -> skills separated by lines
+ */
+function formatSkillsForDisplay(formattedSkills) {
+    if (!formattedSkills) {
+        return '(no skills)';
+    }
+    // Find the header (everything before first ### Name)
+    const firstNameIndex = formattedSkills.search(/^###\s+Name/m);
+    if (firstNameIndex === -1) {
+        return '(no skills)';
+    }
+    const header = formattedSkills.slice(0, firstNameIndex).trim();
+    const skillsContent = formattedSkills.slice(firstNameIndex);
+    // Split by ### Name to get individual skills
+    const skillParts = skillsContent
+        .split(/(?=^###\s+Name)/m)
+        .map((s) => s.trim())
+        .filter(Boolean);
+    if (skillParts.length === 0) {
+        return '(no skills)';
+    }
+    // Join header and skills with separators
+    return joinWithSeparators([header, ...skillParts]);
+}
+/**
+ * Format prompt content based on the specified detail level
+ *
+ * - LLM: Returns header + base instructions + formatted skills (as sent to LLM)
+ * - Skills: Returns header + skills with visual separators (no base instructions)
+ * - Summary: Returns header + skill summaries (Name, Steps, Execution)
+ */
+export function formatPromptContent(toolName, command, baseInstructions, formattedSkills, mode, definitions) {
+    const header = ['', `Tool: ${toolName}`, `Command: ${command}`];
+    switch (mode) {
+        case PromptDisplay.LLM:
+            return [...header, '', baseInstructions + formattedSkills].join('\n');
+        case PromptDisplay.Skills: {
+            // Layout: header -> separator -> skills with visual separators
+            const headerString = header.join('\n');
+            const skillsDisplay = formatSkillsForDisplay(formattedSkills);
+            return joinWithSeparators([headerString, skillsDisplay]);
+        }
+        case PromptDisplay.Summary: {
+            const headerString = header.join('\n');
+            const summary = definitions
+                ? formatSkillsSummary(definitions)
+                : '(no skills)';
+            return joinWithSeparators([headerString, summary]);
+        }
+    }
+}
 /**
  * Create debug component for system prompts sent to the LLM
  * Only creates at Verbose level
+ *
+ * @param toolName - Name of the tool being invoked
+ * @param command - User command being processed
+ * @param baseInstructions - Base tool instructions (without skills)
+ * @param formattedSkills - Formatted skills section (as sent to LLM)
+ * @param definitions - Parsed skill definitions for summary display
  */
-export function logPrompt(toolName, command, instructions) {
+export function logPrompt(toolName, command, baseInstructions, formattedSkills, definitions = []) {
     if (currentDebugLevel !== DebugLevel.Verbose) {
         return null;
     }
-    const content = [
-        '',
-        `Tool: ${toolName}`,
-        `Command: ${command}`,
-        '',
-        instructions,
-    ].join('\n');
-    // Calculate stats for the instructions
-    const lines = instructions.split('\n').length;
-    const bytes = Buffer.byteLength(instructions, 'utf-8');
+    const content = formatPromptContent(toolName, command, baseInstructions, formattedSkills, PromptDisplay.Summary, definitions);
+    // Calculate stats for the full prompt
+    const fullPrompt = baseInstructions + formattedSkills;
+    const lines = fullPrompt.split('\n').length;
+    const bytes = Buffer.byteLength(fullPrompt, 'utf-8');
     const title = `SYSTEM PROMPT (${String(lines)} lines, ${String(bytes)} bytes)`;
     return createDebug({ title, content, color: Palette.Gray });
 }
@@ -85,5 +198,5 @@ export function logResponse(toolName, response, durationMs) {
         JSON.stringify(response, null, 2),
     ].join('\n');
     const title = `LLM RESPONSE (${String(durationMs)} ms)`;
-    return createDebug({ title, content, color: Palette.AshGray });
+    return createDebug({ title, content, color: Palette.LightGray });
 }

package/dist/services/messages.js

@@ -162,3 +162,22 @@ export function getExecutionErrorMessage(_error) {
     ];
     return messages[Math.floor(Math.random() * messages.length)];
 }
+/**
+ * Returns a loading message while fetching an answer.
+ * Randomly selects from variations to sound natural.
+ */
+export function getAnswerLoadingMessage() {
+    const messages = [
+        'Finding that out for you.',
+        'Looking into this.',
+        'Let me find out.',
+        'One moment please.',
+        'Checking on that.',
+        'Let me look that up.',
+        'Give me a moment.',
+        'Looking that up now.',
+        'Let me check.',
+        'Just a moment.',
+    ];
+    return messages[Math.floor(Math.random() * messages.length)];
+}