alita-sdk 0.3.522__py3-none-any.whl → 0.3.532__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
@@ -43,6 +44,7 @@ class AlitaClient:
         self.base_url = base_url.rstrip('/')
         self.api_path = '/api/v1'
         self.llm_path = '/llm/v1'
+        self.allm_path = '/llm'
         self.project_id = project_id
         self.auth_token = auth_token
         self.headers = {
@@ -74,6 +76,10 @@ class AlitaClient:
         self.configurations: list = configurations or []
         self.model_timeout = kwargs.get('model_timeout', 120)
         self.model_image_generation = kwargs.get('model_image_generation')
+        
+        # Cache for generated images to avoid token consumption
+        # This is used by image_generation and artifact toolkits to pass data via reference
+        self._generated_images_cache: Dict[str, Dict[str, Any]] = {}
 
     def get_mcp_toolkits(self):
         if user_id := self._get_real_user_id():
@@ -219,21 +225,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 +266,62 @@ 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
-
-        return ChatOpenAI(**target_kwargs)
+        if is_anthropic:
+            # ChatAnthropic configuration
+            target_kwargs = {
+                "base_url": f"{self.base_url}{self.allm_path}",
+                "model": model_name,
+                "api_key": self.auth_token,
+                "streaming": model_config.get("streaming", True),
+                "max_tokens": llm_max_tokens,
+                "temperature": model_config.get("temperature"),
+                "max_retries": model_config.get("max_retries", 3),
+                "default_headers": {"openai-organization": str(self.project_id),
+                                    "Authorization": f"Bearer {self.auth_token}"},
+            }
+            
+            # TODO": Check on ChatAnthropic client when they get "effort" support back
+            if model_config.get("reasoning_effort"):
+                if model_config["reasoning_effort"].lower() == "low":
+                    target_kwargs['thinking'] = {"type": "enabled", "budget_tokens": 2048}
+                    target_kwargs['temperature'] = 1
+                    target_kwargs["max_tokens"] = 2048 + target_kwargs["max_tokens"]
+                elif model_config["reasoning_effort"].lower() == "medium":
+                    target_kwargs['thinking'] = {"type": "enabled", "budget_tokens": 4096}
+                    target_kwargs['temperature'] = 1
+                    target_kwargs["max_tokens"] = 4096 + target_kwargs["max_tokens"]
+                elif model_config["reasoning_effort"].lower() == "high":
+                    target_kwargs['thinking'] = {"type": "enabled", "budget_tokens": 9092}
+                    target_kwargs['temperature'] = 1
+                    target_kwargs["max_tokens"] = 9092 + target_kwargs["max_tokens"]
+                    
+            # 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/artifact.py

@@ -1,3 +1,4 @@
+import base64
 import hashlib
 import io
 import json
@@ -14,7 +15,7 @@ from pydantic import create_model, Field, model_validator
 from ...tools.non_code_indexer_toolkit import NonCodeIndexerToolkit
 from ...tools.utils.available_tools_decorator import extend_with_parent_available_tools
 from ...tools.elitea_base import extend_with_file_operations, BaseCodeToolApiWrapper
-from ...runtime.utils.utils import IndexerKeywords
+from ...runtime.utils.utils import IndexerKeywords, resolve_image_from_cache
 
 
 class ArtifactWrapper(NonCodeIndexerToolkit):
@@ -63,23 +64,30 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         if was_modified:
             logging.warning(f"Filename sanitized: '{filename}' -> '{sanitized_filename}'")
         
+        # Auto-detect and extract base64 from image_url structures (from image_generation tool)
+        # Returns tuple: (processed_data, is_from_image_generation)
+        filedata, is_from_image_generation = self._extract_base64_if_needed(filedata)
+        
         if sanitized_filename.endswith(".xlsx"):
             data = json.loads(filedata)
             filedata = self.create_xlsx_filedata(data)
 
         result = self.artifact.create(sanitized_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
-            }
-        })
+        # Skip file_modified event for images from image_generation tool
+        # These are already tracked in the tool output and don't need duplicate events
+        if not is_from_image_generation:
+            # 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
+                }
+            })
 
         return result
     
@@ -109,6 +117,43 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
         
         sanitized = sanitized_name + extension
         return sanitized, (sanitized != original)
+    
+    def _extract_base64_if_needed(self, filedata: str) -> tuple[str | bytes, bool]:
+        """
+        Resolve cached_image_id references from cache and decode to binary data.
+        
+        Requires JSON format with cached_image_id field: {"cached_image_id": "img_xxx"}
+        LLM must extract specific cached_image_id from generate_image response.
+        
+        Returns:
+            tuple: (processed_data, is_from_image_generation)
+                - processed_data: Original filedata or resolved binary image data
+                - is_from_image_generation: True if data came from image_generation cache
+        """
+        if not filedata or not isinstance(filedata, str):
+            return filedata, False
+        
+        # Require JSON format - fail fast if not JSON
+        if '{' not in filedata:
+            return filedata, False
+        
+        try:
+            data = json.loads(filedata)
+        except json.JSONDecodeError:
+            # Not valid JSON, return as-is (regular file content)
+            return filedata, False
+        
+        if not isinstance(data, dict):
+            return filedata, False
+        
+        # Only accept direct cached_image_id format: {"cached_image_id": "img_xxx"}
+        # LLM must parse generate_image response and extract specific cached_image_id
+        if 'cached_image_id' in data:
+            binary_data = resolve_image_from_cache(self.alita, data['cached_image_id'])
+            return binary_data, True  # Mark as from image_generation
+        
+        # If JSON doesn't have cached_image_id, treat as regular file content
+        return filedata, False
 
     def create_xlsx_filedata(self, data: dict[str, list[list]]) -> bytes:
         try:
@@ -377,15 +422,19 @@ class ArtifactWrapper(NonCodeIndexerToolkit):
                     "createFile", 
                     filename=(str, Field(description="Filename")),
                     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"]
-                        ]
-                    }
+                    
+                    Supports three input formats:
+                    
+                    1. CACHED IMAGE REFERENCE (for generated/cached images):
+                       Pass JSON with cached_image_id field: {"cached_image_id": "img_xxx"}
+                       The tool will automatically resolve and decode the image from cache.
+                       This is typically used when another tool returns an image reference.
+                    
+                    2. EXCEL FILES (.xlsx extension):
+                       Pass JSON with sheet structure: {"Sheet1": [["Name", "Age"], ["Alice", 25], ["Bob", 30]]}
+                    
+                    3. TEXT/OTHER FILES:
+                       Pass the plain text string directly.
                     """)),
                     bucket_name=bucket_name
                 )

alita_sdk/runtime/tools/image_generation.py

@@ -1,7 +1,9 @@
 """
 Image generation tool for Alita SDK.
 """
+import json
 import logging
+import uuid
 from typing import Optional, Type, Any, List, Literal
 from langchain_core.tools import BaseTool, BaseToolkit
 from pydantic import BaseModel, Field, create_model, ConfigDict
@@ -76,7 +78,12 @@ class ImageGenerationTool(BaseTool):
     """Tool for generating images using the Alita client."""
     
     name: str = "generate_image"
-    description: str = "Generate images from text prompts using AI models"
+    description: str = (
+        "Generate images from text prompts using AI models. "
+        "Returns a JSON object with 'cached_image_id' field containing a reference to the generated image data. "
+        "The cached_image_id can be used to save or process the image. "
+        "The actual image data is stored temporarily and can be retrieved using the cached_image_id reference."
+    )
     args_schema: Type[BaseModel] = ImageGenerationInput
     alita_client: Any = None
     
@@ -85,10 +92,10 @@ class ImageGenerationTool(BaseTool):
         self.alita_client = client
     
     def _run(self, prompt: str, n: int = 1, size: str = "auto",
-             quality: str = "auto", style: Optional[str] = None) -> list:
+             quality: str = "auto", style: Optional[str] = None) -> str:
         """Generate an image based on the provided parameters."""
         try:
-            logger.info(f"Generating image with prompt: {prompt[:50]}...")
+            logger.debug(f"Generating image with prompt: {prompt[:50]}...")
             
             result = self.alita_client.generate_image(
                 prompt=prompt,
@@ -98,57 +105,56 @@ class ImageGenerationTool(BaseTool):
                 style=style
             )
             
-            # Return multimodal content format for LLM consumption
+            # Return simple JSON structure with reference ID instead of full base64
             if 'data' in result:
                 images = result['data']
-                content_chunks = []
                 
-                # Add a text description of what was generated
-                if len(images) == 1:
-                    content_chunks.append({
-                        "type": "text",
-                        "text": f"Generated image for prompt: '{prompt}'"
-                    })
-                else:
-                    content_chunks.append({
-                        "type": "text",
-                        "text": f"Generated {len(images)} images for "
-                                f"prompt: '{prompt}'"
+                # Process all images with unified structure
+                images_list = []
+                for idx, image_data in enumerate(images, 1):
+                    if not image_data.get('b64_json'):
+                        continue
+                    
+                    cached_image_id = f"img_{uuid.uuid4().hex[:12]}"
+                    
+                    # Store in cache
+                    if hasattr(self.alita_client, '_generated_images_cache'):
+                        self.alita_client._generated_images_cache[cached_image_id] = {
+                            'base64_data': image_data['b64_json']
+                        }
+                        logger.debug(f"Stored generated image in cache with ID: {cached_image_id}")
+                    
+                    images_list.append({
+                        "image_number": idx,
+                        "image_type": "png",
+                        "cached_image_id": cached_image_id
                     })
                 
-                # Add image content for each generated image
-                for image_data in images:
-                    if image_data.get('url'):
-                        content_chunks.append({
-                            "type": "image_url",
-                            "image_url": {
-                                "url": image_data['url']
-                            }
-                        })
-                    elif image_data.get('b64_json'):
-                        content_chunks.append({
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/png;base64,"
-                                       f"{image_data['b64_json']}"
-                            }
-                        })
+                if not images_list:
+                    return json.dumps({
+                        "status": "error",
+                        "message": "No base64 image data found"
+                    })
                 
-                return content_chunks
+                return json.dumps({
+                    "status": "success",
+                    "prompt": prompt,
+                    "total_images": len(images_list),
+                    "images": images_list
+                })
             
-            # Fallback to text response if no images in result
-            return [{
-                "type": "text",
-                "text": f"Image generation completed but no images "
-                        f"returned: {result}"
-            }]
+            # Fallback to error response if no images in result
+            return json.dumps({
+                "status": "error",
+                "message": f"Image generation completed but no images returned: {result}"
+            })
             
         except Exception as e:
             logger.error(f"Error generating image: {e}")
-            return [{
-                "type": "text",
-                "text": f"Error generating image: {str(e)}"
-            }]
+            return json.dumps({
+                "status": "error",
+                "message": f"Error generating image: {str(e)}"
+            })
     
     async def _arun(self, prompt: str, n: int = 1, size: str = "256x256",
                     quality: str = "auto",

alita_sdk/runtime/tools/llm.py

@@ -6,6 +6,8 @@ from typing import Any, Optional, List, Union, Literal
 from langchain_core.messages import HumanMessage, SystemMessage, AIMessage
 from langchain_core.runnables import RunnableConfig
 from langchain_core.tools import BaseTool, ToolException
+from langchain_core.exceptions import OutputParserException
+from langchain_core.callbacks import dispatch_custom_event
 from pydantic import Field
 
 from ..langchain.constants import ELITEA_RS
@@ -14,6 +16,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"""
     
@@ -190,20 +221,54 @@ class LLMNode(BaseTool):
                     try:
                         llm = self.__get_struct_output_model(llm_client, struct_model)
                         completion = llm.invoke(messages, config=config)
-                    except ValueError as e:
+                    except (ValueError, OutputParserException) as e:
                         logger.error(f"Error invoking structured output model: {format_exc()}")
-                        logger.info("Attemping to fall back to json mode")
-                        # Fallback to regular LLM with JSON extraction
-                        completion = self.__get_struct_output_model(llm_client, struct_model,
-                                                                    method="json_mode").invoke(messages, config=config)
+                        logger.info("Attempting to fall back to json mode")
+                        try:
+                            # Fallback to regular LLM with JSON extraction
+                            completion = self.__get_struct_output_model(llm_client, struct_model,
+                                                                        method="json_mode").invoke(messages, config=config)
+                        except (ValueError, OutputParserException) as e2:
+                            logger.error(f"json_mode fallback also failed: {format_exc()}")
+                            logger.info("Attempting to fall back to function_calling")
+                            # Final fallback to function_calling method
+                            completion = self.__get_struct_output_model(llm_client, struct_model,
+                                                                        method="json_schema").invoke(messages, config=config)
                     result = completion.model_dump()
 
                 # Ensure messages are properly formatted
                 if result.get('messages') and isinstance(result['messages'], list):
                     result['messages'] = [{'role': 'assistant', 'content': '\n'.join(result['messages'])}]
                 else:
-                    result['messages'] = messages + [
-                        AIMessage(content=result.get(ELITEA_RS, '') or initial_completion.content)]
+                    # Extract content from initial_completion, handling thinking blocks
+                    fallback_content = result.get(ELITEA_RS, '')
+                    if not fallback_content and initial_completion:
+                        content_parts = self._extract_content_from_completion(initial_completion)
+                        fallback_content = content_parts.get('text') or ''
+                        thinking = content_parts.get('thinking')
+                        
+                        # Dispatch thinking event if present
+                        if thinking:
+                            try:
+                                model_name = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'LLM')
+                                dispatch_custom_event(
+                                    name="thinking_step",
+                                    data={
+                                        "message": thinking,
+                                        "tool_name": f"LLM ({model_name})",
+                                        "toolkit": "reasoning",
+                                    },
+                                    config=config,
+                                )
+                            except Exception as e:
+                                logger.warning(f"Failed to dispatch thinking event: {e}")
+                        
+                        if not fallback_content:
+                            # Final fallback to raw content
+                            content = initial_completion.content
+                            fallback_content = content if isinstance(content, str) else str(content)
+                    
+                    result['messages'] = messages + [AIMessage(content=fallback_content)]
 
                 return result
             else:
@@ -221,28 +286,98 @@ class LLMNode(BaseTool):
                     if self.output_variables:
                         if self.output_variables[0] == 'messages':
                             return output_msgs
-                        output_msgs[self.output_variables[0]] = current_completion.content if current_completion else None
+                        # Extract content properly from thinking-enabled responses
+                        if current_completion:
+                            content_parts = self._extract_content_from_completion(current_completion)
+                            text_content = content_parts.get('text')
+                            thinking = content_parts.get('thinking')
+                            
+                            # Dispatch thinking event if present
+                            if thinking:
+                                try:
+                                    model_name = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'LLM')
+                                    dispatch_custom_event(
+                                        name="thinking_step",
+                                        data={
+                                            "message": thinking,
+                                            "tool_name": f"LLM ({model_name})",
+                                            "toolkit": "reasoning",
+                                        },
+                                        config=config,
+                                    )
+                                except Exception as e:
+                                    logger.warning(f"Failed to dispatch thinking event: {e}")
+                            
+                            if text_content:
+                                output_msgs[self.output_variables[0]] = text_content
+                            else:
+                                # Fallback to raw content
+                                content = current_completion.content
+                                output_msgs[self.output_variables[0]] = content if isinstance(content, str) else str(content)
+                        else:
+                            output_msgs[self.output_variables[0]] = None
 
                     return output_msgs
                 else:
-                    # Regular text response
-                    content = completion.content.strip() if hasattr(completion, 'content') else str(completion)
+                    # Regular text response - handle both simple strings and thinking-enabled responses
+                    content_parts = self._extract_content_from_completion(completion)
+                    thinking = content_parts.get('thinking')
+                    text_content = content_parts.get('text') or ''
+                    
+                    # Fallback to string representation if no content extracted
+                    if not text_content:
+                        if hasattr(completion, 'content'):
+                            content = completion.content
+                            text_content = content.strip() if isinstance(content, str) else str(content)
+                        else:
+                            text_content = str(completion)
+                    
+                    # Dispatch thinking step event to chat if present
+                    if thinking:
+                        logger.info(f"Model thinking: {thinking[:200]}..." if len(thinking) > 200 else f"Model thinking: {thinking}")
+                        
+                        # Dispatch custom event for thinking step to be displayed in chat
+                        try:
+                            model_name = getattr(llm_client, 'model_name', None) or getattr(llm_client, 'model', 'LLM')
+                            dispatch_custom_event(
+                                name="thinking_step",
+                                data={
+                                    "message": thinking,
+                                    "tool_name": f"LLM ({model_name})",
+                                    "toolkit": "reasoning",
+                                },
+                                config=config,
+                            )
+                        except Exception as e:
+                            logger.warning(f"Failed to dispatch thinking event: {e}")
+                    
+                    # Build the AI message with both thinking and text
+                    # Store thinking in additional_kwargs for potential future use
+                    ai_message_kwargs = {'content': text_content}
+                    if thinking:
+                        ai_message_kwargs['additional_kwargs'] = {'thinking': thinking}
+                    ai_message = AIMessage(**ai_message_kwargs)
 
                     # Try to extract JSON if output variables are specified (but exclude 'messages' which is handled separately)
                     json_output_vars = [var for var in (self.output_variables or []) if var != 'messages']
                     if json_output_vars:
                         # set response to be the first output variable for non-structured output
-                        response_data = {json_output_vars[0]: content}
-                        new_messages = messages + [AIMessage(content=content)]
+                        response_data = {json_output_vars[0]: text_content}
+                        new_messages = messages + [ai_message]
                         response_data['messages'] = new_messages
                         return response_data
 
                     # Simple text response (either no output variables or JSON parsing failed)
-                    new_messages = messages + [AIMessage(content=content)]
+                    new_messages = messages + [ai_message]
                     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}
@@ -251,6 +386,56 @@ class LLMNode(BaseTool):
         # Legacy support for old interface
         return self.invoke(kwargs, **kwargs)
     
+    @staticmethod
+    def _extract_content_from_completion(completion) -> dict:
+        """Extract thinking and text content from LLM completion.
+        
+        Handles Anthropic's extended thinking format where content is a list
+        of blocks with types: 'thinking' and 'text'.
+        
+        Args:
+            completion: LLM completion object with content attribute
+            
+        Returns:
+            dict with 'thinking' and 'text' keys
+        """
+        result = {'thinking': None, 'text': None}
+        
+        if not hasattr(completion, 'content'):
+            return result
+            
+        content = completion.content
+        
+        # Handle list of content blocks (Anthropic extended thinking format)
+        if isinstance(content, list):
+            thinking_blocks = []
+            text_blocks = []
+            
+            for block in content:
+                if isinstance(block, dict):
+                    block_type = block.get('type', '')
+                    if block_type == 'thinking':
+                        thinking_blocks.append(block.get('thinking', ''))
+                    elif block_type == 'text':
+                        text_blocks.append(block.get('text', ''))
+                elif hasattr(block, 'type'):
+                    # Handle object format
+                    if block.type == 'thinking':
+                        thinking_blocks.append(getattr(block, 'thinking', ''))
+                    elif block.type == 'text':
+                        text_blocks.append(getattr(block, 'text', ''))
+            
+            if thinking_blocks:
+                result['thinking'] = '\n\n'.join(thinking_blocks)
+            if text_blocks:
+                result['text'] = '\n\n'.join(text_blocks)
+        
+        # Handle simple string content
+        elif isinstance(content, str):
+            result['text'] = content
+        
+        return result
+    
     def _run_async_in_sync_context(self, coro):
         """Run async coroutine from sync context.
         
@@ -403,6 +588,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 +710,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 +740,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 +876,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/runtime/utils/AlitaCallback.py

@@ -313,7 +313,8 @@ class AlitaStreamlitCallback(BaseCallbackHandler):
         if self.debug:
             log.debug("on_llm_end(%s, %s)", response, kwargs)
         llm_run_id = str(run_id)
-        if self.callback_state.get(llm_run_id):
+        # Check if callback_state exists and is not None before accessing
+        if self.callback_state is not None and self.callback_state.get(llm_run_id):
             status_widget = self.callback_state[llm_run_id]
             self._safe_streamlit_call(
                 status_widget.update,

alita_sdk/runtime/utils/utils.py

@@ -1,5 +1,8 @@
+import base64
+import logging
 import re
 from enum import Enum
+from typing import Any
 
 # DEPRECATED: Tool names no longer use prefixes
 # Kept for backward compatibility only
@@ -32,3 +35,34 @@ 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
+
+
+def resolve_image_from_cache(client: Any, cached_image_id: str) -> bytes:
+    """
+    Resolve cached_image_id from client's image cache and return decoded binary data.
+
+    Args:
+        client: AlitaClient instance with _generated_images_cache attribute
+        cached_image_id: The cached image ID to resolve
+
+    Returns:
+        bytes: Decoded binary image data
+
+    Raises:
+        ValueError: If cached_image_id not found or decoding fails
+    """
+    cache = getattr(client, '_generated_images_cache', {})
+
+    if cached_image_id not in cache:
+        raise ValueError(f"Image reference '{cached_image_id}' not found. The image may have expired.")
+
+    cached_data = cache[cached_image_id]
+    base64_data = cached_data.get('base64_data', '')
+    logging.debug(f"Resolved cached_image_id '{cached_image_id}' from cache (length: {len(base64_data)} chars)")
+    # Decode base64 to binary data for image files
+    try:
+        binary_data = base64.b64decode(base64_data)
+        logging.debug(f"Decoded base64 to binary data ({len(binary_data)} bytes)")
+        return binary_data
+    except Exception as e:
+        raise ValueError(f"Failed to decode image data for '{cached_image_id}': {e}")

{alita_sdk-0.3.522.dist-info → alita_sdk-0.3.532.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.522
+Version: 0.3.532
 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
@@ -31,7 +31,7 @@ Requires-Dist: langchain_core<0.4.0,>=0.3.76; extra == "runtime"
 Requires-Dist: langchain<0.4.0,>=0.3.22; extra == "runtime"
 Requires-Dist: langchain_community<0.4.0,>=0.3.7; extra == "runtime"
 Requires-Dist: langchain-openai<0.4.0,>=0.3.0; extra == "runtime"
-Requires-Dist: langchain-anthropic<0.4.0,>=0.3.10; extra == "runtime"
+Requires-Dist: langchain-anthropic<0.4.0,>=0.3.20; extra == "runtime"
 Requires-Dist: anthropic>=0.57.0; extra == "runtime"
 Requires-Dist: langgraph<0.5,>=0.4.8; extra == "runtime"
 Requires-Dist: langgraph-prebuilt==0.5.2; extra == "runtime"

{alita_sdk-0.3.522.dist-info → alita_sdk-0.3.532.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=qsXM5wfQ6BaT44sH9wW3M4YkbFUK7WGLcWT8U0SHWGA,54748
 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
@@ -170,14 +170,14 @@ alita_sdk/runtime/toolkits/vectorstore.py,sha256=H-HQsHhLm-vQWS3kvwkh-OHrOWKuylB
 alita_sdk/runtime/tools/__init__.py,sha256=Fx7iHqkzA90-KfjdcUUzMUI_7kDarjuTsSpSzOW2pN0,568
 alita_sdk/runtime/tools/agent.py,sha256=m98QxOHwnCRTT9j18Olbb5UPS8-ZGeQaGiUyZJSyFck,3162
 alita_sdk/runtime/tools/application.py,sha256=RCGe-mRfj8372gTFkEX2xBvcYhw7IKdU1t50lXaBPOY,3701
-alita_sdk/runtime/tools/artifact.py,sha256=1ZeqgHwDToFr98SX4aUWwvr5iVltdpWjooRd0euO7pg,21081
+alita_sdk/runtime/tools/artifact.py,sha256=wZ6nPracF-SWkH52YtZWs2pePQavIDutUZ6BQpr5THU,23625
 alita_sdk/runtime/tools/datasource.py,sha256=pvbaSfI-ThQQnjHG-QhYNSTYRnZB0rYtZFpjCfpzxYI,2443
 alita_sdk/runtime/tools/echo.py,sha256=spw9eCweXzixJqHnZofHE1yWiSUa04L4VKycf3KCEaM,486
 alita_sdk/runtime/tools/function.py,sha256=HSMO1nBTRKMvWC_m0M8TOLGaZ2k_7ksPgLqzuRh6kV4,7083
 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/image_generation.py,sha256=waxxFIAgmh9-COcljL9uZ7e_s7EL9OWveUxYk0ulEUM,7855
 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=j2d7Pd0TUMYCGNSD7B440N7gpbzuJVVshftRlqe8Jgw,52911
 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
@@ -193,7 +193,7 @@ alita_sdk/runtime/tools/vectorstore_base.py,sha256=GUO7Gxgy4GKTttsOrsPQTUb_I5EDe
 alita_sdk/runtime/tools/planning/__init__.py,sha256=15eWTtz4oMB5vnKsLEFPW7lVY7y1Fxk3edo2bNf0ooE,821
 alita_sdk/runtime/tools/planning/models.py,sha256=bcwfjEnDTqirTT9bjHEDF8o3UYIAD8IqiqrZsca8gfw,8816
 alita_sdk/runtime/tools/planning/wrapper.py,sha256=om-4f3qMzkqBcBmINQ469IykBubm_UwJ-WZsEchehto,22412
-alita_sdk/runtime/utils/AlitaCallback.py,sha256=t2KYBrLLjjpw79KWJJo9PLjwRj4PZWCc3PbQ-6FXfLk,12020
+alita_sdk/runtime/utils/AlitaCallback.py,sha256=G-UU30P_Q9jiCr7eBZUDVRZ7Z6qlBPX5f0Cvt5tx528,12130
 alita_sdk/runtime/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/runtime/utils/constants.py,sha256=Xntx1b_uxUzT4clwqHA_U6K8y5bBqf_4lSQwXdcWrp4,13586
 alita_sdk/runtime/utils/evaluate.py,sha256=iM1P8gzBLHTuSCe85_Ng_h30m52hFuGuhNXJ7kB1tgI,1872
@@ -206,7 +206,7 @@ alita_sdk/runtime/utils/save_dataframe.py,sha256=i-E1wp-t4wb17Zq3nA3xYwgSILjoXNi
 alita_sdk/runtime/utils/streamlit.py,sha256=0TotNKnvMPHuwBdhMEpM5DhIedQQa1AUz9BlmXFBhAU,107179
 alita_sdk/runtime/utils/toolkit_runtime.py,sha256=MU63Fpxj0b5_r1IUUc0Q3-PN9VwL7rUxp2MRR4tmYR8,5136
 alita_sdk/runtime/utils/toolkit_utils.py,sha256=g1Au_nzJgde2NW732GACZGSIQOt7o0mjAbrRxG6GVwA,6579
-alita_sdk/runtime/utils/utils.py,sha256=6XkmoWjG_ZCIycU4qPhUSr9EdTrknhWbedbqE1fk1iU,1128
+alita_sdk/runtime/utils/utils.py,sha256=d0RLiKfBnobC3PrEFPvZt3uUx3Jie2rR32Fp-3hkWCU,2380
 alita_sdk/tools/__init__.py,sha256=jzj502O3yO40cjs37Uzqcbd6fG3pFmoU1TLw1-j4_3M,13011
 alita_sdk/tools/base_indexer_toolkit.py,sha256=AXygnaQZFEEeq6kkJbWIzUF1i31HoWdL7yidcDy_iKk,34305
 alita_sdk/tools/code_indexer_toolkit.py,sha256=4uQHnv7sHzECmOWbeqoVPT4prt_hv91gYxWxvvRdOjg,9219
@@ -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.532.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.532.dist-info/METADATA,sha256=bAsh58nb6kyLbv_sI2BbOdxFiYfqGcmyhJrOpnlXo70,24266
+alita_sdk-0.3.532.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.532.dist-info/entry_points.txt,sha256=VijN0h4alp1WXm8tfS3P7vuGxN4a5RZqHjXAoEIBZnI,49
+alita_sdk-0.3.532.dist-info/top_level.txt,sha256=0vJYy5p_jK6AwVb1aqXr7Kgqgk3WDtQ6t5C-XI9zkmg,10
+alita_sdk-0.3.532.dist-info/RECORD,,