alita-sdk 0.3.365__py3-none-any.whl → 0.3.462__py3-none-any.whl

alita_sdk/runtime/langchain/document_loaders/constants.py

@@ -30,78 +30,73 @@ from enum import Enum
 
 
 class LoaderProperties(Enum):
-    LLM = 'llm'
+    LLM = 'use_llm'
+    PROMPT_DEFAULT = 'use_default_prompt'
     PROMPT = 'prompt'
-    PROMPT_DEFAULT = 'prompt_default'
 
+DEFAULT_ALLOWED_BASE = {'max_tokens': 512}
 
-# Image file loaders mapping
+DEFAULT_ALLOWED_WITH_LLM = {
+    **DEFAULT_ALLOWED_BASE,
+    LoaderProperties.LLM.value: False,
+    LoaderProperties.PROMPT_DEFAULT.value: False,
+    LoaderProperties.PROMPT.value: "",
+}
+
+# Image file loaders mapping - directly supported by LLM with image_url
 image_loaders_map = {
     '.png': {
         'class': AlitaImageLoader,
         'mime_type': 'image/png',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ],
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM,
     },
     '.jpg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/jpeg',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.jpeg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/jpeg',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.gif': {
         'class': AlitaImageLoader,
         'mime_type': 'image/gif',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
+    '.webp': {
+        'class': AlitaImageLoader,
+        'mime_type': 'image/webp',
+        'is_multimodal_processing': True,
+        'kwargs': {},
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
+    }
+}
+
+# Image file loaders mapping - require conversion before sending to LLM
+image_loaders_map_converted = {
     '.bmp': {
         'class': AlitaImageLoader,
         'mime_type': 'image/bmp',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.svg': {
         'class': AlitaImageLoader,
         'mime_type': 'image/svg+xml',
         'is_multimodal_processing': True,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     }
 }
 
@@ -114,25 +109,25 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.yml': {
         'class': AlitaTextLoader,
-        'mime_type': 'application/x-yaml',
+        'mime_type': 'application/yaml',
         'is_multimodal_processing': False,
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.yaml': {
         'class': AlitaTextLoader,
-        'mime_type': 'application/x-yaml',
+        'mime_type': 'application/yaml',
         'is_multimodal_processing': False,
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.groovy': {
         'class': AlitaTextLoader,
@@ -141,14 +136,14 @@ document_loaders_map = {
         'kwargs': {
             'autodetect_encoding': True
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.md': {
         'class': AlitaMarkdownLoader,
         'mime_type': 'text/markdown',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.csv': {
         'class': AlitaCSVLoader,
@@ -159,7 +154,7 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.xlsx': {
         'class': AlitaExcelLoader,
@@ -171,11 +166,7 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.xls': {
         'class': AlitaExcelLoader,
@@ -186,22 +177,14 @@ document_loaders_map = {
             'raw_content': True,
             'cleanse': False
         },
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.pdf': {
         'class': AlitaPDFLoader,
         'mime_type': 'application/pdf',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.docx': {
         'class': AlitaDocxMammothLoader,
@@ -211,58 +194,42 @@ document_loaders_map = {
         'kwargs': {
             'extract_images': True
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': {**DEFAULT_ALLOWED_WITH_LLM, 'mode': 'paged'}
     },
     '.json': {
         'class': AlitaJSONLoader,
         'mime_type': 'application/json',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.jsonl': {
         'class': AirbyteJSONLoader,
         'mime_type': 'application/jsonl',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': ['max_tokens']
+        'allowed_to_override': DEFAULT_ALLOWED_BASE
     },
     '.htm': {
         'class': UnstructuredHTMLLoader,
         'mime_type': 'text/html',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.html': {
         'class': UnstructuredHTMLLoader,
         'mime_type': 'text/html',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.xml': {
         'class': UnstructuredXMLLoader,
         'mime_type': 'text/xml',
         'is_multimodal_processing': False,
         'kwargs': {},
-        'allowed_to_override': [
-            'max_tokens', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': DEFAULT_ALLOWED_WITH_LLM
     },
     '.ppt': {
         'class': AlitaPowerPointLoader,
@@ -271,11 +238,7 @@ document_loaders_map = {
         'kwargs': {
             'mode': 'paged'
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value
-        ]
+        'allowed_to_override': {**DEFAULT_ALLOWED_WITH_LLM, 'mode': 'paged'}
     },
     '.pptx': {
         'class': AlitaPowerPointLoader,
@@ -285,25 +248,24 @@ document_loaders_map = {
         'kwargs': {
             'mode': 'paged'
         },
-        'allowed_to_override': [
-            'max_tokens', 'mode', LoaderProperties.LLM.value,
-            LoaderProperties.PROMPT.value,
-            LoaderProperties.PROMPT_DEFAULT.value,
-            "pages_per_chunk",
-            "extract_images"
-        ]
+        'allowed_to_override': {
+            **DEFAULT_ALLOWED_WITH_LLM,
+            'mode': 'paged',
+            'pages_per_chunk': 5,
+            'extract_images': False,
+        }
     },
-    '.py': {
-        'class': AlitaPythonLoader,
-        'mime_type': 'text/x-python',
-        'is_multimodal_processing': False,
-        'kwargs': {},
-        'allowed_to_override': ['max_tokens']
-    }
+    # '.py': {
+    #     'class': AlitaPythonLoader,
+    #     'mime_type': 'text/x-python',
+    #     'is_multimodal_processing': False,
+    #     'kwargs': {},
+    #     'allowed_to_override': DEFAULT_ALLOWED_BASE
+    # }
 }
 
 code_extensions = [
-    # '.py',  # Python
+    '.py',  # Python
     '.js',  # JavaScript
     '.ts',  # TypeScript
     '.java',  # Java
@@ -335,10 +297,21 @@ default_loader_config = {
     'mime_type': 'text/plain',
     'is_multimodal_processing': False,
     'kwargs': {},
-    'allowed_to_override': ['max_tokens']
+    'allowed_to_override': DEFAULT_ALLOWED_BASE
 }
 
 code_loaders_map = {ext: default_loader_config for ext in code_extensions}
 
 # Combined mapping for backward compatibility
-loaders_map = {**image_loaders_map, **document_loaders_map, **code_loaders_map}
+loaders_map = {
+    **image_loaders_map,
+    **image_loaders_map_converted,
+    **document_loaders_map,
+    **code_loaders_map
+}
+
+loaders_allowed_to_override = {
+    extension: config.get('allowed_to_override')
+    for extension, config in loaders_map.items()
+    if 'allowed_to_override' in config
+}

alita_sdk/runtime/langchain/langraph_agent.py

@@ -19,8 +19,9 @@ 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, PRINTER_COMPLETED_STATE
 from .mixedAgentRenderes import convert_message_to_json
-from .utils import create_state, propagate_the_input_mapping
+from .utils import create_state, propagate_the_input_mapping, safe_format
 from ..tools.function import FunctionTool
 from ..tools.indexer_tool import IndexerNode
 from ..tools.llm import LLMNode
@@ -232,6 +233,32 @@ class StateDefaultNode(Runnable):
                     result[key] = temp_value
         return result
 
+class PrinterNode(Runnable):
+    name = "PrinterNode"
+
+    def __init__(self, input_mapping: Optional[dict[str, dict]]):
+        self.input_mapping = input_mapping
+
+    def invoke(self, state: BaseStore, config: Optional[RunnableConfig] = None) -> dict:
+        logger.info(f"Printer Node - Current state variables: {state}")
+        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 not formatted_output == PRINTER_COMPLETED_STATE:
+            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
+        return result
+
 
 class StateModifierNode(Runnable):
     name = "StateModifierNode"
@@ -348,8 +375,8 @@ class StateModifierNode(Runnable):
         return result
 
 
-
-def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=None, interrupt_after=None, state_class=None, output_variables=None):
+def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=None, interrupt_after=None,
+                          state_class=None, output_variables=None):
     # prepare output channels
     if interrupt_after is None:
         interrupt_after = []
@@ -453,10 +480,14 @@ def create_graph(
             if toolkit_name:
                 tool_name = f"{clean_string(toolkit_name)}{TOOLKIT_SPLITTER}{tool_name}"
             logger.info(f"Node: {node_id} : {node_type} - {tool_name}")
-            if node_type in ['function', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+            if node_type in ['function', 'toolkit', 'mcp', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph', 'pipeline', 'agent']:
+                if node_type == 'mcp' and tool_name not in [tool.name for tool in tools]:
+                    # MCP is not connected and node cannot be added
+                    raise ToolException(f"MCP tool '{tool_name}' not found in the provided tools. "
+                                        f"Make sure it is connected properly. Available tools: {[tool.name for tool in tools]}")
                 for tool in tools:
                     if tool.name == tool_name:
-                        if node_type == 'function':
+                        if node_type in ['function', 'toolkit', 'mcp']:
                             lg_builder.add_node(node_id, FunctionTool(
                                 tool=tool, name=node_id, return_type='dict',
                                 output_variables=node.get('output', []),
@@ -466,11 +497,12 @@ def create_graph(
                         elif node_type == 'agent':
                             input_params = node.get('input', ['messages'])
                             input_mapping = node.get('input_mapping',
-                                                       {'messages': {'type': 'variable', 'value': 'messages'}})
+                                                     {'messages': {'type': 'variable', 'value': 'messages'}})
+                            output_vars = node.get('output', [])
                             lg_builder.add_node(node_id, FunctionTool(
                                 client=client, tool=tool,
                                 name=node_id, return_type='str',
-                                output_variables=node.get('output', []),
+                                output_variables=output_vars + ['messages'] if 'messages' not in output_vars else output_vars,
                                 input_variables=input_params,
                                 input_mapping= input_mapping
                             ))
@@ -481,7 +513,8 @@ def create_graph(
                             # wrap with mappings
                             pipeline_name = node.get('tool', None)
                             if not pipeline_name:
-                                raise ValueError("Subgraph must have a 'tool' node: add required tool to the subgraph node")
+                                raise ValueError(
+                                    "Subgraph must have a 'tool' node: add required tool to the subgraph node")
                             node_fn = SubgraphRunnable(
                                 inner=tool.graph,
                                 name=pipeline_name,
@@ -499,15 +532,6 @@ def create_graph(
                                 structured_output=node.get('structured_output', False),
                                 task=node.get('task')
                             ))
-                        # TODO: decide on struct output for agent nodes
-                        # elif node_type == 'agent':
-                        #     lg_builder.add_node(node_id, AgentNode(
-                        #         client=client, tool=tool,
-                        #         name=node['id'], return_type='dict',
-                        #         output_variables=node.get('output', []),
-                        #         input_variables=node.get('input', ['messages']),
-                        #         task=node.get('task')
-                        #     ))
                         elif node_type == 'loop':
                             lg_builder.add_node(node_id, LoopNode(
                                 client=client, tool=tool,
@@ -520,7 +544,8 @@ def create_graph(
                             loop_toolkit_name = node.get('loop_toolkit_name')
                             loop_tool_name = node.get('loop_tool')
                             if (loop_toolkit_name and loop_tool_name) or loop_tool_name:
-                                loop_tool_name = f"{clean_string(loop_toolkit_name)}{TOOLKIT_SPLITTER}{loop_tool_name}" if loop_toolkit_name else clean_string(loop_tool_name)
+                                loop_tool_name = f"{clean_string(loop_toolkit_name)}{TOOLKIT_SPLITTER}{loop_tool_name}" if loop_toolkit_name else clean_string(
+                                    loop_tool_name)
                                 for t in tools:
                                     if t.name == loop_tool_name:
                                         logger.debug(f"Loop tool discovered: {t}")
@@ -553,6 +578,19 @@ def create_graph(
                                 input_variables=node.get('input', ['messages']),
                                 structured_output=node.get('structured_output', False)))
                         break
+            elif node_type == 'code':
+                from ..tools.sandbox import create_sandbox_tool
+                sandbox_tool = create_sandbox_tool(stateful=False, allow_net=True,
+                                                   alita_client=kwargs.get('alita_client', None))
+                code_data = node.get('code', {'type': 'fixed', 'value': "return 'Code block is empty'"})
+                lg_builder.add_node(node_id, FunctionTool(
+                    tool=sandbox_tool, name=node['id'], return_type='dict',
+                    output_variables=node.get('output', []),
+                    input_mapping={'code': code_data},
+                    input_variables=node.get('input', ['messages']),
+                    structured_output=node.get('structured_output', False),
+                    alita_client=kwargs.get('alita_client', None)
+                ))
             elif node_type == 'llm':
                 output_vars = node.get('output', [])
                 output_vars_dict = {
@@ -581,7 +619,7 @@ def create_graph(
                 else:
                     # Use all available tools
                     available_tools = [tool for tool in tools if isinstance(tool, BaseTool)]
-                
+
                 lg_builder.add_node(node_id, LLMNode(
                     client=client,
                     input_mapping=node.get('input_mapping', {'messages': {'type': 'variable', 'value': 'messages'}}),
@@ -592,7 +630,9 @@ def create_graph(
                     input_variables=node.get('input', ['messages']),
                     structured_output=node.get('structured_output', False),
                     available_tools=available_tools,
-                    tool_names=tool_names))
+                    tool_names=tool_names,
+                    steps_limit=kwargs.get('steps_limit', 25)
+                ))
             elif node_type == 'router':
                 # Add a RouterNode as an independent node
                 lg_builder.add_node(node_id, RouterNode(
@@ -612,6 +652,7 @@ def create_graph(
                         default_output=node.get('default_output', 'END')
                     )
                 )
+                continue
             elif node_type == 'state_modifier':
                 lg_builder.add_node(node_id, StateModifierNode(
                     template=node.get('template', ''),
@@ -619,6 +660,22 @@ def create_graph(
                     input_variables=node.get('input', ['messages']),
                     output_variables=node.get('output', [])
                 ))
+            elif node_type == 'printer':
+                lg_builder.add_node(node_id, PrinterNode(
+                    input_mapping=node.get('input_mapping', {'printer': {'type': 'fixed', 'value': ''}}),
+                ))
+
+                # add interrupts after printer node if specified
+                interrupt_after.append(clean_string(node_id))
+
+                # 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': 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'])))
+                continue
             if node.get('transition'):
                 next_step = clean_string(node['transition'])
                 logger.info(f'Adding transition: {next_step}')
@@ -765,45 +822,114 @@ class LangGraphAgentRunnable(CompiledStateGraph):
             # Convert chat history dict messages to LangChain message objects
             chat_history = input.pop('chat_history')
             input['messages'] = [convert_dict_to_message(msg) for msg in chat_history]
-        
+
+        # handler for LLM node: if no input (Chat perspective), then take last human message
+        # Track if input came from messages to handle content extraction properly
+        input_from_messages = False
+        if not input.get('input'):
+            if input.get('messages'):
+                input['input'] = [next((msg for msg in reversed(input['messages']) if isinstance(msg, HumanMessage)),
+                                      None)]
+                if input['input'] is not None:
+                    input_from_messages = True
+
         # Append current input to existing messages instead of overwriting
         if input.get('input'):
-            current_message = input.get('input')[-1]
+            if isinstance(input['input'], str):
+                current_message = input['input']
+            else:
+                # input can be a list of messages or a single message object
+                current_message = input.get('input')[-1]
+
             # TODO: add handler after we add 2+ inputs (filterByType, etc.)
-            input['input'] = current_message if isinstance(current_message, str) else str(current_message)
+            if isinstance(current_message, HumanMessage):
+                current_content = current_message.content
+                if isinstance(current_content, list):
+                    # Extract text parts and keep non-text parts (images, etc.)
+                    text_contents = []
+                    non_text_parts = []
+                    
+                    for item in current_content:
+                        if isinstance(item, dict) and item.get('type') == 'text':
+                            text_contents.append(item['text'])
+                        elif isinstance(item, str):
+                            text_contents.append(item)
+                        else:
+                            # Keep image_url and other non-text content
+                            non_text_parts.append(item)
+                    
+                    # Set input to the joined text
+                    input['input'] = ". ".join(text_contents) if text_contents else ""
+                    
+                    # If this message came from input['messages'], update or remove it
+                    if input_from_messages:
+                        if non_text_parts:
+                            # Keep the message but only with non-text content (images, etc.)
+                            current_message.content = non_text_parts
+                        else:
+                            # All content was text, remove this message from the list
+                            input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                
+                elif isinstance(current_content, str):
+                    # on regenerate case
+                    input['input'] = current_content
+                    # If from messages and all content is text, remove the message
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+                else:
+                    input['input'] = str(current_content)
+                    # If from messages, remove since we extracted the content
+                    if input_from_messages:
+                        input['messages'] = [msg for msg in input['messages'] if msg is not current_message]
+            elif isinstance(current_message, str):
+                input['input'] = current_message
+            else:
+                input['input'] = str(current_message)
             if input.get('messages'):
                 # Ensure existing messages are LangChain objects
                 input['messages'] = [convert_dict_to_message(msg) for msg in input['messages']]
                 # Append to existing messages
-                input['messages'].append(current_message)
-            else:
-                # No existing messages, create new list
-                input['messages'] = [current_message]
+                # input['messages'].append(current_message)
+            # else:
+                # NOTE: Commented out to prevent duplicates with input['input']
+                # input['messages'] = [current_message]
+        
+        # Validate that input is not empty after all processing
+        if not input.get('input'):
+            raise RuntimeError(
+                "Empty input after processing. Cannot send empty string to LLM. "
+                "This likely means the message contained only non-text content "
+                "with no accompanying text."
+            )
+        
         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 self.output_variables and self.output_variables[0] != "messages":
-                # If output_variables are specified, use the value of first one or use the last messages as default
-                output = result.get(self.output_variables[0])
-                if not output:
-                    output = result['messages'][-1].content
+            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:
-                output = result['messages'][-1].content
+                # used for printer node output - it will be reset by next `reset` node
+                output = result.get(PRINTER_NODE_RS)
         except:
             output = list(result.values())[-1]
-        thread_id = None
         config_state = self.get_state(config)
-        if config_state.next:
-            thread_id = config['configurable']['thread_id']
+        is_execution_finished = not config_state.next
+        if is_execution_finished:
+            thread_id = None
 
         result_with_state = {
             "output": output,
             "thread_id": thread_id,
-            "execution_finished": not config_state.next
+            "execution_finished": is_execution_finished
         }
 
         # Include all state values in the result