alita-sdk 0.3.350__tar.gz → 0.3.352__tar.gz

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.350
+Version: 0.3.352
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -255,7 +255,7 @@ document_loaders_map = {
     },
     '.xml': {
         'class': UnstructuredXMLLoader,
-        'mime_type': 'application/xml',
+        'mime_type': 'text/xml',
         'is_multimodal_processing': False,
         'kwargs': {},
         'allowed_to_override': [
@@ -300,5 +300,43 @@ document_loaders_map = {
     }
 }
 
+code_extensions = [
+    # '.py',  # Python
+    '.js',  # JavaScript
+    '.ts',  # TypeScript
+    '.java',  # Java
+    '.cpp',  # C++
+    '.c',  # C
+    '.cs',  # C#
+    '.rb',  # Ruby
+    '.go',  # Go
+    '.php',  # PHP
+    '.swift',  # Swift
+    '.kt',  # Kotlin
+    '.rs',  # Rust
+    '.m',  # Objective-C
+    '.scala',  # Scala
+    '.pl',  # Perl
+    '.sh',  # Shell
+    '.bat',  # Batch
+    '.lua',  # Lua
+    '.r',  # R
+    '.pas',  # Pascal
+    '.asm',  # Assembly
+    '.dart',  # Dart
+    '.groovy',  # Groovy
+    '.sql',  # SQL
+]
+
+default_loader_config = {
+    'class': AlitaTextLoader,
+    'mime_type': 'text/plain',
+    'is_multimodal_processing': False,
+    'kwargs': {},
+    'allowed_to_override': ['max_tokens']
+}
+
+code_loaders_map = {ext: default_loader_config for ext in code_extensions}
+
 # Combined mapping for backward compatibility
-loaders_map = {**image_loaders_map, **document_loaders_map}
+loaders_map = {**image_loaders_map, **document_loaders_map, **code_loaders_map}

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -583,11 +583,10 @@ def create_graph(
                     available_tools = [tool for tool in tools if isinstance(tool, BaseTool)]
                 
                 lg_builder.add_node(node_id, LLMNode(
-                    client=client, 
-                    prompt=node.get('prompt', {}),
-                    name=node['id'], 
+                    client=client,
+                    input_mapping=node.get('input_mapping', {'messages': {'type': 'variable', 'value': 'messages'}}),
+                    name=node['id'],
                     return_type='dict',
-                    response_key=node.get('response_key', 'messages'),
                     structured_output_dict=output_vars_dict,
                     output_variables=output_vars,
                     input_variables=node.get('input', ['messages']),

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk/runtime/tools/llm.py

@@ -1,73 +1,31 @@
-import json
 import logging
 from traceback import format_exc
-from typing import Any, Optional, Dict, List, Union
+from typing import Any, Optional, List, Union
 
-from langchain_core.messages import HumanMessage, BaseMessage, SystemMessage, AIMessage
-from langchain_core.tools import BaseTool, ToolException
+from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool, ToolException
 from pydantic import Field
 
-from ..langchain.utils import _extract_json, create_pydantic_model, create_params
+from ..langchain.utils import create_pydantic_model, propagate_the_input_mapping
 
 logger = logging.getLogger(__name__)
 
-
-def create_llm_input_with_messages(
-    prompt: Dict[str, str],
-    params: Dict[str, Any]
-) -> List[BaseMessage]:
-    """
-    Create LLM input by combining system prompt with chat history messages.
-    
-    Args:
-        prompt: The prompt configuration with template
-        params: Additional parameters for prompt formatting
-        
-    Returns:
-        List of messages to send to LLM
-    """
-    logger.info(f"Creating LLM input with params: {params}")
-    
-    # Build the input messages
-    input_messages = []
-    messages = params.get('messages', [])
-    
-    # Add system message from prompt if available
-    if prompt:
-        try:
-            # Format the system message using the prompt template or value and params
-            prompt_str = prompt['template'] if 'template' in prompt else prompt['value']
-            prompt_content = prompt_str.format(**params) if params else prompt_str
-            # if user hasn't specified chat history, add system message as HumanMessage
-            input_messages.append(SystemMessage(content=prompt_content) if messages else HumanMessage(content=prompt_content))
-        except KeyError as e:
-            error_msg = f"KeyError in prompt formatting: {e}. Available params: {list(params.keys())}"
-            logger.error(error_msg)
-            raise ToolException(error_msg)
-    
-    # Add the chat history messages
-
-    if messages:
-        input_messages.extend(messages)
-
-    return input_messages
-
-
 class LLMNode(BaseTool):
     """Enhanced LLM node with chat history and tool binding support"""
     
     # Override BaseTool required fields
     name: str = Field(default='LLMNode', description='Name of the LLM node')
-    description: str = Field(default='This is tool node for LLM with chat history and tool support', description='Description of the LLM node')
-    
+    description: str = Field(default='This is tool node for LLM with chat history and tool support',
+                             description='Description of the LLM node')
+
     # LLM-specific fields
-    prompt: Dict[str, str] = Field(default_factory=dict, description='Prompt configuration')
     client: Any = Field(default=None, description='LLM client instance')
     return_type: str = Field(default="str", description='Return type')
     response_key: str = Field(default="messages", description='Response key')
     structured_output_dict: Optional[dict[str, str]] = Field(default=None, description='Structured output dictionary')
     output_variables: Optional[List[str]] = Field(default=None, description='Output variables')
+    input_mapping: Optional[dict[str, dict]] = Field(default=None, description='Input mapping')
     input_variables: Optional[List[str]] = Field(default=None, description='Input variables')
     structured_output: Optional[bool] = Field(default=False, description='Whether to use structured output')
     available_tools: Optional[List[BaseTool]] = Field(default=None, description='Available tools for binding')
@@ -101,10 +59,10 @@ class LLMNode(BaseTool):
         return filtered_tools
 
     def invoke(
-        self,
-        state: Union[str, dict],
-        config: Optional[RunnableConfig] = None,
-        **kwargs: Any,
+            self,
+            state: Union[str, dict],
+            config: Optional[RunnableConfig] = None,
+            **kwargs: Any,
     ) -> dict:
         """
         Invoke the LLM node with proper message handling and tool binding.
@@ -118,24 +76,33 @@ class LLMNode(BaseTool):
             Updated state with LLM response
         """
         # Extract messages from state
-        
-        messages = state.get("messages", []) if isinstance(state, dict) else []
-        logger.info(f"Invoking LLMNode with {len(messages)} messages")
-        logger.info("Messages: %s", messages)
-        # Create parameters for prompt formatting from state
-        params = {}
-        if isinstance(state, dict):
-            params = {var: state[var] for var in (self.input_variables or []) if var != "messages" and var in state}
-            # message as a part of chat history added ONLY if "messages" is in input_variables
-            if "messages" in (self.input_variables or []):
-                params["messages"] = messages
-        
-        # Create LLM input with proper message handling
-        llm_input = create_llm_input_with_messages(self.prompt, params)
-        
+
+        func_args = propagate_the_input_mapping(input_mapping=self.input_mapping, input_variables=self.input_variables,
+                                                state=state)
+
+        # there are 2 possible flows here: LLM node from pipeline (with prompt and task)
+        # or standalone LLM node for chat (with messages only)
+        if 'system' in func_args.keys():
+            # Flow for LLM node with prompt/task from pipeline
+            if not func_args.get('system') or not func_args.get('task'):
+                raise ToolException(f"LLMNode requires 'system' and 'task' parameters in input mapping. "
+                                    f"Actual params: {func_args}")
+            messages = [SystemMessage(content=func_args.get('system')), HumanMessage(content=func_args.get('task'))]
+            messages.extend(func_args.get('chat_history', []))
+        else:
+            # Flow for chat-based LLM node w/o prompt/task from pipeline but with messages in state
+            # verify messages structure
+            messages = state.get("messages", []) if isinstance(state, dict) else []
+            if messages:
+                # the last message has to be HumanMessage
+                if not isinstance(messages[-1], HumanMessage):
+                    raise ToolException("LLMNode requires the last message to be a HumanMessage")
+            else:
+                raise ToolException("LLMNode requires 'messages' in state for chat-based interaction")
+
         # Get the LLM client, potentially with tools bound
         llm_client = self.client
-        
+
         if len(self.tool_names or []) > 0:
             filtered_tools = self.get_filtered_tools()
             if filtered_tools:
@@ -143,7 +110,7 @@ class LLMNode(BaseTool):
                 llm_client = self.client.bind_tools(filtered_tools)
             else:
                 logger.warning("No tools to bind to LLM")
-        
+
         try:
             if self.structured_output and self.output_variables:
                 # Handle structured output
@@ -156,17 +123,17 @@ class LLMNode(BaseTool):
                 }
                 struct_model = create_pydantic_model(f"LLMOutput", struct_params)
                 llm = llm_client.with_structured_output(struct_model)
-                completion = llm.invoke(llm_input, config=config)
+                completion = llm.invoke(messages, config=config)
                 result = completion.model_dump()
-                
+
                 # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
-                
+
                 return result
             else:
                 # Handle regular completion
-                completion = llm_client.invoke(llm_input, config=config)
+                completion = llm_client.invoke(messages, config=config)
                 logger.info(f"Initial completion: {completion}")
                 # Handle both tool-calling and regular responses
                 if hasattr(completion, 'tool_calls') and completion.tool_calls:
@@ -174,24 +141,30 @@ class LLMNode(BaseTool):
                     new_messages = messages + [completion]
                     max_iterations = 15
                     iteration = 0
-                    
+
                     # Continue executing tools until no more tool calls or max iterations reached
                     current_completion = completion
-                    while (hasattr(current_completion, 'tool_calls') and 
-                           current_completion.tool_calls and 
+                    while (hasattr(current_completion, 'tool_calls') and
+                           current_completion.tool_calls and
                            iteration < max_iterations):
-                        
+
                         iteration += 1
                         logger.info(f"Tool execution iteration {iteration}/{max_iterations}")
-                        
+
                         # Execute each tool call in the current completion
-                        tool_calls = current_completion.tool_calls if hasattr(current_completion.tool_calls, '__iter__') else []
-                        
+                        tool_calls = current_completion.tool_calls if hasattr(current_completion.tool_calls,
+                                                                              '__iter__') else []
+
                         for tool_call in tool_calls:
-                            tool_name = tool_call.get('name', '') if isinstance(tool_call, dict) else getattr(tool_call, 'name', '')
-                            tool_args = tool_call.get('args', {}) if isinstance(tool_call, dict) else getattr(tool_call, 'args', {})
-                            tool_call_id = tool_call.get('id', '') if isinstance(tool_call, dict) else getattr(tool_call, 'id', '')
-                            
+                            tool_name = tool_call.get('name', '') if isinstance(tool_call, dict) else getattr(tool_call,
+                                                                                                              'name',
+                                                                                                              '')
+                            tool_args = tool_call.get('args', {}) if isinstance(tool_call, dict) else getattr(tool_call,
+                                                                                                              'args',
+                                                                                                              {})
+                            tool_call_id = tool_call.get('id', '') if isinstance(tool_call, dict) else getattr(
+                                tool_call, 'id', '')
+
                             # Find the tool in filtered tools
                             filtered_tools = self.get_filtered_tools()
                             tool_to_execute = None
@@ -199,12 +172,12 @@ class LLMNode(BaseTool):
                                 if tool.name == tool_name:
                                     tool_to_execute = tool
                                     break
-                            
+
                             if tool_to_execute:
                                 try:
                                     logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
                                     tool_result = tool_to_execute.invoke(tool_args)
-                                    
+
                                     # Create tool message with result
                                     from langchain_core.messages import ToolMessage
                                     tool_message = ToolMessage(
@@ -212,7 +185,7 @@ class LLMNode(BaseTool):
                                         tool_call_id=tool_call_id
                                     )
                                     new_messages.append(tool_message)
-                                    
+
                                 except Exception as e:
                                     logger.error(f"Error executing tool '{tool_name}': {e}")
                                     # Create error tool message
@@ -231,26 +204,26 @@ class LLMNode(BaseTool):
                                     tool_call_id=tool_call_id
                                 )
                                 new_messages.append(tool_message)
-                        
+
                         # Call LLM again with tool results to get next response
                         try:
                             current_completion = llm_client.invoke(new_messages, config=config)
                             new_messages.append(current_completion)
-                            
+
                             # Check if we still have tool calls
                             if hasattr(current_completion, 'tool_calls') and current_completion.tool_calls:
                                 logger.info(f"LLM requested {len(current_completion.tool_calls)} more tool calls")
                             else:
                                 logger.info("LLM completed without requesting more tools")
                                 break
-                                
+
                         except Exception as e:
                             logger.error(f"Error in LLM call during iteration {iteration}: {e}")
                             # Add error message and break the loop
                             error_msg = f"Error processing tool results in iteration {iteration}: {str(e)}"
                             new_messages.append(AIMessage(content=error_msg))
                             break
-                    
+
                     # Log completion status
                     if iteration >= max_iterations:
                         logger.warning(f"Reached maximum iterations ({max_iterations}) for tool execution")
@@ -259,30 +232,25 @@ class LLMNode(BaseTool):
                         new_messages.append(AIMessage(content=warning_msg))
                     else:
                         logger.info(f"Tool execution completed after {iteration} iterations")
-                    
+
                     return {"messages": new_messages}
                 else:
                     # Regular text response
                     content = completion.content.strip() if hasattr(completion, 'content') else str(completion)
-                    
+
                     # Try to extract JSON if output variables are specified (but exclude 'messages' which is handled separately)
                     json_output_vars = [var for var in (self.output_variables or []) if var != 'messages']
                     if json_output_vars:
-                        try:
-                            response = _extract_json(content) or {}
-                            response_data = {key: response.get(key, content) for key in json_output_vars}
-                        except (ValueError, json.JSONDecodeError) as e:
-                            logger.warning(
-                                f"Expected JSON output but got plain text. Output variables specified: {json_output_vars}. Error: {e}")
-                            response_data = {var: content for var in json_output_vars}
+                        # set response to be the first output variable for non-structured output
+                        response_data = {json_output_vars[0]: content}
                         new_messages = messages + [AIMessage(content=content)]
                         response_data['messages'] = new_messages
                         return response_data
-                    
+
                     # Simple text response (either no output variables or JSON parsing failed)
                     new_messages = messages + [AIMessage(content=content)]
                     return {"messages": new_messages}
-                        
+
         except Exception as e:
             logger.error(f"Error in LLM Node: {format_exc()}")
             error_msg = f"Error: {e}"
@@ -291,4 +259,4 @@ class LLMNode(BaseTool):
 
     def _run(self, *args, **kwargs):
         # Legacy support for old interface
-        return self.invoke(kwargs, **kwargs)
+        return self.invoke(kwargs, **kwargs)

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk/tools/ado/repos/repos_wrapper.py

@@ -644,6 +644,9 @@ class ReposApiWrapper(BaseCodeToolApiWrapper):
 
         return dumps(data)
 
+    def download_file(self, path):
+        return b"".join(self._client.get_item_content(self.repository_id, path=path, project=self.project, download=True))
+
     def get_file_content(self, commit_id, path):
         version_descriptor = GitVersionDescriptor(
             version=commit_id, version_type="commit"

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk/tools/ado/wiki/ado_wrapper.py

@@ -1,5 +1,7 @@
 import hashlib
 import logging
+import re
+import requests
 from typing import Generator, Literal, Optional
 
 from azure.devops.connection import Connection
@@ -15,8 +17,11 @@ from pydantic import create_model, PrivateAttr, SecretStr
 from pydantic import model_validator
 from pydantic.fields import Field
 
+import alita_sdk.tools.ado.work_item
+from ..repos import ReposApiWrapper
 from ...non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ...utils.available_tools_decorator import extend_with_parent_available_tools
+from ...utils.content_parser import parse_file_content
 from ....runtime.utils.utils import IndexerKeywords
 
 logger = logging.getLogger(__name__)
@@ -29,13 +34,17 @@ GetWikiInput = create_model(
 GetPageByPathInput = create_model(
     "GetPageByPathInput",
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
-    page_name=(str, Field(description="Wiki page path"))
+    page_name=(str, Field(description="Wiki page path")),
+    image_description_prompt=(Optional[str],
+                              Field(description="Prompt which is used for image description", default=None))
 )
 
 GetPageByIdInput = create_model(
     "GetPageByIdInput",
     wiki_identified=(str, Field(description="Wiki ID or wiki name")),
-    page_id=(int, Field(description="Wiki page ID"))
+    page_id=(int, Field(description="Wiki page ID")),
+    image_description_prompt=(Optional[str],
+                              Field(description="Prompt which is used for image description", default=None))
 )
 
 ModifyPageInput = create_model(
@@ -94,24 +103,75 @@ class AzureDevOpsApiWrapper(NonCodeIndexerToolkit):
             logger.error(f"Error during the attempt to extract wiki: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki: {str(e)}")
 
-    def get_wiki_page_by_path(self, wiki_identified: str, page_name: str):
+    def get_wiki_page_by_path(self, wiki_identified: str, page_name: str, image_description_prompt=None):
         """Extract ADO wiki page content."""
         try:
-            return self._client.get_page(project=self.project, wiki_identifier=wiki_identified, path=page_name,
-                                         include_content=True).page.content
+            return self._process_images(self._client.get_page(project=self.project, wiki_identifier=wiki_identified, path=page_name,
+                                         include_content=True).page.content,
+                                        image_description_prompt=image_description_prompt)
         except Exception as e:
             logger.error(f"Error during the attempt to extract wiki page: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki page: {str(e)}")
 
-    def get_wiki_page_by_id(self, wiki_identified: str, page_id: int):
+    def get_wiki_page_by_id(self, wiki_identified: str, page_id: int, image_description_prompt=None):
         """Extract ADO wiki page content."""
         try:
-            return (self._client.get_page_by_id(project=self.project, wiki_identifier=wiki_identified, id=page_id,
-                                                include_content=True).page.content)
+            return self._process_images(self._client.get_page_by_id(project=self.project, wiki_identifier=wiki_identified, id=page_id,
+                                                include_content=True).page.content,
+                                        image_description_prompt=image_description_prompt)
         except Exception as e:
             logger.error(f"Error during the attempt to extract wiki page: {str(e)}")
             return ToolException(f"Error during the attempt to extract wiki page: {str(e)}")
 
+    def _process_images(self, page_content: str, image_description_prompt=None):
+
+        image_pattern = r"!\[(.*?)\]\((.*?)\)"
+        matches = re.findall(image_pattern, page_content)
+
+        for image_name, image_url in matches:
+            if image_url.startswith("/.attachments/"):
+                try:
+                    description = self.process_attachment(attachment_url=image_url,
+                                                          attachment_name=image_name,
+                                                          image_description_prompt=image_description_prompt)
+                except Exception as e:
+                    logger.error(f"Error parsing attachment: {str(e)}")
+                    description = f"Error parsing attachment: {image_url}"
+            else:
+                try:
+                    response = requests.get(image_url)
+                    response.raise_for_status()
+                    file_content = response.content
+                    description = parse_file_content(
+                        file_content=file_content,
+                        file_name="image.png",
+                        llm=self.llm,
+                        prompt=image_description_prompt
+                    )
+                except Exception as e:
+                    logger.error(f"Error fetching external image: {str(e)}")
+                    description = f"Error fetching external image: image_url"
+
+            new_image_markdown = f"![{image_name}]({description})"
+            page_content = page_content.replace(f"![{image_name}]({image_url})", new_image_markdown)
+        return page_content
+
+    def process_attachment(self, attachment_url, attachment_name, image_description_prompt):
+        wiki_master_branch = "wikiMaster"
+        repos_wrapper = ReposApiWrapper(organization_url=self.organization_url,
+                                        project=self.project,
+                                        token=self.token.get_secret_value(),
+                                        repository_id="Test_agent.wiki",
+                                        base_branch=wiki_master_branch,
+                                        active_branch=wiki_master_branch)
+        attachment_content = repos_wrapper.download_file(path=attachment_url)
+        return parse_file_content(
+            file_content=attachment_content,
+            file_name=attachment_name,
+            llm=self.llm,
+            prompt=image_description_prompt
+        )
+
     def delete_page_by_path(self, wiki_identified: str, page_name: str):
         """Extract ADO wiki page content."""
         try:

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.350
+Version: 0.3.352
 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 <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.350 → alita_sdk-0.3.352}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "alita_sdk"
-version = "0.3.350"
+version = "0.3.352"
 description = "SDK for building langchain agents using resources from Alita"
 readme = "README.md"
 requires-python = ">=3.10"