alita-sdk 0.3.155__py3-none-any.whl → 0.3.157__py3-none-any.whl

alita_sdk/tools/postman/api_wrapper.py

@@ -1,14 +1,16 @@
+import copy
 import json
 import logging
 import re
-from typing import Any, Dict, List, Optional, Union
+from typing import Any, Dict, List, Optional, Tuple
 from traceback import format_exc
 
 import requests
 from langchain_core.tools import ToolException
-from pydantic import Field, PrivateAttr, model_validator, create_model, SecretStr
+from pydantic import Field, model_validator, create_model, SecretStr
 
 from ..elitea_base import BaseToolApiWrapper
+from .postman_analysis import PostmanAnalyzer
 
 logger = logging.getLogger(__name__)
 
@@ -18,21 +20,17 @@ PostmanGetCollections = create_model(
 )
 
 PostmanGetCollection = create_model(
-    "PostmanGetCollection",
-    collection_id=(str, Field(
-        description="The ID of the collection to retrieve"))
+    "PostmanGetCollection"
 )
 
 PostmanGetFolder = create_model(
     "PostmanGetFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
     folder_path=(str, Field(
         description="The path to the folder (e.g., 'API/Users' for nested folders)"))
 )
 
 PostmanGetFolderRequests = create_model(
     "PostmanGetFolderRequests",
-    collection_id=(str, Field(description="The ID of the collection")),
     folder_path=(str, Field(description="The path to the folder")),
     include_details=(bool, Field(
         description="Include detailed request information", default=False))
@@ -40,8 +38,6 @@ PostmanGetFolderRequests = create_model(
 
 PostmanSearchRequests = create_model(
     "PostmanSearchRequests",
-    collection_id=(str, Field(
-        description="The ID of the collection to search in")),
     query=(str, Field(description="The search query")),
     search_in=(str, Field(
         description="Where to search: name, url, description, all", default="all")),
@@ -51,20 +47,22 @@ PostmanSearchRequests = create_model(
 
 PostmanAnalyzeCollection = create_model(
     "PostmanAnalyzeCollection",
-    collection_id=(str, Field(
-        description="The ID of the collection to analyze"))
+    include_improvements=(bool, Field(
+        description="Include improvement suggestions in the analysis", default=False))
 )
 
 PostmanAnalyzeFolder = create_model(
     "PostmanAnalyzeFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
-    folder_path=(str, Field(description="The path to the folder to analyze"))
+    folder_path=(str, Field(description="The path to the folder to analyze")),
+    include_improvements=(bool, Field(
+        description="Include improvement suggestions in the analysis", default=False))
 )
 
-PostmanGetImprovementSuggestions = create_model(
-    "PostmanGetImprovementSuggestions",
-    collection_id=(str, Field(
-        description="The ID of the collection to get improvements for"))
+PostmanAnalyzeRequest = create_model(
+    "PostmanAnalyzeRequest",
+    request_path=(str, Field(description="The path to the request to analyze")),
+    include_improvements=(bool, Field(
+        description="Include improvement suggestions in the analysis", default=False))
 )
 
 PostmanCreateCollection = create_model(
@@ -78,36 +76,37 @@ PostmanCreateCollection = create_model(
         description="Optional default authentication", default=None))
 )
 
-PostmanUpdateCollection = create_model(
-    "PostmanUpdateCollection",
-    collection_id=(str, Field(
-        description="The ID of the collection to update")),
-    name=(Optional[str], Field(
-        description="New name for the collection", default=None)),
-    description=(Optional[str], Field(
-        description="New description for the collection", default=None)),
-    variables=(Optional[List[Dict]], Field(
-        description="Updated collection variables", default=None)),
-    auth=(Optional[Dict], Field(
-        description="Updated authentication settings", default=None))
+PostmanUpdateCollectionName = create_model(
+    "PostmanUpdateCollectionName",
+    name=(str, Field(description="New name for the collection"))
+)
+
+PostmanUpdateCollectionDescription = create_model(
+    "PostmanUpdateCollectionDescription",
+    description=(str, Field(description="New description for the collection"))
+)
+
+PostmanUpdateCollectionVariables = create_model(
+    "PostmanUpdateCollectionVariables",
+    variables=(List[Dict], Field(description="Updated collection variables"))
+)
+
+PostmanUpdateCollectionAuth = create_model(
+    "PostmanUpdateCollectionAuth",
+    auth=(Dict, Field(description="Updated authentication settings"))
 )
 
 PostmanDeleteCollection = create_model(
-    "PostmanDeleteCollection",
-    collection_id=(str, Field(
-        description="The ID of the collection to delete"))
+    "PostmanDeleteCollection"
 )
 
 PostmanDuplicateCollection = create_model(
     "PostmanDuplicateCollection",
-    collection_id=(str, Field(
-        description="The ID of the collection to duplicate")),
     new_name=(str, Field(description="Name for the new collection copy"))
 )
 
 PostmanCreateFolder = create_model(
     "PostmanCreateFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
     name=(str, Field(description="Name of the new folder")),
     description=(Optional[str], Field(
         description="Optional description for the folder", default=None)),
@@ -119,7 +118,6 @@ PostmanCreateFolder = create_model(
 
 PostmanUpdateFolder = create_model(
     "PostmanUpdateFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
     folder_path=(str, Field(description="Path to the folder to update")),
     name=(Optional[str], Field(
         description="New name for the folder", default=None)),
@@ -131,13 +129,11 @@ PostmanUpdateFolder = create_model(
 
 PostmanDeleteFolder = create_model(
     "PostmanDeleteFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
     folder_path=(str, Field(description="Path to the folder to delete"))
 )
 
 PostmanMoveFolder = create_model(
     "PostmanMoveFolder",
-    collection_id=(str, Field(description="The ID of the collection")),
     source_path=(str, Field(description="Current path of the folder to move")),
     target_path=(Optional[str], Field(
         description="New parent folder path", default=None))
@@ -145,7 +141,6 @@ PostmanMoveFolder = create_model(
 
 PostmanCreateRequest = create_model(
     "PostmanCreateRequest",
-    collection_id=(str, Field(description="The ID of the collection")),
     folder_path=(Optional[str], Field(
         description="Path to the folder", default=None)),
     name=(str, Field(description="Name of the new request")),
@@ -165,38 +160,67 @@ PostmanCreateRequest = create_model(
         description="Optional pre-request script code", default=None))
 )
 
-PostmanUpdateRequest = create_model(
-    "PostmanUpdateRequest",
-    collection_id=(str, Field(description="The ID of the collection")),
-    request_path=(str, Field(
-        description="Path to the request (folder/requestName)")),
-    name=(Optional[str], Field(
-        description="New name for the request", default=None)),
-    method=(Optional[str], Field(
-        description="HTTP method for the request", default=None)),
-    url=(Optional[str], Field(
-        description="URL for the request", default=None)),
-    description=(Optional[str], Field(
-        description="Description for the request", default=None)),
-    headers=(Optional[List[Dict]], Field(
-        description="Request headers", default=None)),
-    body=(Optional[Dict], Field(description="Request body", default=None)),
-    auth=(Optional[Dict], Field(
-        description="Request authentication", default=None)),
-    tests=(Optional[str], Field(description="Test script code", default=None)),
-    pre_request_script=(Optional[str], Field(
-        description="Pre-request script code", default=None))
+PostmanUpdateRequestName = create_model(
+    "PostmanUpdateRequestName",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    name=(str, Field(description="New name for the request"))
+)
+
+PostmanUpdateRequestMethod = create_model(
+    "PostmanUpdateRequestMethod",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    method=(str, Field(description="HTTP method for the request"))
+)
+
+PostmanUpdateRequestUrl = create_model(
+    "PostmanUpdateRequestUrl",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    url=(str, Field(description="URL for the request"))
+)
+
+PostmanUpdateRequestDescription = create_model(
+    "PostmanUpdateRequestDescription",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    description=(str, Field(description="Description for the request"))
+)
+
+PostmanUpdateRequestHeaders = create_model(
+    "PostmanUpdateRequestHeaders",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    headers=(List[Dict], Field(description="Request headers"))
+)
+
+PostmanUpdateRequestBody = create_model(
+    "PostmanUpdateRequestBody",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    body=(Dict, Field(description="Request body"))
+)
+
+PostmanUpdateRequestAuth = create_model(
+    "PostmanUpdateRequestAuth",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    auth=(Dict, Field(description="Request authentication"))
+)
+
+PostmanUpdateRequestTests = create_model(
+    "PostmanUpdateRequestTests",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    tests=(str, Field(description="Test script code"))
+)
+
+PostmanUpdateRequestPreScript = create_model(
+    "PostmanUpdateRequestPreScript",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    pre_request_script=(str, Field(description="Pre-request script code"))
 )
 
 PostmanDeleteRequest = create_model(
     "PostmanDeleteRequest",
-    collection_id=(str, Field(description="The ID of the collection")),
     request_path=(str, Field(description="Path to the request to delete"))
 )
 
 PostmanDuplicateRequest = create_model(
     "PostmanDuplicateRequest",
-    collection_id=(str, Field(description="The ID of the collection")),
     source_path=(str, Field(description="Path to the request to duplicate")),
     new_name=(str, Field(description="Name for the duplicated request")),
     target_path=(Optional[str], Field(
@@ -205,13 +229,24 @@ PostmanDuplicateRequest = create_model(
 
 PostmanMoveRequest = create_model(
     "PostmanMoveRequest",
-    collection_id=(str, Field(description="The ID of the collection")),
     source_path=(str, Field(
         description="Current path of the request to move")),
     target_path=(Optional[str], Field(
         description="New folder path", default=None))
 )
 
+PostmanGetRequest = create_model(
+    "PostmanGetRequest",
+    request_path=(str, Field(
+        description="The path to the request (e.g., 'API/Users/Get User' or 'applications/recommendations')"))
+)
+
+PostmanGetRequestScript = create_model(
+    "PostmanGetRequestScript",
+    request_path=(str, Field(description="Path to the request (folder/requestName)")),
+    script_type=(str, Field(description="The type of script to retrieve: 'test' or 'prerequest'", default="prerequest"))
+)
+
 
 class PostmanApiWrapper(BaseToolApiWrapper):
     """Wrapper for Postman API."""
@@ -221,7 +256,12 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     collection_id: Optional[str] = None
     workspace_id: Optional[str] = None
     timeout: int = 30
-    _session: requests.Session = PrivateAttr()
+    session: Any = None
+    analyzer: PostmanAnalyzer = None
+
+    model_config = {
+        "arbitrary_types_allowed": True
+    }
 
     @model_validator(mode='before')
     @classmethod
@@ -233,16 +273,14 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "`requests` package not found, please run "
                 "`pip install requests`"
             )
+        values["session"] = requests.Session()
+        values["session"].headers.update({
+            'X-API-Key': values.get('api_key'),
+            'Content-Type': 'application/json'
+        })
+        values["analyzer"] = PostmanAnalyzer()
         return values
 
-    def __init__(self, **data):
-        super().__init__(**data)
-        self._session = requests.Session()
-        self._session.headers.update({
-            'X-API-Key': self.api_key.get_secret_value(),
-            'Content-Type': 'application/json',
-        })
-        # Removed ineffective timeout assignment. Timeout will be enforced in `_make_request`.
 
     def _make_request(self, method: str, endpoint: str, **kwargs) -> Dict[str, Any]:
         """Make HTTP request to Postman API."""
@@ -250,7 +288,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
         try:
             logger.info(f"Making {method.upper()} request to {url}")
-            response = self._session.request(method, url, timeout=self.timeout, **kwargs)
+            response = self.session.request(method, url, timeout=self.timeout, **kwargs)
             response.raise_for_status()
 
             if response.content:
@@ -258,8 +296,14 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             return {}
 
         except requests.exceptions.RequestException as e:
-            logger.error(f"Request failed: {e}")
-            raise ToolException(f"Postman API request failed: {str(e)}")
+            error_details = ""
+            if hasattr(e, 'response') and e.response is not None:
+                try:
+                    error_details = f" Response content: {e.response.text}"
+                except:
+                    error_details = f" Response status: {e.response.status_code}"
+            logger.error(f"Request failed: {e}{error_details}")
+            raise ToolException(f"Postman API request failed: {str(e)}{error_details}")
         except json.JSONDecodeError as e:
             logger.error(f"Failed to decode JSON response: {e}")
             raise ToolException(
@@ -296,6 +340,20 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "args_schema": PostmanGetFolderRequests,
                 "ref": self.get_folder_requests
             },
+            {
+                "name": "get_request",
+                "mode": "get_request",
+                "description": "Get a specific request by path",
+                "args_schema": PostmanGetRequest,
+                "ref": self.get_request
+            },
+            {
+                "name": "get_request_script",
+                "mode": "get_request_script",
+                "description": "Get the test or pre-request script content for a specific request",
+                "args_schema": PostmanGetRequestScript,
+                "ref": self.get_request_script
+            },
             {
                 "name": "search_requests",
                 "mode": "search_requests",
@@ -318,11 +376,11 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "ref": self.analyze_folder
             },
             {
-                "name": "get_improvement_suggestions",
-                "mode": "get_improvement_suggestions",
-                "description": "Get improvement suggestions for a collection",
-                "args_schema": PostmanGetImprovementSuggestions,
-                "ref": self.get_improvement_suggestions
+                "name": "analyze_request",
+                "mode": "analyze_request",
+                "description": "Analyze a specific request within a collection",
+                "args_schema": PostmanAnalyzeRequest,
+                "ref": self.analyze_request
             },
             {
                 "name": "create_collection",
@@ -332,19 +390,40 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "ref": self.create_collection
             },
             {
-                "name": "update_collection",
-                "mode": "update_collection",
-                "description": "Update an existing collection (name, description, variables, auth)",
-                "args_schema": PostmanUpdateCollection,
-                "ref": self.update_collection
+                "name": "update_collection_name",
+                "mode": "update_collection_name",
+                "description": "Update collection name",
+                "args_schema": PostmanUpdateCollectionName,
+                "ref": self.update_collection_name
+            },
+            {
+                "name": "update_collection_description",
+                "mode": "update_collection_description",
+                "description": "Update collection description",
+                "args_schema": PostmanUpdateCollectionDescription,
+                "ref": self.update_collection_description
+            },
+            {
+                "name": "update_collection_variables",
+                "mode": "update_collection_variables",
+                "description": "Update collection variables",
+                "args_schema": PostmanUpdateCollectionVariables,
+                "ref": self.update_collection_variables
             },
             {
-                "name": "delete_collection",
-                "mode": "delete_collection",
-                "description": "Delete a collection permanently",
-                "args_schema": PostmanDeleteCollection,
-                "ref": self.delete_collection
+                "name": "update_collection_auth",
+                "mode": "update_collection_auth",
+                "description": "Update collection authentication settings",
+                "args_schema": PostmanUpdateCollectionAuth,
+                "ref": self.update_collection_auth
             },
+            # {
+            #     "name": "delete_collection",
+            #     "mode": "delete_collection",
+            #     "description": "Delete a collection permanently",
+            #     "args_schema": PostmanDeleteCollection,
+            #     "ref": self.delete_collection
+            # },
             {
                 "name": "duplicate_collection",
                 "mode": "duplicate_collection",
@@ -367,13 +446,13 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "args_schema": PostmanUpdateFolder,
                 "ref": self.update_folder
             },
-            {
-                "name": "delete_folder",
-                "mode": "delete_folder",
-                "description": "Delete a folder and all its contents permanently",
-                "args_schema": PostmanDeleteFolder,
-                "ref": self.delete_folder
-            },
+            # {
+            #     "name": "delete_folder",
+            #     "mode": "delete_folder",
+            #     "description": "Delete a folder and all its contents permanently",
+            #     "args_schema": PostmanDeleteFolder,
+            #     "ref": self.delete_folder
+            # },
             {
                 "name": "move_folder",
                 "mode": "move_folder",
@@ -389,19 +468,75 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "ref": self.create_request
             },
             {
-                "name": "update_request",
-                "mode": "update_request",
-                "description": "Update an existing API request",
-                "args_schema": PostmanUpdateRequest,
-                "ref": self.update_request
+                "name": "update_request_name",
+                "mode": "update_request_name",
+                "description": "Update request name",
+                "args_schema": PostmanUpdateRequestName,
+                "ref": self.update_request_name
+            },
+            {
+                "name": "update_request_method",
+                "mode": "update_request_method",
+                "description": "Update request HTTP method",
+                "args_schema": PostmanUpdateRequestMethod,
+                "ref": self.update_request_method
             },
             {
-                "name": "delete_request",
-                "mode": "delete_request",
-                "description": "Delete an API request permanently",
-                "args_schema": PostmanDeleteRequest,
-                "ref": self.delete_request
+                "name": "update_request_url",
+                "mode": "update_request_url",
+                "description": "Update request URL",
+                "args_schema": PostmanUpdateRequestUrl,
+                "ref": self.update_request_url
             },
+            {
+                "name": "update_request_description",
+                "mode": "update_request_description",
+                "description": "Update request description",
+                "args_schema": PostmanUpdateRequestDescription,
+                "ref": self.update_request_description
+            },
+            {
+                "name": "update_request_headers",
+                "mode": "update_request_headers",
+                "description": "Update request headers",
+                "args_schema": PostmanUpdateRequestHeaders,
+                "ref": self.update_request_headers
+            },
+            {
+                "name": "update_request_body",
+                "mode": "update_request_body",
+                "description": "Update request body",
+                "args_schema": PostmanUpdateRequestBody,
+                "ref": self.update_request_body
+            },
+            {
+                "name": "update_request_auth",
+                "mode": "update_request_auth",
+                "description": "Update request authentication",
+                "args_schema": PostmanUpdateRequestAuth,
+                "ref": self.update_request_auth
+            },
+            {
+                "name": "update_request_tests",
+                "mode": "update_request_tests",
+                "description": "Update request test scripts",
+                "args_schema": PostmanUpdateRequestTests,
+                "ref": self.update_request_tests
+            },
+            {
+                "name": "update_request_pre_script",
+                "mode": "update_request_pre_script",
+                "description": "Update request pre-request scripts",
+                "args_schema": PostmanUpdateRequestPreScript,
+                "ref": self.update_request_pre_script
+            },
+            # {
+            #     "name": "delete_request",
+            #     "mode": "delete_request",
+            #     "description": "Delete an API request permanently",
+            #     "args_schema": PostmanDeleteRequest,
+            #     "ref": self.delete_request
+            # },
             {
                 "name": "duplicate_request",
                 "mode": "duplicate_request",
@@ -432,25 +567,25 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when getting collections: {stacktrace}")
             raise ToolException(f"Unable to get collections: {str(e)}")
 
-    def get_collection(self, collection_id: str, **kwargs) -> str:
+    def get_collection(self, **kwargs) -> str:
         """Get a specific collection by ID."""
         try:
             response = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             return json.dumps(response, indent=2)
         except Exception as e:
             stacktrace = format_exc()
             logger.error(
-                f"Exception when getting collection {collection_id}: {stacktrace}")
+                f"Exception when getting collection {self.collection_id}: {stacktrace}")
             raise ToolException(
-                f"Unable to get collection {collection_id}: {str(e)}")
+                f"Unable to get collection {self.collection_id}: {str(e)}")
 
-    def get_folder(self, collection_id: str, folder_path: str, **kwargs) -> str:
+    def get_folder(self, folder_path: str, **kwargs) -> str:
         """Get folders from a collection by path."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            folders = self._find_folders_by_path(
+                'GET', f'/collections/{self.collection_id}')
+            folders = self.analyzer.find_folders_by_path(
                 collection['collection']['item'], folder_path)
             return json.dumps(folders, indent=2)
         except Exception as e:
@@ -458,21 +593,21 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(
                 f"Exception when getting folder {folder_path}: {stacktrace}")
             raise ToolException(
-                f"Unable to get folder {folder_path} from collection {collection_id}: {str(e)}")
+                f"Unable to get folder {folder_path} from collection {self.collection_id}: {str(e)}")
 
-    def get_folder_requests(self, collection_id: str, folder_path: str, include_details: bool = False, **kwargs) -> str:
+    def get_folder_requests(self, folder_path: str, include_details: bool = False, **kwargs) -> str:
         """Get detailed information about all requests in a folder."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            folders = self._find_folders_by_path(
+                'GET', f'/collections/{self.collection_id}')
+            folders = self.analyzer.find_folders_by_path(
                 collection['collection']['item'], folder_path)
 
             if not folders:
-                raise ToolException(f"Folder '{folder_path}' not found in collection '{collection_id}'.")
+                raise ToolException(f"Folder '{folder_path}' not found in collection '{self.collection_id}'.")
 
             folder = folders[0]
-            requests = self._extract_requests_from_items(
+            requests = self.analyzer.extract_requests_from_items(
                 folder.get('item', []), include_details)
 
             result = {
@@ -490,16 +625,16 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to get requests from folder {folder_path}: {str(e)}")
 
-    def search_requests(self, collection_id: str, query: str, search_in: str = "all", method: str = None, **kwargs) -> str:
+    def search_requests(self, query: str, search_in: str = "all", method: str = None, **kwargs) -> str:
         """Search for requests across the collection."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            requests = self._search_requests_in_items(
+                'GET', f'/collections/{self.collection_id}')
+            requests = self.analyzer.search_requests_in_items(
                 collection['collection']['item'], query, search_in, method)
 
             result = {
-                "collection_id": collection_id,
+                "collection_id": self.collection_id,
                 "query": query,
                 "search_in": search_in,
                 "method_filter": method,
@@ -512,27 +647,33 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             stacktrace = format_exc()
             logger.error(f"Exception when searching requests: {stacktrace}")
             raise ToolException(
-                f"Unable to search requests in collection {collection_id}: {str(e)}")
+                f"Unable to search requests in collection {self.collection_id}: {str(e)}")
 
-    def analyze_collection(self, collection_id: str, **kwargs) -> str:
+    def analyze_collection(self, include_improvements: bool = False, **kwargs) -> str:
         """Analyze a collection for API quality and best practices."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            analysis = self._perform_collection_analysis(collection)
+                'GET', f'/collections/{self.collection_id}')
+            analysis = self.analyzer.perform_collection_analysis(collection)
+            
+            if include_improvements:
+                improvements = self.analyzer.generate_improvements(analysis)
+                analysis["improvements"] = improvements
+                analysis["improvement_count"] = len(improvements)
+            
             return json.dumps(analysis, indent=2)
         except Exception as e:
             stacktrace = format_exc()
             logger.error(f"Exception when analyzing collection: {stacktrace}")
             raise ToolException(
-                f"Unable to analyze collection {collection_id}: {str(e)}")
+                f"Unable to analyze collection {self.collection_id}: {str(e)}")
 
-    def analyze_folder(self, collection_id: str, folder_path: str, **kwargs) -> str:
+    def analyze_folder(self, folder_path: str, include_improvements: bool = False, **kwargs) -> str:
         """Analyze a specific folder within a collection."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            folders = self._find_folders_by_path(
+                'GET', f'/collections/{self.collection_id}')
+            folders = self.analyzer.find_folders_by_path(
                 collection['collection']['item'], folder_path)
 
             if not folders:
@@ -540,7 +681,13 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
             folder_analyses = []
             for folder in folders:
-                analysis = self._perform_folder_analysis(folder, folder_path)
+                analysis = self.analyzer.perform_folder_analysis(folder, folder_path)
+                
+                if include_improvements:
+                    improvements = self.analyzer.generate_folder_improvements(analysis)
+                    analysis["improvements"] = improvements
+                    analysis["improvement_count"] = len(improvements)
+                
                 folder_analyses.append(analysis)
 
             return json.dumps(folder_analyses, indent=2)
@@ -550,28 +697,35 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to analyze folder {folder_path}: {str(e)}")
 
-    def get_improvement_suggestions(self, collection_id: str, **kwargs) -> str:
-        """Get improvement suggestions for a collection."""
+    def analyze_request(self, request_path: str, include_improvements: bool = False, **kwargs) -> str:
+        """Analyze a specific request within a collection."""
         try:
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            analysis = self._perform_collection_analysis(collection)
-            improvements = self._generate_improvements(analysis)
+                'GET', f'/collections/{self.collection_id}')
+            collection_data = collection["collection"]
 
-            result = {
-                "collection_id": collection_id,
-                "collection_name": analysis["collection_name"],
-                "improvement_count": len(improvements),
-                "improvements": improvements
-            }
+            # Find the request
+            request_item = self.analyzer.find_request_by_path(
+                collection_data["item"], request_path)
+            if not request_item:
+                raise ToolException(f"Request '{request_path}' not found")
 
-            return json.dumps(result, indent=2)
+            # Perform request analysis
+            analysis = self.analyzer.perform_request_analysis(request_item)
+            analysis["request_path"] = request_path
+            analysis["collection_id"] = self.collection_id
+            
+            if include_improvements:
+                improvements = self.analyzer.generate_request_improvements(analysis)
+                analysis["improvements"] = improvements
+                analysis["improvement_count"] = len(improvements)
+
+            return json.dumps(analysis, indent=2)
         except Exception as e:
             stacktrace = format_exc()
-            logger.error(
-                f"Exception when generating improvements: {stacktrace}")
+            logger.error(f"Exception when analyzing request: {stacktrace}")
             raise ToolException(
-                f"Unable to generate improvements for collection {collection_id}: {str(e)}")
+                f"Unable to analyze request {request_path}: {str(e)}")
 
     # =================================================================
     # COLLECTION MANAGEMENT METHODS
@@ -608,52 +762,104 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to create collection '{name}': {str(e)}")
 
-    def update_collection(self, collection_id: str, name: str = None, description: str = None,
-                          variables: List[Dict] = None, auth: Dict = None, **kwargs) -> str:
-        """Update an existing collection."""
+    def update_collection_name(self, name: str, **kwargs) -> str:
+        """Update collection name."""
         try:
             # Get current collection
             current = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = current["collection"]
 
-            # Update fields if provided
-            if name:
-                collection_data["info"]["name"] = name
-            if description is not None:
-                collection_data["info"]["description"] = description
-            if variables is not None:
-                collection_data["variable"] = variables
-            if auth is not None:
-                collection_data["auth"] = auth
+            # Update name
+            collection_data["info"]["name"] = name
+
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
+                                          json={"collection": collection_data})
+            return json.dumps(response, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating collection name: {stacktrace}")
+            raise ToolException(
+                f"Unable to update collection {self.collection_id} name: {str(e)}")
+
+    def update_collection_description(self, description: str, **kwargs) -> str:
+        """Update collection description."""
+        try:
+            # Get current collection
+            current = self._make_request(
+                'GET', f'/collections/{self.collection_id}')
+            collection_data = current["collection"]
+
+            # Update description
+            collection_data["info"]["description"] = description
+
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
+                                          json={"collection": collection_data})
+            return json.dumps(response, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating collection description: {stacktrace}")
+            raise ToolException(
+                f"Unable to update collection {self.collection_id} description: {str(e)}")
+
+    def update_collection_variables(self, variables: List[Dict], **kwargs) -> str:
+        """Update collection variables."""
+        try:
+            # Get current collection
+            current = self._make_request(
+                'GET', f'/collections/{self.collection_id}')
+            collection_data = current["collection"]
+
+            # Update variables
+            collection_data["variable"] = variables
+
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
+                                          json={"collection": collection_data})
+            return json.dumps(response, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating collection variables: {stacktrace}")
+            raise ToolException(
+                f"Unable to update collection {self.collection_id} variables: {str(e)}")
 
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+    def update_collection_auth(self, auth: Dict, **kwargs) -> str:
+        """Update collection authentication settings."""
+        try:
+            # Get current collection
+            current = self._make_request(
+                'GET', f'/collections/{self.collection_id}')
+            collection_data = current["collection"]
+
+            # Update auth
+            collection_data["auth"] = auth
+
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps(response, indent=2)
         except Exception as e:
             stacktrace = format_exc()
-            logger.error(f"Exception when updating collection: {stacktrace}")
+            logger.error(f"Exception when updating collection auth: {stacktrace}")
             raise ToolException(
-                f"Unable to update collection {collection_id}: {str(e)}")
+                f"Unable to update collection {self.collection_id} auth: {str(e)}")
 
-    def delete_collection(self, collection_id: str, **kwargs) -> str:
+    def delete_collection(self, **kwargs) -> str:
         """Delete a collection permanently."""
         try:
             response = self._make_request(
-                'DELETE', f'/collections/{collection_id}')
-            return json.dumps({"message": f"Collection {collection_id} deleted successfully"}, indent=2)
+                'DELETE', f'/collections/{self.collection_id}')
+            return json.dumps({"message": f"Collection {self.collection_id} deleted successfully"}, indent=2)
         except Exception as e:
             stacktrace = format_exc()
             logger.error(f"Exception when deleting collection: {stacktrace}")
             raise ToolException(
-                f"Unable to delete collection {collection_id}: {str(e)}")
+                f"Unable to delete collection {self.collection_id}: {str(e)}")
 
-    def duplicate_collection(self, collection_id: str, new_name: str, **kwargs) -> str:
+    def duplicate_collection(self, new_name: str, **kwargs) -> str:
         """Create a copy of an existing collection."""
         try:
             # Get the original collection
             original = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = original["collection"]
 
             # Update the name and remove IDs to create a new collection
@@ -662,7 +868,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 del collection_data["info"]["_postman_id"]
 
             # Remove item IDs recursively
-            self._remove_item_ids(collection_data.get("item", []))
+            self.analyzer.remove_item_ids(collection_data.get("item", []))
 
             response = self._make_request(
                 'POST', '/collections', json={"collection": collection_data})
@@ -672,19 +878,19 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(
                 f"Exception when duplicating collection: {stacktrace}")
             raise ToolException(
-                f"Unable to duplicate collection {collection_id}: {str(e)}")
+                f"Unable to duplicate collection {self.collection_id}: {str(e)}")
 
     # =================================================================
     # FOLDER MANAGEMENT METHODS
     # =================================================================
 
-    def create_folder(self, collection_id: str, name: str, description: str = None,
+    def create_folder(self, name: str, description: str = None,
                       parent_path: str = None, auth: Dict = None, **kwargs) -> str:
         """Create a new folder in a collection."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Create folder item
@@ -700,7 +906,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
             # Add folder to appropriate location
             if parent_path:
-                parent_folders = self._find_folders_by_path(
+                parent_folders = self.analyzer.find_folders_by_path(
                     collection_data["item"], parent_path)
                 if not parent_folders:
                     raise ToolException(
@@ -710,7 +916,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 collection_data["item"].append(folder_item)
 
             # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps({"message": f"Folder '{name}' created successfully"}, indent=2)
         except Exception as e:
@@ -718,53 +924,78 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when creating folder: {stacktrace}")
             raise ToolException(f"Unable to create folder '{name}': {str(e)}")
 
-    def update_folder(self, collection_id: str, folder_path: str, name: str = None,
-                      description: str = None, auth: Dict = None, **kwargs) -> str:
-        """Update folder properties."""
-        try:
-            # Get current collection
-            collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            collection_data = collection["collection"]
+    def _get_folder_id(self, folder_path: str) -> str:
+        """Helper method to get folder ID by path."""
+        collection = self._make_request(
+            'GET', f'/collections/{self.collection_id}')
+        collection_data = collection["collection"]
 
-            # Find the folder
-            folders = self._find_folders_by_path(
-                collection_data["item"], folder_path)
-            if not folders:
-                raise ToolException(f"Folder '{folder_path}' not found")
+        # Find the folder
+        folders = self.analyzer.find_folders_by_path(
+            collection_data["item"], folder_path)
+        if not folders:
+            raise ToolException(f"Folder '{folder_path}' not found")
 
-            folder = folders[0]
+        folder = folders[0]
+
+        # Get the folder ID
+        folder_id = folder.get("id")
+        if not folder_id:
+            # If ID is not available directly, try to use the item ID
+            if "_postman_id" in folder:
+                folder_id = folder["_postman_id"]
+            else:
+                raise ToolException(f"Folder ID not found for '{folder_path}'")
+
+        return folder_id
 
-            # Update fields if provided
+    def update_folder(self, folder_path: str, name: str = None,
+                      description: str = None, auth: Dict = None, **kwargs) -> str:
+        """Update folder properties using the direct folder endpoint."""
+        try:
+            # Get the folder ID
+            folder_id = self._get_folder_id(folder_path)
+            
+            # Create update payload
+            folder_update = {}
             if name:
-                folder["name"] = name
+                folder_update["name"] = name
             if description is not None:
-                folder["description"] = description
+                folder_update["description"] = description
             if auth is not None:
-                folder["auth"] = auth
-
-            # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
-                                          json={"collection": collection_data})
-            return json.dumps({"message": f"Folder '{folder_path}' updated successfully"}, indent=2)
+                folder_update["auth"] = auth
+                
+            # Only update if we have properties to change
+            if folder_update:
+                # Update folder using the direct API endpoint
+                response = self._make_request('PUT', f'/collections/{self.collection_id}/folders/{folder_id}',
+                                            json=folder_update)
+                return json.dumps({"success": True, "message": f"Folder '{folder_path}' updated successfully"}, indent=2)
+            else:
+                return json.dumps({"success": True, "message": f"No changes requested for folder '{folder_path}'"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating folder: {stacktrace}")
+            raise ToolException(
+                f"Unable to update folder '{folder_path}': {str(e)}")
         except Exception as e:
             stacktrace = format_exc()
             logger.error(f"Exception when updating folder: {stacktrace}")
             raise ToolException(
                 f"Unable to update folder '{folder_path}': {str(e)}")
 
-    def delete_folder(self, collection_id: str, folder_path: str, **kwargs) -> str:
+    def delete_folder(self, folder_path: str, **kwargs) -> str:
         """Delete a folder and all its contents permanently."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Find and remove the folder
-            if self._remove_folder_by_path(collection_data["item"], folder_path):
+            if self.analyzer.remove_folder_by_path(collection_data["item"], folder_path):
                 # Update collection
-                response = self._make_request('PUT', f'/collections/{collection_id}',
+                response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                               json={"collection": collection_data})
                 return json.dumps({"message": f"Folder '{folder_path}' deleted successfully"}, indent=2)
             else:
@@ -775,16 +1006,16 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to delete folder '{folder_path}': {str(e)}")
 
-    def move_folder(self, collection_id: str, source_path: str, target_path: str = None, **kwargs) -> str:
+    def move_folder(self, source_path: str, target_path: str = None, **kwargs) -> str:
         """Move a folder to a different location within the collection."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Find source folder
-            source_folder = self._find_folders_by_path(
+            source_folder = self.analyzer.find_folders_by_path(
                 collection_data["item"], source_path)
             if not source_folder:
                 raise ToolException(f"Source folder '{source_path}' not found")
@@ -792,11 +1023,11 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             folder_data = source_folder[0].copy()
 
             # Remove from source location
-            self._remove_folder_by_path(collection_data["item"], source_path)
+            self.analyzer.remove_folder_by_path(collection_data["item"], source_path)
 
             # Add to target location
             if target_path:
-                target_folders = self._find_folders_by_path(
+                target_folders = self.analyzer.find_folders_by_path(
                     collection_data["item"], target_path)
                 if not target_folders:
                     raise ToolException(
@@ -806,7 +1037,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 collection_data["item"].append(folder_data)
 
             # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps({"message": f"Folder moved from '{source_path}' to '{target_path or 'root'}'"}, indent=2)
         except Exception as e:
@@ -819,7 +1050,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     # REQUEST MANAGEMENT METHODS
     # =================================================================
 
-    def create_request(self, collection_id: str, name: str, method: str, url: str,
+    def create_request(self, name: str, method: str, url: str,
                        folder_path: str = None, description: str = None, headers: List[Dict] = None,
                        body: Dict = None, auth: Dict = None, tests: str = None,
                        pre_request_script: str = None, **kwargs) -> str:
@@ -827,7 +1058,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Create request item
@@ -870,7 +1101,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
             # Add request to appropriate location
             if folder_path:
-                folders = self._find_folders_by_path(
+                folders = self.analyzer.find_folders_by_path(
                     collection_data["item"], folder_path)
                 if not folders:
                     raise ToolException(f"Folder '{folder_path}' not found")
@@ -879,7 +1110,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 collection_data["item"].append(request_item)
 
             # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps({"message": f"Request '{name}' created successfully"}, indent=2)
         except Exception as e:
@@ -887,92 +1118,263 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when creating request: {stacktrace}")
             raise ToolException(f"Unable to create request '{name}': {str(e)}")
 
-    def update_request(self, collection_id: str, request_path: str, name: str = None,
-                       method: str = None, url: str = None, description: str = None,
-                       headers: List[Dict] = None, body: Dict = None, auth: Dict = None,
-                       tests: str = None, pre_request_script: str = None, **kwargs) -> str:
-        """Update an existing API request."""
+    def update_request_name(self, request_path: str, name: str, **kwargs) -> str:
+        """Update request name."""
         try:
-            # Get current collection
-            collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
-            collection_data = collection["collection"]
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "name": name
+            }
 
-            # Find the request
-            request_item = self._find_request_by_path(
-                collection_data["item"], request_path)
-            if not request_item:
-                raise ToolException(f"Request '{request_path}' not found")
+            # Update the name field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' name updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request name: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' name: {str(e)}")
 
-            # Update fields if provided
-            if name:
-                request_item["name"] = name
-            if method:
-                request_item["request"]["method"] = method.upper()
-            if url:
-                request_item["request"]["url"] = url
-            if description is not None:
-                request_item["request"]["description"] = description
-            if headers is not None:
-                request_item["request"]["header"] = headers
-            if body is not None:
-                request_item["request"]["body"] = body
-            if auth is not None:
-                request_item["request"]["auth"] = auth
+    def update_request_method(self, request_path: str, method: str, **kwargs) -> str:
+        """Update request HTTP method."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "method": method.upper()
+            }
 
-            # Update events
-            if tests is not None or pre_request_script is not None:
-                events = request_item.get("event", [])
-
-                if pre_request_script is not None:
-                    # Remove existing prerequest events
-                    events = [e for e in events if e.get(
-                        "listen") != "prerequest"]
-                    if pre_request_script:
-                        events.append({
-                            "listen": "prerequest",
-                            "script": {
-                                "exec": pre_request_script.split('\n'),
-                                "type": "text/javascript"
-                            }
-                        })
-
-                if tests is not None:
-                    # Remove existing test events
-                    events = [e for e in events if e.get("listen") != "test"]
-                    if tests:
-                        events.append({
-                            "listen": "test",
-                            "script": {
-                                "exec": tests.split('\n'),
-                                "type": "text/javascript"
-                            }
-                        })
+            # Update the method field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' method updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request method: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' method: {str(e)}")
 
-                request_item["event"] = events
+    def update_request_url(self, request_path: str, url: str, **kwargs) -> str:
+        """Update request URL."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "url": url
+            }
 
-            # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
-                                          json={"collection": collection_data})
-            return json.dumps({"message": f"Request '{request_path}' updated successfully"}, indent=2)
+            # Update the URL field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' URL updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request URL: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' URL: {str(e)}")
+
+    def _get_request_item_and_id(self, request_path: str) -> Tuple[Dict, str, Dict]:
+        """Helper method to get request item and ID by path. Returns (request_item, request_id, collection_data)."""
+        collection = self._make_request(
+            'GET', f'/collections/{self.collection_id}')
+        collection_data = collection["collection"]
+
+        # Find the request
+        request_item = self.analyzer.find_request_by_path(
+            collection_data["item"], request_path)
+        if not request_item:
+            raise ToolException(f"Request '{request_path}' not found")
+
+        # Get the request ID
+        request_id = request_item.get("id")
+        if not request_id:
+            # If ID is not available directly, try to use the full item ID path
+            if "_postman_id" in request_item:
+                request_id = request_item["_postman_id"]
+            else:
+                raise ToolException(f"Request ID not found for '{request_path}'")
+
+        return request_item, request_id, collection_data
+        
+    def update_request_description(self, request_path: str, description: str, **kwargs) -> str:
+        """Update request description."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # For description update, we need to properly format the payload
+            # according to Postman API requirements
+            request_update = {
+                "description": description
+            }
+
+            # Update only the description field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' description updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request description: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' description: {str(e)}")
+
+    def update_request_headers(self, request_path: str, headers: List[Dict], **kwargs) -> str:
+        """Update request headers."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "header": headers
+            }
+
+            # Update the headers field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' headers updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request headers: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' headers: {str(e)}")
+
+    def update_request_body(self, request_path: str, body: Dict, **kwargs) -> str:
+        """Update request body."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "body": body
+            }
+
+            # Update the body field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' body updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request body: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' body: {str(e)}")
+
+    def update_request_auth(self, request_path: str, auth: Dict, **kwargs) -> str:
+        """Update request authentication."""
+        try:
+            # Get request item and ID
+            request_item, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Create update payload
+            request_update = {
+                "auth": auth
+            }
+
+            # Update the auth field
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                          json=request_update)
+            return json.dumps({"success": True, "message": f"Request '{request_path}' auth updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request auth: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' auth: {str(e)}")
+
+    def update_request_tests(self, request_path: str, tests: str, **kwargs) -> str:
+        """Update request test scripts."""
+        try:
+            # Get the request ID
+            _, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Get current request to preserve existing data
+            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
+            request_data = current_request.get("data", {})
+            
+            # Prepare the events array - preserve any non-test events
+            events = [event for event in request_data.get("events", []) if event.get("listen") != "test"]
+            
+            # Add the new test script
+            events.append({
+                "listen": "test",
+                "script": {
+                    "type": "text/javascript",
+                    "exec": tests.strip().split('\n')
+                }
+            })
+            
+            # Update the events array in the request data
+            request_data["events"] = events
+            
+            # Update the request using the individual request endpoint
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                        json=request_data)
+            
+            logger.info(f"Test script updated successfully for request '{request_path}'")
+            return json.dumps({"success": True, "message": f"Request '{request_path}' tests updated successfully"}, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when updating request tests: {stacktrace}")
+            raise ToolException(
+                f"Unable to update request '{request_path}' tests: {str(e)}")
+
+    def update_request_pre_script(self, request_path: str, pre_request_script: str, **kwargs) -> str:
+        """Update request pre-request scripts."""
+        try:
+            # Get the request ID
+            _, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Get current request to preserve existing data
+            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
+            request_data = current_request.get("data", {})
+            
+            # Prepare the events array - preserve any non-prerequest events
+            events = [event for event in request_data.get("events", []) if event.get("listen") != "prerequest"]
+            
+            # Add the new prerequest script
+            events.append({
+                "listen": "prerequest",
+                "script": {
+                    "type": "text/javascript",
+                    "exec": pre_request_script.strip().split('\n')
+                }
+            })
+            
+            # Update the events array in the request data
+            request_data["events"] = events
+            
+            # Update the request using the individual request endpoint
+            response = self._make_request('PUT', f'/collections/{self.collection_id}/requests/{request_id}',
+                                        json=request_data)
+            
+            logger.info(f"Pre-request script updated successfully for request '{request_path}'")
+            return json.dumps({"success": True, "message": f"Request '{request_path}' pre-script updated successfully"}, indent=2)
         except Exception as e:
             stacktrace = format_exc()
-            logger.error(f"Exception when updating request: {stacktrace}")
+            logger.error(f"Exception when updating request pre-script: {stacktrace}")
             raise ToolException(
-                f"Unable to update request '{request_path}': {str(e)}")
+                f"Unable to update request '{request_path}' pre-script: {str(e)}")
 
-    def delete_request(self, collection_id: str, request_path: str, **kwargs) -> str:
+    def delete_request(self, request_path: str, **kwargs) -> str:
         """Delete an API request permanently."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Find and remove the request
-            if self._remove_request_by_path(collection_data["item"], request_path):
+            if self.analyzer.remove_request_by_path(collection_data["item"], request_path):
                 # Update collection
-                response = self._make_request('PUT', f'/collections/{collection_id}',
+                response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                               json={"collection": collection_data})
                 return json.dumps({"message": f"Request '{request_path}' deleted successfully"}, indent=2)
             else:
@@ -983,17 +1385,17 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to delete request '{request_path}': {str(e)}")
 
-    def duplicate_request(self, collection_id: str, source_path: str, new_name: str,
+    def duplicate_request(self, source_path: str, new_name: str,
                           target_path: str = None, **kwargs) -> str:
         """Create a copy of an existing API request."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Find source request
-            source_request = self._find_request_by_path(
+            source_request = self.analyzer.find_request_by_path(
                 collection_data["item"], source_path)
             if not source_request:
                 raise ToolException(
@@ -1009,7 +1411,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
 
             # Add to target location
             if target_path:
-                folders = self._find_folders_by_path(
+                folders = self.analyzer.find_folders_by_path(
                     collection_data["item"], target_path)
                 if not folders:
                     raise ToolException(
@@ -1019,14 +1421,14 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 # Add to same location as source
                 source_folder_path = "/".join(source_path.split("/")[:-1])
                 if source_folder_path:
-                    folders = self._find_folders_by_path(
+                    folders = self.analyzer.find_folders_by_path(
                         collection_data["item"], source_folder_path)
                     folders[0]["item"].append(request_copy)
                 else:
                     collection_data["item"].append(request_copy)
 
             # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps({"message": f"Request duplicated as '{new_name}'"}, indent=2)
         except Exception as e:
@@ -1035,16 +1437,16 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to duplicate request '{source_path}': {str(e)}")
 
-    def move_request(self, collection_id: str, source_path: str, target_path: str = None, **kwargs) -> str:
+    def move_request(self, source_path: str, target_path: str = None, **kwargs) -> str:
         """Move an API request to a different folder."""
         try:
             # Get current collection
             collection = self._make_request(
-                'GET', f'/collections/{collection_id}')
+                'GET', f'/collections/{self.collection_id}')
             collection_data = collection["collection"]
 
             # Find source request
-            source_request = self._find_request_by_path(
+            source_request = self.analyzer.find_request_by_path(
                 collection_data["item"], source_path)
             if not source_request:
                 raise ToolException(
@@ -1053,11 +1455,11 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             request_data = json.loads(json.dumps(source_request))  # Deep copy
 
             # Remove from source location
-            self._remove_request_by_path(collection_data["item"], source_path)
+            self.analyzer.remove_request_by_path(collection_data["item"], source_path)
 
             # Add to target location
             if target_path:
-                folders = self._find_folders_by_path(
+                folders = self.analyzer.find_folders_by_path(
                     collection_data["item"], target_path)
                 if not folders:
                     raise ToolException(
@@ -1067,7 +1469,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 collection_data["item"].append(request_data)
 
             # Update collection
-            response = self._make_request('PUT', f'/collections/{collection_id}',
+            response = self._make_request('PUT', f'/collections/{self.collection_id}',
                                           json={"collection": collection_data})
             return json.dumps({"message": f"Request moved from '{source_path}' to '{target_path or 'root'}'"}, indent=2)
         except Exception as e:
@@ -1075,958 +1477,75 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             logger.error(f"Exception when moving request: {stacktrace}")
             raise ToolException(
                 f"Unable to move request '{source_path}': {str(e)}")
-
+                
     # =================================================================
     # HELPER METHODS
     # =================================================================
 
-    def _find_folders_by_path(self, items: List[Dict], path: str) -> List[Dict]:
-        """Find folders by path (supports nested paths like 'API/Users')."""
-        path_parts = [part.strip() for part in path.split('/') if part.strip()]
-        if not path_parts:
-            return items
-
-        results = []
-
-        def find_in_items(current_items: List[Dict], current_path: List[str], depth: int = 0):
-            if depth >= len(current_path):
-                results.extend(current_items)
-                return
-
-            target_name = current_path[depth]
-            for item in current_items:
-                if (item.get('name', '').lower() == target_name.lower() or
-                        target_name.lower() in item.get('name', '').lower()) and item.get('item'):
-                    if depth == len(current_path) - 1:
-                        # This is the target folder
-                        results.append(item)
-                    else:
-                        # Continue searching in subfolders
-                        find_in_items(item['item'], current_path, depth + 1)
-
-        find_in_items(items, path_parts)
-        return results
-
-    def _extract_requests_from_items(self, items: List[Dict], include_details: bool = False) -> List[Dict]:
-        """Extract requests from items recursively."""
-        requests = []
-
-        for item in items:
-            if item.get('request'):
-                # This is a request
-                request_data = {
-                    "name": item.get('name'),
-                    "method": item['request'].get('method'),
-                    "url": item['request'].get('url')
-                }
-
-                if include_details:
-                    request_data.update({
-                        "description": item.get('description'),
-                        "headers": item['request'].get('header', []),
-                        "body": item['request'].get('body'),
-                        "auth": item['request'].get('auth'),
-                        "tests": [e for e in item.get('event', []) if e.get('listen') == 'test'],
-                        "pre_request_scripts": [e for e in item.get('event', []) if e.get('listen') == 'prerequest']
-                    })
-
-                requests.append(request_data)
-            elif item.get('item'):
-                # This is a folder, recurse
-                requests.extend(self._extract_requests_from_items(
-                    item['item'], include_details))
-
-        return requests
-
-    def _search_requests_in_items(self, items: List[Dict], query: str, search_in: str, method: str = None) -> List[Dict]:
-        """Search for requests in items recursively."""
-        results = []
-        query_lower = query.lower()
-
-        for item in items:
-            if item.get('request'):
-                # This is a request
-                request = item['request']
-                matches = False
-
-                # Check method filter first
-                if method and request.get('method', '').upper() != method.upper():
-                    continue
-
-                # Check search criteria
-                if search_in == 'all' or search_in == 'name':
-                    if query_lower in item.get('name', '').lower():
-                        matches = True
-
-                if search_in == 'all' or search_in == 'url':
-                    url = request.get('url', '')
-                    if isinstance(url, dict):
-                        url = url.get('raw', '')
-                    if query_lower in url.lower():
-                        matches = True
-
-                if search_in == 'all' or search_in == 'description':
-                    description = item.get(
-                        'description', '') or request.get('description', '')
-                    if query_lower in description.lower():
-                        matches = True
-
-                if matches:
-                    results.append({
-                        "name": item.get('name'),
-                        "method": request.get('method'),
-                        "url": request.get('url'),
-                        "description": item.get('description') or request.get('description'),
-                        "path": self._get_item_path(items, item)
-                    })
-
-            elif item.get('item'):
-                # This is a folder, recurse
-                results.extend(self._search_requests_in_items(
-                    item['item'], query, search_in, method))
-
-        return results
-
-    def _get_item_path(self, root_items: List[Dict], target_item: Dict, current_path: str = "") -> str:
-        """Get the path of an item within the collection structure."""
-        for item in root_items:
-            item_path = f"{current_path}/{item['name']}" if current_path else item['name']
-
-            if item == target_item:
-                return item_path
-
-            if item.get('item'):
-                result = self._get_item_path(
-                    item['item'], target_item, item_path)
-                if result:
-                    return result
-
-        return ""
-
-    def _find_request_by_path(self, items: List[Dict], request_path: str) -> Optional[Dict]:
-        """Find a request by its path."""
-        path_parts = [part.strip()
-                      for part in request_path.split('/') if part.strip()]
-        if not path_parts:
-            return None
-
-        current_items = items
-
-        # Navigate through folders to the request
-        for i, part in enumerate(path_parts):
-            found = False
-            for item in current_items:
-                if item.get('name', '').lower() == part.lower():
-                    if i == len(path_parts) - 1:
-                        # This should be the request
-                        if item.get('request'):
-                            return item
-                        else:
-                            return None
+    def get_request(self, request_path: str, **kwargs) -> str:
+        """Get a specific request by path.
+        
+        Uses the _get_request_item_and_id helper to find the request and then fetches complete
+        information using the Postman API endpoint for individual requests.
+        """
+        try:
+            # Get request item and ID
+            _, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Fetch the complete request information from the API
+            response = self._make_request(
+                'GET', f'/collections/{self.collection_id}/requests/{request_id}'
+            )
+            
+            return json.dumps(response, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when getting request: {stacktrace}")
+            raise ToolException(
+                f"Unable to get request '{request_path}': {str(e)}")
+
+    def get_request_script(self, request_path: str, script_type: str = "prerequest", **kwargs) -> str:
+        """
+        Get the script (pre-request or test) for a request by path.
+        
+        Args:
+            request_path: Path to the request within the collection
+            script_type: The type of script to retrieve ("prerequest" or "test")
+            
+        Returns:
+            The script content as JSON string, or an error message if the script doesn't exist
+        """
+        try:
+            # Get the request ID and fetch current request data
+            _, request_id, _ = self._get_request_item_and_id(request_path)
+            
+            # Get current request to have the latest version with updated scripts
+            current_request = self._make_request('GET', f'/collections/{self.collection_id}/requests/{request_id}')
+            request_data = current_request.get("data", {})
+            
+            # Find the script by type
+            script_content = None
+            for event in request_data.get("events", []):
+                if event.get("listen") == script_type:
+                    script = event.get("script", {})
+                    exec_content = script.get("exec", [])
+                    if isinstance(exec_content, list):
+                        script_content = "\n".join(exec_content)
                     else:
-                        # This should be a folder
-                        if item.get('item'):
-                            current_items = item['item']
-                            found = True
-                            break
-                        else:
-                            return None
-
-            if not found:
-                return None
-
-        return None
-
-    def _remove_folder_by_path(self, items: List[Dict], folder_path: str) -> bool:
-        """Remove a folder by its path."""
-        path_parts = [part.strip()
-                      for part in folder_path.split('/') if part.strip()]
-        if not path_parts:
-            return False
-
-        if len(path_parts) == 1:
-            # Remove from current level
-            for i, item in enumerate(items):
-                if item.get('name', '').lower() == path_parts[0].lower() and item.get('item') is not None:
-                    del items[i]
-                    return True
-            return False
-        else:
-            # Navigate to parent folder
-            parent_path = '/'.join(path_parts[:-1])
-            parent_folders = self._find_folders_by_path(items, parent_path)
-            if parent_folders:
-                return self._remove_folder_by_path(parent_folders[0]['item'], path_parts[-1])
-            return False
-
-    def _remove_request_by_path(self, items: List[Dict], request_path: str) -> bool:
-        """Remove a request by its path."""
-        path_parts = [part.strip()
-                      for part in request_path.split('/') if part.strip()]
-        if not path_parts:
-            return False
-
-        if len(path_parts) == 1:
-            # Remove from current level
-            for i, item in enumerate(items):
-                if item.get('name', '').lower() == path_parts[0].lower() and item.get('request'):
-                    del items[i]
-                    return True
-            return False
-        else:
-            # Navigate to parent folder
-            parent_path = '/'.join(path_parts[:-1])
-            parent_folders = self._find_folders_by_path(items, parent_path)
-            if parent_folders:
-                return self._remove_request_by_path(parent_folders[0]['item'], path_parts[-1])
-            return False
-
-    def _remove_item_ids(self, items: List[Dict]):
-        """Remove IDs from items recursively for duplication."""
-        for item in items:
-            if 'id' in item:
-                del item['id']
-            if item.get('item'):
-                self._remove_item_ids(item['item'])
-
-    # =================================================================
-    # ANALYSIS HELPER METHODS
-    # =================================================================
-
-    def _perform_collection_analysis(self, collection: Dict) -> Dict:
-        """Perform comprehensive analysis of a collection."""
-        collection_data = collection['collection']
-        folders = self._analyze_folders(collection_data.get('item', []))
-        total_requests = self._count_requests(collection_data.get('item', []))
-        issues = self._identify_collection_issues(collection_data)
-        score = self._calculate_quality_score(collection_data, folders, issues)
-        recommendations = self._generate_recommendations(issues)
-
-        return {
-            "collection_id": collection_data['info'].get('_postman_id', ''),
-            "collection_name": collection_data['info'].get('name', ''),
-            "total_requests": total_requests,
-            "folders": folders,
-            "issues": issues,
-            "recommendations": recommendations,
-            "score": score,
-            "overall_security_score": self._calculate_overall_security_score(folders),
-            "overall_performance_score": self._calculate_overall_performance_score(folders),
-            "overall_documentation_score": self._calculate_overall_documentation_score(folders)
-        }
-
-    def _analyze_folders(self, items: List[Dict], base_path: str = "") -> List[Dict]:
-        """Analyze all folders in a collection."""
-        folders = []
-
-        for item in items:
-            if item.get('item') is not None:  # This is a folder
-                folder_path = f"{base_path}/{item['name']}" if base_path else item['name']
-                analysis = self._perform_folder_analysis(item, folder_path)
-                folders.append(analysis)
-
-                # Recursively analyze subfolders
-                subfolders = self._analyze_folders(item['item'], folder_path)
-                folders.extend(subfolders)
-
-        return folders
-
-    def _perform_folder_analysis(self, folder: Dict, path: str) -> Dict:
-        """Perform analysis of a specific folder."""
-        requests = self._analyze_requests(folder.get('item', []))
-        request_count = self._count_requests(folder.get('item', []))
-        issues = self._identify_folder_issues(folder, requests)
-
-        return {
-            "name": folder['name'],
-            "path": path,
-            "request_count": request_count,
-            "requests": requests,
-            "issues": issues,
-            "has_consistent_naming": self._check_consistent_naming(folder.get('item', [])),
-            "has_proper_structure": bool(folder.get('description') and folder.get('item')),
-            "auth_consistency": self._check_auth_consistency(requests),
-            "avg_documentation_quality": self._calculate_avg_documentation_quality(requests),
-            "avg_security_score": self._calculate_avg_security_score(requests),
-            "avg_performance_score": self._calculate_avg_performance_score(requests)
-        }
-
-    def _analyze_requests(self, items: List[Dict]) -> List[Dict]:
-        """Analyze requests within a folder."""
-        requests = []
-
-        for item in items:
-            if item.get('request'):  # This is a request
-                analysis = self._perform_request_analysis(item)
-                requests.append(analysis)
-
-        return requests
-
-    def _perform_request_analysis(self, item: Dict) -> Dict:
-        """Perform comprehensive analysis of a specific request."""
-        request = item['request']
-        issues = []
-
-        # Basic checks
-        has_auth = bool(request.get('auth')
-                        or self._has_auth_in_headers(request))
-        has_description = bool(item.get('description')
-                               or request.get('description'))
-        has_tests = bool([e for e in item.get('event', [])
-                         if e.get('listen') == 'test'])
-        has_examples = bool(item.get('response', []))
-
-        # Enhanced analysis
-        url = request.get('url', '')
-        if isinstance(url, dict):
-            url = url.get('raw', '')
-
-        has_hardcoded_url = self._detect_hardcoded_url(url)
-        has_hardcoded_data = self._detect_hardcoded_data(request)
-        has_proper_headers = self._validate_headers(request)
-        has_variables = self._detect_variable_usage(request)
-        has_error_handling = self._detect_error_handling(item)
-        follows_naming_convention = self._validate_naming_convention(
-            item['name'])
-        has_security_issues = self._detect_security_issues(request)
-        has_performance_issues = self._detect_performance_issues(request)
-
-        # Calculate scores
-        security_score = self._calculate_security_score(
-            request, has_auth, has_security_issues)
-        performance_score = self._calculate_performance_score(
-            request, has_performance_issues)
-
-        # Generate issues
-        self._generate_request_issues(issues, item, {
-            'has_description': has_description,
-            'has_auth': has_auth,
-            'has_tests': has_tests,
-            'has_hardcoded_url': has_hardcoded_url,
-            'has_hardcoded_data': has_hardcoded_data,
-            'has_proper_headers': has_proper_headers,
-            'has_security_issues': has_security_issues,
-            'follows_naming_convention': follows_naming_convention
-        })
-
-        return {
-            "name": item['name'],
-            "method": request.get('method'),
-            "url": url,
-            "has_auth": has_auth,
-            "has_description": has_description,
-            "has_tests": has_tests,
-            "has_examples": has_examples,
-            "issues": issues,
-            "has_hardcoded_url": has_hardcoded_url,
-            "has_hardcoded_data": has_hardcoded_data,
-            "has_proper_headers": has_proper_headers,
-            "has_variables": has_variables,
-            "has_error_handling": has_error_handling,
-            "follows_naming_convention": follows_naming_convention,
-            "has_security_issues": has_security_issues,
-            "has_performance_issues": has_performance_issues,
-            "auth_type": request.get('auth', {}).get('type'),
-            "response_examples": len(item.get('response', [])),
-            "test_coverage": self._assess_test_coverage(item),
-            "documentation_quality": self._assess_documentation_quality(item),
-            "security_score": security_score,
-            "performance_score": performance_score
-        }
-
-    def _count_requests(self, items: List[Dict]) -> int:
-        """Count total requests in items."""
-        count = 0
-        for item in items:
-            if item.get('request'):
-                count += 1
-            elif item.get('item'):
-                count += self._count_requests(item['item'])
-        return count
-
-    def _has_auth_in_headers(self, request: Dict) -> bool:
-        """Check if request has authentication in headers."""
-        headers = request.get('header', [])
-        auth_headers = ['authorization', 'x-api-key', 'x-auth-token']
-        return any(h.get('key', '').lower() in auth_headers for h in headers)
-
-    def _detect_hardcoded_url(self, url: str) -> bool:
-        """Detect hardcoded URLs that should use variables."""
-        hardcoded_patterns = [
-            r'^https?://\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}',  # IP addresses
-            r'^https?://localhost',  # localhost
-            # Direct domains
-            r'^https?://[a-zA-Z0-9.-]+\.(com|org|net|io|dev)',
-            r'api\.example\.com',  # Example domains
-            r'staging\.|dev\.|test\.'  # Environment-specific
-        ]
-        return any(re.search(pattern, url) for pattern in hardcoded_patterns) and '{{' not in url
-
-    def _detect_hardcoded_data(self, request: Dict) -> bool:
-        """Detect hardcoded data in request body and headers."""
-        # Check headers
-        headers = request.get('header', [])
-        has_hardcoded_headers = any(
-            ('token' in h.get('key', '').lower() or
-             'key' in h.get('key', '').lower() or
-             'secret' in h.get('key', '').lower()) and
-            '{{' not in h.get('value', '')
-            for h in headers
-        )
-
-        # Check body
-        has_hardcoded_body = False
-        body = request.get('body', {})
-        if body.get('raw'):
-            try:
-                body_data = json.loads(body['raw'])
-                has_hardcoded_body = self._contains_hardcoded_values(body_data)
-            except json.JSONDecodeError:
-                # If not JSON, check for common patterns
-                has_hardcoded_body = re.search(
-                    r'("api_key"|"token"|"password"):\s*"[^{]', body['raw']) is not None
-
-        return has_hardcoded_headers or has_hardcoded_body
-
-    def _contains_hardcoded_values(self, obj: Any) -> bool:
-        """Check if object contains hardcoded values that should be variables."""
-        if not isinstance(obj, dict):
-            return False
-
-        for key, value in obj.items():
-            if isinstance(value, str):
-                # Check for sensitive keys
-                if key.lower() in ['token', 'key', 'secret', 'password', 'api_key', 'client_id', 'client_secret']:
-                    if '{{' not in value:
-                        return True
-                # Check for email patterns, URLs
-                if re.search(r'@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', value) or value.startswith('http'):
-                    if '{{' not in value:
-                        return True
-            elif isinstance(value, dict):
-                if self._contains_hardcoded_values(value):
-                    return True
-
-        return False
-
-    def _validate_headers(self, request: Dict) -> bool:
-        """Validate request headers."""
-        headers = request.get('header', [])
-        header_names = [h.get('key', '').lower() for h in headers]
-        method = request.get('method', '').upper()
-
-        # Check for essential headers
-        if method in ['POST', 'PUT', 'PATCH'] and request.get('body'):
-            if 'content-type' not in header_names:
-                return False
-
-        if method in ['GET', 'POST', 'PUT', 'PATCH']:
-            if 'accept' not in header_names:
-                return False
-
-        return True
-
-    def _detect_variable_usage(self, request: Dict) -> bool:
-        """Detect variable usage in request."""
-        url = request.get('url', '')
-        if isinstance(url, dict):
-            url = url.get('raw', '')
-
-        has_url_variables = '{{' in url
-        has_header_variables = any('{{' in h.get('value', '')
-                                   for h in request.get('header', []))
-
-        has_body_variables = False
-        body = request.get('body', {})
-        if body.get('raw'):
-            has_body_variables = '{{' in body['raw']
-
-        return has_url_variables or has_header_variables or has_body_variables
-
-    def _detect_error_handling(self, item: Dict) -> bool:
-        """Detect error handling in tests."""
-        test_scripts = [e for e in item.get(
-            'event', []) if e.get('listen') == 'test']
-
-        for script in test_scripts:
-            script_code = '\n'.join(script.get('script', {}).get('exec', []))
-            if ('4' in script_code or '5' in script_code or
-                    'error' in script_code.lower() or 'fail' in script_code.lower()):
-                return True
-
-        return False
-
-    def _validate_naming_convention(self, name: str) -> bool:
-        """Validate naming convention."""
-        has_consistent_case = re.match(
-            r'^[a-zA-Z][a-zA-Z0-9\s\-_]*$', name) is not None
-        has_descriptive_name = len(
-            name) > 3 and 'test' not in name.lower() and 'temp' not in name.lower()
-        return has_consistent_case and has_descriptive_name
-
-    def _detect_security_issues(self, request: Dict) -> bool:
-        """Detect security issues."""
-        url = request.get('url', '')
-        if isinstance(url, dict):
-            url = url.get('raw', '')
-
-        # Check for exposed credentials in URL
-        if re.search(r'[?&](token|key|password|secret)=([^&\s]+)', url):
-            return True
-
-        # Check for weak authentication
-        auth = request.get('auth', {})
-        if auth.get('type') == 'basic' and not url.startswith('https'):
-            return True
-
-        # Check headers for exposed credentials
-        headers = request.get('header', [])
-        return any('secret' in h.get('key', '').lower() or 'password' in h.get('key', '').lower()
-                   for h in headers)
-
-    def _detect_performance_issues(self, request: Dict) -> bool:
-        """Detect performance issues."""
-        # Large request body
-        body = request.get('body', {})
-        if body.get('raw') and len(body['raw']) > 10000:
-            return True
-
-        # Too many headers
-        if len(request.get('header', [])) > 20:
-            return True
-
-        # Too many query parameters
-        url = request.get('url', '')
-        if isinstance(url, dict):
-            url = url.get('raw', '')
-
-        query_params = url.split('?')[1] if '?' in url else ''
-        if query_params and len(query_params.split('&')) > 15:
-            return True
-
-        return False
-
-    def _calculate_security_score(self, request: Dict, has_auth: bool, has_security_issues: bool) -> int:
-        """Calculate security score."""
-        score = 100
-        method = request.get('method', '').upper()
-
-        if not has_auth and method in ['POST', 'PUT', 'PATCH', 'DELETE']:
-            score -= 40
-
-        if has_security_issues:
-            score -= 30
-
-        url = request.get('url', '')
-        if isinstance(url, dict):
-            url = url.get('raw', '')
-
-        if url.startswith('http://'):
-            score -= 20
-
-        auth = request.get('auth', {})
-        if auth.get('type') == 'basic':
-            score -= 10
-
-        return max(0, score)
-
-    def _calculate_performance_score(self, request: Dict, has_performance_issues: bool) -> int:
-        """Calculate performance score."""
-        score = 100
-
-        if has_performance_issues:
-            score -= 50
-
-        headers = request.get('header', [])
-        header_names = [h.get('key', '').lower() for h in headers]
-
-        if 'cache-control' not in header_names:
-            score -= 10
-
-        if 'accept-encoding' not in header_names:
-            score -= 10
-
-        return max(0, score)
-
-    def _assess_test_coverage(self, item: Dict) -> str:
-        """Assess test coverage."""
-        test_scripts = [e for e in item.get(
-            'event', []) if e.get('listen') == 'test']
-
-        if not test_scripts:
-            return 'none'
-
-        all_test_code = '\n'.join([
-            '\n'.join(script.get('script', {}).get('exec', []))
-            for script in test_scripts
-        ])
-
-        checks = [
-            'pm.response.code' in all_test_code or 'status' in all_test_code,
-            'responseTime' in all_test_code,
-            'pm.response.json' in all_test_code or 'body' in all_test_code,
-            '4' in all_test_code or '5' in all_test_code
-        ]
-
-        check_count = sum(checks)
-
-        if check_count >= 3:
-            return 'comprehensive'
-        elif check_count >= 1:
-            return 'basic'
-
-        return 'none'
-
-    def _assess_documentation_quality(self, item: Dict) -> str:
-        """Assess documentation quality."""
-        description = item.get('description', '') or item.get(
-            'request', {}).get('description', '')
-
-        if not description:
-            return 'none'
-
-        description_lower = description.lower()
-        quality_factors = [
-            'parameter' in description_lower,
-            'response' in description_lower,
-            'example' in description_lower,
-            'auth' in description_lower,
-            'error' in description_lower
-        ]
-
-        factor_count = sum(quality_factors)
-
-        if factor_count >= 4:
-            return 'excellent'
-        elif factor_count >= 2:
-            return 'good'
-        elif factor_count >= 1 or len(description) > 50:
-            return 'minimal'
-
-        return 'none'
-
-    def _check_consistent_naming(self, items: List[Dict]) -> bool:
-        """Check if items have consistent naming."""
-        if len(items) <= 1:
-            return True
-
-        naming_patterns = []
-        for item in items:
-            name = item.get('name', '').lower()
-            if re.match(r'^[a-z][a-z0-9]*(_[a-z0-9]+)*$', name):
-                naming_patterns.append('snake_case')
-            elif re.match(r'^[a-z][a-zA-Z0-9]*$', name):
-                naming_patterns.append('camelCase')
-            elif re.match(r'^[a-z][a-z0-9]*(-[a-z0-9]+)*$', name):
-                naming_patterns.append('kebab-case')
-            else:
-                naming_patterns.append('mixed')
-
-        unique_patterns = set(naming_patterns)
-        return len(unique_patterns) == 1 and 'mixed' not in unique_patterns
-
-    def _check_auth_consistency(self, requests: List[Dict]) -> str:
-        """Check authentication consistency across requests."""
-        if not requests:
-            return 'none'
-
-        auth_types = set(req.get('auth_type') or 'none' for req in requests)
-
-        if len(auth_types) == 1:
-            return 'none' if 'none' in auth_types else 'consistent'
-
-        return 'mixed'
-
-    def _calculate_avg_documentation_quality(self, requests: List[Dict]) -> int:
-        """Calculate average documentation quality score."""
-        if not requests:
-            return 0
-
-        quality_scores = {
-            'excellent': 100,
-            'good': 75,
-            'minimal': 50,
-            'none': 0
-        }
-
-        scores = [quality_scores.get(
-            req.get('documentation_quality', 'none'), 0) for req in requests]
-        return round(sum(scores) / len(scores))
-
-    def _calculate_avg_security_score(self, requests: List[Dict]) -> int:
-        """Calculate average security score."""
-        if not requests:
-            return 0
-
-        scores = [req.get('security_score', 0) for req in requests]
-        return round(sum(scores) / len(scores))
-
-    def _calculate_avg_performance_score(self, requests: List[Dict]) -> int:
-        """Calculate average performance score."""
-        if not requests:
-            return 0
-
-        scores = [req.get('performance_score', 0) for req in requests]
-        return round(sum(scores) / len(scores))
-
-    def _identify_collection_issues(self, collection_data: Dict) -> List[Dict]:
-        """Identify collection-level issues."""
-        issues = []
-
-        if not collection_data.get('info', {}).get('description'):
-            issues.append({
-                'type': 'warning',
-                'severity': 'medium',
-                'message': 'Collection lacks description',
-                'location': 'Collection root',
-                'suggestion': 'Add a description explaining the purpose of this collection'
-            })
-
-        if not collection_data.get('auth'):
-            issues.append({
-                'type': 'info',
-                'severity': 'low',
-                'message': 'Collection lacks default authentication',
-                'location': 'Collection root',
-                'suggestion': 'Consider setting up collection-level authentication'
-            })
-
-        return issues
-
-    def _identify_folder_issues(self, folder: Dict, requests: List[Dict]) -> List[Dict]:
-        """Identify folder-level issues."""
-        issues = []
-
-        if not folder.get('description'):
-            issues.append({
-                'type': 'warning',
-                'severity': 'low',
-                'message': 'Folder lacks description',
-                'location': folder['name'],
-                'suggestion': 'Add a description explaining the purpose of this folder'
-            })
-
-        if not requests and (not folder.get('item') or len(folder['item']) == 0):
-            issues.append({
-                'type': 'warning',
-                'severity': 'medium',
-                'message': 'Empty folder',
-                'location': folder['name'],
-                'suggestion': 'Consider removing empty folders or adding requests'
-            })
-
-        return issues
-
-    def _generate_request_issues(self, issues: List[Dict], item: Dict, analysis: Dict):
-        """Generate request-specific issues."""
-        if not analysis['has_description']:
-            issues.append({
-                'type': 'warning',
-                'severity': 'medium',
-                'message': 'Request lacks description',
-                'location': item['name'],
-                'suggestion': 'Add a clear description explaining what this request does'
-            })
-
-        if not analysis['has_auth'] and item['request']['method'] in ['POST', 'PUT', 'PATCH', 'DELETE']:
-            issues.append({
-                'type': 'warning',
-                'severity': 'high',
-                'message': 'Sensitive operation without authentication',
-                'location': item['name'],
-                'suggestion': 'Add authentication for this request'
-            })
-
-        if not analysis['has_tests']:
-            issues.append({
-                'type': 'info',
-                'severity': 'high',
-                'message': 'Request lacks test scripts',
-                'location': item['name'],
-                'suggestion': 'Add test scripts to validate response'
-            })
-
-        if analysis['has_hardcoded_url']:
-            issues.append({
-                'type': 'warning',
-                'severity': 'high',
-                'message': 'Request contains hardcoded URL',
-                'location': item['name'],
-                'suggestion': 'Replace hardcoded URLs with environment variables'
-            })
-
-        if analysis['has_security_issues']:
-            issues.append({
-                'type': 'error',
-                'severity': 'high',
-                'message': 'Security vulnerabilities detected',
-                'location': item['name'],
-                'suggestion': 'Address security issues such as exposed credentials'
-            })
-
-    def _calculate_quality_score(self, collection_data: Dict, folders: List[Dict], issues: List[Dict]) -> int:
-        """Calculate quality score (0-100)."""
-        score = 100
-
-        # Deduct points for issues
-        for issue in issues:
-            severity = issue.get('severity', 'low')
-            if severity == 'high':
-                score -= 10
-            elif severity == 'medium':
-                score -= 5
-            elif severity == 'low':
-                score -= 2
-
-        # Deduct points for folder and request issues
-        for folder in folders:
-            for issue in folder.get('issues', []):
-                severity = issue.get('severity', 'low')
-                if severity == 'high':
-                    score -= 5
-                elif severity == 'medium':
-                    score -= 3
-                elif severity == 'low':
-                    score -= 1
-
-            for request in folder.get('requests', []):
-                for issue in request.get('issues', []):
-                    severity = issue.get('severity', 'low')
-                    if severity == 'high':
-                        score -= 3
-                    elif severity == 'medium':
-                        score -= 2
-                    elif severity == 'low':
-                        score -= 1
-
-        return max(0, min(100, score))
-
-    def _generate_recommendations(self, issues: List[Dict]) -> List[str]:
-        """Generate recommendations based on issues."""
-        recommendations = []
-        suggestion_counts = {}
-
-        # Count similar suggestions
-        for issue in issues:
-            suggestion = issue.get('suggestion', '')
-            if suggestion:
-                suggestion_counts[suggestion] = suggestion_counts.get(
-                    suggestion, 0) + 1
-
-        # Generate recommendations from most common suggestions
-        sorted_suggestions = sorted(
-            suggestion_counts.items(), key=lambda x: x[1], reverse=True)[:10]
-
-        for suggestion, count in sorted_suggestions:
-            if count > 1:
-                recommendations.append(f"{suggestion} ({count} instances)")
-            else:
-                recommendations.append(suggestion)
-
-        return recommendations
-
-    def _calculate_overall_security_score(self, folders: List[Dict]) -> int:
-        """Calculate overall security score."""
-        if not folders:
-            return 0
-
-        scores = []
-        for folder in folders:
-            avg_score = folder.get('avg_security_score', 0)
-            if avg_score > 0:
-                scores.append(avg_score)
-
-        return round(sum(scores) / len(scores)) if scores else 0
-
-    def _calculate_overall_performance_score(self, folders: List[Dict]) -> int:
-        """Calculate overall performance score."""
-        if not folders:
-            return 0
-
-        scores = []
-        for folder in folders:
-            avg_score = folder.get('avg_performance_score', 0)
-            if avg_score > 0:
-                scores.append(avg_score)
-
-        return round(sum(scores) / len(scores)) if scores else 0
-
-    def _calculate_overall_documentation_score(self, folders: List[Dict]) -> int:
-        """Calculate overall documentation score."""
-        if not folders:
-            return 0
-
-        scores = []
-        for folder in folders:
-            avg_score = folder.get('avg_documentation_quality', 0)
-            if avg_score > 0:
-                scores.append(avg_score)
-
-        return round(sum(scores) / len(scores)) if scores else 0
-
-    def _generate_improvements(self, analysis: Dict) -> List[Dict]:
-        """Generate improvement suggestions with enhanced analysis."""
-        improvements = []
-
-        # Collection-level improvements
-        if analysis['score'] < 80:
-            improvements.append({
-                'id': 'collection-quality',
-                'title': 'Improve Overall Collection Quality',
-                'description': f"Collection quality score is {analysis['score']}/100. Focus on addressing high-priority issues.",
-                'priority': 'high',
-                'category': 'quality',
-                'impact': 'high'
-            })
-
-        if analysis['overall_security_score'] < 70:
-            improvements.append({
-                'id': 'security-enhancement',
-                'title': 'Enhance Security Practices',
-                'description': f"Security score is {analysis['overall_security_score']}/100. Review authentication and data handling.",
-                'priority': 'high',
-                'category': 'security',
-                'impact': 'high'
-            })
-
-        if analysis['overall_documentation_score'] < 60:
-            improvements.append({
-                'id': 'documentation-improvement',
-                'title': 'Improve Documentation',
-                'description': f"Documentation score is {analysis['overall_documentation_score']}/100. Add descriptions and examples.",
-                'priority': 'medium',
-                'category': 'documentation',
-                'impact': 'medium'
-            })
-
-        # Add specific improvements based on common issues
-        issue_counts = {}
-        for folder in analysis.get('folders', []):
-            for request in folder.get('requests', []):
-                for issue in request.get('issues', []):
-                    issue_type = issue.get('message', '')
-                    issue_counts[issue_type] = issue_counts.get(
-                        issue_type, 0) + 1
-
-        # Generate improvements for most common issues
-        if issue_counts.get('Request lacks test scripts', 0) > 3:
-            improvements.append({
-                'id': 'add-test-scripts',
-                'title': 'Add Test Scripts to Requests',
-                'description': f"Found {issue_counts['Request lacks test scripts']} requests without test scripts.",
-                'priority': 'medium',
-                'category': 'testing',
-                'impact': 'medium'
-            })
-
-        if issue_counts.get('Request contains hardcoded URL', 0) > 2:
-            improvements.append({
-                'id': 'use-environment-variables',
-                'title': 'Use Environment Variables',
-                'description': f"Found {issue_counts['Request contains hardcoded URL']} requests with hardcoded URLs.",
-                'priority': 'high',
-                'category': 'maintainability',
-                'impact': 'high'
-            })
-
-        return improvements
+                        script_content = str(exec_content)
+                    break
+            
+            if script_content is None:
+                return json.dumps({"success": False, "message": f"No {script_type} script found for request '{request_path}'"}, indent=2)
+            
+            return json.dumps({
+                "success": True,
+                "script_type": script_type, 
+                "script_content": script_content, 
+                "request_path": request_path
+            }, indent=2)
+                
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(f"Exception when getting request {script_type} script: {stacktrace}")
+            raise ToolException(f"Unable to get {script_type} script for request '{request_path}': {str(e)}")