alita-sdk 0.3.360__tar.gz → 0.3.361__tar.gz

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.360
+Version: 0.3.361
 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.360 → alita_sdk-0.3.361}/alita_sdk/runtime/clients/client.py

@@ -231,21 +231,17 @@ class AlitaClient:
         if not self.model_image_generation:
             raise ValueError("Image generation model is not configured for this client")
 
-        # Prepare the request data - only include non-"auto" parameters
-        # This prevents LiteLLM from adding unsupported parameters to extra_body
         image_generation_data = {
             "prompt": prompt,
             "model": self.model_image_generation,
             "n": n,
             "response_format": response_format,
-            # Enable drop_params to prevent LiteLLM from adding unsupported params to extra_body
-            "drop_params": True
         }
 
         # Only add optional parameters if they have meaningful values
         if size and size.lower() != "auto":
             image_generation_data["size"] = size
-            
+
         if quality and quality.lower() != "auto":
             image_generation_data["quality"] = quality
 
@@ -259,7 +255,6 @@ class AlitaClient:
         })
 
         logger.info(f"Generating image with model: {self.model_image_generation}, prompt: {prompt[:50]}...")
-        logger.debug(f"Image generation request data: {image_generation_data}")
 
         try:
             response = requests.post(
@@ -274,12 +269,6 @@ class AlitaClient:
 
         except requests.exceptions.HTTPError as e:
             logger.error(f"Image generation failed: {e.response.status_code} - {e.response.text}")
-            # Try to parse the error response for more details
-            try:
-                error_details = e.response.json()
-                logger.error(f"Error details: {error_details}")
-            except:
-                pass
             raise
         except requests.exceptions.RequestException as e:
             logger.error(f"Image generation request failed: {e}")

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk/runtime/langchain/langraph_agent.py

@@ -458,7 +458,7 @@ def create_graph(
                     if tool.name == tool_name:
                         if node_type == 'function':
                             lg_builder.add_node(node_id, FunctionTool(
-                                tool=tool, name=node['id'], return_type='dict',
+                                tool=tool, name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_mapping=node.get('input_mapping',
                                                        {'messages': {'type': 'variable', 'value': 'messages'}}),
@@ -469,7 +469,7 @@ def create_graph(
                                                        {'messages': {'type': 'variable', 'value': 'messages'}})
                             lg_builder.add_node(node_id, FunctionTool(
                                 client=client, tool=tool,
-                                name=node['id'], return_type='str',
+                                name=node_id, return_type='str',
                                 output_variables=node.get('output', []),
                                 input_variables=input_params,
                                 input_mapping= input_mapping
@@ -493,7 +493,7 @@ def create_graph(
                         elif node_type == 'tool':
                             lg_builder.add_node(node_id, ToolNode(
                                 client=client, tool=tool,
-                                name=node['id'], return_type='dict',
+                                name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_variables=node.get('input', ['messages']),
                                 structured_output=node.get('structured_output', False),
@@ -511,7 +511,7 @@ def create_graph(
                         elif node_type == 'loop':
                             lg_builder.add_node(node_id, LoopNode(
                                 client=client, tool=tool,
-                                name=node['id'], return_type='dict',
+                                name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
                                 input_variables=node.get('input', ['messages']),
                                 task=node.get('task', '')
@@ -526,7 +526,7 @@ def create_graph(
                                         logger.debug(f"Loop tool discovered: {t}")
                                         lg_builder.add_node(node_id, LoopToolNode(
                                             client=client,
-                                            name=node['id'], return_type='dict',
+                                            name=node_id, return_type='dict',
                                             tool=tool, loop_tool=t,
                                             variables_mapping=node.get('variables_mapping', {}),
                                             output_variables=node.get('output', []),
@@ -546,7 +546,7 @@ def create_graph(
                                 client=client, tool=tool,
                                 index_tool=indexer_tool,
                                 input_mapping=node.get('input_mapping', {}),
-                                name=node['id'], return_type='dict',
+                                name=node_id, return_type='dict',
                                 chunking_tool=node.get('chunking_tool', None),
                                 chunking_config=node.get('chunking_config', {}),
                                 output_variables=node.get('output', []),
@@ -585,7 +585,7 @@ def create_graph(
                 lg_builder.add_node(node_id, LLMNode(
                     client=client,
                     input_mapping=node.get('input_mapping', {'messages': {'type': 'variable', 'value': 'messages'}}),
-                    name=node['id'],
+                    name=node_id,
                     return_type='dict',
                     structured_output_dict=output_vars_dict,
                     output_variables=output_vars,
@@ -596,7 +596,7 @@ def create_graph(
             elif node_type == 'router':
                 # Add a RouterNode as an independent node
                 lg_builder.add_node(node_id, RouterNode(
-                    name=node['id'],
+                    name=node_id,
                     condition=node.get('condition', ''),
                     routes=node.get('routes', []),
                     default_output=node.get('default_output', 'END'),
@@ -701,6 +701,9 @@ def set_defaults(d):
         'bool': False,
         # add more types as needed
     }
+    # Build state_types mapping with STRING type names (not actual type objects)
+    state_types = {}
+
     for k, v in d.items():
         # Skip 'input' key as it is not a state initial variable
         if k == 'input':
@@ -708,6 +711,16 @@ def set_defaults(d):
         # set value or default if type is defined
         if 'value' not in v:
             v['value'] = type_defaults.get(v['type'], None)
+
+        # Also build the state_types mapping with STRING type names
+        var_type = v['type'] if isinstance(v, dict) else v
+        if var_type in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number']:
+            # Store the string type name, not the actual type object
+            state_types[k] = var_type if var_type != 'number' else 'int'
+
+    # Add state_types as a default value that will be set at initialization
+    # Use string type names to avoid serialization issues
+    d['state_types'] = {'type': 'dict', 'value': state_types}
     return d
 
 def convert_dict_to_message(msg_dict):
@@ -741,7 +754,7 @@ class LangGraphAgentRunnable(CompiledStateGraph):
     def invoke(self, input: Union[dict[str, Any], Any],
                config: Optional[RunnableConfig] = None,
                *args, **kwargs):
-        logger.info(f"Incomming Input: {input}")
+        logger.info(f"Incoming Input: {input}")
         if config is None:
             config = RunnableConfig()
         if not config.get("configurable", {}).get("thread_id", ""):
@@ -775,7 +788,9 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         try:
             if self.output_variables and self.output_variables[0] != "messages":
                 # If output_variables are specified, use the value of first one or use the last messages as default
-                output = result.get(self.output_variables[0], result['messages'][-1].content)
+                output = result.get(self.output_variables[0])
+                if not output:
+                    output = result['messages'][-1].content
             else:
                 output = result['messages'][-1].content
         except:

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk/runtime/langchain/utils.py

@@ -131,6 +131,7 @@ def parse_type(type_str):
 
 def create_state(data: Optional[dict] = None):
     state_dict = {'input': str, 'router_output': str}  # Always include router_output
+    types_dict = {}
     if not data:
         data = {'messages': 'list[str]'}
     for key, value in data.items():
@@ -140,6 +141,9 @@ def create_state(data: Optional[dict] = None):
             state_dict[key] = Annotated[list[AnyMessage], add_messages]
         elif value in ['str', 'int', 'float', 'bool', 'list', 'dict', 'number', 'dict']:
             state_dict[key] = parse_type(value)
+
+    state_dict["state_types"] = types_dict  # Default value for state_types
+    types_dict["state_types"] = dict
     logger.debug(f"Created state: {state_dict}")
     return TypedDict('State', state_dict)
 

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk/runtime/tools/artifact.py

@@ -1,4 +1,6 @@
 import hashlib
+import io
+import json
 import logging
 import re
 from typing import Any, Optional, Generator, List
@@ -6,6 +8,7 @@ from typing import Any, Optional, Generator, List
 from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.documents import Document
 from langchain_core.tools import ToolException
+from openpyxl.workbook.workbook import Workbook
 from pydantic import create_model, Field, model_validator
 
 from ...tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
@@ -31,22 +34,57 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         return self.artifact.list(bucket_name, return_as_string)
 
     def create_file(self, filename: str, filedata: str, bucket_name = None):
+        if filename.endswith(".xlsx"):
+            data = json.loads(filedata)
+            filedata = self.create_xlsx_filedata(data)
+
         result = self.artifact.create(filename, filedata, bucket_name)
         
         # Dispatch custom event for file creation
-        dispatch_custom_event("file_modified", {
-            "message": f"File '{filename}' created successfully",
-            "filename": filename,
-            "tool_name": "createFile",
-            "toolkit": "artifact",
-            "operation_type": "create",
-            "meta": {
-                "bucket": bucket_name or self.bucket
-            }
-        })
-        
+        self._log_tool_event(
+            tool_name="file_modified",
+            message="""
+            {
+                "message": f"File '{filename}' created successfully",
+                "filename": filename,
+                "tool_name": "createFile",
+                "toolkit": "artifact",
+                "operation_type": "create",
+                "meta": {
+                    "bucket": bucket_name or self.bucket
+                }
+            }""")
+
         return result
 
+    def create_xlsx_filedata(self, data: dict[str, list[list]]) -> bytes:
+        try:
+            workbook = Workbook()
+
+            first_sheet = True
+            for sheet_name, sheet_data in data.items():
+                if first_sheet:
+                    sheet = workbook.active
+                    sheet.title = sheet_name
+                    first_sheet = False
+                else:
+                    sheet = workbook.create_sheet(title=sheet_name)
+
+                for row in sheet_data:
+                    sheet.append(row)
+
+            file_buffer = io.BytesIO()
+            workbook.save(file_buffer)
+            file_buffer.seek(0)
+
+            return file_buffer.read()
+
+        except json.JSONDecodeError:
+            raise ValueError("Invalid JSON format for .xlsx file data.")
+        except Exception as e:
+            raise ValueError(f"Error processing .xlsx file data: {e}")
+
+
     def read_file(self,
                   filename: str,
                   bucket_name = None,
@@ -190,7 +228,17 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                 "args_schema": create_model(
                     "createFile", 
                     filename=(str, Field(description="Filename")),
-                    filedata=(str, Field(description="Stringified content of the file")),
+                    filedata=(str, Field(description="""Stringified content of the file.
+                    Example for .xlsx filedata format:
+                    {
+                        "Sheet1":[
+                            ["Name", "Age", "City"],
+                            ["Alice", 25, "New York"],
+                            ["Bob", 30, "San Francisco"],
+                            ["Charlie", 35, "Los Angeles"]
+                        ]
+                    }
+                    """)),
                     bucket_name=bucket_name
                 )
             },

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk/runtime/tools/router.py

@@ -8,10 +8,6 @@ from ..utils.utils import clean_string
 
 logger = logging.getLogger(__name__)
 
-def clean_node_str(s: str)-> str:
-        cleaned_string = re.sub(r'[^\w\s]', '', s)
-        return cleaned_string
-
 class RouterNode(BaseTool):
     name: str = 'RouterNode'
     description: str = 'A router node that evaluates a condition and routes accordingly.'
@@ -27,8 +23,8 @@ class RouterNode(BaseTool):
         template = EvaluateTemplate(self.condition, input_data)
         result = template.evaluate()
         logger.info(f"RouterNode evaluated condition '{self.condition}' with input {input_data} => {result}")
-        result = clean_node_str(str(result))
-        if result in self.routes:
+        result = clean_string(str(result))
+        if result in [clean_string(formatted_result) for formatted_result in self.routes]:
             # If the result is one of the routes, return it
             return {"router_output": result}
         elif result == self.default_output:

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk/runtime/utils/utils.py

@@ -20,3 +20,9 @@ def clean_string(s: str) -> str:
     # Replace these characters with an empty string
     cleaned_string = re.sub(clean_string_pattern, '', s)
     return cleaned_string
+
+
+def clean_node_str(s: str) -> str:
+    """Cleans a node string by removing all non-alphanumeric characters except underscores and spaces."""
+    cleaned_string = re.sub(r'[^\w\s]', '', s)
+    return cleaned_string

{alita_sdk-0.3.360 → alita_sdk-0.3.361}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.360
+Version: 0.3.361
 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.360 → alita_sdk-0.3.361}/pyproject.toml

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