ziya 0.3.0__py3-none-any.whl → 0.3.2__py3-none-any.whl

app/extensions/prompt_extensions/claude_extensions.py

@@ -39,8 +39,30 @@ CLAUDE FAMILY INSTRUCTIONS:
 4. Use XML tags for structured outputs when appropriate
 5. Your job is not to proclaim the greatness of the user or the success of your efforts. You are being engaged, at each exchange, to solve a problem, not to congratulate yourself or the user. Look for the problem not the success.
 
+TOOL USAGE PRIORITIZATION:
+1. **Answer from available context first** - If information is available in the provided codebase, files, or conversation context, use that directly
+2. **Avoid redundant file access** - If file contents or directory structures are already included in the context, DO NOT use tools like `cat`, `ls`, or `find` to re-examine the same files or directories
+3. **Use reasoning and analysis** - Apply your knowledge and analytical capabilities before reaching for tools  
+4. **Use tools for computational analysis** - DO use tools like `grep`, `sort`, `uniq`, `wc`, `sed`, etc. on provided context when you need discrete numerical values, counts, or precise pattern matching that requires computational accuracy
+5. **Tools are secondary for discovery** - Only use discovery tools when:
+   - Information cannot be determined from available context
+   - You need to perform an action (like running code, checking files, etc.)
+   - The user explicitly requests tool usage
+   - You need to check for changes since the context was captured
+6. **Don't duplicate context unnecessarily** - Avoid using tools to re-fetch information you already have
+
+CONTEXT UTILIZATION:
+When file contents, directory listings, or code structures are already provided in your context:
+- Analyze that information directly rather than using tools to re-examine the same files or directories
+- BUT use computational tools (grep, sort, uniq, wc, sed, etc.) when you need precise counts, numerical analysis, or pattern matching that requires computational accuracy
+- The goal is to avoid redundant file access while still leveraging tools for their computational strengths
+
 TOOL EXECUTION AND CONTINUATION:
-When you need to use a tool:
+
+INTERNAL CONTEXT CHECK:
+Before using any tools, silently assess: "Do I already have the information needed in my provided context?" Only proceed with tools if the answer is clearly "no."
+
+When you have determined that a tool is necessary:
 1. Introduce what you're about to do
 2. Execute the tool call
 3. **STOP IMMEDIATELY after </TOOL_SENTINEL>** - DO NOT CONTINUE YOUR RESPONSE
@@ -48,10 +70,10 @@ When you need to use a tool:
 5. **DO NOT** guess what the tool output will be
 6. **DO NOT** write "Based on the result..." or similar text
 7. **WAIT** for the actual tool result to be provided
- 
-After I provide the tool result, I will ask you to continue. Only then should you resume your response.
- 
-Example: "I'll check the current directory." [TOOL CALL] [STOP AND WAIT] [TOOL RESULT PROVIDED] "Based on the result, the current directory is..."
+
+CRITICAL: Use ONLY native tool calling. Never generate fake tool calling syntax like ```tool:mcp_run_shell_command. Use the provided tools directly. Regular markdown code blocks like ```bash for examples are perfectly fine.
+
+If the provided context doesn't fully answer the user's request, use tools to gather the missing information. However, if file contents or directory structures are already shown in the context, work with that information directly instead of re-examining files. When you find relevant files through exploration, examine their contents. Check that all the required parameters for each tool call are provided or can reasonably be inferred from context. IF there are no relevant tools or there are missing values for required parameters, ask the user to supply these values; otherwise proceed with the tool calls. If the user provides a specific value for a parameter (for example provided in quotes), make sure to use that value EXACTLY. DO NOT make up values for or ask about optional parameters. Carefully analyze descriptive terms in the request as they may indicate required parameter values that should be included even if not explicitly quoted.
 """
     
     # Find a good place to insert the instructions

app/extensions/prompt_extensions/mcp_prompt_extensions.py

@@ -61,16 +61,28 @@ def mcp_usage_guidelines(prompt: str, context: dict) -> str:
         logger.info("MCP_GUIDELINES: Skipping for gemini-2.5-pro due to prompt size limits")
         return prompt
     
+    # Check if MCP is enabled
+    import os
+    if not os.environ.get("ZIYA_ENABLE_MCP", "true").lower() in ("true", "1", "yes"):
+        logger.info("MCP_GUIDELINES: MCP is disabled, returning original prompt")
+        return prompt
+    
     # Check if MCP tools are available in the context
     # This would be passed from the agent system when MCP is initialized
-    mcp_tools_available = context.get("mcp_tools_available", False)
-    from app.mcp.tools import create_mcp_tools
-    all_mcp_tools = create_mcp_tools()
-    available_tools = [tool.name for tool in all_mcp_tools]
+    # Get server-specific tools only (exclude MCPResourceTool which is always present)
+    try:
+        from app.mcp.manager import get_mcp_manager
+        mcp_manager = get_mcp_manager()
+        server_tools = mcp_manager.get_all_tools() if mcp_manager.is_initialized else []
+        available_tools = [f"mcp_{tool.name}" if not tool.name.startswith("mcp_") else tool.name for tool in server_tools]
+    except Exception as e:
+        logger.warning(f"Could not get MCP server tools: {e}")
+        available_tools = []
     
     if not available_tools:
         logger.info("MCP_GUIDELINES: No MCP tools available or list is empty, returning original prompt.")
         return prompt
+
  
     # For Google models, native function calling is used. Do not add XML tool instructions.
     if is_google_endpoint:
@@ -87,6 +99,19 @@ def mcp_usage_guidelines(prompt: str, context: dict) -> str:
         # For other models (Bedrock, etc.), provide XML-based tool instructions
         mcp_guidelines = """
 
+🚨 CRITICAL FILE MODIFICATION PROHIBITION 🚨
+═══════════════════════════════════════════════
+NEVER use tools to:
+- Copy files (cp, backup, etc.)
+- Modify files directly (sed, awk, etc.) 
+- Create new files
+- Move or rename files
+- Change file permissions
+
+ONLY suggest changes through Git diff patches in your response text.
+If you catch yourself about to modify a file with a tool - STOP and provide a diff instead.
+═══════════════════════════════════════════════
+
 ## MCP Tool Usage - CRITICAL INSTRUCTIONS
 **EXECUTE TOOLS WHEN REQUESTED - Never simulate or describe what you would do.**
 
@@ -96,13 +121,33 @@ def mcp_usage_guidelines(prompt: str, context: dict) -> str:
 """ + _get_tool_call_formats_from_mcp(available_tools) + """
 
 **Usage Rules:**
-0. **Prefer local context and AST over tools when either can provide similar information**
-1. **Always use actual tool results** - Never fabricate output
-2. **Shell commands**: Use read-only commands (ls, cat, grep) when possible; format output as terminal session
-3. **Time queries**: Always use tool rather than guessing current time
-4. **Error handling**: Show actual errors and try alternatives
-5. **Verification**: Use tools to verify system state rather than making assumptions
-6. **No Empty Calls**: Do not generate empty or incomplete tool calls. Only output a tool call block if you have a valid command to execute.
+0. **Answer from context first** - Only use tools when you need information not available in the provided context
+1. **Prefer local context and AST over tools** when either can provide similar information
+2. **When using tools, use actual results** - Never fabricate output
+
+⚠️  BEFORE EVERY TOOL CALL ASK YOURSELF: ⚠️
+"Do I need information not in the context? Am I about to modify a file? If modifying files, I must provide a Git diff patch instead!"
+3. **Shell commands**: Use read-only commands (ls, cat, grep) when possible; format output as terminal session
+4. **Time queries**: Use tool only when current time is actually needed
+5. **Error handling**: Show actual errors and try alternatives
+6. **Verification**: Use tools to verify system state only when assumptions aren't sufficient
+7. **No Empty Calls**: Do not generate empty or incomplete tool calls. Only output a tool call block if you have a valid command to execute.
+"""
+
+        # Add shell-specific warning if shell command tool is available
+        if any("shell" in tool.lower() or "run_shell_command" in tool for tool in available_tools):
+            mcp_guidelines += """
+
+🛑 SHELL COMMAND RESTRICTIONS 🛑
+Tools are for READING and ANALYZING code, not changing it.
+When using shell commands, stick to read-only operations like:
+- ls, find, grep, cat, head, tail, wc, du, df
+- git status, git log, git show, git diff
+
+PROHIBITED shell operations:
+- File modifications: cp, mv, rm, touch, mkdir, chmod, chown
+- Text editing: sed, awk with -i, nano, vim, echo >
+- System changes: sudo, su, systemctl, service
 """
 
     logger.info(f"MCP_GUIDELINES: Original prompt length: {len(prompt)}")
@@ -112,13 +157,8 @@ def mcp_usage_guidelines(prompt: str, context: dict) -> str:
     logger.info(f"MCP_GUIDELINES: Last 500 chars of modified prompt: ...{modified_prompt[-500:]}")
     return modified_prompt
 
-def _get_tool_description(tool_name: str) -> str:
-    """Get a brief description of what an MCP tool is used for."""
-    descriptions = {
-        "mcp_get_current_time": "checking current system time and date",
-        "mcp_run_shell_command": "executing safe shell commands to inspect system state", 
-    }
-    return descriptions.get(tool_name, "specialized system operations")
+# Removed _get_tool_description() function as it was hardcoding shell tool descriptions
+# even when shell server was disabled. Now we only show descriptions for actually enabled tools.
 
 def _get_tool_descriptions_from_mcp(available_tools: list) -> str:
     """Get tool descriptions from actual MCP tool definitions."""
@@ -130,6 +170,7 @@ def _get_tool_descriptions_from_mcp(available_tools: list) -> str:
         
         if mcp_manager.is_initialized:
             # Get all MCP tools with their descriptions
+            # This already filters by enabled servers only
             mcp_tools = mcp_manager.get_all_tools()
             tool_map = {tool.name: tool.description for tool in mcp_tools}
             
@@ -138,20 +179,23 @@ def _get_tool_descriptions_from_mcp(available_tools: list) -> str:
                 clean_name = tool_name[4:] if tool_name.startswith("mcp_") else tool_name
                 description = tool_map.get(clean_name, "Specialized system operations")
                 
-                display_name = f"mcp_{clean_name}" if not tool_name.startswith("mcp_") else tool_name
-                tool_descriptions.append(f"- **{display_name}**: {description}")
+                # Only add description if the tool is actually available from enabled servers
+                if clean_name in tool_map:
+                    display_name = f"mcp_{clean_name}" if not tool_name.startswith("mcp_") else tool_name
+                    tool_descriptions.append(f"- **{display_name}**: {description}")
         else:
-            # Fallback if MCP manager not initialized
-            for tool_name in available_tools:
-                display_name = f"mcp_{tool_name}" if not tool_name.startswith("mcp_") else tool_name
-                tool_descriptions.append(f"- **{display_name}**: Specialized system operations")
+            # If MCP manager not initialized, don't show any tool descriptions
+            logger.warning("MCP manager not initialized, no tool descriptions available")
+            return ""
                 
     except Exception as e:
         logger.warning(f"Could not get MCP tool descriptions: {e}")
-        # Fallback to generic descriptions
-        for tool_name in available_tools:
-            display_name = f"mcp_{tool_name}" if not tool_name.startswith("mcp_") else tool_name
-            tool_descriptions.append(f"- **{display_name}**: Specialized system operations")
+        # Don't provide fallback descriptions - only show what's actually available
+        return ""
+    
+    if not tool_descriptions:
+        logger.info("No tool descriptions available from enabled servers")
+        return "No tools currently available."
     
     return "\n".join(tool_descriptions)
 
@@ -164,7 +208,7 @@ def _get_tool_call_formats_from_mcp(available_tools: list) -> str:
         if not mcp_manager.is_initialized:
             return _get_fallback_tool_formats(available_tools)
             
-        # Get all MCP tools with their schemas
+        # Get all MCP tools with their schemas (already filters by enabled servers only)
         mcp_tools = mcp_manager.get_all_tools()
         tool_schemas = {tool.name: tool.inputSchema for tool in mcp_tools}
         
@@ -174,8 +218,9 @@ def _get_tool_call_formats_from_mcp(available_tools: list) -> str:
             clean_name = tool_name[4:] if tool_name.startswith("mcp_") else tool_name
             display_name = f"mcp_{clean_name}" if not tool_name.startswith("mcp_") else tool_name
             
+            # Only generate format examples for tools that are actually available from enabled servers
             schema = tool_schemas.get(clean_name)
-            if schema and "properties" in schema:
+            if clean_name in tool_schemas and schema and "properties" in schema:
                 # Generate example arguments from schema
                 example_args = _generate_example_args_from_schema(schema, clean_name)
                 
@@ -190,11 +235,14 @@ def _get_tool_call_formats_from_mcp(available_tools: list) -> str:
         if format_sections:
             return "\n\n".join(format_sections)
         else:
-            return _get_fallback_tool_formats(available_tools)
+            # Don't use fallback formats - only show what's actually available
+            logger.info("No tool format examples available from enabled servers")
+            return "No tool formats currently available."
             
     except Exception as e:
         logger.warning(f"Could not get MCP tool schemas: {e}")
-        return _get_fallback_tool_formats(available_tools)
+        # Don't provide fallback formats - only show what's actually available
+        return ""
  
 def _generate_example_args_from_schema(schema: dict, tool_name: str) -> str:
     """Generate example arguments JSON from tool schema."""
@@ -240,30 +288,8 @@ def _get_example_value_for_property(prop_info: dict, prop_name: str, tool_name:
     else:
         return f"your_{prop_name}_here"
  
-def _get_fallback_tool_formats(available_tools: list) -> str:
-    """Fallback tool format examples when schema info isn't available."""
-    formats = []
-    
-    for tool_name in available_tools:
-        clean_name = tool_name[4:] if tool_name.startswith("mcp_") else tool_name
-        display_name = f"mcp_{clean_name}" if not tool_name.startswith("mcp_") else tool_name
-        
-        if clean_name == "run_shell_command":
-            example_args = '{{"command": "ls -la"}}'
-        elif clean_name == "get_current_time":
-            example_args = '{{"format": "readable"}}'
-        else:
-            example_args = '{{"key": "value"}}'
-            
-        formats.append(f"""**{display_name} Format:**
-```
-{TOOL_SENTINEL_OPEN}
-<name>{display_name}</name>
-<arguments>{example_args}</arguments>
-{TOOL_SENTINEL_CLOSE}
-```""")
-    
-    return "\n\n".join(formats)
+# Removed _get_fallback_tool_formats() function as it was hardcoding shell tool examples
+# even when shell server was disabled. Now we only show formats for actually enabled tools.
 
 def register_extensions(manager):
     """

app/main.py

@@ -78,11 +78,13 @@ def parse_arguments():
     parser.add_argument("--list-models", action="store_true",
                         help="List all supported endpoints and their available models")
     parser.add_argument("--ast", action="store_true",
-                        help="Enable AST-based code understanding capabilities")
+                        help="Enable AST-based code understanding capabilities (disabled by default)")
     parser.add_argument("--ast-resolution", choices=['disabled', 'minimal', 'medium', 'detailed', 'comprehensive'], 
                        default='medium', help="AST context resolution level (default: medium)")
-    parser.add_argument("--mcp", action="store_true",
-                       help="Enable MCP (Model Context Protocol) server integration")
+    parser.add_argument("--mcp", action="store_true", default=True,
+                       help="Enable MCP (Model Context Protocol) server integration (enabled by default)")
+    parser.add_argument("--no-mcp", action="store_false", dest="mcp",
+                       help="Disable MCP (Model Context Protocol) server integration")
     return parser.parse_args()
 
 

app/mcp/client.py

@@ -237,6 +237,9 @@ class MCPClient:
     
     async def _send_request(self, method: str, params: Optional[Dict[str, Any]] = None, _retry_count: int = 0) -> Optional[Dict[str, Any]]:
         """Send a JSON-RPC request to the MCP server."""
+        import time
+        start_time = time.time()
+        
         max_retries = 3
         
         if not self.process or not self.process.stdin:
@@ -270,12 +273,18 @@ class MCPClient:
             
         try:
             request_json = json.dumps(request) + "\n"
+            write_start = time.time()
             self.process.stdin.write(request_json)
             self.process.stdin.flush()
+            write_time = time.time() - write_start
+            logger.info(f"🔍 MCP_TIMING: Write took {write_time*1000:.1f}ms")
             
             # Read response
             try:
+                read_start = time.time()
                 response_line = self.process.stdout.readline()
+                read_time = time.time() - read_start
+                logger.info(f"🔍 MCP_TIMING: Read took {read_time*1000:.1f}ms")
                 timeout_occurred = False
             except Exception as e:
                 logger.error(f"Error reading from MCP server: {e}")
@@ -300,25 +309,23 @@ class MCPClient:
             if "error" in response:
                 error_info = response['error']
                 error_code = error_info.get("code", -1)
-                error_message = error_info.get("message", "Unknown MCP server error")
+                error_message = str(error_info.get("message", "Unknown error"))
                 
                 # Check if this is a timeout error and we haven't exhausted retries
                 is_timeout = (error_code == -32603 and 
                              ("timed out" in error_message.lower() or "timeout" in error_message.lower()))
                 
-                if is_timeout and _retry_count < max_retries:
-                    logger.warning(f"MCP server timeout (attempt {_retry_count + 1}/{max_retries + 1}), retrying silently: {error_message}")
-                    # Wait a brief moment before retry
+                # Timeouts should fail immediately to let the model choose a lighter alternative
+                if not is_timeout and _retry_count < max_retries:
+                    logger.error(f"MCP server error: {error_info}")
+                    # Only retry non-timeout errors
                     await asyncio.sleep(0.5)
                     return await self._send_request(method, params, _retry_count + 1)
                 
-                # Log error (only after retries exhausted for timeouts)
-                if is_timeout:
-                    logger.error(f"MCP server timeout after {max_retries + 1} attempts: {error_info}")
-                else:
-                    logger.error(f"MCP server error: {error_info}")
+                # Log all errors (timeouts fail immediately, others after retries)
+                logger.error(f"MCP server {'timeout' if is_timeout else 'error'}: {error_info}")
                 
-                # Return error information so it can be displayed to the user
+                # Create error result
                 return {
                     "error": True,
                     "message": error_message,
@@ -327,6 +334,8 @@ class MCPClient:
                 
             # Update successful call timestamp
             self._last_successful_call = time.time()
+            total_time = time.time() - start_time
+            logger.info(f"🔍 MCP_TIMING: Total request took {total_time*1000:.1f}ms for method '{method}'")
             return response.get("result")
             
         except Exception as e:

app/mcp/manager.py

@@ -45,6 +45,11 @@ class MCPManager:
         self._reconnection_attempts: Dict[str, float] = {}  # Track last reconnection attempt per server
         self._failed_servers: set = set()  # Servers that have failed too many times
         
+        # Loop detection for repetitive tool calls
+        self._recent_tool_calls: List[tuple] = []  # (tool_name, arguments, timestamp)
+        self._max_recent_calls = 10
+        self._loop_detection_window = 30  # seconds
+        
     def _get_builtin_server_definitions(self) -> Dict[str, Dict[str, Any]]:
         """Defines configurations for built-in MCP servers."""
         builtin_servers = {}
@@ -334,16 +339,16 @@ class MCPManager:
                     logger.error(f"No configuration found for server '{server_name}' during restart.")
                     return False
             
-                # Create and connect new client
-                client = MCPClient(server_config)
-                self.clients[server_name] = client
-                success = await self._connect_server(server_name, client)
-                
-                # Invalidate cache when client configuration changes
-                self.invalidate_tools_cache()
-                
-                logger.info(f"Server {server_name} restart {'successful' if success else 'failed'}")
-                return success
+            # Create and connect new client
+            client = MCPClient(server_config)
+            self.clients[server_name] = client
+            success = await self._connect_server(server_name, client)
+            
+            # Invalidate cache when client configuration changes
+            self.invalidate_tools_cache()
+            
+            logger.info(f"Server {server_name} restart {'successful' if success else 'failed'}")
+            return success
             
         except Exception as e:
             logger.error(f"Error restarting server {server_name}: {str(e)}")
@@ -394,6 +399,8 @@ class MCPManager:
             server_config = self.server_configs.get(server_name, {})
             is_enabled = server_config.get("enabled", True)
             
+            logger.info(f"MCP_MANAGER.get_all_tools: Server '{server_name}' - connected: {client.is_connected}, enabled: {is_enabled}")
+            
             if client.is_connected and is_enabled:
                 client_tools = client.tools
                 logger.info(f"MCP_MANAGER.get_all_tools: Server '{server_name}' has {len(client_tools)} tools: {[t.name for t in client_tools]}")
@@ -464,6 +471,30 @@ class MCPManager:
                         return content
         return None
     
+    def _is_repetitive_call(self, tool_name: str, arguments: Dict[str, Any]) -> bool:
+        """Check if this tool call is repetitive within the detection window."""
+        current_time = time.time()
+        call_signature = (tool_name, str(arguments))
+        
+        # Clean old calls outside the window
+        self._recent_tool_calls = [
+            (name, args, timestamp) for name, args, timestamp in self._recent_tool_calls
+            if current_time - timestamp <= self._loop_detection_window
+        ]
+        
+        # Count identical calls in the window
+        identical_calls = sum(1 for name, args, _ in self._recent_tool_calls 
+                             if (name, args) == call_signature)
+        
+        # Add current call
+        self._recent_tool_calls.append((tool_name, str(arguments), current_time))
+        
+        # Keep only recent calls
+        if len(self._recent_tool_calls) > self._max_recent_calls:
+            self._recent_tool_calls = self._recent_tool_calls[-self._max_recent_calls:]
+        
+        return identical_calls >= 3  # Allow max 3 identical calls
+
     async def call_tool(self, tool_name: str, arguments: Dict[str, Any], server_name: Optional[str] = None) -> Optional[Dict[str, Any]]:
         """
         Call an MCP tool.
@@ -476,6 +507,11 @@ class MCPManager:
         Returns:
             Tool execution result or None if not found
         """
+        # Check for repetitive calls
+        if self._is_repetitive_call(tool_name, arguments):
+            logger.warning(f"🔍 MCP_MANAGER: Blocking repetitive tool call: {tool_name} with {arguments}")
+            return {"content": [{"type": "text", "text": "Tool call blocked due to repetitive execution pattern"}]}
+        
         # Remove mcp_ prefix if present for internal tool lookup
         internal_tool_name = tool_name
         if tool_name.startswith("mcp_"):
@@ -559,6 +595,28 @@ class MCPManager:
 _mcp_manager: Optional[MCPManager] = None
 def get_mcp_manager() -> MCPManager:
     """Get the global MCP manager instance."""
+    import os
+    
+    # Check if MCP is enabled before creating manager
+    if not os.environ.get("ZIYA_ENABLE_MCP", "true").lower() in ("true", "1", "yes"):
+        # Return a dummy manager that's never initialized when MCP is disabled
+        class DisabledMCPManager:
+            def __init__(self):
+                self.is_initialized = False
+                self.clients = {}
+                self.server_configs = {}
+            
+            async def initialize(self):
+                pass
+            
+            def get_all_tools(self):
+                return []
+            
+            def get_server_status(self):
+                return {}
+                
+        return DisabledMCPManager()
+    
     global _mcp_manager
     if _mcp_manager is None:
         _mcp_manager = MCPManager()

app/mcp/tools.py

@@ -82,9 +82,10 @@ def parse_tool_call(content: str) -> Optional[Dict[str, Any]]:
     sentinel_open_escaped = re.escape(TOOL_SENTINEL_OPEN)
     sentinel_close_escaped = re.escape(TOOL_SENTINEL_CLOSE)
     
-    # Format 1: <n> format with complete closing tag
+    # Format 1: Handle both <name> and <n> formats
+    # Pattern: <TOOL_SENTINEL><name>tool_name</name><arguments>{...}</arguments></TOOL_SENTINEL>
     # Pattern: <TOOL_SENTINEL><n>tool_name</n><arguments>{...}</arguments></TOOL_SENTINEL>
-    complete_pattern = f'{sentinel_open_escaped}\\s*<n>([^<]+)</n>\\s*<arguments>\\s*(\\{{.*?\\}})\\s*</arguments>\\s*{sentinel_close_escaped}'
+    complete_pattern = f'{sentinel_open_escaped}\\s*<(?:name|n)>([^<]+)</(?:name|n)>\\s*<arguments>\\s*(\\{{.*?\\}})\\s*</arguments>\\s*{sentinel_close_escaped}'
     match = re.search(complete_pattern, content, re.DOTALL)
     if match:
         tool_name = match.group(1).strip()
@@ -93,11 +94,11 @@ def parse_tool_call(content: str) -> Optional[Dict[str, Any]]:
             logger.info(f"🔍 PARSE_DEBUG: Raw arguments string: '{match.group(2)}'")
             logger.info(f"🔍 PARSE_DEBUG: Parsed arguments: {arguments}")
             print(f"🔍 PARSE_DEBUG: Raw arguments string: '{match.group(2)}', Parsed: {arguments}")
-            logger.debug(f"🔍 PARSE: Successfully parsed complete <n> format - tool: {tool_name}, args: {arguments}")
+            logger.debug(f"🔍 PARSE: Successfully parsed tool format - tool: {tool_name}, args: {arguments}")
             logger.info(f"🔍 PARSE SUCCESS: tool_name='{tool_name}', arguments={arguments}")
             print(f"🔍 PARSE SUCCESS: tool_name='{tool_name}', arguments={arguments}")
             return {"tool_name": tool_name, "arguments": arguments}
-        except json.JSONDecodeError:
+        except json.JSONDecodeError as e:
             # Try to fix common JSON parsing issues with shell commands
             try:
                 # Extract the raw arguments string and attempt to repair it
@@ -111,13 +112,11 @@ def parse_tool_call(content: str) -> Optional[Dict[str, Any]]:
                 print(f"🔍 PARSE REPAIRED: tool_name='{tool_name}', arguments={arguments}")
                 logger.debug(f"🔍 PARSE: Successfully parsed repaired JSON - tool: {tool_name}, args: {arguments}")
                 return {"tool_name": tool_name, "arguments": arguments}
-            except Exception as e:
-                logger.error(f"🔍 PARSE_DEBUG: Both original and repair parsing failed: {e}")
-                print(f"🔍 PARSE_DEBUG: Both original and repair parsing failed: {e}")
+            except Exception as repair_error:
+                logger.error(f"🔍 PARSE_DEBUG: Both original and repair parsing failed: {repair_error}")
+                print(f"🔍 PARSE_DEBUG: Both original and repair parsing failed: {repair_error}")
             logger.warning(f"Failed to parse JSON arguments for tool {tool_name}: {e}")
             return None
-
-    # Format 1b: <name> format with complete closing tag (alternative format)
     # Pattern: <TOOL_SENTINEL><name>tool_name</name><arguments>{...}</arguments></TOOL_SENTINEL>
     complete_name_pattern = f'{sentinel_open_escaped}\\s*<name>([^<]+)</name>\\s*<arguments>\\s*(\\{{.*?\\}})\\s*</arguments>\\s*{sentinel_close_escaped}'
     match = re.search(complete_name_pattern, content, re.DOTALL)

app/mcp_servers/shell_server.py

@@ -15,7 +15,7 @@ from typing import Dict, Any, Optional
 
 # Import centralized shell configuration
 sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
-from config.shell_config import DEFAULT_SHELL_CONFIG
+from app.config.shell_config import DEFAULT_SHELL_CONFIG
 
 
 # Global timeout tracking
@@ -185,13 +185,13 @@ class ShellServer:
                     "tools": [
                         {
                             "name": "run_shell_command",
-                            "description": f"Execute a shell command. Allowed commands: {self.get_allowed_commands_description()}",
+                            "description": f"Execute a complete, non-interactive shell command. Commands must be self-contained with all arguments provided - do NOT use interactive mode (e.g., use 'echo \"2+2\" | bc' not just 'bc'). Allowed commands: {self.get_allowed_commands_description()}",
                             "inputSchema": {
                                 "type": "object",
                                 "properties": {
                                     "command": {
                                         "type": "string",
-                                        "description": "The shell command to execute"
+                                        "description": "A complete, non-interactive shell command with all required arguments (e.g., 'ls -la', 'grep pattern file', 'echo \"2+2\" | bc'). CRITICAL: Commands must be complete operations that do not require interactive input. For calculators like bc, pipe the expression: 'echo \"expression\" | bc'. Do not use incomplete commands or interactive modes."
                                     },
                                     "timeout": {
                                         "type": "number",