alita-sdk 0.3.516__py3-none-any.whl → 0.3.528__py3-none-any.whl

alita_sdk/runtime/clients/client.py

@@ -13,6 +13,7 @@ from langchain_core.messages import (
 from langchain_core.tools import ToolException
 from langgraph.store.base import BaseStore
 from langchain_openai import OpenAIEmbeddings, ChatOpenAI
+from langchain_anthropic import ChatAnthropic
 
 from ..langchain.assistant import Assistant as LangChainAssistant
 # from ..llamaindex.assistant import Assistant as LLamaAssistant
@@ -219,21 +220,25 @@ class AlitaClient:
             request_timeout=self.model_timeout
         )
 
-    def get_llm(self, model_name: str, model_config: dict) -> ChatOpenAI:
+    def get_llm(self, model_name: str, model_config: dict):
         """
-        Get a ChatOpenAI model instance based on the model name and configuration.
+        Get a ChatOpenAI or ChatAnthropic model instance based on the model name and configuration.
 
         Args:
             model_name: Name of the model to retrieve
             model_config: Configuration parameters for the model
 
         Returns:
-            An instance of ChatOpenAI configured with the provided parameters.
+            An instance of ChatOpenAI or ChatAnthropic configured with the provided parameters.
         """
         if not model_name:
             raise ValueError("Model name must be provided")
 
-        logger.info(f"Creating ChatOpenAI model: {model_name} with config: {model_config}")
+        # Determine if this is an Anthropic model
+        model_name_lower = model_name.lower()
+        is_anthropic = "anthropic" in model_name_lower or "claude" in model_name_lower
+
+        logger.info(f"Creating {'ChatAnthropic' if is_anthropic else 'ChatOpenAI'} model: {model_name} with config: {model_config}")
 
         try:
             from tools import this  # pylint: disable=E0401,C0415
@@ -256,25 +261,48 @@ class AlitaClient:
             # default nuber for a case when auto is selected for an agent
             llm_max_tokens = 4000
 
-        target_kwargs = {
-            "base_url": f"{self.base_url}{self.llm_path}",
-            "model": model_name,
-            "api_key": self.auth_token,
-            "streaming": model_config.get("streaming", True),
-            "stream_usage": model_config.get("stream_usage", True),
-            "max_tokens": llm_max_tokens,
-            "temperature": model_config.get("temperature"),
-            "reasoning_effort": model_config.get("reasoning_effort"),
-            "max_retries": model_config.get("max_retries", 3),
-            "seed": model_config.get("seed", None),
-            "openai_organization": str(self.project_id),
-        }
-
-        if use_responses_api:
-            target_kwargs["use_responses_api"] = True
+        if is_anthropic:
+            # ChatAnthropic configuration
+            target_kwargs = {
+                "base_url": f"{self.base_url}{self.llm_path}",
+                "model": model_name,
+                "api_key": self.auth_token,
+                "streaming": model_config.get("streaming", True),
+                "max_tokens": llm_max_tokens,
+                "effort": model_config.get("reasoning_effort"),
+                "temperature": model_config.get("temperature"),
+                "max_retries": model_config.get("max_retries", 3),
+                "default_headers": {"openai-organization": str(self.project_id)},
+            }
 
-        return ChatOpenAI(**target_kwargs)
+            # Add http_client if provided
+            if "http_client" in model_config:
+                target_kwargs["http_client"] = model_config["http_client"]
+            
+            llm = ChatAnthropic(**target_kwargs)
+        else:
+            # ChatOpenAI configuration
+            target_kwargs = {
+                "base_url": f"{self.base_url}{self.llm_path}",
+                "model": model_name,
+                "api_key": self.auth_token,
+                "streaming": model_config.get("streaming", True),
+                "stream_usage": model_config.get("stream_usage", True),
+                "max_tokens": llm_max_tokens,
+                "temperature": model_config.get("temperature"),
+                "reasoning_effort": model_config.get("reasoning_effort"),
+                "max_retries": model_config.get("max_retries", 3),
+                "seed": model_config.get("seed", None),
+                "openai_organization": str(self.project_id),
+            }
 
+            if use_responses_api:
+                target_kwargs["use_responses_api"] = True
+            
+            llm = ChatOpenAI(**target_kwargs)
+        
+        return llm
+        
     def generate_image(self,
                        prompt: str,
                        n: int = 1,

alita_sdk/runtime/clients/sandbox_client.py

@@ -6,7 +6,6 @@ import requests
 from typing import Any
 from json import dumps
 import chardet
-from ...tools import instantiate_toolkit
 
 logger = logging.getLogger(__name__)
 
@@ -49,27 +48,6 @@ class SandboxArtifact:
             return f'{data['error']}. {data['content'] if data['content'] else ''}'
         detected = chardet.detect(data)
         return data
-        # TODO: add proper handling for binary files (images, pdf, etc.) for sandbox
-        # if detected['encoding'] is not None:
-        #     try:
-        #         return data.decode(detected['encoding'])
-        #     except Exception:
-        #         logger.error('Error while default encoding')
-        #         return parse_file_content(file_name=artifact_name,
-        #                                   file_content=data,
-        #                                   is_capture_image=is_capture_image,
-        #                                   page_number=page_number,
-        #                                   sheet_name=sheet_name,
-        #                                   excel_by_sheets=excel_by_sheets,
-        #                                   llm=llm)
-        # else:
-        #     return parse_file_content(file_name=artifact_name,
-        #                               file_content=data,
-        #                               is_capture_image=is_capture_image,
-        #                               page_number=page_number,
-        #                               sheet_name=sheet_name,
-        #                               excel_by_sheets=excel_by_sheets,
-        #                               llm=llm)
 
     def delete(self, artifact_name: str, bucket_name=None):
         if not bucket_name:
@@ -185,19 +163,6 @@ class SandboxClient:
         data = requests.get(url, headers=self.headers, verify=False).json()
         return data
 
-    def toolkit(self, toolkit_id: int):
-        url = f"{self.base_url}{self.api_path}/tool/prompt_lib/{self.project_id}/{toolkit_id}"
-        response = requests.get(url, headers=self.headers, verify=False)
-        if not response.ok:
-            raise ValueError(f"Failed to fetch toolkit {toolkit_id}: {response.text}")
-        
-        tool_data = response.json()
-        if 'settings' not in tool_data:
-            tool_data['settings'] = {}
-        tool_data['settings']['alita'] = self
-        
-        return instantiate_toolkit(tool_data)
-
     def get_list_of_apps(self):
         apps = []
         limit = 10

alita_sdk/runtime/langchain/assistant.py

@@ -278,6 +278,7 @@ class Assistant:
             prompt_instructions = self.prompt
         
         # Add tool binding only if tools are present
+        tool_names = []
         if simple_tools:
             tool_names = [tool.name for tool in simple_tools]
             logger.info("Binding tools: %s", tool_names)
@@ -290,8 +291,8 @@ class Assistant:
         plan_addon = PLAN_ADDON if 'update_plan' in tool_names else ""
         pyodite_addon = PYODITE_ADDON if 'pyodide_sandbox' in tool_names else ""
         escaped_prompt = DEFAULT_ASSISTANT.format(
-            user_addon=user_addon,
-            plan_addon=plan_addon,
+            users_instructions=user_addon,
+            planning_instructions=plan_addon,
             pyodite_addon=pyodite_addon
         )
             

alita_sdk/runtime/langchain/constants.py

@@ -345,14 +345,136 @@ PYODITE_ADDON = """
 
 ## Using the Python (Pyodide) sandbox
 
-Python sandbox is available, it runs in a **Pyodide (browser-based) environment** with limitations:
+Python sandbox available via `pyodide_sandbox` (stateless) or `stateful_pyodide_sandbox` tools.
+
+### Use for:
+- Lightweight data analysis, parsing, validation
+- Testing algorithms and calculations
+- Processing standard library modules
+
+### Limitations:
+- No local filesystem access (beyond sandbox cache)
+- No OS commands or subprocess operations
+- No native C extensions
+- No background processes
+
+### CRITICAL: How to return results
+
+The sandbox returns a dict with these keys:
+- **`result`**: The last evaluated expression (final line without assignment)
+- **`output`**: Anything printed via `print()`
+- **`error`**: Any stderr output
+- **`execution_info`**: Timing and package info
+
+**Two valid patterns to return data:**
+
+✅ Option 1 - Last expression (returned in `result` key):
+```python
+import json
+data = {"result": 42, "status": "complete"}
+data  # Auto-captured as result
+```
+
+✅ Option 2 - Print output (returned in `output` key):
+```python
+import json
+data = {"result": 42, "status": "complete"}
+print(json.dumps(data))  # Captured as output
+```
+
+Both work! Choose based on preference. For structured data, JSON format is recommended.
+
+### Using alita_client (auto-injected)
+
+The `alita_client` object is automatically available in sandbox code. It provides access to Alita platform APIs.
+
+**Key capabilities:**
+
+**Artifacts** - Store/retrieve files in buckets:
+```python
+# Get artifact from bucket and decode
+csv_data = alita_client.artifact('my_bucket').get('file.csv').decode('utf-8')
+
+# Create/overwrite artifact
+alita_client.artifact('my_bucket').create('output.txt', 'data content')
+
+# List artifacts in bucket
+files = alita_client.artifact('my_bucket').list()
+
+# Append to artifact
+alita_client.artifact('my_bucket').append('log.txt', 'new line\\n')
+
+# Delete artifact
+alita_client.artifact('my_bucket').delete('old_file.txt')
+```
+
+**Secrets** - Access stored credentials:
+```python
+api_key = alita_client.unsecret('my_api_key')
+```
+
+**MCP Tools** - Call Model Context Protocol tools:
+```python
+# List available tools
+tools = alita_client.get_mcp_toolkits()
+
+# Call a tool
+result = alita_client.mcp_tool_call({
+    'server_name': 'my_server',
+    'params': {
+        'name': 'tool_name',
+        'arguments': {'arg1': 'value1'}
+    }
+})
+```
+
+**Toolkits** - Instantiate and use toolkits:
+```python
+toolkit = alita_client.toolkit(toolkit_id=123)
+```
+
+**Applications** - Get app details:
+```python
+apps = alita_client.get_list_of_apps()
+app_details = alita_client.get_app_details(application_id=456)
+```
+
+**Image Generation**:
+```python
+result = alita_client.generate_image(
+    prompt="A sunset over mountains",
+    n=1,
+    size="1024x1024"
+)
+```
+
+**Common pattern - Load CSV from artifacts:**
+```python
+import csv
+from io import StringIO
+
+# Load CSV from artifact
+csv_text = alita_client.artifact('tests').get('data.csv').decode('utf-8')
+
+# Parse CSV
+reader = csv.DictReader(StringIO(csv_text))
+data = list(reader)
+
+# Return result
+data
+```
+
+### Execution modes:
+- **Stateless** (default): Faster, each run starts fresh
+- **Stateful**: Preserves variables/imports between calls
 
-- Use it only for lightweight data analysis, parsing, transformation, or validation
-- Do not assume access to the local filesystem, network, OS commands, or background processes
-- Do not attempt `pip install` or rely on unavailable native extensions
-- Treat all inputs as in-memory data provided by the harness or previous tool outputs
-- For large datasets, long-running tasks, or environment-dependent execution, request an external tool or user-provided artifacts instead
+### Code requirements:
+1. Always include necessary imports
+2. Either end with an expression OR use `print()` for output
+3. Work with in-memory data only
+4. Include error handling with try-except
 
-If a task cannot be reliably executed in Pyodide, explicitly state the limitation and propose an alternative approach.
+### When NOT to use:
+For large datasets, long-running tasks, or native system access, request alternative tools instead.
 
 """

alita_sdk/runtime/langchain/langraph_agent.py

@@ -937,7 +937,7 @@ class LangGraphAgentRunnable(CompiledStateGraph):
                 "with no accompanying text."
             )
         
-        logging.info(f"Input: {thread_id} - {input}")
+        logger.info(f"Input: {thread_id} - {input}")
         try:
             if self.checkpointer and self.checkpointer.get_tuple(config):
                 if config.pop("should_continue", False):

alita_sdk/runtime/toolkits/application.py

@@ -22,7 +22,8 @@ class ApplicationToolkit(BaseToolkit):
     
     @classmethod
     def get_toolkit(cls, client: 'AlitaClient', application_id: int, application_version_id: int,
-                    selected_tools: list[str] = [], store: Optional[BaseStore] = None):
+                    selected_tools: list[str] = [], store: Optional[BaseStore] = None,
+                    ignored_mcp_servers: Optional[list] = None):
         
         app_details = client.get_app_details(application_id)
         version_details = client.get_app_version_details(application_id, application_version_id)
@@ -34,7 +35,8 @@ class ApplicationToolkit(BaseToolkit):
 
         app = client.application(application_id, application_version_id, store=store, 
                                  llm=client.get_llm(version_details['llm_settings']['model_name'], 
-                                                    model_settings))
+                                                    model_settings),
+                                 ignored_mcp_servers=ignored_mcp_servers)
         return cls(tools=[Application(name=app_details.get("name"), 
                                       description=app_details.get("description"), 
                                       application=app, 
@@ -46,6 +48,7 @@ class ApplicationToolkit(BaseToolkit):
                                           "application_version_id": application_version_id,
                                           "store": store,
                                           "llm": client.get_llm(version_details['llm_settings']['model_name'], model_settings),
+                                          "ignored_mcp_servers": ignored_mcp_servers,
                                       })])
             
     def get_tools(self):

alita_sdk/runtime/toolkits/tools.py

@@ -59,7 +59,8 @@ def get_tools(tools_list: list, alita_client=None, llm=None, memory_store: BaseS
                     alita_client,
                     application_id=int(tool['settings']['application_id']),
                     application_version_id=int(tool['settings']['application_version_id']),
-                    selected_tools=[]
+                    selected_tools=[],
+                    ignored_mcp_servers=ignored_mcp_servers
                 ).get_tools())
                 # backward compatibility for pipeline application type as subgraph node
                 if tool.get('agent_type', '') == 'pipeline':

alita_sdk/runtime/tools/llm.py

@@ -14,6 +14,35 @@ from ..langchain.utils import create_pydantic_model, propagate_the_input_mapping
 logger = logging.getLogger(__name__)
 
 
+# def _is_thinking_model(llm_client: Any) -> bool:
+#     """
+#     Check if a model uses extended thinking capability by reading cached metadata.
+    
+#     Thinking models require special message formatting where assistant messages
+#     must start with thinking blocks before tool_use blocks.
+    
+#     This function reads the `_supports_reasoning` attribute that should be set
+#     when the LLM client is created (by checking the model's supports_reasoning field).
+    
+#     Args:
+#         llm_client: LLM client instance with optional _supports_reasoning attribute
+        
+#     Returns:
+#         True if the model is a thinking model, False otherwise
+#     """
+#     if not llm_client:
+#         return False
+    
+#     # Check if supports_reasoning was cached on the client
+#     supports_reasoning = getattr(llm_client, '_supports_reasoning', False)
+    
+#     if supports_reasoning:
+#         model_name = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'unknown')
+#         logger.debug(f"Model '{model_name}' is a thinking/reasoning model (cached from API metadata)")
+    
+#     return supports_reasoning
+
+
 class LLMNode(BaseTool):
     """Enhanced LLM node with chat history and tool binding support"""
     
@@ -242,7 +271,12 @@ class LLMNode(BaseTool):
                     return {"messages": new_messages}
 
         except Exception as e:
+            # Enhanced error logging with model diagnostics
+            model_info = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'unknown')
             logger.error(f"Error in LLM Node: {format_exc()}")
+            logger.error(f"Model being used: {model_info}")
+            logger.error(f"Error type: {type(e).__name__}")
+            
             error_msg = f"Error: {e}"
             new_messages = messages + [AIMessage(content=error_msg)]
             return {"messages": new_messages}
@@ -403,6 +437,20 @@ class LLMNode(BaseTool):
     async def __perform_tool_calling(self, completion, messages, llm_client, config):
         # Handle iterative tool-calling and execution
         logger.info(f"__perform_tool_calling called with {len(completion.tool_calls) if hasattr(completion, 'tool_calls') else 0} tool calls")
+        
+        # Check if this is a thinking model - they require special message handling
+        # model_name = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', '')
+        # if _is_thinking_model(llm_client):
+        #     logger.warning(
+        #         f"⚠️ THINKING/REASONING MODEL DETECTED: '{model_name}'\n"
+        #         f"Tool execution with thinking models may fail due to message format requirements.\n"
+        #         f"Thinking models require 'thinking_blocks' to be preserved between turns, which this "
+        #         f"framework cannot do.\n"
+        #         f"Recommendation: Use standard model variants (e.g., claude-3-5-sonnet-20241022-v2:0) "
+        #         f"instead of thinking/reasoning variants for tool calling.\n"
+        #         f"See: https://docs.litellm.ai/docs/reasoning_content"
+        #     )
+        
         new_messages = messages + [completion]
         iteration = 0
 
@@ -511,6 +559,29 @@ class LLMNode(BaseTool):
             except Exception as e:
                 error_str = str(e).lower()
                 
+                # Check for thinking model message format errors
+                is_thinking_format_error = any(indicator in error_str for indicator in [
+                    'expected `thinking`',
+                    'expected `redacted_thinking`',
+                    'thinking block',
+                    'must start with a thinking block',
+                    'when `thinking` is enabled'
+                ])
+                
+                # Check for non-recoverable errors that should fail immediately
+                # These indicate configuration or permission issues, not content size issues
+                is_non_recoverable = any(indicator in error_str for indicator in [
+                    'model identifier is invalid',
+                    'authentication',
+                    'unauthorized',
+                    'access denied',
+                    'permission denied',
+                    'invalid credentials',
+                    'api key',
+                    'quota exceeded',
+                    'rate limit'
+                ])
+                
                 # Check for context window / token limit errors
                 is_context_error = any(indicator in error_str for indicator in [
                     'context window', 'context_window', 'token limit', 'too long',
@@ -518,17 +589,76 @@ class LLMNode(BaseTool):
                     'contextwindowexceedederror', 'max_tokens', 'content too large'
                 ])
                 
-                # Check for Bedrock/Claude output limit errors
-                # These often manifest as "model identifier is invalid" when output exceeds limits
+                # Check for Bedrock/Claude output limit errors (recoverable by truncation)
                 is_output_limit_error = any(indicator in error_str for indicator in [
-                    'model identifier is invalid',
-                    'bedrockexception',
                     'output token',
                     'response too large',
                     'max_tokens_to_sample',
-                    'output_token_limit'
+                    'output_token_limit',
+                    'output exceeds'
                 ])
                 
+                # Handle thinking model format errors
+                if is_thinking_format_error:
+                    model_info = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'unknown')
+                    logger.error(f"Thinking model message format error during tool execution iteration {iteration}")
+                    logger.error(f"Model: {model_info}")
+                    logger.error(f"Error details: {e}")
+                    
+                    error_msg = (
+                        f"⚠️ THINKING MODEL FORMAT ERROR\n\n"
+                        f"The model '{model_info}' uses extended thinking and requires specific message formatting.\n\n"
+                        f"**Issue**: When 'thinking' is enabled, assistant messages must start with thinking blocks "
+                        f"before any tool_use blocks. This framework cannot preserve thinking_blocks during iterative "
+                        f"tool execution.\n\n"
+                        f"**Root Cause**: Anthropic's Messages API is stateless - clients must manually preserve and "
+                        f"resend thinking_blocks with every tool response. LangChain's message abstraction doesn't "
+                        f"include thinking_blocks, so they are lost between turns.\n\n"
+                        f"**Solutions**:\n"
+                        f"1. **Recommended**: Use non-thinking model variants:\n"
+                        f"   - claude-3-5-sonnet-20241022-v2:0 (instead of thinking variants)\n"
+                        f"   - anthropic.claude-3-5-sonnet-20241022-v2:0 (Bedrock)\n"
+                        f"2. Disable extended thinking: Set reasoning_effort=None or remove thinking config\n"
+                        f"3. Use LiteLLM directly with modify_params=True (handles thinking_blocks automatically)\n"
+                        f"4. Avoid tool calling with thinking models (use for reasoning tasks only)\n\n"
+                        f"**Technical Context**: {str(e)}\n\n"
+                        f"References:\n"
+                        f"- https://docs.claude.com/en/docs/build-with-claude/extended-thinking\n"
+                        f"- https://docs.litellm.ai/docs/reasoning_content (See 'Tool Calling with thinking' section)"
+                    )
+                    new_messages.append(AIMessage(content=error_msg))
+                    raise ValueError(error_msg)
+                
+                # Handle non-recoverable errors immediately
+                if is_non_recoverable:
+                    # Enhanced error logging with model information for better diagnostics
+                    model_info = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'unknown')
+                    logger.error(f"Non-recoverable error during tool execution iteration {iteration}")
+                    logger.error(f"Model: {model_info}")
+                    logger.error(f"Error details: {e}")
+                    logger.error(f"Error type: {type(e).__name__}")
+                    
+                    # Provide detailed error message for debugging
+                    error_details = []
+                    error_details.append(f"Model configuration error: {str(e)}")
+                    error_details.append(f"Model identifier: {model_info}")
+                    
+                    # Check for common Bedrock model ID issues
+                    if 'model identifier is invalid' in error_str:
+                        error_details.append("\nPossible causes:")
+                        error_details.append("1. Model not available in the configured AWS region")
+                        error_details.append("2. Model not enabled in your AWS Bedrock account")
+                        error_details.append("3. LiteLLM model group prefix not stripped (check for prefixes like '1_')")
+                        error_details.append("4. Incorrect model version or typo in model name")
+                        error_details.append("\nPlease verify:")
+                        error_details.append("- AWS Bedrock console shows this model as available")
+                        error_details.append("- LiteLLM router configuration is correct")
+                        error_details.append("- Model ID doesn't contain unexpected prefixes")
+                    
+                    error_msg = "\n".join(error_details)
+                    new_messages.append(AIMessage(content=error_msg))
+                    break
+                
                 if is_context_error or is_output_limit_error:
                     error_type = "output limit" if is_output_limit_error else "context window"
                     logger.warning(f"{error_type.title()} exceeded during tool execution iteration {iteration}")
@@ -595,9 +725,27 @@ class LLMNode(BaseTool):
                         )
                         new_messages[last_tool_msg_idx] = truncated_msg
                         
-                        logger.info(f"Truncated large tool result from '{last_tool_name}' and continuing")
-                        # Continue to next iteration - the model will see the truncation message
-                        continue
+                        logger.info(f"Truncated large tool result from '{last_tool_name}' and retrying LLM call")
+                        
+                        # CRITICAL FIX: Call LLM again with truncated message to get fresh completion
+                        # This prevents duplicate tool_call_ids that occur when we continue with
+                        # the same current_completion that still has the original tool_calls
+                        try:
+                            current_completion = llm_client.invoke(new_messages, config=config)
+                            new_messages.append(current_completion)
+                            
+                            # Continue to process any new tool calls in the fresh completion
+                            if hasattr(current_completion, 'tool_calls') and current_completion.tool_calls:
+                                logger.info(f"LLM requested {len(current_completion.tool_calls)} more tool calls after truncation")
+                                continue
+                            else:
+                                logger.info("LLM completed after truncation without requesting more tools")
+                                break
+                        except Exception as retry_error:
+                            logger.error(f"Error retrying LLM after truncation: {retry_error}")
+                            error_msg = f"Failed to retry after truncation: {str(retry_error)}"
+                            new_messages.append(AIMessage(content=error_msg))
+                            break
                     else:
                         # Couldn't find tool message, add error and break
                         if is_output_limit_error:

alita_sdk/tools/testrail/api_wrapper.py

@@ -697,7 +697,7 @@ class TestrailAPIWrapper(NonCodeIndexerToolkit):
                 'id': str(case.get('id', '')),
                 IndexerKeywords.UPDATED_ON.value: case.get('updated_on') or -1,
                 'labels': [lbl['title'] for lbl in case.get('labels', [])],
-                'type': case.get('type_id') or -1,
+                'type': "testrail_test_case",
                 'priority': case.get('priority_id') or -1,
                 'milestone': case.get('milestone_id') or -1,
                 'estimate': case.get('estimate') or '',

{alita_sdk-0.3.516.dist-info → alita_sdk-0.3.528.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.516
+Version: 0.3.528
 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.516.dist-info → alita_sdk-0.3.528.dist-info}/RECORD

@@ -93,18 +93,18 @@ alita_sdk/configurations/zephyr_essential.py,sha256=TiZedsBlfIDroflipvoqxjJeEWPo
 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=7C1e9RtftqOJd3Mo5gNDnBuYg1Z9xTqjxmfdWeJH5Cc,4014
-alita_sdk/runtime/clients/client.py,sha256=8DGrto3RcURZQE2qUTFJ3boDat_YvedqmbTTHpRXyDg,52069
+alita_sdk/runtime/clients/client.py,sha256=LUQ-pH3tmp_f4uh_8ss0KP1c-wyr34ZJMT9Qyonpg6Y,53394
 alita_sdk/runtime/clients/datasource.py,sha256=HAZovoQN9jBg0_-lIlGBQzb4FJdczPhkHehAiVG3Wx0,1020
 alita_sdk/runtime/clients/mcp_discovery.py,sha256=aFJ0wYQ8EAmXa9qLUusHZfQXkNec1wbgkqHdVeSFX-g,11697
 alita_sdk/runtime/clients/mcp_manager.py,sha256=DRbqiO761l7UgOdv_keHbD2g0oZodtPHejpArXYZIoE,9050
 alita_sdk/runtime/clients/prompt.py,sha256=li1RG9eBwgNK_Qf0qUaZ8QNTmsncFrAL2pv3kbxZRZg,1447
-alita_sdk/runtime/clients/sandbox_client.py,sha256=4GLoCFZXtTYKM3SFMJAfFO7QNE38c1V7DI1b88uOySY,17227
+alita_sdk/runtime/clients/sandbox_client.py,sha256=z8emjrMe9hkEKOnr19qDxRzXG1ug-XJXBKQzGtjXEAs,15390
 alita_sdk/runtime/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/runtime/langchain/assistant.py,sha256=-w7gfBlpW27q4O8jF1ba9qaQnprPGynNRcsnAYynOYc,18404
+alita_sdk/runtime/langchain/assistant.py,sha256=yVTosONjQYUHbzhtTWG53odpXbWCQLLe18oaqniqvx8,18447
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
-alita_sdk/runtime/langchain/constants.py,sha256=h6FBMOLT-vDuDI-s49sd4LUi5qwFJwYq1Ysptltiy8Y,14427
+alita_sdk/runtime/langchain/constants.py,sha256=tbVA-OPRDzEMspO9raOj_jb57Yt-TUYulG6FOXCmu78,17150
 alita_sdk/runtime/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/runtime/langchain/langraph_agent.py,sha256=4rWJ6tQXIzVHgF9zzDL3kiR67rvBAxrJxpglJ6Z_2w0,59364
+alita_sdk/runtime/langchain/langraph_agent.py,sha256=vQ5HPzgngNgZ6amco7PPx0Gn0TdaW8dvYVexPT68bB8,59363
 alita_sdk/runtime/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/runtime/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/runtime/langchain/store_manager.py,sha256=i8Fl11IXJhrBXq1F1ukEVln57B1IBe-tqSUvfUmBV4A,2218
@@ -157,7 +157,7 @@ alita_sdk/runtime/llms/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3
 alita_sdk/runtime/llms/preloaded.py,sha256=tZ_-nIV91cjgdNV5xw5cIlvia9CYUG94PTsoNRmTF-I,11223
 alita_sdk/runtime/models/mcp_models.py,sha256=rbWCAtF8Jjb7uNgQHhVWyDttXaqPNbRLL087Lf0AjNU,2301
 alita_sdk/runtime/toolkits/__init__.py,sha256=7bic6YGLiyAwFD3KZvrntWqS57sND72VoGBhuAx75yI,692
-alita_sdk/runtime/toolkits/application.py,sha256=EyYdGTJzsqz6pV3XAywy8BR2kYU6QNRar7QcC9-WGSI,2714
+alita_sdk/runtime/toolkits/application.py,sha256=iHs6PzNIbwalDtSP2LuIsqiWGxQSFI2pubKXIFGPB8k,2938
 alita_sdk/runtime/toolkits/artifact.py,sha256=_m7Ppwc04cpL0RPU_5ZHXFjBIWLeylv1if-H16OvF-o,3737
 alita_sdk/runtime/toolkits/configurations.py,sha256=kIDAlnryPQfbZyFxV-9SzN2-Vefzx06TX1BBdIIpN90,141
 alita_sdk/runtime/toolkits/datasource.py,sha256=ZNPCAAZKy90u_5CKkr6fi7gaLuao2KOIV8spGjb-AbA,2926
@@ -165,7 +165,7 @@ alita_sdk/runtime/toolkits/mcp.py,sha256=4KOobcuCUsZGza1CJ0EUdYRTL9v4pJwM2Joswxi
 alita_sdk/runtime/toolkits/planning.py,sha256=6i83WDkjRs-b8UNlDub44NHzUFUgTVuxQ_IHSuHI85U,7433
 alita_sdk/runtime/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
 alita_sdk/runtime/toolkits/subgraph.py,sha256=wwUK8JjPXkGzyVZ3tAukmvST6eGbqx_U11rpnmbrvtg,2105
-alita_sdk/runtime/toolkits/tools.py,sha256=MGhyp5K5fRKCa4g2qorIfM_xHngDQZjltHYDtjXH_PI,17586
+alita_sdk/runtime/toolkits/tools.py,sha256=WjoszaL2o-w_8vy0JkulXc02HP_vNdvl-CWwWTkkYO8,17647
 alita_sdk/runtime/toolkits/vectorstore.py,sha256=H-HQsHhLm-vQWS3kvwkh-OHrOWKuylBXcSH9cQo5jKM,3282
 alita_sdk/runtime/tools/__init__.py,sha256=Fx7iHqkzA90-KfjdcUUzMUI_7kDarjuTsSpSzOW2pN0,568
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
@@ -177,7 +177,7 @@ alita_sdk/runtime/tools/function.py,sha256=HSMO1nBTRKMvWC_m0M8TOLGaZ2k_7ksPgLqzu
 alita_sdk/runtime/tools/graph.py,sha256=7jImBBSEdP5Mjnn2keOiyUwdGDFhEXLUrgUiugO3mgA,3503
 alita_sdk/runtime/tools/image_generation.py,sha256=Kls9D_ke_SK7xmVr7I9SlQcAEBJc86gf66haN0qIj9k,7469
 alita_sdk/runtime/tools/indexer_tool.py,sha256=whSLPevB4WD6dhh2JDXEivDmTvbjiMV1MrPl9cz5eLA,4375
-alita_sdk/runtime/tools/llm.py,sha256=jcOwqdYH8VIlnxn775bxYJ2haFUB5GbySUYD4WPlA5o,35700
+alita_sdk/runtime/tools/llm.py,sha256=lLDqsOef6-zakNcZdd9_5iJyZ3-wBXunPEH0h9qsnyY,44774
 alita_sdk/runtime/tools/loop.py,sha256=uds0WhZvwMxDVFI6MZHrcmMle637cQfBNg682iLxoJA,8335
 alita_sdk/runtime/tools/loop_output.py,sha256=U4hO9PCQgWlXwOq6jdmCGbegtAxGAPXObSxZQ3z38uk,8069
 alita_sdk/runtime/tools/mcp_inspect_tool.py,sha256=38X8euaxDbEGjcfp6ElvExZalpZun6QEr6ZEW4nU5pQ,11496
@@ -401,7 +401,7 @@ alita_sdk/tools/sql/models.py,sha256=AKJgSl_kEEz4fZfw3kbvdGHXaRZ-yiaqfJOB6YOj3i0
 alita_sdk/tools/testio/__init__.py,sha256=KttkGmwKRlY5OG6kr_ZTrMXECpea-61B4w3Z5zlDtB4,2904
 alita_sdk/tools/testio/api_wrapper.py,sha256=BvmL5h634BzG6p7ajnQLmj-uoAw1gjWnd4FHHu1h--Q,21638
 alita_sdk/tools/testrail/__init__.py,sha256=oyw1bmITlfb1cusInMpc-Nuh0XwKV7yxjmW6veXr_n4,4561
-alita_sdk/tools/testrail/api_wrapper.py,sha256=tQcGlFJmftvs5ZiO4tsP19fCo4CrJeq_UEvQR1liVfE,39891
+alita_sdk/tools/testrail/api_wrapper.py,sha256=XycH0iEH2cCAv7InJotmsGE9lPj6hP45Za1d2jSQ_Lg,39886
 alita_sdk/tools/utils/__init__.py,sha256=Bt1TsxkQIezgkxCgn5wFIOMsTsW5vEoWdM6KznodktU,4027
 alita_sdk/tools/utils/available_tools_decorator.py,sha256=IbrdfeQkswxUFgvvN7-dyLMZMyXLiwvX7kgi3phciCk,273
 alita_sdk/tools/utils/content_parser.py,sha256=KqiZzsurLspxCLemf9eqYhgW266FgWP4r-xElcK8a38,15881
@@ -427,9 +427,9 @@ alita_sdk/tools/zephyr_scale/api_wrapper.py,sha256=kT0TbmMvuKhDUZc0i7KO18O38JM9S
 alita_sdk/tools/zephyr_squad/__init__.py,sha256=gZTEanHf9pRCiZaKobF4Wbm33wUxxXoIjOr544TcXas,2903
 alita_sdk/tools/zephyr_squad/api_wrapper.py,sha256=kmw_xol8YIYFplBLWTqP_VKPRhL_1ItDD0_vXTe_UuI,14906
 alita_sdk/tools/zephyr_squad/zephyr_squad_cloud_client.py,sha256=R371waHsms4sllHCbijKYs90C-9Yu0sSR3N4SUfQOgU,5066
-alita_sdk-0.3.516.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.516.dist-info/METADATA,sha256=ig9rddgKLhojWxyfHNUX9PjKHzJLJ9YNJStMSdNiAz4,24266
-alita_sdk-0.3.516.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.516.dist-info/entry_points.txt,sha256=VijN0h4alp1WXm8tfS3P7vuGxN4a5RZqHjXAoEIBZnI,49
-alita_sdk-0.3.516.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.516.dist-info/RECORD,,
+alita_sdk-0.3.528.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.528.dist-info/METADATA,sha256=eTapGprJ7IEFsGKfI9BndpjRPD-eh0oTLK2yS7cLvlw,24266
+alita_sdk-0.3.528.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.528.dist-info/entry_points.txt,sha256=VijN0h4alp1WXm8tfS3P7vuGxN4a5RZqHjXAoEIBZnI,49
+alita_sdk-0.3.528.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.528.dist-info/RECORD,,