alita-sdk 0.3.522__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/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/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-0.3.522.dist-info → alita_sdk-0.3.528.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.522
+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.522.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=yVTosONjQYUHbzhtTWG53odpXbWCQLLe18oaqniqvx8,18447
 alita_sdk/runtime/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 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
@@ -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
@@ -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.522.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-alita_sdk-0.3.522.dist-info/METADATA,sha256=wfMuqtLZNiFVBOEI0aUg4OV61OhqNGmnpp5j4LNKxo8,24266
-alita_sdk-0.3.522.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-alita_sdk-0.3.522.dist-info/entry_points.txt,sha256=VijN0h4alp1WXm8tfS3P7vuGxN4a5RZqHjXAoEIBZnI,49
-alita_sdk-0.3.522.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
-alita_sdk-0.3.522.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,,