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

alita_sdk/runtime/clients/artifact.py

@@ -24,7 +24,7 @@ class Artifact:
             logger.error(f"Error: {e}")
             return f"Error: {e}"
     
-    def get(self, artifact_name: str, bucket_name: str = None, is_capture_image: bool = False, page_number: int = None):
+    def get(self, artifact_name: str, bucket_name: str = None, is_capture_image: bool = False, page_number: int = None, sheet_name: str = None):
         if not bucket_name:
             bucket_name = self.bucket_name
         data = self.client.download_artifact(bucket_name, artifact_name)
@@ -37,7 +37,7 @@ class Artifact:
         if detected['encoding'] is not None:
             return data.decode(detected['encoding'])
         else:
-            return parse_file_content(artifact_name, data, is_capture_image, page_number)
+            return parse_file_content(artifact_name, data, is_capture_image, page_number, sheet_name)
 
     def delete(self, artifact_name: str, bucket_name = None):
         if not bucket_name:

alita_sdk/runtime/langchain/assistant.py

@@ -61,8 +61,8 @@ class Assistant:
                                 "Review toolkits configuration or use pipeline as master agent.")
 
         # configure memory store if memory tool is defined
-        # memory_tool = next((tool for tool in data['tools'] if tool['type'] == 'memory'), None)
-        # self._configure_store(memory_tool)
+        memory_tool = next((tool for tool in data['tools'] if tool['type'] == 'memory'), None)
+        self._configure_store(memory_tool)
         
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools

alita_sdk/runtime/toolkits/tools.py

@@ -94,7 +94,7 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
     # Add community tools
     tools += community_tools(tools_list, alita_client, llm)
     # Add alita tools
-    tools += alita_tools(tools_list, alita_client, llm)
+    tools += alita_tools(tools_list, alita_client, llm, memory_store)
     # Add MCP tools
     tools += _mcp_tools(tools_list, alita_client)
     

alita_sdk/runtime/tools/artifact.py

@@ -23,8 +23,8 @@ class ArtifactWrapper(BaseToolApiWrapper):
     def create_file(self, filename: str, filedata: str, bucket_name = None):
         return self.artifact.create(filename, filedata, bucket_name)
 
-    def read_file(self, filename: str, bucket_name = None, is_capture_image: bool = False, page_number: int = None):
-        return self.artifact.get(filename, bucket_name, is_capture_image, page_number)
+    def read_file(self, filename: str, bucket_name = None, is_capture_image: bool = False, page_number: int = None, sheet_name: str = None):
+        return self.artifact.get(filename, bucket_name, is_capture_image, page_number, sheet_name)
 
     def delete_file(self, filename: str, bucket_name = None):
         return self.artifact.delete(filename, bucket_name)
@@ -75,6 +75,9 @@ class ArtifactWrapper(BaseToolApiWrapper):
                                             default=False)),
                     page_number=(Optional[int], Field(
                         description="Specifies which page to read. If it is None, then full document will be read.",
+                        default=None)),
+                    sheet_name=(Optional[str], Field(
+                        description="Specifies which sheet to read. If it is None, then full document will be read.",
                         default=None))
                 )
             },

alita_sdk/tools/__init__.py

@@ -1,5 +1,8 @@
 import logging
 from importlib import import_module
+from typing import Optional
+
+from langgraph.store.base import BaseStore
 
 logger = logging.getLogger(__name__)
 
@@ -74,13 +77,14 @@ _safe_import_tool('carrier', 'carrier', 'get_tools', 'AlitaCarrierToolkit')
 _safe_import_tool('ocr', 'ocr', 'get_tools', 'OCRToolkit')
 _safe_import_tool('pptx', 'pptx', 'get_tools', 'PPTXToolkit')
 _safe_import_tool('postman', 'postman', 'get_tools', 'PostmanToolkit')
+_safe_import_tool('memory', 'memory', 'get_tools', 'MemoryToolkit')
 
 # Log import summary
 available_count = len(AVAILABLE_TOOLS)
 total_attempted = len(AVAILABLE_TOOLS) + len(FAILED_IMPORTS)
 logger.info(f"Tool imports completed: {available_count}/{total_attempted} successful")
 
-def get_tools(tools_list, alita, llm, *args, **kwargs):
+def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args, **kwargs):
     tools = []
     for tool in tools_list:
         # validate tool name syntax - it cannot be started with _
@@ -90,6 +94,7 @@ def get_tools(tools_list, alita, llm, *args, **kwargs):
         
         tool['settings']['alita'] = alita
         tool['settings']['llm'] = llm
+        tool['settings']['store'] = store
         tool_type = tool['type']
         
         # Check if tool is available and has get_tools function

alita_sdk/tools/memory/__init__.py

@@ -15,6 +15,13 @@ from pydantic import create_model, BaseModel, ConfigDict, Field, SecretStr
 
 name = "memory"
 
+def get_tools(tool):
+    return MemoryToolkit().get_toolkit(
+        namespace=tool['settings'].get('namespace', str(tool['id'])),
+        store=tool['settings'].get('store', None),
+        toolkit_name=tool.get('toolkit_name', '')
+).get_tools()
+
 class MemoryToolkit(BaseToolkit):
     tools: List[BaseTool] = []
 

alita_sdk/tools/postman/api_wrapper.py

@@ -23,6 +23,16 @@ PostmanGetCollection = create_model(
     "PostmanGetCollection"
 )
 
+PostmanGetCollectionFlat = create_model(
+    "PostmanGetCollectionFlat"
+)
+
+PostmanGetFolderFlat = create_model(
+    "PostmanGetFolderFlat",
+    folder_path=(str, Field(
+        description="The path to the folder to parse (e.g., 'API/Users' for nested folders)"))
+)
+
 PostmanGetFolder = create_model(
     "PostmanGetFolder",
     folder_path=(str, Field(
@@ -45,24 +55,17 @@ PostmanSearchRequests = create_model(
         description="Optional HTTP method filter", default=None))
 )
 
-PostmanAnalyzeCollection = create_model(
-    "PostmanAnalyzeCollection",
-    include_improvements=(bool, Field(
-        description="Include improvement suggestions in the analysis", default=False))
-)
-
-PostmanAnalyzeFolder = create_model(
-    "PostmanAnalyzeFolder",
-    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))
-)
-
-PostmanAnalyzeRequest = create_model(
-    "PostmanAnalyzeRequest",
-    request_path=(str, Field(description="The path to the request to analyze")),
+PostmanAnalyze = create_model(
+    "PostmanAnalyze",
+    scope=(str, Field(
+        description="The scope of analysis: 'collection', 'folder', or 'request'", 
+        default="collection")),
+    target_path=(Optional[str], Field(
+        description="The path to the folder or request to analyze (required for folder/request scope)", 
+        default=None)),
     include_improvements=(bool, Field(
-        description="Include improvement suggestions in the analysis", default=False))
+        description="Include improvement suggestions in the analysis", 
+        default=False))
 )
 
 PostmanCreateCollection = create_model(
@@ -235,12 +238,18 @@ PostmanMoveRequest = create_model(
         description="New folder path", default=None))
 )
 
-PostmanGetRequest = create_model(
-    "PostmanGetRequest",
+PostmanGetRequestByPath = create_model(
+    "PostmanGetRequestByPath",
     request_path=(str, Field(
         description="The path to the request (e.g., 'API/Users/Get User' or 'applications/recommendations')"))
 )
 
+PostmanGetRequestById = create_model(
+    "PostmanGetRequestById",
+    request_id=(str, Field(
+        description="The unique ID of the request"))
+)
+
 PostmanGetRequestScript = create_model(
     "PostmanGetRequestScript",
     request_path=(str, Field(description="Path to the request (folder/requestName)")),
@@ -319,33 +328,54 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "args_schema": PostmanGetCollections,
                 "ref": self.get_collections
             },
+            # {
+            #     "name": "get_collection",
+            #     "mode": "get_collection",
+            #     "description": "Get a specific Postman collection by ID",
+            #     "args_schema": PostmanGetCollection,
+            #     "ref": self.get_collection
+            # },
             {
                 "name": "get_collection",
                 "mode": "get_collection",
-                "description": "Get a specific Postman collection by ID",
-                "args_schema": PostmanGetCollection,
-                "ref": self.get_collection
+                "description": "Get a specific Postman collection in flattened format with path-based structure",
+                "args_schema": PostmanGetCollectionFlat,
+                "ref": self.get_collection_flat
             },
             {
                 "name": "get_folder",
                 "mode": "get_folder",
-                "description": "Get folders from a collection by path (supports nested paths like 'API/Users')",
-                "args_schema": PostmanGetFolder,
-                "ref": self.get_folder
+                "description": "Get a specific folder in flattened format with path-based structure",
+                "args_schema": PostmanGetFolderFlat,
+                "ref": self.get_folder_flat
             },
+            # {
+            #     "name": "get_folder",
+            #     "mode": "get_folder",
+            #     "description": "Get folders from a collection by path (supports nested paths like 'API/Users')",
+            #     "args_schema": PostmanGetFolder,
+            #     "ref": self.get_folder
+            # },
+            # {
+            #     "name": "get_folder_requests",
+            #     "mode": "get_folder_requests",
+            #     "description": "Get detailed information about all requests in a folder",
+            #     "args_schema": PostmanGetFolderRequests,
+            #     "ref": self.get_folder_requests
+            # },
             {
-                "name": "get_folder_requests",
-                "mode": "get_folder_requests",
-                "description": "Get detailed information about all requests in a folder",
-                "args_schema": PostmanGetFolderRequests,
-                "ref": self.get_folder_requests
+                "name": "get_request_by_path",
+                "mode": "get_request_by_path",
+                "description": "Get a specific request by path",
+                "args_schema": PostmanGetRequestByPath,
+                "ref": self.get_request_by_path
             },
             {
-                "name": "get_request",
-                "mode": "get_request",
-                "description": "Get a specific request by path",
-                "args_schema": PostmanGetRequest,
-                "ref": self.get_request
+                "name": "get_request_by_id",
+                "mode": "get_request_by_id",
+                "description": "Get a specific request by ID",
+                "args_schema": PostmanGetRequestById,
+                "ref": self.get_request_by_id
             },
             {
                 "name": "get_request_script",
@@ -362,40 +392,26 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 "ref": self.search_requests
             },
             {
-                "name": "analyze_collection",
-                "mode": "analyze_collection",
-                "description": "Analyze a collection for API quality, best practices, and issues",
-                "args_schema": PostmanAnalyzeCollection,
-                "ref": self.analyze_collection
-            },
-            {
-                "name": "analyze_folder",
-                "mode": "analyze_folder",
-                "description": "Analyze a specific folder within a collection",
-                "args_schema": PostmanAnalyzeFolder,
-                "ref": self.analyze_folder
-            },
-            {
-                "name": "analyze_request",
-                "mode": "analyze_request",
-                "description": "Analyze a specific request within a collection",
-                "args_schema": PostmanAnalyzeRequest,
-                "ref": self.analyze_request
-            },
-            {
-                "name": "create_collection",
-                "mode": "create_collection",
-                "description": "Create a new Postman collection",
-                "args_schema": PostmanCreateCollection,
-                "ref": self.create_collection
-            },
-            {
-                "name": "update_collection_name",
-                "mode": "update_collection_name",
-                "description": "Update collection name",
-                "args_schema": PostmanUpdateCollectionName,
-                "ref": self.update_collection_name
+                "name": "analyze",
+                "mode": "analyze",
+                "description": "Analyze collection, folder, or request for API quality, best practices, and issues",
+                "args_schema": PostmanAnalyze,
+                "ref": self.analyze
             },
+            # {
+            #     "name": "create_collection",
+            #     "mode": "create_collection",
+            #     "description": "Create a new Postman collection",
+            #     "args_schema": PostmanCreateCollection,
+            #     "ref": self.create_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",
@@ -570,8 +586,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     def get_collection(self, **kwargs) -> str:
         """Get a specific collection by ID."""
         try:
-            response = self._make_request(
-                'GET', f'/collections/{self.collection_id}')
+            response = self._make_request('GET', f'/collections/{self.collection_id}')
             return json.dumps(response, indent=2)
         except Exception as e:
             stacktrace = format_exc()
@@ -580,6 +595,19 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to get collection {self.collection_id}: {str(e)}")
 
+    def get_collection_flat(self, **kwargs) -> str:
+        """Get a specific collection by ID in flattened format."""
+        try:
+            response = self._make_request('GET', f'/collections/{self.collection_id}')
+            flattened = self.parse_collection_to_flat_structure(response)
+            return json.dumps(flattened, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(
+                f"Exception when getting flattened collection {self.collection_id}: {stacktrace}")
+            raise ToolException(
+                f"Unable to get flattened collection {self.collection_id}: {str(e)}")
+
     def get_folder(self, folder_path: str, **kwargs) -> str:
         """Get folders from a collection by path."""
         try:
@@ -595,6 +623,19 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to get folder {folder_path} from collection {self.collection_id}: {str(e)}")
 
+    def get_folder_flat(self, folder_path: str, **kwargs) -> str:
+        """Get a specific folder in flattened format with path-based structure."""
+        try:
+            response = self._make_request('GET', f'/collections/{self.collection_id}')
+            flattened = self.parse_collection_to_flat_structure(response, folder_path)
+            return json.dumps(flattened, indent=2)
+        except Exception as e:
+            stacktrace = format_exc()
+            logger.error(
+                f"Exception when getting flattened folder {folder_path}: {stacktrace}")
+            raise ToolException(
+                f"Unable to get flattened folder {folder_path}: {str(e)}")
+
     def get_folder_requests(self, folder_path: str, include_details: bool = False, **kwargs) -> str:
         """Get detailed information about all requests in a folder."""
         try:
@@ -626,20 +667,55 @@ class PostmanApiWrapper(BaseToolApiWrapper):
                 f"Unable to get requests from folder {folder_path}: {str(e)}")
 
     def search_requests(self, query: str, search_in: str = "all", method: str = None, **kwargs) -> str:
-        """Search for requests across the collection."""
+        """Search for requests across the collection and return results in flattened structure."""
         try:
-            collection = self._make_request(
+            collection_response = self._make_request(
                 'GET', f'/collections/{self.collection_id}')
-            requests = self.analyzer.search_requests_in_items(
-                collection['collection']['item'], query, search_in, method)
-
+            
+            # Get the collection in flattened structure
+            flattened = self.parse_collection_to_flat_structure(collection_response)
+            
+            # Filter only requests that match the search criteria
+            matching_requests = {}
+            
+            for path, item in flattened['items'].items():
+                if item.get('type') != 'request':
+                    continue
+                
+                # Apply method filter if specified
+                if method and item.get('method', '').upper() != method.upper():
+                    continue
+                
+                # Apply search criteria
+                match_found = False
+                query_lower = query.lower()
+                
+                if search_in == "all" or search_in == "name":
+                    # Extract request name from path (last part after /)
+                    request_name = path.split('/')[-1] if '/' in path else path
+                    if query_lower in request_name.lower():
+                        match_found = True
+                
+                if not match_found and (search_in == "all" or search_in == "url"):
+                    url = item.get('request_url', '') or item.get('url', '')
+                    if query_lower in url.lower():
+                        match_found = True
+                
+                if not match_found and (search_in == "all" or search_in == "description"):
+                    description = item.get('description', '')
+                    if isinstance(description, str) and query_lower in description.lower():
+                        match_found = True
+                
+                if match_found:
+                    matching_requests[path] = item
+            
+            # Create result structure similar to flattened format
             result = {
-                "collection_id": self.collection_id,
                 "query": query,
                 "search_in": search_in,
                 "method_filter": method,
-                "results_count": len(requests),
-                "results": requests
+                "results_count": len(matching_requests),
+                "items": matching_requests
             }
 
             return json.dumps(result, indent=2)
@@ -649,83 +725,85 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to search requests in collection {self.collection_id}: {str(e)}")
 
-    def analyze_collection(self, include_improvements: bool = False, **kwargs) -> str:
-        """Analyze a collection for API quality and best practices."""
+    def analyze(self, scope: str = "collection", target_path: str = None, include_improvements: bool = False, **kwargs) -> str:
+        """Unified analysis method for collection, folder, or request analysis.
+        
+        Args:
+            scope: The scope of analysis ('collection', 'folder', or 'request')
+            target_path: The path to the folder or request (required for folder/request scope)
+            include_improvements: Whether to include improvement suggestions
+        """
         try:
-            collection = self._make_request(
-                'GET', f'/collections/{self.collection_id}')
-            analysis = self.analyzer.perform_collection_analysis(collection)
+            # Validate parameters
+            if scope not in ["collection", "folder", "request"]:
+                raise ToolException(f"Invalid scope '{scope}'. Must be 'collection', 'folder', or 'request'")
             
-            if include_improvements:
-                improvements = self.analyzer.generate_improvements(analysis)
-                analysis["improvements"] = improvements
-                analysis["improvement_count"] = len(improvements)
+            if scope in ["folder", "request"] and not target_path:
+                raise ToolException(f"target_path is required when scope is '{scope}'")
             
-            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 {self.collection_id}: {str(e)}")
-
-    def analyze_folder(self, folder_path: str, include_improvements: bool = False, **kwargs) -> str:
-        """Analyze a specific folder within a collection."""
-        try:
+            # Get collection data
             collection = self._make_request(
                 'GET', f'/collections/{self.collection_id}')
-            folders = self.analyzer.find_folders_by_path(
-                collection['collection']['item'], folder_path)
-
-            if not folders:
-                return json.dumps({"error": f"Folder '{folder_path}' not found"}, indent=2)
-
-            folder_analyses = []
-            for folder in folders:
-                analysis = self.analyzer.perform_folder_analysis(folder, folder_path)
+            
+            if scope == "collection":
+                # Analyze entire collection
+                analysis = self.analyzer.perform_collection_analysis(collection)
                 
                 if include_improvements:
-                    improvements = self.analyzer.generate_folder_improvements(analysis)
+                    improvements = self.analyzer.generate_improvements(analysis)
                     analysis["improvements"] = improvements
                     analysis["improvement_count"] = len(improvements)
                 
-                folder_analyses.append(analysis)
-
-            return json.dumps(folder_analyses, indent=2)
-        except Exception as e:
-            stacktrace = format_exc()
-            logger.error(f"Exception when analyzing folder: {stacktrace}")
-            raise ToolException(
-                f"Unable to analyze folder {folder_path}: {str(e)}")
+                return json.dumps(analysis, indent=2)
+                
+            elif scope == "folder":
+                # Analyze specific folder
+                folders = self.analyzer.find_folders_by_path(
+                    collection['collection']['item'], target_path)
 
-    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/{self.collection_id}')
-            collection_data = collection["collection"]
+                if not folders:
+                    return json.dumps({"error": f"Folder '{target_path}' not found"}, indent=2)
+
+                folder_analyses = []
+                for folder in folders:
+                    analysis = self.analyzer.perform_folder_analysis(folder, target_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)
+                
+            elif scope == "request":
+                # Analyze specific request
+                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")
+                # Find the request
+                request_item = self.analyzer.find_request_by_path(
+                    collection_data["item"], target_path)
+                if not request_item:
+                    raise ToolException(f"Request '{target_path}' not found")
 
-            # 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)
+                # Perform request analysis
+                analysis = self.analyzer.perform_request_analysis(request_item)
+                analysis["request_path"] = target_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)
+                return json.dumps(analysis, indent=2)
+                
         except Exception as e:
             stacktrace = format_exc()
-            logger.error(f"Exception when analyzing request: {stacktrace}")
+            logger.error(f"Exception when analyzing {scope}: {stacktrace}")
             raise ToolException(
-                f"Unable to analyze request {request_path}: {str(e)}")
+                f"Unable to analyze {scope} {target_path or self.collection_id}: {str(e)}")
 
     # =================================================================
     # COLLECTION MANAGEMENT METHODS
@@ -1482,7 +1560,7 @@ class PostmanApiWrapper(BaseToolApiWrapper):
     # HELPER METHODS
     # =================================================================
 
-    def get_request(self, request_path: str, **kwargs) -> str:
+    def get_request_by_path(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
@@ -1500,10 +1578,28 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             return json.dumps(response, indent=2)
         except Exception as e:
             stacktrace = format_exc()
-            logger.error(f"Exception when getting request: {stacktrace}")
+            logger.error(f"Exception when getting request by path: {stacktrace}")
             raise ToolException(
                 f"Unable to get request '{request_path}': {str(e)}")
 
+    def get_request_by_id(self, request_id: str, **kwargs) -> str:
+        """Get a specific request by ID.
+        
+        Directly fetches the request using its unique ID from the Postman API.
+        """
+        try:
+            # Fetch the complete request information from the API using the ID
+            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 by ID: {stacktrace}")
+            raise ToolException(
+                f"Unable to get request with ID '{request_id}': {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.
@@ -1549,3 +1645,143 @@ class PostmanApiWrapper(BaseToolApiWrapper):
             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)}")
+
+    def parse_collection_to_flat_structure(self, collection_response: Dict[str, Any], folder_path: str = None) -> Dict[str, Any]:
+        """Parse collection response into a flattened structure with path-based keys.
+        
+        Args:
+            collection_response: The Postman collection response JSON
+            folder_path: Optional folder path to filter results. If provided, only items
+                        within this folder will be included in the output, and collection
+                        metadata will be excluded.
+        """
+        collection = collection_response.get('collection', {})
+        info = collection.get('info', {})
+        
+        # If folder_path is specified, return minimal structure focused on the folder
+        if folder_path is not None:
+            result = {
+                "folder_path": folder_path,
+                "items": {}
+            }
+        else:
+            # Full collection structure with metadata
+            result = {
+                "collection_postman_id": info.get('_postman_id'),
+                "name": info.get('name'),
+                "updatedAt": info.get('updatedAt'),
+                "createdAt": info.get('createdAt'),
+                "lastUpdatedBy": info.get('lastUpdatedBy'),
+                "uid": info.get('uid'),
+                "items": {}
+            }
+        
+        def parse_items(items, parent_path=""):
+            """Recursively parse items into flat structure."""
+            for item in items:
+                item_name = item.get('name', '')
+                current_path = f"{parent_path}/{item_name}" if parent_path else item_name
+                
+                # If folder_path is specified, check if we should include this item
+                if folder_path is not None:
+                    # Check if current path is within the specified folder
+                    if not (current_path == folder_path or current_path.startswith(folder_path + "/")):
+                        # If this is a folder, we need to check if it contains the target folder
+                        if 'item' in item and folder_path.startswith(current_path + "/"):
+                            # This folder is an ancestor of the target folder, continue traversing
+                            parse_items(item['item'], current_path)
+                        continue
+                
+                # Check if this is a folder (has 'item' property) or a request
+                if 'item' in item:
+                    # This is a folder
+                    result['items'][current_path] = {
+                        "type": "folder",
+                        "id": item.get('id'),
+                        "uid": item.get('uid')
+                    }
+                    # Recursively parse nested items
+                    parse_items(item['item'], current_path)
+                else:
+                    # This is a request
+                    request_info = item.get('request', {})
+                    
+                    # Parse URL
+                    url_info = request_info.get('url', {})
+                    if isinstance(url_info, str):
+                        url = url_info
+                    else:
+                        # URL is an object with raw property
+                        url = url_info.get('raw', '')
+                    
+                    # Parse headers
+                    headers = request_info.get('header', [])
+                    
+                    # Parse body
+                    body_info = None
+                    body = request_info.get('body', {})
+                    if body:
+                        body_mode = body.get('mode', '')
+                        if body_mode == 'raw':
+                            try:
+                                raw_data = body.get('raw', '')
+                                if raw_data:
+                                    body_info = {
+                                        "type": "json",
+                                        "data": json.loads(raw_data) if raw_data.strip() else {}
+                                    }
+                            except json.JSONDecodeError:
+                                body_info = {
+                                    "type": "raw",
+                                    "data": body.get('raw', '')
+                                }
+                        elif body_mode == 'formdata':
+                            body_info = {
+                                "type": "formdata",
+                                "data": body.get('formdata', [])
+                            }
+                        elif body_mode == 'urlencoded':
+                            body_info = {
+                                "type": "urlencoded",
+                                "data": body.get('urlencoded', [])
+                            }
+                    
+                    # Parse URL parameters
+                    params = []
+                    if isinstance(url_info, dict):
+                        query = url_info.get('query', [])
+                        for param in query:
+                            if isinstance(param, dict):
+                                params.append({
+                                    "key": param.get('key', ''),
+                                    "value": param.get('value', ''),
+                                    "disabled": param.get('disabled', False)
+                                })
+                    
+                    request_data = {
+                        "id": item.get('id'),
+                        "uid": item.get('uid'),
+                        "full_postman_path": current_path,
+                        "type": "request",
+                        "method": request_info.get('method', 'GET'),
+                        "request_url": url,
+                        "headers": headers,
+                        "params": params
+                    }
+                    
+                    # Add body if present
+                    if body_info:
+                        request_data["body"] = body_info
+                    
+                    # Add description if present
+                    description = request_info.get('description')
+                    if description:
+                        request_data["description"] = description
+                    
+                    result['items'][current_path] = request_data
+        
+        # Parse the top-level items
+        items = collection.get('item', [])
+        parse_items(items)
+        
+        return result

alita_sdk/tools/utils/content_parser.py

@@ -9,13 +9,13 @@ import pymupdf
 from langchain_core.tools import ToolException
 from transformers import BlipProcessor, BlipForConditionalGeneration
 
-def parse_file_content(file_name, file_content, is_capture_image: bool = False, page_number: int = None):
+def parse_file_content(file_name, file_content, is_capture_image: bool = False, page_number: int = None, sheet_name: str = None):
     if file_name.endswith('.txt'):
         return parse_txt(file_content)
     elif file_name.endswith('.docx'):
         return read_docx_from_bytes(file_content)
     elif file_name.endswith('.xlsx') or file_name.endswith('.xls'):
-        return parse_excel(file_content)
+        return parse_excel(file_content, sheet_name)
     elif file_name.endswith('.pdf'):
         return parse_pdf(file_content, page_number, is_capture_image)
     elif file_name.endswith('.pptx'):
@@ -30,15 +30,25 @@ def parse_txt(file_content):
     except Exception as e:
         return ToolException(f"Error decoding file content: {e}")
 
-def parse_excel(file_content):
+def parse_excel(file_content, sheet_name = None):
     try:
         excel_file = io.BytesIO(file_content)
-        df = pd.read_excel(excel_file)
-        df.fillna('', inplace=True)
-        return df.to_string()
+        if sheet_name:
+            return parse_sheet(excel_file, sheet_name)
+        dfs = pd.read_excel(excel_file, sheet_name=sheet_name)
+        result = []
+        for sheet_name, df in dfs.items():
+            df.fillna('', inplace=True)
+            result.append(f"=== Sheet: {sheet_name} ===\n{df.to_string(index=False)}")
+        return "\n\n".join(result)
     except Exception as e:
         return ToolException(f"Error reading Excel file: {e}")
 
+def parse_sheet(excel_file, sheet_name):
+    df = pd.read_excel(excel_file, sheet_name=sheet_name)
+    df.fillna('', inplace=True)
+    return df.to_string()
+
 def parse_pdf(file_content, page_number, is_capture_image):
     with pymupdf.open(stream=file_content, filetype="pdf") as report:
         text_content = ''

{alita_sdk-0.3.157.dist-info → alita_sdk-0.3.159.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.157
+Version: 0.3.159
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedjik@gmail.com>
 License-Expression: Apache-2.0
@@ -31,8 +31,8 @@ Requires-Dist: langchain_community~=0.3.7; extra == "runtime"
 Requires-Dist: langchain-openai~=0.3.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-sqlite~=2.0.0; extra == "runtime"
 Requires-Dist: langgraph-checkpoint-postgres~=2.0.1; extra == "runtime"
-Requires-Dist: langsmith==0.1.144; extra == "runtime"
-Requires-Dist: langgraph~=0.2.53; extra == "runtime"
+Requires-Dist: langsmith>=0.3.45; extra == "runtime"
+Requires-Dist: langgraph>=0.4.8; extra == "runtime"
 Requires-Dist: langchain_chroma~=0.2.2; extra == "runtime"
 Requires-Dist: langchain-unstructured~=0.1.6; extra == "runtime"
 Requires-Dist: langchain-postgres~=0.0.13; extra == "runtime"
@@ -122,6 +122,7 @@ Requires-Dist: yagmail==0.15.293; extra == "tools"
 Requires-Dist: pysnc==1.1.10; extra == "tools"
 Requires-Dist: shortuuid==1.0.13; extra == "tools"
 Requires-Dist: yarl==1.17.1; extra == "tools"
+Requires-Dist: langmem==0.0.27; extra == "tools"
 Provides-Extra: community
 Requires-Dist: retry-extended==0.2.3; extra == "community"
 Requires-Dist: browser-use==0.1.43; extra == "community"

{alita_sdk-0.3.157.dist-info → alita_sdk-0.3.159.dist-info}/RECORD

@@ -43,12 +43,12 @@ alita_sdk/community/deep_researcher/utils/md_to_pdf.py,sha256=EgCaUGLsP5-5F301aB
 alita_sdk/community/deep_researcher/utils/os.py,sha256=Q1xX7c7_p7EmuzzXIAY9TDmraDNvU0GGcpfgIfWKQ2A,793
 alita_sdk/runtime/__init__.py,sha256=4W0UF-nl3QF2bvET5lnah4o24CoTwSoKXhuN0YnwvEE,828
 alita_sdk/runtime/clients/__init__.py,sha256=BdehU5GBztN1Qi1Wul0cqlU46FxUfMnI6Vq2Zd_oq1M,296
-alita_sdk/runtime/clients/artifact.py,sha256=33prjst8z3Wn3SZ8Xl2gJIgQmKzaJPDyaVzay87mDes,2643
+alita_sdk/runtime/clients/artifact.py,sha256=4N2t5x3GibyXLq3Fvrv2o_VA7Z000yNfc-UN4eGsHZg,2679
 alita_sdk/runtime/clients/client.py,sha256=jbC_M72CybwZgFfMRL6paj-NmICrSuk1vVnVTm_u-kc,19734
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/runtime/langchain/assistant.py,sha256=1G4yBhBc-tXgqerujUVu5Z8T49m_7ov-7zYYsm-jGb4,7511
+alita_sdk/runtime/langchain/assistant.py,sha256=QJEMiEOrFMJ4GpnK24U2pKFblrvdQpKFdfhZsI2wAUI,7507
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/runtime/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
@@ -102,12 +102,12 @@ alita_sdk/runtime/toolkits/artifact.py,sha256=7fTr9VpGd2zwCB3EwW4aqWa5jVKRTunqV3
 alita_sdk/runtime/toolkits/datasource.py,sha256=qk78OdPoReYPCWwahfkKLbKc4pfsu-061oXRryFLP6I,2498
 alita_sdk/runtime/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/runtime/toolkits/subgraph.py,sha256=ZYqI4yVLbEPAjCR8dpXbjbL2ipX598Hk3fL6AgaqFD4,1758
-alita_sdk/runtime/toolkits/tools.py,sha256=jGjavYf6tugvLJOU-Vc1L9bDtN295dVK9aqUk8dy490,6114
+alita_sdk/runtime/toolkits/tools.py,sha256=iDWnGpEnmiD226osSlMy7l5suUxOl6vDo8BTtzb8oCw,6128
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=BGppQADa1ZiLO17fC0uCACTTEvPHlodEDYEzUcBRbAA,2901
 alita_sdk/runtime/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
 alita_sdk/runtime/tools/application.py,sha256=7XSqwASZGihvQ9uZxnQp61ypFT6twrzBH_BIFC1cX0w,2785
-alita_sdk/runtime/tools/artifact.py,sha256=-5c4vAh1EC-brLwjVC2Q2yR8CkHc-A5Pyc-pQgKaOsU,6164
+alita_sdk/runtime/tools/artifact.py,sha256=ILpRclmyHCqz1Byb0zV9LBzI6r9YooNq7-2EYQZCTxU,6412
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
 alita_sdk/runtime/tools/function.py,sha256=ZFpd7TGwIawze2e7BHlKwP0NHwNw42wwrmmnXyJQJhk,2600
@@ -129,7 +129,7 @@ alita_sdk/runtime/utils/logging.py,sha256=svPyiW8ztDfhqHFITv5FBCj8UhLxz6hWcqGIY6
 alita_sdk/runtime/utils/save_dataframe.py,sha256=i-E1wp-t4wb17Zq3nA3xYwgSILjoXNizaQAA9opWvxY,1576
 alita_sdk/runtime/utils/streamlit.py,sha256=z4J_bdxkA0zMROkvTB4u379YBRFCkKh-h7PD8RlnZWQ,85644
 alita_sdk/runtime/utils/utils.py,sha256=dM8whOJAuFJFe19qJ69-FLzrUp6d2G-G6L7d4ss2XqM,346
-alita_sdk/tools/__init__.py,sha256=qsF21SiBa7P5gcWybCLP4K3xqA34LW9TVuM1QKaU-xc,9716
+alita_sdk/tools/__init__.py,sha256=F1Mrl8jEUUnmfg_VwrNcVSwJKPBp-xmh9vv9goPRA0o,9933
 alita_sdk/tools/elitea_base.py,sha256=NQaIxPX6DVIerHCb18jwUR6maZxxk73NZaTsFHkBQWE,21119
 alita_sdk/tools/ado/__init__.py,sha256=mD6GHcYMTtffPJkJvFPe2rzvye_IRmXmWfI7xYuZhO4,912
 alita_sdk/tools/ado/utils.py,sha256=PTCludvaQmPLakF2EbCGy66Mro4-rjDtavVP-xcB2Wc,1252
@@ -248,7 +248,7 @@ alita_sdk/tools/llm/llm_utils.py,sha256=v3_lWP_Nk6tJLkj0BYohOun0OWNfvzqLjPdPAMl-
 alita_sdk/tools/localgit/__init__.py,sha256=NScO0Eu-wl-rc63jjD5Qv1RXXB1qukSIJXx-yS_JQLI,2529
 alita_sdk/tools/localgit/local_git.py,sha256=gsAftNcK7nMCd8VsIkwDLs2SoG0MgpYdkQG5tmoynkA,18074
 alita_sdk/tools/localgit/tool.py,sha256=It_B24rMvFPurB355Oy5IShg2BsZTASsEoSS8hu2SXw,998
-alita_sdk/tools/memory/__init__.py,sha256=QBzuOQapovmbcFS4nG39p3g-fUPp3kQrjh8EGk6VmBs,1901
+alita_sdk/tools/memory/__init__.py,sha256=SOB5Lhf8v8v0-IDUXUgb1KNdv5je-ooi6oGor8iYPpI,2148
 alita_sdk/tools/ocr/__init__.py,sha256=pvslKVXyJmK0q23FFDNieuc7RBIuzNXTjTNj-GqhGb0,3335
 alita_sdk/tools/ocr/api_wrapper.py,sha256=08UF8wj1sR8DcW0z16pw19bgLatLkBF8dySW-Ds8iRk,29649
 alita_sdk/tools/ocr/text_detection.py,sha256=1DBxt54r3_HdEi93QynSIVta3rH3UpIvy799TPtDTtk,23825
@@ -273,7 +273,7 @@ alita_sdk/tools/pandas/statsmodels/descriptive.py,sha256=APdofBnEiRhMrn6tLKwH076
 alita_sdk/tools/pandas/statsmodels/hypothesis_testing.py,sha256=fdNAayMB3W7avMfKJCcbf2_P54vUXbq8KVebOB48348,10508
 alita_sdk/tools/pandas/statsmodels/regression.py,sha256=Y1pWK4u_qzrfA740K-FX0nZ5FREGGPk8mfvykPIYoiI,9164
 alita_sdk/tools/postman/__init__.py,sha256=W0HdtACnTZw6tnzj7_qY_X5RoRyX3czcUSVaZJjBW-Y,4236
-alita_sdk/tools/postman/api_wrapper.py,sha256=G6pfCzZUok25qHkiZQvte7lrPYF3gbZX01jx0Si9MN8,66869
+alita_sdk/tools/postman/api_wrapper.py,sha256=4Hf_aOvUB1G_BdlKvNaAqnQaoCnKDph-E7v4VEwaw5Y,77933
 alita_sdk/tools/postman/postman_analysis.py,sha256=2d-Oi2UORosIePIUyncSONw9hY7dw8Zc7BQvCd4aqpg,45115
 alita_sdk/tools/pptx/__init__.py,sha256=LNSTQk0BncfdWLXAOGX2WXezG3D4qSEuYwLpokmF9iM,3438
 alita_sdk/tools/pptx/pptx_wrapper.py,sha256=yyCYcTlIY976kJ4VfPo4dyxj4yeii9j9TWP6W8ZIpN8,29195
@@ -303,7 +303,7 @@ alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4F
 alita_sdk/tools/testrail/__init__.py,sha256=83G9oS2fSiATLnW9783LqdoDyubgnmABEk-1hQcsTGE,3805
 alita_sdk/tools/testrail/api_wrapper.py,sha256=QkF1j2QIdtqeWUZB0GYtdmKATu0gPTQVmM5faK-ASaI,24495
 alita_sdk/tools/utils/__init__.py,sha256=155xepXPr4OEzs2Mz5YnjXcBpxSv1X2eznRUVoPtyK0,3268
-alita_sdk/tools/utils/content_parser.py,sha256=-87Lrl3_50YFFxf6pcIWwyMwEC8tomgcg2qk15urem4,4262
+alita_sdk/tools/utils/content_parser.py,sha256=cdAENBS2-KPBAVbUczsuT-YJEdouKQ0SxCU6bWFfgak,4736
 alita_sdk/tools/xray/__init__.py,sha256=dn-Ine9mHF8c_yZ-pWkn-gvSvSmGwdrqxPJOz6Cmqc4,3297
 alita_sdk/tools/xray/api_wrapper.py,sha256=l7Cwvh_5bEaH0IM3yLo1PSClqV1E20wH_sEHaJntM3s,8517
 alita_sdk/tools/yagmail/__init__.py,sha256=c4Qn3em0tLxzRmFKpzbBgY9W2EnOoKf0azoDJHng5CY,2208
@@ -317,8 +317,8 @@ alita_sdk/tools/zephyr_enterprise/api_wrapper.py,sha256=Ir3zHljhbZQJRJJQOBzS_GL5
 alita_sdk/tools/zephyr_enterprise/zephyr_enterprise.py,sha256=hV9LIrYfJT6oYp-ZfQR0YHflqBFPsUw2Oc55HwK0H48,6809
 alita_sdk/tools/zephyr_scale/__init__.py,sha256=2NTcdrfkx4GSegqyXhsPLsEpc4FlACuDy85b0fk6cAo,4572
 alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=UHVQUVqcBc3SZvDfO78HSuBzwAsRw2cCDQa-xMOzndE,68663
-alita_sdk-0.3.157.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.157.dist-info/METADATA,sha256=IO3yoKg0xK703bmf11i1s-ifXSEuaWvZ6al0kqK6r9U,18667
-alita_sdk-0.3.157.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.157.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.157.dist-info/RECORD,,
+alita_sdk-0.3.159.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.159.dist-info/METADATA,sha256=C4uRfDlRMstPa_EMg1hsUN1lHDkB80Xnme6REnRJ_Yk,18714
+alita_sdk-0.3.159.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.159.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.159.dist-info/RECORD,,