alita-sdk 0.3.115__py3-none-any.whl → 0.3.117__py3-none-any.whl

alita_sdk/community/analysis/jira_analyse/__init__.py

@@ -90,10 +90,8 @@ class AnalyseJira(BaseToolkit):
         jira_username = kwargs.get('jira_username')
         jira_token = kwargs.get('jira_token')
         jira_api_key = kwargs.get('jira_api_key')
-        try:
-            jira_custom_fields = json.loads(kwargs.get('jira_custom_fields', '{}'))
-        except:
-            jira_custom_fields = {}
+       
+        jira_custom_fields = kwargs.get('jira_custom_fields', {})
         jira_custom_fields['team'] = kwargs.get('team_field', '')
         jira_custom_fields['environment'] = kwargs.get('environment_field', '')
         closed_status = kwargs.get('closed_status', '')

alita_sdk/community/analysis/jira_analyse/api_wrapper.py

@@ -99,8 +99,6 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
     ):
         """
         Extract Jira issues for the specified projects.
-        projects: str
-            one or more projects keys separated with comma
         closed_issues_based_on: int
             define whether issues can be thought as closed based on their status (1) or not empty resolved date (2)
         resolved_after: str
@@ -111,8 +109,9 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
             created after date (i.e. 2023-01-01)
         add_filter: str
             additional filter for Jira issues in JQL format like "customfield_10000 = 'value' AND customfield_10001 = 'value'"
+        project_keys: str
+            one or more projects keys separated with comma
         """
-
         if not (
             (
                 closed_issues_based_on == 1
@@ -123,15 +122,21 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
             return (
                 "ERROR: Check input parameters closed_issues_based_on and closed_status"
             )
+        
+        project_keys = project_keys or self.project_keys
 
         dispatch_custom_event(
-            name="jira_issues_extraction_start",
+            name="thinking_step",
             data={
-                "closed_issues_based_on": closed_issues_based_on,
-                "closed_status": self.closed_status,
-            }
+                "message": f"I am extracting Jira issues with initial parameters:\
+                    project keys: {project_keys}, closed status: {self.closed_status},\
+                    defects name: {self.defects_name}, custom fields: {self.custom_fields}, \
+                    closed status based on: {closed_issues_based_on}, resolved after: {resolved_after}, \
+                    updated after: {updated_after}, created after: {created_after}, additional filter:{add_filter}",
+                "tool_name": "jira_issues_extraction_start",
+                "toolkit": "analyse_jira",
+            },
         )
-        project_keys = project_keys or self.project_keys
 
         jira_issues = JiraIssues(
             self.jira,
@@ -144,12 +149,15 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
         df_issues, df_map = jira_issues.extract_issues_from_jira_and_transform(
             self.custom_fields, (resolved_after, updated_after, created_after)
         )
+
         dispatch_custom_event(
-            name="jira_issues_extracted",
+            name="thinking_step",
             data={
-                "project_keys": jira_issues.projects,
-                "issue_count": len(df_issues),
-                "map_rows": len(df_map),
+                "message": f"I am saving the extracted Jira issues to the artifact repository. \
+                            issues count: {len(df_issues)}, mapping rows: {len(df_map)}, \
+                            output file: {OUTPUT_MAPPING_FILE}{jira_issues.projects}.csv",
+                "tool_name": "get_jira_issues",
+                "toolkit": "analyse_jira",
             },
         )
         self.save_dataframe(
@@ -157,13 +165,6 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
             f"{OUTPUT_MAPPING_FILE}{jira_issues.projects}.csv",
             csv_options={"index_label": "id"},
         )
-        dispatch_custom_event(
-            name="jira_map_statuces_saved",
-            data={
-                "output_file": f"{OUTPUT_MAPPING_FILE}{jira_issues.projects}.csv",
-                "row_count": len(df_map),
-            }
-        )
 
         if not df_issues.empty:
             self.save_dataframe(
@@ -172,11 +173,14 @@ class JiraAnalyseWrapper(BaseToolApiWrapper):
                 csv_options={"index_label": "id"},
             )
             dispatch_custom_event(
-                name="jira_issues_saved",
+                name="thinking_step",
                 data={
-                    "output_file": f"{OUTPUT_WORK_ITEMS_FILE}{jira_issues.projects}.csv",
-                    "row_count": len(df_issues),
-                }
+                    "message": f"Saving Jira issues to the file . \
+                                 output file: {OUTPUT_WORK_ITEMS_FILE}{jira_issues.projects}.csv,\
+                                 row count: {len(df_issues)}",
+                    "tool_name": "get_jira_issues",
+                    "toolkit": "analyse_jira",
+                },
             )
 
         return f"{jira_issues.projects} Data has been extracted successfully."

alita_sdk/langchain/langraph_agent.py

@@ -26,6 +26,7 @@ from ..tools.loop_output import LoopToolNode
 from ..tools.tool import ToolNode
 from ..utils.evaluate import EvaluateTemplate
 from ..utils.utils import clean_string, TOOLKIT_SPLITTER
+from ..tools.router import RouterNode
 
 logger = logging.getLogger(__name__)
 
@@ -124,6 +125,58 @@ class TransitionalEdge(Runnable):
         return self.next_step if self.next_step != 'END' else END
 
 
+class StateModifierNode(Runnable):
+    name = "StateModifierNode"
+
+    def __init__(self, template: str, variables_to_clean: Optional[list[str]] = None, 
+                 input_variables: Optional[list[str]] = None, 
+                 output_variables: Optional[list[str]] = None):
+        self.template = template
+        self.variables_to_clean = variables_to_clean or []
+        self.input_variables = input_variables or ["messages"]
+        self.output_variables = output_variables or []
+
+    def invoke(self, state: Annotated[BaseStore, InjectedStore()], config: Optional[RunnableConfig] = None) -> dict:
+        logger.info(f"Modifying state with template: {self.template}")
+
+        # Collect input variables from state
+        input_data = {}
+        for var in self.input_variables:
+            if var in state:
+                input_data[var] = state.get(var)
+
+        # Render the template using Jinja
+        from jinja2 import Template
+        rendered_message = Template(self.template).render(**input_data)
+        result = {}
+        # Store the rendered message in the state or messages
+        if len(self.output_variables) > 0:
+            # Use the first output variable to store the rendered content
+            output_var = self.output_variables[0]
+            result[output_var] = rendered_message
+
+        # Clean up specified variables (make them empty, not delete)
+        
+        for var in self.variables_to_clean:
+            if var in state:
+                # Empty the variable based on its type
+                if isinstance(state[var], list):
+                    result[var] = []
+                elif isinstance(state[var], dict):
+                    result[var] = {}
+                elif isinstance(state[var], str):
+                    result[var] = ""
+                elif isinstance(state[var], (int, float)):
+                    result[var] = 0
+                elif state[var] is None:
+                    pass
+                else:
+                    # For other types, set to None
+                    result[var] = None
+        logger.info(f"State modifier result: {result}")
+        return result
+
+
 def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=[], interrupt_after=[]):
     # prepare output channels
     output_channels = (
@@ -283,6 +336,32 @@ def create_graph(
                     output_variables=node.get('output', []),
                     input_variables=node.get('input', ['messages']),
                     structured_output=node.get('structured_output', False)))
+            elif node_type == 'router':
+                # Add a RouterNode as an independent node
+                lg_builder.add_node(node_id, RouterNode(
+                    name=node['id'],
+                    condition=node.get('condition', ''),
+                    routes=node.get('routes', []),
+                    default_output=node.get('default_output', 'END'),
+                    input_variables=node.get('input', ['messages'])
+                ))
+                # Add a single conditional edge for all routes
+                lg_builder.add_conditional_edges(
+                    node_id,
+                    ConditionalEdge(
+                        condition="{{router_output}}",  # router node returns the route key in 'router_output'
+                        condition_inputs=["router_output"],
+                        conditional_outputs=node.get('routes', []),
+                        default_output=node.get('default_output', 'END')
+                    )
+                )
+            elif node_type == 'state_modifier':
+                lg_builder.add_node(node_id, StateModifierNode(
+                    template=node.get('template', ''),
+                    variables_to_clean=node.get('variables_to_clean', []),
+                    input_variables=node.get('input', ['messages']),
+                    output_variables=node.get('output', [])
+                ))
             if node.get('transition'):
                 next_step = clean_string(node['transition'])
                 logger.info(f'Adding transition: {next_step}')
@@ -294,7 +373,7 @@ def create_graph(
                     node['decision'].get('description', ""),
                     decisional_inputs=node['decision'].get('decisional_inputs', ['messages']),
                     default_output=node['decision'].get('default_output', 'END')))
-            elif node.get('condition'):
+            elif node.get('condition') and node_type != 'router':
                 logger.info(f'Adding condition: {node["condition"]}')
                 condition_input = node['condition'].get('condition_input', ['messages'])
                 condition_definition = node['condition'].get('condition_definition', '')

alita_sdk/langchain/utils.py

@@ -128,7 +128,7 @@ def parse_type(type_str):
 
 
 def create_state(data: Optional[dict] = None):
-    state_dict = {'input': str,}
+    state_dict = {'input': str, 'router_output': str}  # Always include router_output
     if not data:
         data = {'messages': 'list[str]'}
     for key, value in data.items():

alita_sdk/tools/router.py

@@ -0,0 +1,35 @@
+import logging
+from typing import Any, Optional, Union, List
+from langchain_core.runnables import RunnableConfig
+from langchain_core.tools import BaseTool
+from ..utils.evaluate import EvaluateTemplate
+from ..utils.utils import clean_string
+
+logger = logging.getLogger(__name__)
+
+class RouterNode(BaseTool):
+    name: str = 'RouterNode'
+    description: str = 'A router node that evaluates a condition and routes accordingly.'
+    condition: str = ''
+    routes: List[str] = []  # List of possible output node keys
+    default_output: str = 'END'
+    input_variables: Optional[list[str]] = None
+
+    def invoke(self, state: Union[str, dict], config: Optional[RunnableConfig] = None, **kwargs: Any) -> dict:
+        input_data = {}
+        for field in self.input_variables or []:
+            input_data[field] = state.get(field, "")
+        template = EvaluateTemplate(self.condition, input_data)
+        result = template.evaluate()
+        logger.info(f"RouterNode evaluated condition '{self.condition}' with input {input_data} => {result}")
+        result = clean_string(str(result))
+        if result in self.routes:
+            # If the result is one of the routes, return it
+            return {"router_output": result}
+        elif result == self.default_output:
+            # If the result is the default output, return it
+            return {"router_output": clean_string(self.default_output)}
+        return {"router_output": 'END'}
+
+    def _run(self, *args, **kwargs):
+        return self.invoke(**kwargs)

alita_sdk/utils/AlitaCallback.py

@@ -1,6 +1,7 @@
 import logging
 import json
 import traceback
+from datetime import datetime, timezone
 from uuid import UUID, uuid4
 from typing import Any, Dict, List, Optional
 from collections import defaultdict
@@ -51,6 +52,35 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
     # Tool
     #
 
+    def on_custom_event(
+        self,
+        name: str,
+        data: Any,
+        *,
+        run_id: UUID,
+        tags: Optional[List[str]] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs: Any,
+    ) -> None:
+        """Callback containing a group of custom events"""
+
+        payload = {
+            "name": name,
+            "run_id": str(run_id),
+            "tool_run_id": str(run_id),  # compatibility
+            "metadata": metadata,
+            "datetime": str(datetime.now(tz=timezone.utc)),
+            **data,
+        }
+        payload = json.loads(
+            json.dumps(payload, ensure_ascii=False, default=lambda o: str(o))
+        )
+
+        self.callback_state[str(run_id)] = self.st.status(
+            f"Running {payload.get("tool_name")}...", expanded=True
+        )
+        self.callback_state[str(run_id)].write(f"Tool inputs: {payload}")
+
     def on_tool_start(self, *args, run_id: UUID, **kwargs):
         """ Callback """
         if self.debug:
@@ -125,7 +155,7 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
 
         self.current_model_name = metadata.get('ls_model_name', self.current_model_name)
         llm_run_id = str(run_id)
-        
+
         self.callback_state[llm_run_id] = self.st.status(f"Running LLM ...", expanded=True)
         self.callback_state[llm_run_id].write(f"LLM inputs: {messages}")
 
@@ -176,4 +206,4 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
             log.debug("on_llm_end(%s, %s)", response, kwargs)
         llm_run_id = str(run_id)
         self.callback_state[llm_run_id].update(label=f"Completed LLM call", state="complete", expanded=False)
-        self.callback_state.pop(llm_run_id, None)
+        self.callback_state.pop(llm_run_id, None)

{alita_sdk-0.3.115.dist-info → alita_sdk-0.3.117.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.115
+Version: 0.3.117
 Summary: SDK for building langchain agents using resouces 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>
 Project-URL: Homepage, https://projectalita.ai

{alita_sdk-0.3.115.dist-info → alita_sdk-0.3.117.dist-info}/RECORD

@@ -10,8 +10,8 @@ alita_sdk/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1
 alita_sdk/community/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/community/utils.py,sha256=lvuCJaNqVPHOORJV6kIPcXJcdprVW_TJvERtYAEgpjM,249
 alita_sdk/community/analysis/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/community/analysis/jira_analyse/__init__.py,sha256=bimXRFxQ4mUO3X-_9IPulLJe8k8G2JTZPf8e2zmB1dg,6020
-alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=ISLmKcawStahxgsf0I2Nav6yIq19K_L-gkBM_XJ8NTY,8691
+alita_sdk/community/analysis/jira_analyse/__init__.py,sha256=Rm-HKEi_HIxrgHdq9mZ-XzxMKLXm8-81eJwJT2lar-c,5945
+alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=FPYAOh2SV5ggWg0ywDdkyt6udyR3juQvZM7lOIwvcKU,9327
 alita_sdk/community/browseruse/__init__.py,sha256=uAxPZEX7ihpt8HtcGDFrzTNv9WcklT1wG1ItTwUO8y4,3601
 alita_sdk/community/browseruse/api_wrapper.py,sha256=Y05NKWfTROPmBxe8ZFIELSGBX5v3RTNP30OTO2Tj8uI,10838
 alita_sdk/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -19,10 +19,10 @@ alita_sdk/langchain/assistant.py,sha256=V0MpZG9IQRlKMr1SfAabVbUsIp-gNPO9A1SWxuFi
 alita_sdk/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/langchain/langraph_agent.py,sha256=DJyItdnscqceupHbdNnEENnfbinAMi7KuKvO7saix2M,17044
+alita_sdk/langchain/langraph_agent.py,sha256=vxsbjOE0UWZIuyXNGEMR1QJ8t5yHS7Kzjt8a8nLb-jw,20626
 alita_sdk/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
-alita_sdk/langchain/utils.py,sha256=JPfl96bUwp8asXzP11Fl8QLvcU3TUtGgybXTSxZGWho,6578
+alita_sdk/langchain/utils.py,sha256=Npferkn10dvdksnKzLJLBI5bNGQyVWTBwqp3vQtUqmY,6631
 alita_sdk/langchain/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/langchain/agents/xml_chat.py,sha256=Mx7PK5T97_GrFCwHHZ3JZP42S7MwtUzV0W-_8j6Amt8,6212
 alita_sdk/langchain/document_loaders/AlitaBDDScenariosLoader.py,sha256=4kFU1ijrM1Jw7cywQv8mUiBHlE6w-uqfzSZP4hUV5P4,3771
@@ -82,17 +82,18 @@ alita_sdk/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/tools/loop_output.py,sha256=NoGIGYc42wY3NNcWRijYzRnUVXcCn5cRVd8QmuIpoHU,8068
 alita_sdk/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8QwB0UwpsWCYruXU,11692
 alita_sdk/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
+alita_sdk/tools/router.py,sha256=wCvZjVkdXK9dMMeEerrgKf5M790RudH68pDortnHSz0,1517
 alita_sdk/tools/tool.py,sha256=jFRq8BeC55NwpgdpsqGk_Y3tZL4YKN0rE7sVS5OE3yg,5092
 alita_sdk/tools/vectorstore.py,sha256=F-DoHxPa4UVsKB-FEd-wWa59QGQifKMwcSNcZ5WZOKc,23496
-alita_sdk/utils/AlitaCallback.py,sha256=nRdLEY0icMFQJcQ0Daiz99UqFKhqYNBFPp2B0tuKjOE,6429
+alita_sdk/utils/AlitaCallback.py,sha256=cvpDhR4QLVCNQci6CO6TEUrUVDZU9_CRSwzcHGm3SGw,7356
 alita_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/utils/evaluate.py,sha256=iM1P8gzBLHTuSCe85_Ng_h30m52hFuGuhNXJ7kB1tgI,1872
 alita_sdk/utils/streamlit.py,sha256=zp8owZwHI3HZplhcExJf6R3-APtWx-z6s5jznT2hY_k,29124
 alita_sdk/utils/utils.py,sha256=dM8whOJAuFJFe19qJ69-FLzrUp6d2G-G6L7d4ss2XqM,346
-alita_sdk-0.3.115.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.117.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_jira_analysis.py,sha256=I0cErH5R_dHVyutpXrM1QEo7jfBuKWTmDQvJBPjx18I,3281
-alita_sdk-0.3.115.dist-info/METADATA,sha256=qJne58yRgLKhXd6WbxVWqMoorDE2ptNA7PY_CH9kuXA,7075
-alita_sdk-0.3.115.dist-info/WHEEL,sha256=Nw36Djuh_5VDukK0H78QzOX-_FQEo6V37m3nkm96gtU,91
-alita_sdk-0.3.115.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
-alita_sdk-0.3.115.dist-info/RECORD,,
+alita_sdk-0.3.117.dist-info/METADATA,sha256=UKs2mCU1AvQTt5jMaeRngvrGk8z6WwY4DX6aNBmaEzo,7075
+alita_sdk-0.3.117.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
+alita_sdk-0.3.117.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
+alita_sdk-0.3.117.dist-info/RECORD,,

{alita_sdk-0.3.115.dist-info → alita_sdk-0.3.117.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.7.1)
+Generator: setuptools (80.8.0)
 Root-Is-Purelib: true
 Tag: py3-none-any