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

alita_sdk/runtime/clients/client.py

@@ -44,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 = {
@@ -75,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():
@@ -264,17 +269,32 @@ class AlitaClient:
         if is_anthropic:
             # ChatAnthropic configuration
             target_kwargs = {
-                "base_url": f"{self.base_url}{self.llm_path}",
+                "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,
-                "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)},
+                "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"]
@@ -300,7 +320,6 @@ class AlitaClient:
                 target_kwargs["use_responses_api"] = True
             
             llm = ChatOpenAI(**target_kwargs)
-        
         return llm
         
     def generate_image(self,

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
@@ -219,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:
@@ -250,24 +286,89 @@ 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:
@@ -285,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.
         

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.528.dist-info → alita_sdk-0.3.532.dist-info}/METADATA

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

@@ -93,7 +93,7 @@ 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=LUQ-pH3tmp_f4uh_8ss0KP1c-wyr34ZJMT9Qyonpg6Y,53394
+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
@@ -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=lLDqsOef6-zakNcZdd9_5iJyZ3-wBXunPEH0h9qsnyY,44774
+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.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,,
+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,,