alita-sdk 0.3.177__tar.gz → 0.3.179__tar.gz

{alita_sdk-0.3.177 → alita_sdk-0.3.179}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.177
+Version: 0.3.179
 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.177 → alita_sdk-0.3.179}/alita_sdk/runtime/langchain/assistant.py

@@ -7,10 +7,14 @@ from langchain.agents import (
     create_json_chat_agent)
 from langgraph.store.base import BaseStore
 
+# Note: Traditional LangChain agents (OpenAI, XML, JSON) do not support 
+# checkpointing natively. Only LangGraph agents support checkpointing.
+# For checkpointing in traditional agents, you need to migrate to LangGraph.
+
 from .agents.xml_chat import create_xml_chat_agent
 from .langraph_agent import create_graph
 from langchain_core.messages import (
-    BaseMessage, SystemMessage, HumanMessage
+    BaseMessage, SystemMessage, HumanMessage, AIMessage
 )
 from langchain_core.prompts import MessagesPlaceholder
 from .constants import REACT_ADDON, REACT_VARS, XML_ADDON
@@ -29,7 +33,8 @@ class Assistant:
                  app_type: str = "openai",
                  tools: Optional[list] = [],
                  memory: Optional[Any] = None,
-                 store: Optional[BaseStore] = None):
+                 store: Optional[BaseStore] = None,
+                 use_checkpointing: bool = False):
 
         self.client = copy(client)
         self.client.max_tokens = data['llm_settings']['max_tokens']
@@ -42,6 +47,7 @@ class Assistant:
         self.app_type = app_type
         self.memory = memory
         self.store = store
+        self.use_checkpointing = use_checkpointing
 
         logger.debug("Data for agent creation: %s", data)
         logger.info("App type: %s", app_type)
@@ -118,12 +124,17 @@ class Assistant:
         if self.app_type == 'pipeline':
             return self.pipeline()
         elif self.app_type == 'openai':
+            # Check if checkpointing is enabled - if so, use LangGraph for auto-continue capability
+            if self.use_checkpointing:
+                return self.getLangGraphAgentWithAutoContinue()
             return self.getOpenAIToolsAgentExecutor()
         elif self.app_type == 'xml':
+            # Check if checkpointing is enabled - if so, use LangGraph for auto-continue capability
+            if self.use_checkpointing:
+                return self.getLangGraphAgentWithAutoContinue()
             return self.getXMLAgentExecutor()
         else:
-            self.tools = [EchoTool()] + self.tools
-            return self.getAgentExecutor()
+            return self.getLangGraphAgentWithAutoContinue()
 
     def _agent_executor(self, agent: Any):
         return AgentExecutor.from_agent_and_tools(agent=agent, tools=self.tools,
@@ -169,3 +180,81 @@ class Assistant:
 
     def predict(self, messages: list[BaseMessage]):
         return self.client.invoke(messages)
+
+    def getLangGraphAgentWithAutoContinue(self):
+        """
+        Create a LangGraph agent with auto-continue capability for when responses get truncated.
+        This provides better handling of length-limited responses compared to traditional AgentExecutor.
+        Uses simple in-memory checkpointing for auto-continue functionality.
+        """
+        from langgraph.prebuilt import create_react_agent
+        from langgraph.checkpoint.memory import MemorySaver
+    
+        # Use simple in-memory checkpointer for auto-continue functionality
+        # This ensures clean, predictable behavior for continuation logic
+        memory = MemorySaver()
+        
+        # Filter tools to only include BaseTool instances
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        
+        # Create the agent with checkpointing enabled
+        agent = create_react_agent(
+            prompt=self.prompt,
+            model=self.client,
+            tools=simple_tools,
+            checkpointer=memory,
+            state_modifier=self._create_auto_continue_state_modifier()
+        )
+        
+        return agent
+    
+    def _create_auto_continue_state_modifier(self):
+        """
+        Create a state modifier that implements auto-continue logic.
+        This checks if the last AI response was truncated and automatically continues if needed.
+        Limits auto-continue to prevent infinite loops.
+        """
+        MAX_CONTINUATIONS = 3  # Maximum number of auto-continuations allowed
+        
+        def auto_continue_modifier(state):
+            messages = state.get("messages", [])
+            
+            # Count how many auto-continue messages we've already sent
+            continuation_count = sum(
+                1 for msg in messages 
+                if isinstance(msg, HumanMessage) and 
+                "continue your previous response" in msg.content.lower()
+            )
+            
+            # Don't continue if we've reached the limit
+            if continuation_count >= MAX_CONTINUATIONS:
+                return state
+            
+            # Check if the last AI message was truncated
+            if messages and isinstance(messages[-1], AIMessage):
+                last_ai_message = messages[-1]
+                
+                # Check for truncation indicators
+                is_truncated = (
+                    hasattr(last_ai_message, 'response_metadata') and 
+                    last_ai_message.response_metadata.get('finish_reason') == 'length'
+                ) or (
+                    # Fallback: check if message seems to end abruptly
+                    last_ai_message.content and 
+                    not last_ai_message.content.rstrip().endswith(('.', '!', '?', ':', ';'))
+                )
+                
+                # Add continuation logic
+                if is_truncated:
+                    # Add a human message to continue
+                    continuation_msg = HumanMessage(
+                        content="Continue your previous response from where you left off"
+                    )
+                    return {
+                        **state,
+                        "messages": messages + [continuation_msg]
+                    }
+            
+            return state
+        
+        return auto_continue_modifier

{alita_sdk-0.3.177 → alita_sdk-0.3.179}/alita_sdk/tools/__init__.py

@@ -15,19 +15,19 @@ def _safe_import_tool(tool_name, module_path, get_tools_name=None, toolkit_class
     """Safely import a tool module and register available functions/classes."""
     try:
         module = __import__(f'alita_sdk.tools.{module_path}', fromlist=[''])
-        
+
         imported = {}
         if get_tools_name and hasattr(module, get_tools_name):
             imported['get_tools'] = getattr(module, get_tools_name)
-            
+
         if toolkit_class_name and hasattr(module, toolkit_class_name):
             imported['toolkit_class'] = getattr(module, toolkit_class_name)
             AVAILABLE_TOOLKITS[toolkit_class_name] = getattr(module, toolkit_class_name)
-            
+
         if imported:
             AVAILABLE_TOOLS[tool_name] = imported
             logger.debug(f"Successfully imported {tool_name}")
-        
+
     except Exception as e:
         FAILED_IMPORTS[tool_name] = str(e)
         logger.debug(f"Failed to import {tool_name}: {e}")
@@ -92,7 +92,7 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
         for tool_name in tool.get('settings', {}).get('selected_tools', []):
             if isinstance(tool_name, str) and tool_name.startswith('_'):
                 raise ValueError(f"Tool name '{tool_name}' from toolkit '{tool.get('type', '')}' cannot start with '_'")
-        
+
         tool['settings']['alita'] = alita
         tool['settings']['llm'] = llm
         tool['settings']['store'] = store
@@ -107,10 +107,10 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
             try:
                 get_tools_func = AVAILABLE_TOOLS[tool_type]['get_tools']
                 tools.extend(get_tools_func(tool))
-                    
+
             except Exception as e:
                 logger.error(f"Error getting tools for {tool_type}: {e}")
-                
+
         # Handle ADO repos special case (it might be requested as azure_devops_repos)
         elif tool_type in ['ado_repos', 'azure_devops_repos'] and 'ado_repos' in AVAILABLE_TOOLS:
             try:
@@ -118,31 +118,35 @@ def get_tools(tools_list, alita, llm, store: Optional[BaseStore] = None, *args,
                 tools.extend(get_tools_func(tool))
             except Exception as e:
                 logger.error(f"Error getting ADO repos tools: {e}")
-                
+
         # Handle custom modules
         elif tool.get("settings", {}).get("module"):
             try:
                 settings = tool.get("settings", {})
                 mod = import_module(settings.pop("module"))
                 tkitclass = getattr(mod, settings.pop("class"))
-                toolkit = tkitclass.get_toolkit(**tool["settings"])
+                #
+                get_toolkit_params = tool["settings"].copy()
+                get_toolkit_params["name"] = tool.get("name")
+                #
+                toolkit = tkitclass.get_toolkit(**get_toolkit_params)
                 tools.extend(toolkit.get_tools())
             except Exception as e:
                 logger.error(f"Error in getting custom toolkit: {e}")
-                
+
         else:
             # Tool not available or not found
             if tool_type in FAILED_IMPORTS:
                 logger.warning(f"Tool '{tool_type}' is not available: {FAILED_IMPORTS[tool_type]}")
             else:
                 logger.warning(f"Unknown tool type: {tool_type}")
-                
+
     return tools
 
 def get_toolkits():
     """Return toolkit configurations for all successfully imported toolkits."""
     toolkit_configs = []
-    
+
     for toolkit_name, toolkit_class in AVAILABLE_TOOLKITS.items():
         try:
             if hasattr(toolkit_class, 'toolkit_config_schema'):
@@ -151,7 +155,7 @@ def get_toolkits():
                 logger.debug(f"Toolkit {toolkit_name} does not have toolkit_config_schema method")
         except Exception as e:
             logger.error(f"Error getting config schema for {toolkit_name}: {e}")
-    
+
     logger.info(f"Successfully loaded {len(toolkit_configs)} toolkit configurations")
     return toolkit_configs
 
@@ -172,13 +176,13 @@ def diagnose_imports():
     available_count = len(AVAILABLE_TOOLS)
     failed_count = len(FAILED_IMPORTS)
     total_count = available_count + failed_count
-    
+
     print(f"=== Tool Import Diagnostic ===")
     print(f"Total tools: {total_count}")
     print(f"Successfully imported: {available_count}")
     print(f"Failed imports: {failed_count}")
     print(f"Success rate: {(available_count/total_count*100):.1f}%")
-    
+
     if AVAILABLE_TOOLS:
         print(f"\n✅ Available tools ({len(AVAILABLE_TOOLS)}):")
         for tool_name in sorted(AVAILABLE_TOOLS.keys()):
@@ -188,12 +192,12 @@ def diagnose_imports():
             if 'toolkit_class' in AVAILABLE_TOOLS[tool_name]:
                 functions.append('toolkit')
             print(f"  - {tool_name}: {', '.join(functions)}")
-    
+
     if FAILED_IMPORTS:
         print(f"\n❌ Failed imports ({len(FAILED_IMPORTS)}):")
         for tool_name, error in FAILED_IMPORTS.items():
             print(f"  - {tool_name}: {error}")
-    
+
     if AVAILABLE_TOOLKITS:
         print(f"\n🔧 Available toolkits ({len(AVAILABLE_TOOLKITS)}):")
         for toolkit_name in sorted(AVAILABLE_TOOLKITS.keys()):
@@ -204,7 +208,7 @@ __all__ = [
     'get_tools',
     'get_toolkits',
     'get_available_tools',
-    'get_failed_imports', 
+    'get_failed_imports',
     'get_available_toolkits',
     'diagnose_imports'
 ]

{alita_sdk-0.3.177 → alita_sdk-0.3.179}/alita_sdk.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.177
+Version: 0.3.179
 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.177 → alita_sdk-0.3.179}/pyproject.toml

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