alita-sdk 0.3.183__tar.gz → 0.3.185__tar.gz

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.183
+Version: 0.3.185
 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 <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/alita_sdk/runtime/clients/client.py

@@ -432,3 +432,41 @@ class AlitaClient:
         except Exception as e:
             logger.warning(f"Error: Could not determine user ID for MCP tool: {e}")
             return None
+
+    def predict_agent(self, client: Any, instructions: str = "You are a helpful assistant.",
+                      tools: Optional[list] = None, chat_history: Optional[List[Any]] = None,
+                      memory=None, runtime='langchain', variables: Optional[list] = None,
+                      store: Optional[BaseStore] = None):
+        """
+        Create a predict-type agent with minimal configuration.
+        
+        Args:
+            client: The LLM client to use
+            instructions: System instructions for the agent
+            tools: Optional list of tools to provide to the agent
+            chat_history: Optional chat history
+            memory: Optional memory/checkpointer
+            runtime: Runtime type (default: 'langchain')
+            variables: Optional list of variables for the agent
+            store: Optional store for memory
+            
+        Returns:
+            Runnable agent ready for execution
+        """
+        if tools is None:
+            tools = []
+        if chat_history is None:
+            chat_history = []
+        if variables is None:
+            variables = []
+            
+        # Create a minimal data structure for predict agent
+        # All LLM settings are taken from the passed client instance
+        agent_data = {
+            'instructions': instructions,
+            'tools': tools,  # Tools are handled separately in predict agents
+            'variables': variables
+        }
+        return LangChainAssistant(self, agent_data, client,
+                                  chat_history, "predict", memory=memory, store=store).runnable()
+        

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/alita_sdk/runtime/langchain/assistant.py

@@ -30,14 +30,6 @@ class Assistant:
                  memory: Optional[Any] = None,
                  store: Optional[BaseStore] = None):
 
-        self.client = copy(client)
-        self.client.max_tokens = data['llm_settings']['max_tokens']
-        self.client.temperature = data['llm_settings']['temperature']
-        self.client.top_p = data['llm_settings']['top_p']
-        self.client.top_k = data['llm_settings']['top_k']
-        self.client.model_name = data['llm_settings']['model_name']
-        self.client.integration_uid = data['llm_settings']['integration_uid']
-
         self.app_type = app_type
         self.memory = memory
         self.store = store
@@ -45,33 +37,53 @@ class Assistant:
         logger.debug("Data for agent creation: %s", data)
         logger.info("App type: %s", app_type)
 
-        model_type = data["llm_settings"]["indexer_config"]["ai_model"]
-        model_params = data["llm_settings"]["indexer_config"]["ai_model_params"]
-        #
-        target_pkg, target_name = model_type.rsplit(".", 1)
-        target_cls = getattr(
-            importlib.import_module(target_pkg),
-            target_name
-        )
-        self.client = target_cls(**model_params)
+        # For predict agents, use the client as-is since it's already configured
+        if app_type == "predict":
+            self.client = client
+        else:
+            # For other agent types, configure client from llm_settings
+            self.client = copy(client)
+            self.client.max_tokens = data['llm_settings']['max_tokens']
+            self.client.temperature = data['llm_settings']['temperature']
+            self.client.top_p = data['llm_settings']['top_p']
+            self.client.top_k = data['llm_settings']['top_k']
+            self.client.model_name = data['llm_settings']['model_name']
+            self.client.integration_uid = data['llm_settings']['integration_uid']
+
+            model_type = data["llm_settings"]["indexer_config"]["ai_model"]
+            model_params = data["llm_settings"]["indexer_config"]["ai_model_params"]
+            #
+            target_pkg, target_name = model_type.rsplit(".", 1)
+            target_cls = getattr(
+                importlib.import_module(target_pkg),
+                target_name
+            )
+            self.client = target_cls(**model_params)
         # validate agents compatibility: non-pipeline agents cannot have pipelines as toolkits
-        if app_type != "pipeline" and any(tool['agent_type'] == 'pipeline' for tool in data['tools']):
-            raise ToolException("Non-pipeline agents cannot have pipelines as a toolkits. "
-                                "Review toolkits configuration or use pipeline as master agent.")
+        if app_type not in ["pipeline", "predict"]:
+            tools_to_check = data.get('tools', [])
+            if any(tool['agent_type'] == 'pipeline' for tool in tools_to_check):
+                raise ToolException("Non-pipeline agents cannot have pipelines as a toolkits. "
+                                    "Review toolkits configuration or use pipeline as master agent.")
 
-        # configure memory store if memory tool is defined
-        memory_tool = next((tool for tool in data['tools'] if tool['type'] == 'memory'), None)
-        self._configure_store(memory_tool)
+        # configure memory store if memory tool is defined (not needed for predict agents)
+        if app_type != "predict":
+            memory_tool = next((tool for tool in data.get('tools', []) if tool['type'] == 'memory'), None)
+            self._configure_store(memory_tool)
+        else:
+            # For predict agents, initialize memory store to None since they don't use memory
+            self.store = None
         
         # Lazy import to avoid circular dependency
         from ..toolkits.tools import get_tools
+        
         self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client, memory_store=self.store)
+        if tools:
+            self.tools += tools
+        # Handle prompt setup
         if app_type in ["pipeline", "predict", "react"]:
             self.prompt = data['instructions']
-            if tools:
-                self.tools += tools
         else:
-            self.tools += tools
             messages = [SystemMessage(content=data['instructions'])]
             messages.append(MessagesPlaceholder("chat_history"))
             if app_type == "react":

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/alita_sdk/runtime/toolkits/tools.py

@@ -99,9 +99,57 @@ def get_tools(tools_list: list, alita_client, llm, memory_store: BaseStore = Non
     # Add MCP tools
     tools += _mcp_tools(tools_list, alita_client)
     
+    # Sanitize tool names to meet OpenAI's function naming requirements
+    # tools = _sanitize_tool_names(tools)
+    
     return tools
 
 
+def _sanitize_tool_names(tools: list) -> list:
+    """
+    Sanitize tool names to meet OpenAI's function naming requirements.
+    OpenAI function names must match pattern ^[a-zA-Z0-9_\\.-]+$
+    """
+    import re
+    from langchain_core.tools import BaseTool
+    
+    def sanitize_name(name):
+        """Sanitize a single tool name"""
+        # Replace spaces and other invalid characters with underscores
+        sanitized = re.sub(r'[^a-zA-Z0-9_.-]', '_', name)
+        # Remove multiple consecutive underscores
+        sanitized = re.sub(r'_{2,}', '_', sanitized)
+        # Remove leading/trailing underscores
+        sanitized = sanitized.strip('_')
+        return sanitized
+    
+    sanitized_tools = []
+    name_mapping = {}
+    
+    for tool in tools:
+        if isinstance(tool, BaseTool):
+            original_name = tool.name
+            sanitized_name = sanitize_name(original_name)
+            
+            # Only update if the name actually changed
+            if original_name != sanitized_name:
+                logger.info(f"Sanitizing tool name: '{original_name}' -> '{sanitized_name}'")
+                # Create a new tool instance with the sanitized name
+                # We need to be careful here to preserve all other tool properties
+                tool.name = sanitized_name
+                name_mapping[original_name] = sanitized_name
+            
+            sanitized_tools.append(tool)
+        else:
+            # For non-BaseTool objects (like CompiledStateGraph), just pass through
+            sanitized_tools.append(tool)
+    
+    if name_mapping:
+        logger.info(f"Tool name sanitization complete. Mapped {len(name_mapping)} tool names.")
+    
+    return sanitized_tools
+
+
 def _mcp_tools(tools_list, alita):
     try:
         all_available_toolkits = alita.get_mcp_toolkits()

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.183
+Version: 0.3.185
 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 <lifedjik@gmail.com>, Artem Dubrovskiy <ad13box@gmail.com>
 License-Expression: Apache-2.0

{alita_sdk-0.3.183 → alita_sdk-0.3.185}/pyproject.toml

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