@wonderwhy-er/desktop-commander 0.2.16 → 0.2.18-alpha.0

package/dist/server.js

@@ -8,7 +8,7 @@ const OS_GUIDANCE = getOSSpecificGuidance(SYSTEM_INFO);
 const DEV_TOOL_GUIDANCE = getDevelopmentToolGuidance(SYSTEM_INFO);
 const PATH_GUIDANCE = `IMPORTANT: ${getPathGuidance(SYSTEM_INFO)} Relative paths may fail as they depend on the current working directory. Tilde paths (~/...) might not work in all contexts. Unless the user explicitly asks for relative paths, use absolute paths.`;
 const CMD_PREFIX_DESCRIPTION = `This command can be referenced as "DC: ..." or "use Desktop Commander to ..." in your instructions.`;
-import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, } from './tools/schemas.js';
+import { StartProcessArgsSchema, ReadProcessOutputArgsSchema, InteractWithProcessArgsSchema, ForceTerminateArgsSchema, ListSessionsArgsSchema, KillProcessArgsSchema, ReadFileArgsSchema, ReadMultipleFilesArgsSchema, WriteFileArgsSchema, CreateDirectoryArgsSchema, ListDirectoryArgsSchema, MoveFileArgsSchema, GetFileInfoArgsSchema, GetConfigArgsSchema, SetConfigValueArgsSchema, ListProcessesArgsSchema, EditBlockArgsSchema, GetUsageStatsArgsSchema, GiveFeedbackArgsSchema, StartSearchArgsSchema, GetMoreSearchResultsArgsSchema, StopSearchArgsSchema, ListSearchesArgsSchema, GetPromptsArgsSchema, GetRecentToolCallsArgsSchema, } from './tools/schemas.js';
 import { getConfig, setConfigValue } from './tools/config.js';
 import { getUsageStats } from './tools/usage.js';
 import { giveFeedbackToDesktopCommander } from './tools/feedback.js';
@@ -16,6 +16,7 @@ import { getPrompts } from './tools/prompts.js';
 import { trackToolCall } from './utils/trackTools.js';
 import { usageTracker } from './utils/usageTracker.js';
 import { processDockerPrompt } from './utils/dockerPrompt.js';
+import { toolHistory } from './utils/toolHistory.js';
 import { VERSION } from './version.js';
 import { capture, capture_call_tool } from "./utils/capture.js";
 import { logToStderr, logger } from './utils/logger.js';
@@ -95,15 +96,27 @@ server.setRequestHandler(InitializeRequestSchema, async (request) => {
 // Export current client info for access by other modules
 export { currentClient };
 deferLog('info', 'Setting up request handlers...');
+/**
+ * Check if a tool should be included based on current client
+ */
+function shouldIncludeTool(toolName) {
+    // Exclude give_feedback_to_desktop_commander for desktop-commander client
+    if (toolName === 'give_feedback_to_desktop_commander' && currentClient?.name === 'desktop-commander') {
+        return false;
+    }
+    // Add more conditional tool logic here as needed
+    // Example: if (toolName === 'some_tool' && currentClient?.name === 'some_client') return false;
+    return true;
+}
 server.setRequestHandler(ListToolsRequestSchema, async () => {
     try {
         logToStderr('debug', 'Generating tools list...');
-        return {
-            tools: [
-                // Configuration tools
-                {
-                    name: "get_config",
-                    description: `
+        // Build complete tools array
+        const allTools = [
+            // Configuration tools
+            {
+                name: "get_config",
+                description: `
                         Get the complete server configuration as JSON. Config includes fields for:
                         - blockedCommands (array of blocked shell commands)
                         - defaultShell (shell to use for commands)
@@ -116,15 +129,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - version (version of the DesktopCommander)
                         - systemInfo (operating system and environment details)
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetConfigArgsSchema),
-                    annotations: {
-                        title: "Get Configuration",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(GetConfigArgsSchema),
+                annotations: {
+                    title: "Get Configuration",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "set_config_value",
-                    description: `
+            },
+            {
+                name: "set_config_value",
+                description: `
                         Set a specific configuration value by key.
                         
                         WARNING: Should be used in a separate chat from file operations and 
@@ -142,18 +155,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         to the entire file system, regardless of the operating system.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
-                    annotations: {
-                        title: "Set Configuration Value",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(SetConfigValueArgsSchema),
+                annotations: {
+                    title: "Set Configuration Value",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                // Filesystem tools
-                {
-                    name: "read_file",
-                    description: `
+            },
+            // Filesystem tools
+            {
+                name: "read_file",
+                description: `
                         Read the contents of a file from the file system or a URL with optional offset and length parameters.
                         
                         Prefer this over 'execute_command' with cat/type for viewing files.
@@ -186,16 +199,16 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadFileArgsSchema),
-                    annotations: {
-                        title: "Read File or URL",
-                        readOnlyHint: true,
-                        openWorldHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ReadFileArgsSchema),
+                annotations: {
+                    title: "Read File or URL",
+                    readOnlyHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "read_multiple_files",
-                    description: `
+            },
+            {
+                name: "read_multiple_files",
+                description: `
                         Read the contents of multiple files simultaneously.
                         
                         Each file's content is returned with its path as a reference.
@@ -207,15 +220,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
-                    annotations: {
-                        title: "Read Multiple Files",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ReadMultipleFilesArgsSchema),
+                annotations: {
+                    title: "Read Multiple Files",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "write_file",
-                    description: `
+            },
+            {
+                name: "write_file",
+                description: `
                         Write or append to file contents. 
 
                         CHUNKING IS STANDARD PRACTICE: Always write files in chunks of 25-30 lines maximum.
@@ -244,17 +257,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(WriteFileArgsSchema),
-                    annotations: {
-                        title: "Write File",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(WriteFileArgsSchema),
+                annotations: {
+                    title: "Write File",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "create_directory",
-                    description: `
+            },
+            {
+                name: "create_directory",
+                description: `
                         Create a new directory or ensure a directory exists.
                         
                         Can create multiple nested directories in one operation.
@@ -262,28 +275,49 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
-                },
-                {
-                    name: "list_directory",
-                    description: `
+                inputSchema: zodToJsonSchema(CreateDirectoryArgsSchema),
+            },
+            {
+                name: "list_directory",
+                description: `
                         Get a detailed listing of all files and directories in a specified path.
                         
                         Use this instead of 'execute_command' with ls/dir commands.
                         Results distinguish between files and directories with [FILE] and [DIR] prefixes.
+                        
+                        Supports recursive listing with the 'depth' parameter (default: 2):
+                        - depth=1: Only direct contents of the directory
+                        - depth=2: Contents plus one level of subdirectories
+                        - depth=3+: Multiple levels deep
+                        
+                        CONTEXT OVERFLOW PROTECTION:
+                        - Top-level directory shows ALL items
+                        - Nested directories are limited to 100 items maximum per directory
+                        - When a nested directory has more than 100 items, you'll see a warning like:
+                          [WARNING] node_modules: 500 items hidden (showing first 100 of 600 total)
+                        - This prevents overwhelming the context with large directories like node_modules
+                        
+                        Results show full relative paths from the root directory being listed.
+                        Example output with depth=2:
+                        [DIR] src
+                        [FILE] src/index.ts
+                        [DIR] src/tools
+                        [FILE] src/tools/filesystem.ts
+                        
+                        If a directory cannot be accessed, it will show [DENIED] instead.
                         Only works within allowed directories.
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
-                    annotations: {
-                        title: "List Directory Contents",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ListDirectoryArgsSchema),
+                annotations: {
+                    title: "List Directory Contents",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "move_file",
-                    description: `
+            },
+            {
+                name: "move_file",
+                description: `
                         Move or rename files and directories.
                         
                         Can move files between directories and rename them in a single operation.
@@ -291,17 +325,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(MoveFileArgsSchema),
-                    annotations: {
-                        title: "Move/Rename File",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(MoveFileArgsSchema),
+                annotations: {
+                    title: "Move/Rename File",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "start_search",
-                    description: `
+            },
+            {
+                name: "start_search",
+                description: `
                         Start a streaming search that can return results progressively.
                         
                         SEARCH STRATEGY GUIDE:
@@ -380,11 +414,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StartSearchArgsSchema),
-                },
-                {
-                    name: "get_more_search_results",
-                    description: `
+                inputSchema: zodToJsonSchema(StartSearchArgsSchema),
+            },
+            {
+                name: "get_more_search_results",
+                description: `
                         Get more results from an active search with offset-based pagination.
                         
                         Supports partial result reading with:
@@ -406,15 +440,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         results from a search started with start_search.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
-                    annotations: {
-                        title: "Get Search Results",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(GetMoreSearchResultsArgsSchema),
+                annotations: {
+                    title: "Get Search Results",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "stop_search",
-                    description: `
+            },
+            {
+                name: "stop_search",
+                description: `
                         Stop an active search.
                         
                         Stops the background search process gracefully. Use this when you've found
@@ -425,11 +459,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         automatically cleaned up after 5 minutes.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StopSearchArgsSchema),
-                },
-                {
-                    name: "list_searches",
-                    description: `
+                inputSchema: zodToJsonSchema(StopSearchArgsSchema),
+            },
+            {
+                name: "list_searches",
+                description: `
                         List all active searches.
                         
                         Shows search IDs, search types, patterns, status, and runtime.
@@ -437,15 +471,15 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         multiple concurrent searches.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
-                    annotations: {
-                        title: "List Active Searches",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ListSearchesArgsSchema),
+                annotations: {
+                    title: "List Active Searches",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "get_file_info",
-                    description: `
+            },
+            {
+                name: "get_file_info",
+                description: `
                         Retrieve detailed metadata about a file or directory including:
                         - size
                         - creation time
@@ -460,17 +494,17 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
-                    annotations: {
-                        title: "Get File Information",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(GetFileInfoArgsSchema),
+                annotations: {
+                    title: "Get File Information",
+                    readOnlyHint: true,
                 },
-                // Note: list_allowed_directories removed - use get_config to check allowedDirectories
-                // Text editing tools
-                {
-                    name: "edit_block",
-                    description: `
+            },
+            // Note: list_allowed_directories removed - use get_config to check allowedDirectories
+            // Text editing tools
+            {
+                name: "edit_block",
+                description: `
                         Apply surgical text replacements to files.
                         
                         BEST PRACTICE: Make multiple small, focused edits rather than one large edit.
@@ -503,18 +537,18 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(EditBlockArgsSchema),
-                    annotations: {
-                        title: "Edit Text Block",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(EditBlockArgsSchema),
+                annotations: {
+                    title: "Edit Text Block",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                // Terminal tools
-                {
-                    name: "start_process",
-                    description: `
+            },
+            // Terminal tools
+            {
+                name: "start_process",
+                description: `
                         Start a new terminal process with intelligent state detection.
                         
                         PRIMARY TOOL FOR FILE ANALYSIS AND DATA PROCESSING
@@ -557,25 +591,33 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         
                         STATES DETECTED:
                         Process waiting for input (shows prompt)
-                        Process finished execution  
+                        Process finished execution
                         Process running (use read_process_output)
-                        
+
+                        PERFORMANCE DEBUGGING (verbose_timing parameter):
+                        Set verbose_timing: true to get detailed timing information including:
+                        - Exit reason (early_exit_quick_pattern, early_exit_periodic_check, process_exit, timeout)
+                        - Total duration and time to first output
+                        - Complete timeline of all output events with timestamps
+                        - Which detection mechanism triggered early exit
+                        Use this to identify missed optimization opportunities and improve detection patterns.
+
                         ALWAYS USE FOR: Local file analysis, CSV processing, data exploration, system commands
                         NEVER USE ANALYSIS TOOL FOR: Local file access (analysis tool is browser-only and WILL FAIL)
-                        
+
                         ${PATH_GUIDANCE}
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(StartProcessArgsSchema),
-                    annotations: {
-                        title: "Start Terminal Process",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: true,
-                    },
+                inputSchema: zodToJsonSchema(StartProcessArgsSchema),
+                annotations: {
+                    title: "Start Terminal Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "read_process_output",
-                    description: `
+            },
+            {
+                name: "read_process_output",
+                description: `
                         Read output from a running process with intelligent completion detection.
                         
                         Automatically detects when process is ready for more input instead of timing out.
@@ -596,17 +638,25 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Process waiting for input (ready for interact_with_process)
                         Process finished execution
                         Timeout reached (may still be running)
-                        
+
+                        PERFORMANCE DEBUGGING (verbose_timing parameter):
+                        Set verbose_timing: true to get detailed timing information including:
+                        - Exit reason (early_exit_quick_pattern, early_exit_periodic_check, process_finished, timeout)
+                        - Total duration and time to first output
+                        - Complete timeline of all output events with timestamps
+                        - Which detection mechanism triggered early exit
+                        Use this to identify when timeouts could be reduced or detection patterns improved.
+
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
-                    annotations: {
-                        title: "Read Process Output",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ReadProcessOutputArgsSchema),
+                annotations: {
+                    title: "Read Process Output",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "interact_with_process",
-                    description: `
+            },
+            {
+                name: "interact_with_process",
+                description: `
                         Send input to a running process and automatically receive the response.
                         
                         CRITICAL: THIS IS THE PRIMARY TOOL FOR ALL LOCAL FILE ANALYSIS
@@ -647,38 +697,47 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - input: Code/command to execute
                         - timeout_ms: Max wait (default: 8000ms)
                         - wait_for_prompt: Auto-wait for response (default: true)
-                        
+                        - verbose_timing: Enable detailed performance telemetry (default: false)
+
                         Returns execution result with status indicators.
-                        
+
+                        PERFORMANCE DEBUGGING (verbose_timing parameter):
+                        Set verbose_timing: true to get detailed timing information including:
+                        - Exit reason (early_exit_quick_pattern, early_exit_periodic_check, process_finished, timeout, no_wait)
+                        - Total duration and time to first output
+                        - Complete timeline of all output events with timestamps
+                        - Which detection mechanism triggered early exit
+                        Use this to identify slow interactions and optimize detection patterns.
+
                         ALWAYS USE FOR: CSV analysis, JSON processing, file statistics, data visualization prep, ANY local file work
                         NEVER USE ANALYSIS TOOL FOR: Local file access (it cannot read files from disk and WILL FAIL)
-                        
+
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(InteractWithProcessArgsSchema),
-                    annotations: {
-                        title: "Send Input to Process",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: true,
-                    },
+                inputSchema: zodToJsonSchema(InteractWithProcessArgsSchema),
+                annotations: {
+                    title: "Send Input to Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: true,
                 },
-                {
-                    name: "force_terminate",
-                    description: `
+            },
+            {
+                name: "force_terminate",
+                description: `
                         Force terminate a running terminal session.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
-                    annotations: {
-                        title: "Force Terminate Process",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(ForceTerminateArgsSchema),
+                annotations: {
+                    title: "Force Terminate Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "list_sessions",
-                    description: `
+            },
+            {
+                name: "list_sessions",
+                description: `
                         List all active terminal sessions.
                         
                         Shows session status including:
@@ -692,59 +751,80 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         - Long runtime with blocked status may indicate stuck process
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
-                    annotations: {
-                        title: "List Terminal Sessions",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ListSessionsArgsSchema),
+                annotations: {
+                    title: "List Terminal Sessions",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "list_processes",
-                    description: `
+            },
+            {
+                name: "list_processes",
+                description: `
                         List all running processes.
                         
                         Returns process information including PID, command name, CPU usage, and memory usage.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
-                    annotations: {
-                        title: "List Running Processes",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(ListProcessesArgsSchema),
+                annotations: {
+                    title: "List Running Processes",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "kill_process",
-                    description: `
+            },
+            {
+                name: "kill_process",
+                description: `
                         Terminate a running process by PID.
                         
                         Use with caution as this will forcefully terminate the specified process.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(KillProcessArgsSchema),
-                    annotations: {
-                        title: "Kill Process",
-                        readOnlyHint: false,
-                        destructiveHint: true,
-                        openWorldHint: false,
-                    },
+                inputSchema: zodToJsonSchema(KillProcessArgsSchema),
+                annotations: {
+                    title: "Kill Process",
+                    readOnlyHint: false,
+                    destructiveHint: true,
+                    openWorldHint: false,
                 },
-                {
-                    name: "get_usage_stats",
-                    description: `
+            },
+            {
+                name: "get_usage_stats",
+                description: `
                         Get usage statistics for debugging and analysis.
                         
                         Returns summary of tool usage, success/failure rates, and performance metrics.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetUsageStatsArgsSchema),
-                    annotations: {
-                        title: "Get Usage Statistics",
-                        readOnlyHint: true,
-                    },
+                inputSchema: zodToJsonSchema(GetUsageStatsArgsSchema),
+                annotations: {
+                    title: "Get Usage Statistics",
+                    readOnlyHint: true,
                 },
-                {
-                    name: "give_feedback_to_desktop_commander",
-                    description: `
+            },
+            {
+                name: "get_recent_tool_calls",
+                description: `
+                        Get recent tool call history with their arguments and outputs.
+                        Returns chronological list of tool calls made during this session.
+                        
+                        Useful for:
+                        - Onboarding new chats about work already done
+                        - Recovering context after chat history loss
+                        - Debugging tool call sequences
+                        
+                        Note: Does not track its own calls or other meta/query tools.
+                        History kept in memory (last 1000 calls, lost on restart).
+                        
+                        ${CMD_PREFIX_DESCRIPTION}`,
+                inputSchema: zodToJsonSchema(GetRecentToolCallsArgsSchema),
+                annotations: {
+                    title: "Get Recent Tool Calls",
+                    readOnlyHint: true,
+                },
+            },
+            {
+                name: "give_feedback_to_desktop_commander",
+                description: `
                         Open feedback form in browser to provide feedback about Desktop Commander.
                         
                         IMPORTANT: This tool simply opens the feedback form - no pre-filling available.
@@ -777,11 +857,11 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         No parameters are needed - just call the tool to open the form.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GiveFeedbackArgsSchema),
-                },
-                {
-                    name: "get_prompts",
-                    description: `
+                inputSchema: zodToJsonSchema(GiveFeedbackArgsSchema),
+            },
+            {
+                name: "get_prompts",
+                description: `
                         Browse and retrieve curated Desktop Commander prompts for various tasks and workflows.
                         
                         IMPORTANT: When displaying prompt lists to users, do NOT show the internal prompt IDs (like 'onb_001'). 
@@ -811,9 +891,14 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
                         Perfect for discovering proven workflows and getting started with Desktop Commander.
                         
                         ${CMD_PREFIX_DESCRIPTION}`,
-                    inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
-                },
-            ],
+                inputSchema: zodToJsonSchema(GetPromptsArgsSchema),
+            },
+        ];
+        // Filter tools based on current client
+        const filteredTools = allTools.filter(tool => shouldIncludeTool(tool.name));
+        logToStderr('debug', `Returning ${filteredTools.length} tools (filtered from ${allTools.length} total) for client: ${currentClient?.name || 'unknown'}`);
+        return {
+            tools: filteredTools,
         };
     }
     catch (error) {
@@ -824,6 +909,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 import * as handlers from './handlers/index.js';
 server.setRequestHandler(CallToolRequestSchema, async (request) => {
     const { name, arguments: args } = request.params;
+    const startTime = Date.now();
     try {
         // Prepare telemetry data - add config key for set_config_value
         const telemetryData = { name };
@@ -960,6 +1046,18 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     };
                 }
                 break;
+            case "get_recent_tool_calls":
+                try {
+                    result = await handlers.handleGetRecentToolCalls(args);
+                }
+                catch (error) {
+                    capture('server_request_error', { message: `Error in get_recent_tool_calls handler: ${error}` });
+                    result = {
+                        content: [{ type: "text", text: `Error: Failed to get tool call history` }],
+                        isError: true,
+                    };
+                }
+                break;
             case "give_feedback_to_desktop_commander":
                 try {
                     result = await giveFeedbackToDesktopCommander(args);
@@ -1040,6 +1138,14 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     isError: true,
                 };
         }
+        // Add tool call to history (exclude only get_recent_tool_calls to prevent recursion)
+        const duration = Date.now() - startTime;
+        const EXCLUDED_TOOLS = [
+            'get_recent_tool_calls'
+        ];
+        if (!EXCLUDED_TOOLS.includes(name)) {
+            toolHistory.addCall(name, args, result, duration);
+        }
         // Track success or failure based on result
         if (result.isError) {
             await usageTracker.trackFailure(name);