alita-sdk 0.3.457__py3-none-any.whl → 0.3.465__py3-none-any.whl

alita_sdk/runtime/clients/client.py

@@ -68,6 +68,7 @@ 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.models_url = f'{self.base_url}{self.api_path}/configurations/models/{self.project_id}?include_shared=true'
         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)
@@ -175,6 +176,20 @@ class AlitaClient:
             return resp.json()
         return []
 
+    def get_available_models(self):
+        """Get list of available models from the configurations API.
+        
+        Returns:
+            List of model dictionaries with 'name' and other properties,
+            or empty list if request fails.
+        """
+        resp = requests.get(self.models_url, headers=self.headers, verify=False)
+        if resp.ok:
+            data = resp.json()
+            # API returns {"items": [...], ...}
+            return data.get('items', [])
+        return []
+
     def get_embeddings(self, embedding_model: str) -> OpenAIEmbeddings:
         """
         Get an instance of OpenAIEmbeddings configured with the project ID and auth token.
@@ -565,7 +580,7 @@ class AlitaClient:
             monitoring_meta = tasknode_task.meta.get("monitoring", {})
             return monitoring_meta["user_id"]
         except Exception as e:
-            logger.warning(f"Error: Could not determine user ID for MCP tool: {e}")
+            logger.debug(f"Error: Could not determine user ID for MCP tool: {e}")
             return None
 
     def predict_agent(self, llm: ChatOpenAI, instructions: str = "You are a helpful assistant.",

alita_sdk/runtime/langchain/constants.py

@@ -83,4 +83,5 @@ DEFAULT_MULTIMODAL_PROMPT = """
 
 ELITEA_RS = "elitea_response"
 PRINTER = "printer"
-PRINTER_NODE_RS = "printer_output"
+PRINTER_NODE_RS = "printer_output"
+PRINTER_COMPLETED_STATE = "PRINTER_COMPLETED"

alita_sdk/runtime/langchain/langraph_agent.py

@@ -19,7 +19,7 @@ from langgraph.managed.base import is_managed_value
 from langgraph.prebuilt import InjectedStore
 from langgraph.store.base import BaseStore
 
-from .constants import PRINTER_NODE_RS, PRINTER
+from .constants import PRINTER_NODE_RS, PRINTER, PRINTER_COMPLETED_STATE
 from .mixedAgentRenderes import convert_message_to_json
 from .utils import create_state, propagate_the_input_mapping, safe_format
 from ..tools.function import FunctionTool
@@ -244,11 +244,19 @@ class PrinterNode(Runnable):
         result = {}
         logger.debug(f"Initial text pattern: {self.input_mapping}")
         mapping = propagate_the_input_mapping(self.input_mapping, [], state)
+        # for printer node we expect that all the lists will be joined into strings already
+        # Join any lists that haven't been converted yet
+        for key, value in mapping.items():
+            if isinstance(value, list):
+                mapping[key] = ', '.join(str(item) for item in value)
         if mapping.get(PRINTER) is None:
             raise ToolException(f"PrinterNode requires '{PRINTER}' field in input mapping")
         formatted_output = mapping[PRINTER]
         # add info label to the printer's output
-        if formatted_output:
+        if not formatted_output == PRINTER_COMPLETED_STATE:
+            # convert formatted output to string if it's not
+            if not isinstance(formatted_output, str):
+                formatted_output = str(formatted_output)
             formatted_output += f"\n\n-----\n*How to proceed?*\n* *to resume the pipeline - type anything...*"
         logger.debug(f"Formatted output: {formatted_output}")
         result[PRINTER_NODE_RS] = formatted_output
@@ -666,7 +674,7 @@ def create_graph(
                 # reset printer output variable to avoid carrying over
                 reset_node_id = f"{node_id}_reset"
                 lg_builder.add_node(reset_node_id, PrinterNode(
-                    input_mapping={'printer': {'type': 'fixed', 'value': ''}}
+                    input_mapping={'printer': {'type': 'fixed', 'value': PRINTER_COMPLETED_STATE}}
                 ))
                 lg_builder.add_conditional_edges(node_id, TransitionalEdge(reset_node_id))
                 lg_builder.add_conditional_edges(reset_node_id, TransitionalEdge(clean_string(node['transition'])))
@@ -900,11 +908,15 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         logging.info(f"Input: {thread_id} - {input}")
         if self.checkpointer and self.checkpointer.get_tuple(config):
             self.update_state(config, input)
-            result = super().invoke(None, config=config, *args, **kwargs)
+            if config.pop("should_continue", False):
+                invoke_input = input
+            else:
+                invoke_input = None
+            result = super().invoke(invoke_input, config=config, *args, **kwargs)
         else:
             result = super().invoke(input, config=config, *args, **kwargs)
         try:
-            if not result.get(PRINTER_NODE_RS):
+            if result.get(PRINTER_NODE_RS) == PRINTER_COMPLETED_STATE:
                 output = next((msg.content for msg in reversed(result['messages']) if not isinstance(msg, HumanMessage)),
                               result['messages'][-1].content)
             else:

alita_sdk/runtime/langchain/utils.py

@@ -131,7 +131,7 @@ def parse_type(type_str):
 
 
 def create_state(data: Optional[dict] = None):
-    state_dict = {'input': str, 'router_output': str,
+    state_dict = {'input': str, 'messages': 'list[str]', 'router_output': str,
                   ELITEA_RS: str, PRINTER_NODE_RS: str}  # Always include router_output
     types_dict = {}
     if not data:

alita_sdk/runtime/tools/function.py

@@ -16,6 +16,18 @@ from ..langchain.utils import propagate_the_input_mapping
 logger = logging.getLogger(__name__)
 
 
+def replace_escaped_newlines(data):
+    """
+        Replace \\n with \n in all string values recursively.
+        Required for sanitization of state variables in code node
+    """
+    if isinstance(data, dict):
+        return {key: replace_escaped_newlines(value) for key, value in data.items()}
+    elif isinstance(data, str):
+        return data.replace('\\n', '\n')
+    else:
+        return data
+
 class FunctionTool(BaseTool):
     name: str = 'FunctionalTool'
     description: str = 'This is direct call node for tools'
@@ -30,11 +42,13 @@ class FunctionTool(BaseTool):
     def _prepare_pyodide_input(self, state: Union[str, dict, ToolCall]) -> str:
         """Prepare input for PyodideSandboxTool by injecting state into the code block."""
         # add state into the code block here since it might be changed during the execution of the code
-        state_copy = deepcopy(state)
+        state_copy = replace_escaped_newlines(deepcopy(state))
 
         del state_copy['messages']  # remove messages to avoid issues with pickling without langchain-core
         # inject state into the code block as alita_state variable
-        pyodide_predata = f"#state dict\nalita_state = {state_copy}\n"
+        state_json = json.dumps(state_copy, ensure_ascii=False)
+        pyodide_predata = f'#state dict\nimport json\nalita_state = json.loads({json.dumps(state_json)})\n'
+
         return pyodide_predata
 
     def _handle_pyodide_output(self, tool_result: Any) -> dict:
@@ -94,9 +108,7 @@ class FunctionTool(BaseTool):
         # special handler for PyodideSandboxTool
         if self._is_pyodide_tool():
             code = func_args['code']
-            func_args['code'] = (f"{self._prepare_pyodide_input(state)}\n{code}"
-                                # handle new lines in the code properly
-                                 .replace('\\n','\\\\n'))
+            func_args['code'] = f"{self._prepare_pyodide_input(state)}\n{code}"
         try:
             tool_result = self.tool.invoke(func_args, config, **kwargs)
             dispatch_custom_event(

alita_sdk/runtime/tools/llm.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from traceback import format_exc
 from typing import Any, Optional, List, Union
@@ -132,7 +133,9 @@ class LLMNode(BaseTool):
                 struct_model = create_pydantic_model(f"LLMOutput", struct_params)
                 completion = llm_client.invoke(messages, config=config)
                 if hasattr(completion, 'tool_calls') and completion.tool_calls:
-                    new_messages, _ = self.__perform_tool_calling(completion, messages, llm_client, config)
+                    new_messages, _ = self._run_async_in_sync_context(
+                        self.__perform_tool_calling(completion, messages, llm_client, config)
+                    )
                     llm = self.__get_struct_output_model(llm_client, struct_model)
                     completion = llm.invoke(new_messages, config=config)
                     result = completion.model_dump()
@@ -155,7 +158,9 @@ class LLMNode(BaseTool):
                 # Handle both tool-calling and regular responses
                 if hasattr(completion, 'tool_calls') and completion.tool_calls:
                     # Handle iterative tool-calling and execution
-                    new_messages, current_completion = self.__perform_tool_calling(completion, messages, llm_client, config)
+                    new_messages, current_completion = self._run_async_in_sync_context(
+                        self.__perform_tool_calling(completion, messages, llm_client, config)
+                    )
 
                     output_msgs = {"messages": new_messages}
                     if self.output_variables:
@@ -190,9 +195,53 @@ class LLMNode(BaseTool):
     def _run(self, *args, **kwargs):
         # Legacy support for old interface
         return self.invoke(kwargs, **kwargs)
+    
+    def _run_async_in_sync_context(self, coro):
+        """Run async coroutine from sync context.
+        
+        For MCP tools with persistent sessions, we reuse the same event loop
+        that was used to create the MCP client and sessions (set by CLI).
+        """
+        try:
+            loop = asyncio.get_running_loop()
+            # Already in async context - run in thread with new loop
+            import threading
+            
+            result_container = []
+            
+            def run_in_thread():
+                new_loop = asyncio.new_event_loop()
+                asyncio.set_event_loop(new_loop)
+                try:
+                    result_container.append(new_loop.run_until_complete(coro))
+                finally:
+                    new_loop.close()
+            
+            thread = threading.Thread(target=run_in_thread)
+            thread.start()
+            thread.join()
+            return result_container[0] if result_container else None
+            
+        except RuntimeError:
+            # No event loop running - use/create persistent loop
+            # This loop is shared with MCP session creation for stateful tools
+            if not hasattr(self.__class__, '_persistent_loop') or \
+               self.__class__._persistent_loop is None or \
+               self.__class__._persistent_loop.is_closed():
+                self.__class__._persistent_loop = asyncio.new_event_loop()
+                logger.debug("Created persistent event loop for async tools")
+            
+            loop = self.__class__._persistent_loop
+            asyncio.set_event_loop(loop)
+            return loop.run_until_complete(coro)
+    
+    async def _arun(self, *args, **kwargs):
+        # Legacy async support
+        return self.invoke(kwargs, **kwargs)
 
-    def __perform_tool_calling(self, completion, messages, llm_client, config):
+    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")
         new_messages = messages + [completion]
         iteration = 0
 
@@ -230,9 +279,16 @@ class LLMNode(BaseTool):
                 if tool_to_execute:
                     try:
                         logger.info(f"Executing tool '{tool_name}' with args: {tool_args}")
-                        # Pass the underlying config to the tool execution invoke method
-                        # since it may be another agent, graph, etc. to see it properly in thinking steps
-                        tool_result = tool_to_execute.invoke(tool_args, config=config)
+                        
+                        # Try async invoke first (for MCP tools), fallback to sync
+                        tool_result = None
+                        try:
+                            # Try async invocation first
+                            tool_result = await tool_to_execute.ainvoke(tool_args, config=config)
+                        except NotImplementedError:
+                            # Tool doesn't support async, use sync invoke
+                            logger.debug(f"Tool '{tool_name}' doesn't support async, using sync invoke")
+                            tool_result = tool_to_execute.invoke(tool_args, config=config)
 
                         # Create tool message with result - preserve structured content
                         from langchain_core.messages import ToolMessage
@@ -256,7 +312,9 @@ class LLMNode(BaseTool):
                         new_messages.append(tool_message)
 
                     except Exception as e:
-                        logger.error(f"Error executing tool '{tool_name}': {e}")
+                        import traceback
+                        error_details = traceback.format_exc()
+                        logger.error(f"Error executing tool '{tool_name}': {e}\n{error_details}")
                         # Create error tool message
                         from langchain_core.messages import ToolMessage
                         tool_message = ToolMessage(

alita_sdk/tools/base_indexer_toolkit.py

@@ -4,6 +4,7 @@ import logging
 import time
 from typing import Any, Optional, List, Dict, Generator
 
+from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.documents import Document
 from pydantic import create_model, Field, SecretStr
 
@@ -179,11 +180,13 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             #
             results_count = result["count"]
             self.index_meta_update(index_name, IndexerKeywords.INDEX_META_COMPLETED.value, results_count)
+            self._emit_index_event(index_name)
             #
             return {"status": "ok", "message": f"successfully indexed {results_count} documents" if results_count > 0
             else "no new documents to index"}
         except Exception as e:
             self.index_meta_update(index_name, IndexerKeywords.INDEX_META_FAILED.value, result["count"])
+            self._emit_index_event(index_name, error=str(e))
             raise e
             
 
@@ -511,6 +514,54 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
             index_meta_doc = Document(page_content=index_meta_raw.get("content", ""), metadata=metadata)
             add_documents(vectorstore=self.vectorstore, documents=[index_meta_doc], ids=[index_meta_raw.get("id")])
 
+    def _emit_index_event(self, index_name: str, error: Optional[str] = None):
+        """
+        Emit custom event for index data operation.
+        
+        Args:
+            index_name: The name of the index
+            error: Error message if the operation failed, None otherwise
+        """
+        index_meta = super().get_index_meta(index_name)
+        
+        if not index_meta:
+            logger.warning(
+                f"No index_meta found for index '{index_name}'. "
+                "Cannot emit index event."
+            )
+            return
+        
+        metadata = index_meta.get("metadata", {})
+        
+        # Determine if this is a reindex operation
+        history_raw = metadata.get("history", "[]")
+        try:
+            history = json.loads(history_raw) if history_raw.strip() else []
+            is_reindex = len(history) > 1
+        except (json.JSONDecodeError, TypeError):
+            is_reindex = False
+        
+        # Build event message
+        event_data = {
+            "id": index_meta.get("id"),
+            "index_name": index_name,
+            "state": metadata.get("state"),
+            "error": error,
+            "reindex": is_reindex,
+            "indexed": metadata.get("indexed", 0),
+            "updated": metadata.get("updated", 0),
+        }
+        
+        # Emit the event
+        try:
+            dispatch_custom_event("index_data_status", event_data)
+            logger.debug(
+                f"Emitted index_data_status event for index "
+                f"'{index_name}': {event_data}"
+            )
+        except Exception as e:
+            logger.warning(f"Failed to emit index_data_status event: {e}")
+
     def get_available_tools(self):
         """
         Returns the standardized vector search tools (search operations only).
@@ -564,6 +615,7 @@ class BaseIndexerToolkit(VectorStoreWrapperBase):
                 "mode": "list_collections",
                 "ref": self.list_collections,
                 "description": self.list_collections.__doc__,
-                "args_schema": create_model("ListCollectionsParams")  # No parameters
+                # No parameters
+                "args_schema": create_model("ListCollectionsParams")
             },
-        ]
+        ]