alita-sdk 0.3.358__tar.gz → 0.3.359__tar.gz

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.358
+Version: 0.3.359
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/runtime/clients/client.py

@@ -68,8 +68,10 @@ class AlitaClient:
         self.bucket_url = f"{self.base_url}{self.api_path}/artifacts/buckets/{self.project_id}"
         self.configurations_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=configurations&unsecret=true'
         self.ai_section_url = f'{self.base_url}{self.api_path}/integrations/integrations/default/{self.project_id}?section=ai'
+        self.image_generation_url = f"{self.base_url}{self.llm_path}/images/generations"
         self.configurations: list = configurations or []
         self.model_timeout = kwargs.get('model_timeout', 120)
+        self.model_image_generation = kwargs.get('model_image_generation')
 
     def get_mcp_toolkits(self):
         if user_id := self._get_real_user_id():
@@ -218,6 +220,49 @@ class AlitaClient:
             openai_organization=str(self.project_id),
         )
 
+    def generate_image(self,
+                       prompt: str,
+                       n: int = 1,
+                       size: str = "auto",
+                       quality: str = "auto",
+                       response_format: str = "b64_json",
+                       style: Optional[str] = None) -> dict:
+
+        if not self.model_image_generation:
+            raise ValueError("Image generation model is not configured for this client")
+
+        # Prepare the request data
+        image_generation_data = {
+            "prompt": prompt,
+            "model": self.model_image_generation,
+            "n": n,
+            "size": size,
+            "quality": quality,
+            "response_format": response_format,
+        }
+
+        if style:
+            image_generation_data["style"] = style
+
+        logger.info(f"Generating image with model: {self.model_image_generation}, prompt: {prompt[:50]}...")
+
+        try:
+            response = requests.post(
+                self.image_generation_url,
+                headers=self.headers,
+                json=image_generation_data,
+                verify=False,
+                timeout=self.model_timeout
+            )
+            response.raise_for_status()
+            return response.json()
+
+        except requests.exceptions.HTTPError as e:
+            logger.error(f"Image generation failed: {e.response.status_code} - {e.response.text}")
+            raise
+        except requests.exceptions.RequestException as e:
+            logger.error(f"Image generation request failed: {e}")
+            raise
 
     def get_app_version_details(self, application_id: int, application_version_id: int) -> dict:
         url = f"{self.application_versions}/{application_id}/{application_version_id}"

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/runtime/langchain/assistant.py

@@ -38,7 +38,8 @@ class Assistant:
 
         logger.debug("Data for agent creation: %s", data)
         logger.info("App type: %s", app_type)
-        
+
+        self.alita_client = alita
         self.client = client
         # For predict agents, use the client as-is since it's already configured
         # if app_type == "predict":
@@ -192,6 +193,18 @@ class Assistant:
         except Exception as e:
             logger.error(f"Error adding PyodideSandboxTool: {e}")
         
+        # Add image generation tool if model is configured
+        if self.alita_client.model_image_generation is not None:
+            try:
+                from ..tools.image_generation import (
+                    create_image_generation_tool
+                )
+                image_tool = create_image_generation_tool(self.alita_client)
+                simple_tools.append(image_tool)
+                logger.info("Added ImageGenerationTool to react agent")
+            except Exception as e:
+                logger.error(f"Error adding ImageGenerationTool: {e}")
+        
         # Set up memory/checkpointer if available
         checkpointer = None
         if self.memory is not None:

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/runtime/tools/__init__.py

@@ -5,10 +5,13 @@ This module provides various tools that can be used within LangGraph agents.
 
 from .sandbox import PyodideSandboxTool, StatefulPyodideSandboxTool, create_sandbox_tool
 from .echo import EchoTool
+from .image_generation import ImageGenerationTool, create_image_generation_tool
 
 __all__ = [
     "PyodideSandboxTool",
-    "StatefulPyodideSandboxTool", 
+    "StatefulPyodideSandboxTool",
     "create_sandbox_tool",
-    "EchoTool"
+    "EchoTool",
+    "ImageGenerationTool",
+    "create_image_generation_tool"
 ]

alita_sdk-0.3.359/alita_sdk/runtime/tools/image_generation.py

@@ -0,0 +1,116 @@
+"""
+Image generation tool for Alita SDK.
+"""
+import logging
+from typing import Optional, Type, Any
+from langchain_core.tools import BaseTool
+from pydantic import BaseModel, Field
+
+logger = logging.getLogger(__name__)
+
+
+class ImageGenerationInput(BaseModel):
+    """Input schema for image generation tool."""
+    prompt: str = Field(description="Text prompt describing the image to generate")
+    n: int = Field(
+        default=1, description="Number of images to generate (1-10)",
+        ge=1, le=10
+    )
+    size: str = Field(
+        default="auto",
+        description="Size of the generated image (e.g., '1024x1024')"
+    )
+    quality: str = Field(
+        default="auto",
+        description="Quality of the generated image ('low', 'medium', 'high', 'auto')"
+    )
+    style: Optional[str] = Field(
+        default=None, description="Style of the generated image (optional)"
+    )
+
+
+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"
+    args_schema: Type[BaseModel] = ImageGenerationInput
+    alita_client: Any = None
+    
+    def __init__(self, client, **kwargs):
+        super().__init__(**kwargs)
+        self.alita_client = client
+    
+    def _run(self, prompt: str, n: int = 1, size: str = "auto",
+             quality: str = "auto", style: Optional[str] = None) -> list:
+        """Generate an image based on the provided parameters."""
+        try:
+            logger.info(f"Generating image with prompt: {prompt[:50]}...")
+            
+            result = self.alita_client.generate_image(
+                prompt=prompt,
+                n=n,
+                size=size,
+                quality=quality,
+                style=style
+            )
+            
+            # Return multimodal content format for LLM consumption
+            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 prompt: '{prompt}'"
+                    })
+                
+                # 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,{image_data['b64_json']}"
+                            }
+                        })
+                
+                return content_chunks
+            
+            # Fallback to text response if no images in result
+            return [{
+                "type": "text",
+                "text": 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)}"
+            }]
+    
+    async def _arun(self, prompt: str, n: int = 1, size: str = "256x256",
+                    quality: str = "auto",
+                    style: Optional[str] = None) -> list:
+        """Async version - for now just calls the sync version."""
+        return self._run(prompt, n, size, quality, style)
+
+
+def create_image_generation_tool(client):
+    """Create an image generation tool with the provided Alita client."""
+    return ImageGenerationTool(client=client)

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/runtime/tools/llm.py

@@ -179,12 +179,25 @@ class LLMNode(BaseTool):
                                     logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
                                     tool_result = tool_to_execute.invoke(tool_args)
 
-                                    # Create tool message with result
+                                    # Create tool message with result - preserve structured content
                                     from langchain_core.messages import ToolMessage
-                                    tool_message = ToolMessage(
-                                        content=str(tool_result),
-                                        tool_call_id=tool_call_id
-                                    )
+                                    
+                                    # Check if tool_result is structured content (list of dicts)
+                                    # TODO: need solid check for being compatible with ToolMessage content format
+                                    if isinstance(tool_result, list) and all(
+                                        isinstance(item, dict) and 'type' in item for item in tool_result
+                                    ):
+                                        # Use structured content directly for multimodal support
+                                        tool_message = ToolMessage(
+                                            content=tool_result,
+                                            tool_call_id=tool_call_id
+                                        )
+                                    else:
+                                        # Fallback to string conversion for other tool results
+                                        tool_message = ToolMessage(
+                                            content=str(tool_result),
+                                            tool_call_id=tool_call_id
+                                        )
                                     new_messages.append(tool_message)
 
                                 except Exception as e:

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/tools/qtest/__init__.py

@@ -17,8 +17,10 @@ def get_tools(tool):
     toolkit = QtestToolkit.get_toolkit(
         selected_tools=tool['settings'].get('selected_tools', []),
         qtest_project_id=tool['settings'].get('qtest_project_id', tool['settings'].get('project_id', None)),
+        no_of_tests_shown_in_dql_search=tool['settings'].get('no_of_tests_shown_in_dql_search'),
         qtest_configuration=tool['settings']['qtest_configuration'],
-        toolkit_name=tool.get('toolkit_name')
+        toolkit_name=tool.get('toolkit_name'),
+        llm=tool['settings'].get('llm', None)
     )
     return toolkit.tools
 
@@ -37,7 +39,10 @@ class QtestToolkit(BaseToolkit):
                 'configuration_types': ['qtest']})),
             qtest_project_id=(int, Field(default=None, description="QTest project id", json_schema_extra={'toolkit_name': True,
                                                                                             'max_toolkit_length': QtestToolkit.toolkit_max_length})),
-            selected_tools=(List[Literal[tuple(selected_tools)]],
+            no_of_tests_shown_in_dql_search=(Optional[int], Field(description="Max number of items returned by dql search",
+                                                                  default=10)),
+
+        selected_tools=(List[Literal[tuple(selected_tools)]],
                             Field(default=[], json_schema_extra={'args_schemas': selected_tools})),
             __config__=ConfigDict(json_schema_extra={'metadata': {"label": "QTest", "icon_url": "qtest.svg",
                                                                   "categories": ["test management"],

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk/tools/qtest/api_wrapper.py

@@ -1,5 +1,7 @@
+import base64
 import json
 import logging
+import re
 from traceback import format_exc
 from typing import Any, Optional
 
@@ -11,6 +13,7 @@ from swagger_client import TestCaseApi, SearchApi, PropertyResource, ModuleApi
 from swagger_client.rest import ApiException
 
 from ..elitea_base import BaseToolApiWrapper
+from ..utils.content_parser import parse_file_content
 
 QTEST_ID = "QTest Id"
 
@@ -64,7 +67,10 @@ logger = logging.getLogger(__name__)
 
 QtestDataQuerySearch = create_model(
     "QtestDataQuerySearch",
-    dql=(str, Field(description="Qtest Data Query Language (DQL) query string")))
+    dql=(str, Field(description="Qtest Data Query Language (DQL) query string")),
+    extract_images=(Optional[bool], Field(description="Should images be processed by llm", default=False)),
+    prompt=(Optional[str], Field(description="Prompt for image processing", default=None))
+)
 
 QtestCreateTestCase = create_model(
     "QtestCreateTestCase",
@@ -92,6 +98,8 @@ UpdateTestCase = create_model(
 FindTestCaseById = create_model(
     "FindTestCaseById",
     test_id=(str, Field(description="Test case ID e.g. TC-1234")),
+    extract_images=(Optional[bool], Field(description="Should images be processed by llm", default=False)),
+    prompt=(Optional[str], Field(description="Prompt for image processing", default=None))
 )
 
 DeleteTestCase = create_model(
@@ -118,6 +126,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
     page: int = 1
     no_of_tests_shown_in_dql_search: int = 10
     _client: Any = PrivateAttr()
+    llm: Any
 
     @model_validator(mode='before')
     @classmethod
@@ -234,7 +243,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"Unable to create test case in project - {self.qtest_project_id} with the following content:\n{test_case_content}.\n\n Stacktrace was {stacktrace}") from e
 
-    def __parse_data(self, response_to_parse: dict, parsed_data: list):
+    def __parse_data(self, response_to_parse: dict, parsed_data: list, extract_images: bool=False, prompt: str=None):
         import html
         for item in response_to_parse['items']:
             parsed_data_row = {
@@ -245,8 +254,8 @@ class QtestApiWrapper(BaseToolApiWrapper):
                 QTEST_ID: item['id'],
                 'Steps': list(map(lambda step: {
                     'Test Step Number': step[0] + 1,
-                    'Test Step Description': step[1]['description'],
-                    'Test Step Expected Result': step[1]['expected']
+                    'Test Step Description': self._process_image(step[1]['description'], extract_images, prompt),
+                    'Test Step Expected Result':  self._process_image(step[1]['expected'], extract_images, prompt)
                 }, enumerate(item['test_steps']))),
                 'Status': ''.join([properties['field_value_name'] for properties in item['properties']
                                    if properties['field_name'] == 'Status']),
@@ -259,7 +268,27 @@ class QtestApiWrapper(BaseToolApiWrapper):
             }
             parsed_data.append(parsed_data_row)
 
-    def __perform_search_by_dql(self, dql: str) -> list:
+    def _process_image(self, content: str, extract: bool=False, prompt: str=None):
+        #extract image by regex
+        img_regex = r'<img\s+src="data:image\/[^;]+;base64,([^"]+)"\s+[^>]*data-filename="([^"]+)"[^>]*>'
+
+        def replace_image(match):
+            base64_content = match.group(1)
+            file_name = match.group(2)
+
+            file_content = base64.b64decode(base64_content)
+
+            if extract:
+                description = f"<img description=\"{parse_file_content(file_content=file_content, file_name=file_name, prompt=prompt, llm=self.llm)}\">"
+            else:
+                description = ""
+
+            return description
+        #replace image tag by description
+        content = re.sub(img_regex, replace_image, content)
+        return content
+
+    def __perform_search_by_dql(self, dql: str, extract_images:bool=False, prompt: str=None) -> list:
         search_instance: SearchApi = swagger_client.SearchApi(self._client)
         body = swagger_client.ArtifactSearchParams(object_type='test-cases', fields=['*'],
                                                    query=dql)
@@ -270,7 +299,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
             api_response = search_instance.search_artifact(self.qtest_project_id, body, append_test_steps=append_test_steps,
                                                            include_external_properties=include_external_properties,
                                                            page_size=self.no_of_items_per_page, page=self.page)
-            self.__parse_data(api_response, parsed_data)
+            self.__parse_data(api_response, parsed_data, extract_images, prompt)
 
             if api_response['links']:
                 while api_response['links'][0]['rel'] == 'next':
@@ -279,7 +308,7 @@ class QtestApiWrapper(BaseToolApiWrapper):
                                                                    append_test_steps=append_test_steps,
                                                                    include_external_properties=include_external_properties,
                                                                    page_size=self.no_of_items_per_page, page=next_page)
-                    self.__parse_data(api_response, parsed_data)
+                    self.__parse_data(api_response, parsed_data, extract_images, prompt)
         except ApiException as e:
             stacktrace = format_exc()
             logger.error(f"Exception when calling SearchApi->search_artifact: \n {stacktrace}")
@@ -347,9 +376,9 @@ class QtestApiWrapper(BaseToolApiWrapper):
             logger.error(f"Error: {format_exc()}")
             raise e
 
-    def search_by_dql(self, dql: str):
+    def search_by_dql(self, dql: str, extract_images:bool=False, prompt: str=None):
         """Search for the test cases in qTest using Data Query Language """
-        parsed_data = self.__perform_search_by_dql(dql)
+        parsed_data = self.__perform_search_by_dql(dql, extract_images, prompt)
         return "Found " + str(
             len(parsed_data)) + f" Qtest test cases:\n" + str(parsed_data[:self.no_of_tests_shown_in_dql_search])
 
@@ -398,10 +427,10 @@ class QtestApiWrapper(BaseToolApiWrapper):
             raise ToolException(
                 f"""Unable to update test case in project with id - {self.qtest_project_id} and test id - {test_id}.\n Exception: \n {stacktrace}""") from e
 
-    def find_test_case_by_id(self, test_id: str) -> str:
+    def find_test_case_by_id(self, test_id: str, extract_images=False, prompt=None) -> str:
         """ Find the test case by its id. Id should be in format TC-123. """
         dql: str = f"Id = '{test_id}'"
-        return f"{self.search_by_dql(dql=dql)}"
+        return f"{self.search_by_dql(dql=dql, extract_images=extract_images, prompt=prompt)}"
 
     def delete_test_case(self, qtest_id: int) -> str:
         """ Delete the test case by its id. Id should be in format 3534653120. """

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.358
+Version: 0.3.359
 Summary: SDK for building langchain agents using resources from Alita
 Author-email: Artem Rozumenko <artyom.rozumenko@gmail.com>, Mikalai Biazruchka <mikalai_biazruchka@epam.com>, Roman Mitusov <roman_mitusov@epam.com>, Ivan Krakhmaliuk <lifedj27@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/alita_sdk.egg-info/SOURCES.txt

@@ -119,6 +119,7 @@ alita_sdk/runtime/tools/datasource.py
 alita_sdk/runtime/tools/echo.py
 alita_sdk/runtime/tools/function.py
 alita_sdk/runtime/tools/graph.py
+alita_sdk/runtime/tools/image_generation.py
 alita_sdk/runtime/tools/indexer_tool.py
 alita_sdk/runtime/tools/llm.py
 alita_sdk/runtime/tools/loop.py

{alita_sdk-0.3.358 → alita_sdk-0.3.359}/pyproject.toml

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