alita-sdk 0.3.125__py3-none-any.whl → 0.3.127__py3-none-any.whl

alita_sdk/langchain/assistant.py

@@ -1,4 +1,3 @@
-
 import logging
 import importlib
 from copy import deepcopy as copy
@@ -17,6 +16,7 @@ from .constants import REACT_ADDON, REACT_VARS, XML_ADDON
 from .chat_message_template import Jinja2TemplatedChatMessagesTemplate
 from ..tools.echo import EchoTool
 from ..toolkits.tools import get_tools
+from langchain_core.tools import BaseTool
 
 logger = logging.getLogger(__name__)
 
@@ -53,7 +53,7 @@ class Assistant:
             target_name
         )
         self.client = target_cls(**model_params)
-        self.tools = get_tools(data['tools'], alita=alita, llm=self.client)
+        self.tools = get_tools(data['tools'], alita_client=alita, llm=self.client)
         if app_type == "pipeline":
             self.prompt = data['instructions']
         else:
@@ -106,18 +106,22 @@ class Assistant:
                                                   max_execution_time=None, return_intermediate_steps=True)
 
     def getAgentExecutor(self):
-        agent = create_json_chat_agent(llm=self.client, tools=self.tools, prompt=self.prompt,
-                                       #tools_renderer=render_react_text_description_and_args
-                                       )
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_json_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
 
     def getXMLAgentExecutor(self):
-        agent = create_xml_chat_agent(llm=self.client, tools=self.tools, prompt=self.prompt)
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_xml_chat_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
     def getOpenAIToolsAgentExecutor(self):
-        agent = create_openai_tools_agent(llm=self.client, tools=self.tools, prompt=self.prompt)
+        # Exclude compiled graph runnables from simple tool agents
+        simple_tools = [t for t in self.tools if isinstance(t, BaseTool)]
+        agent = create_openai_tools_agent(llm=self.client, tools=simple_tools, prompt=self.prompt)
         return self._agent_executor(agent)
 
     def pipeline(self):

alita_sdk/langchain/langraph_agent.py

@@ -1,8 +1,10 @@
 import logging
 from typing import Union, Any, Optional, Annotated, get_type_hints
 from uuid import uuid4
+from typing import Dict
 
 import yaml
+import ast
 from langchain_core.callbacks import dispatch_custom_event
 from langchain_core.messages import HumanMessage
 from langchain_core.runnables import Runnable
@@ -17,7 +19,7 @@ from langgraph.prebuilt import InjectedStore
 from langgraph.store.base import BaseStore
 
 from .mixedAgentRenderes import convert_message_to_json
-from .utils import create_state
+from .utils import create_state, propagate_the_input_mapping
 from ..tools.function import FunctionTool
 from ..tools.indexer_tool import IndexerNode
 from ..tools.llm import LLMNode
@@ -30,15 +32,101 @@ from ..tools.router import RouterNode
 
 logger = logging.getLogger(__name__)
 
+# Global registry for subgraph definitions
+# Structure: {'subgraph_name': {'yaml': 'yaml_def', 'tools': [tools], 'flattened': False}}
+SUBGRAPH_REGISTRY: Dict[str, Dict[str, Any]] = {}
+
+
+# Wrapper for injecting a compiled subgraph into a parent StateGraph
+class SubgraphRunnable(CompiledStateGraph):
+    def __init__(
+        self,
+        inner: CompiledStateGraph,
+        *,
+        name: str,
+        input_mapping: Dict[str, Any],
+        output_mapping: Dict[str, Any]
+    ):
+        # copy child graph internals
+        super().__init__(
+            builder=inner.builder,
+            config_type=inner.config_type,
+            nodes=inner.nodes,
+            channels=inner.channels,
+            input_channels=inner.input_channels,
+            stream_mode=inner.stream_mode,
+            output_channels=inner.output_channels,
+            stream_channels=inner.stream_channels,
+            checkpointer=inner.checkpointer,
+            interrupt_before_nodes=inner.interrupt_before_nodes,
+            interrupt_after_nodes=inner.interrupt_after_nodes,
+            auto_validate=False,
+            debug=inner.debug,
+            store=inner.store,
+        )
+        self.inner = inner
+        self.name = name
+        self.input_mapping = input_mapping or {}
+        self.output_mapping = output_mapping or {}
+
+    def invoke(
+        self,
+        state: Union[dict[str, Any], Any],
+        config: Optional[RunnableConfig] = None,
+        **kwargs: Any,
+    ) -> Union[dict[str, Any], Any]:
+        # Detailed logging for debugging
+        logger.debug(f"SubgraphRunnable '{self.name}' invoke called with state: {state}")
+        logger.debug(f"SubgraphRunnable '{self.name}' config: {config}")
+
+        # 1) parent -> child mapping
+        if not self.input_mapping:
+            child_input = state.copy()
+        else:
+            child_input = propagate_the_input_mapping(
+                self.input_mapping, list(self.input_mapping.keys()), state
+            )
+        # debug trace of messages flowing into child
+        logger.debug(f"SubgraphRunnable '{self.name}' child_input.messages: {child_input.get('messages')}")
+        logger.debug(f"SubgraphRunnable '{self.name}' child_input.input: {child_input.get('input')}")
+
+        # 2) Invoke the child graph.
+        # Pass None as the first argument for input if the child is expected to resume
+        # using its (now updated) checkpoint. The CompiledStateGraph.invoke method, when
+        # input is None but a checkpoint exists, loads from the checkpoint.
+        # Any resume commands (if applicable for internal child interrupts) are in 'config'.
+        # logger.debug(f"SubgraphRunnable '{self.name}': Invoking child graph super().invoke(None, config).")
+        subgraph_output = super().invoke(child_input, config=config, **kwargs)
+
+        # 3) child complete: apply output_mapping or passthrough
+        logger.debug(f"SubgraphRunnable '{self.name}' child complete, applying mappings")
+        result: Dict[str, Any] = {}
+        if self.output_mapping:
+            for child_key, parent_key in self.output_mapping.items():
+                if child_key in subgraph_output:
+                    state[parent_key] = subgraph_output[child_key]
+                    result[parent_key] = subgraph_output[child_key]
+                    logger.debug(f"SubgraphRunnable '{self.name}' mapped {child_key} -> {parent_key}")
+        else:
+            for k, v in subgraph_output.items():
+                state[k] = v
+                result[k] = v
+
+        # include full messages history on completion
+        if 'messages' not in result:
+            result['messages'] = subgraph_output.get('messages', [])
+        logger.debug(f"SubgraphRunnable '{self.name}' returning result: {result}")
+        return result
+
 
 class ConditionalEdge(Runnable):
     name = "ConditionalEdge"
 
     def __init__(self, condition: str, condition_inputs: Optional[list[str]] = [],
-                 conditional_outputs: Optional[list[str]] = [], default_output: str = 'END'):
+                 conditional_outputs: Optional[list[str]] = [], default_output: str = END):
         self.condition = condition
         self.condition_inputs = condition_inputs
-        self.conditional_outputs = {clean_string(cond) for cond in conditional_outputs}
+        self.conditional_outputs = {clean_string(cond if not 'END' == cond else '__end__') for cond in conditional_outputs}
         self.default_output = clean_string(default_output)
 
     def invoke(self, state: Annotated[BaseStore, InjectedStore()], config: Optional[RunnableConfig] = None) -> str:
@@ -124,6 +212,25 @@ class TransitionalEdge(Runnable):
         )
         return self.next_step if self.next_step != 'END' else END
 
+class StateDefaultNode(Runnable):
+    name = "StateDefaultNode"
+
+    def __init__(self, default_vars: dict = {}):
+        self.default_vars = default_vars
+
+    def invoke(self, state: BaseStore, config: Optional[RunnableConfig] = None) -> dict:
+        logger.info("Setting default state variables")
+        result = {}
+        for key, value in self.default_vars.items():
+            if isinstance(value, dict) and 'value' in value:
+                temp_value = value['value']
+                try:
+                    result[key] = ast.literal_eval(temp_value)
+                except:
+                    logger.debug("Unable to evaluate value, using as is")
+                    result[key] = temp_value
+        return result
+
 
 class StateModifierNode(Runnable):
     name = "StateModifierNode"
@@ -177,8 +284,13 @@ class StateModifierNode(Runnable):
         return result
 
 
-def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=[], interrupt_after=[]):
+
+def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_before=None, interrupt_after=None, state_class=None):
     # prepare output channels
+    if interrupt_after is None:
+        interrupt_after = []
+    if interrupt_before is None:
+        interrupt_before = []
     output_channels = (
         "__root__"
         if len(lg_builder.schemas[lg_builder.output]) == 1
@@ -239,19 +351,30 @@ def prepare_output_schema(lg_builder, memory, store, debug=False, interrupt_befo
 def create_graph(
         client: Any,
         yaml_schema: str,
-        tools: list[BaseTool],
+        tools: list[Union[BaseTool, CompiledStateGraph]],
         *args,
         memory: Optional[Any] = None,
         store: Optional[BaseStore] = None,
         debug: bool = False,
+        for_subgraph: bool = False,
         **kwargs
 ):
     """ Create a message graph from a yaml schema """
+
+    # For top-level graphs (not subgraphs), detect and flatten any subgraphs
+    if not for_subgraph:
+        flattened_yaml, additional_tools = detect_and_flatten_subgraphs(yaml_schema)
+        # Add collected tools from subgraphs to the tools list
+        tools = list(tools) + additional_tools
+        # Use the flattened YAML for building the graph
+        yaml_schema = flattened_yaml
+
     schema = yaml.safe_load(yaml_schema)
     logger.debug(f"Schema: {schema}")
     logger.debug(f"Tools: {tools}")
     logger.info(f"Tools: {[tool.name for tool in tools]}")
-    state_class = create_state(schema.get('state', {}))
+    state = schema.get('state', {})
+    state_class = create_state(state)
     lg_builder = StateGraph(state_class)
     interrupt_before = [clean_string(every) for every in schema.get('interrupt_before', [])]
     interrupt_after = [clean_string(every) for every in schema.get('interrupt_after', [])]
@@ -264,7 +387,7 @@ 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']:
+            if node_type in ['function', 'tool', 'loop', 'loop_from_tool', 'indexer', 'subgraph']:
                 for tool in tools:
                     if tool.name == tool_name:
                         if node_type == 'function':
@@ -274,6 +397,19 @@ def create_graph(
                                 input_mapping=node.get('input_mapping',
                                                        {'messages': {'type': 'variable', 'value': 'messages'}}),
                                 input_variables=node.get('input', ['messages'])))
+                        elif node_type == 'subgraph':
+                            # assign parent memory/store
+                            # tool.checkpointer = memory
+                            # tool.store = store
+                            # wrap with mappings
+                            node_fn = SubgraphRunnable(
+                                inner=tool,
+                                name=node['id'],
+                                input_mapping=node.get('input_mapping', {}),
+                                output_mapping=node.get('output_mapping', {}),
+                            )
+                            lg_builder.add_node(node_id, node_fn)
+                            break  # skip legacy handling
                         elif node_type == 'tool':
                             lg_builder.add_node(node_id, ToolNode(
                                 client=client, tool=tool,
@@ -388,26 +524,54 @@ def create_graph(
                     conditional_outputs=node['condition'].get('conditional_outputs', []),
                     default_output=node['condition'].get('default_output', 'END')))
 
-        lg_builder.set_entry_point(clean_string(schema['entry_point']))
+        # set default value for state variable at START
+        entry_point = clean_string(schema['entry_point'])
+        for key, value in state.items():
+            if 'type' in value and 'value' in value:
+                # set default value for state variable if it is defined in the schema
+                state_default_node = StateDefaultNode(default_vars=state)
+                lg_builder.add_node(state_default_node.name, state_default_node)
+                lg_builder.set_entry_point(state_default_node.name)
+                lg_builder.add_conditional_edges(state_default_node.name, TransitionalEdge(entry_point))
+                break
+        else:
+            # if no state variables are defined, set the entry point directly
+            lg_builder.set_entry_point(entry_point)
 
-        # assign default values
         interrupt_before = interrupt_before or []
         interrupt_after = interrupt_after or []
 
-        # validate the graph
-        lg_builder.validate(
-            interrupt=(
-                (interrupt_before if interrupt_before != "*" else []) + interrupt_after
-                if interrupt_after != "*"
-                else []
+        if not for_subgraph:
+            # validate the graph for LangGraphAgentRunnable before the actual construction
+            lg_builder.validate(
+                interrupt=(
+                    (interrupt_before if interrupt_before != "*" else []) + interrupt_after
+                    if interrupt_after != "*"
+                    else []
+                )
             )
+
+        # Compile into a CompiledStateGraph  for the subgraph
+        graph = lg_builder.compile(
+            checkpointer=True,
+            interrupt_before=interrupt_before,
+            interrupt_after=interrupt_after,
+            store=store,
+            debug=debug,
         )
     except ValueError as e:
         raise ValueError(
             f"Validation of the schema failed. {e}\n\nDEBUG INFO:**Schema Nodes:**\n\n{lg_builder.nodes}\n\n**Schema Enges:**\n\n{lg_builder.edges}\n\n**Tools Available:**\n\n{tools}")
-    compiled = prepare_output_schema(lg_builder, memory, store, debug,
-                                     interrupt_before=interrupt_before,
-                                     interrupt_after=interrupt_after)
+    # If building a nested subgraph, return the raw CompiledStateGraph
+    if for_subgraph:
+        return graph
+    # Otherwise prepare top-level runnable wrapper and validate
+    compiled = prepare_output_schema(
+        lg_builder, memory, store, debug,
+        interrupt_before=interrupt_before,
+        interrupt_after=interrupt_after,
+        state_class={state_class: None}
+    )
     return compiled.validate()
 
 
@@ -440,8 +604,249 @@ class LangGraphAgentRunnable(CompiledStateGraph):
         config_state = self.get_state(config)
         if config_state.next:
             thread_id = config['configurable']['thread_id']
-        return {
+
+        result_with_state = {
             "output": output,
             "thread_id": thread_id,
             "execution_finished": not config_state.next
         }
+
+        # Include all state values in the result
+        if hasattr(config_state, 'values') and config_state.values:
+            for key, value in config_state.values.items():
+                result_with_state[key] = value
+
+        return result_with_state
+
+def merge_subgraphs(parent_yaml: str, registry: Dict[str, Dict[str, Any]]) -> Dict[str, Any]:
+    """
+    Merge subgraphs into parent graph by flattening YAML structures.
+
+    This function implements the complete flattening approach:
+    1. Parse parent YAML
+    2. Detect subgraph nodes
+    3. Recursively flatten subgraphs
+    4. Merge states, nodes, interrupts, and transitions
+    5. Return single unified graph definition
+
+    Args:
+        parent_yaml: YAML string of parent graph
+        registry: Global subgraph registry
+
+    Returns:
+        Dict containing flattened graph definition
+    """
+    import copy
+
+    # Parse parent YAML
+    parent_def = yaml.safe_load(parent_yaml)
+
+    # Check if already flattened (prevent infinite recursion)
+    if parent_def.get('_flattened', False):
+        return parent_def
+
+    # Find subgraph nodes in parent
+    subgraph_nodes = []
+    regular_nodes = []
+
+    for node in parent_def.get('nodes', []):
+        if node.get('type') == 'subgraph':
+            subgraph_nodes.append(node)
+        else:
+            regular_nodes.append(node)
+
+    # If no subgraphs, return as-is
+    if not subgraph_nodes:
+        parent_def['_flattened'] = True
+        return parent_def
+
+    # Start with parent state and merge subgraph states
+    merged_state = copy.deepcopy(parent_def.get('state', {}))
+    merged_nodes = copy.deepcopy(regular_nodes)
+    merged_interrupts_before = set(parent_def.get('interrupt_before', []))
+    merged_interrupts_after = set(parent_def.get('interrupt_after', []))
+    all_tools = []
+
+    # Track node remapping for transition rewiring
+    node_mapping = {}  # subgraph_node_id -> actual_internal_node_id
+
+    # Process each subgraph
+    for subgraph_node in subgraph_nodes:
+        # Support both 'tool' and 'subgraph' fields for subgraph name
+        subgraph_name = subgraph_node.get('tool') or subgraph_node.get('subgraph')
+        subgraph_node_id = subgraph_node['id']
+
+        if subgraph_name not in registry:
+            logger.warning(f"Subgraph '{subgraph_name}' not found in registry")
+            continue
+
+        # Get subgraph definition
+        subgraph_entry = registry[subgraph_name]
+        subgraph_yaml = subgraph_entry['yaml']
+        subgraph_tools = subgraph_entry.get('tools', [])
+
+        # Recursively flatten the subgraph (in case it has nested subgraphs)
+        subgraph_def = merge_subgraphs(subgraph_yaml, registry)
+
+        # Collect tools from subgraph
+        all_tools.extend(subgraph_tools)
+
+        # Merge state (union of all fields)
+        for field_name, field_type in subgraph_def.get('state', {}).items():
+            if field_name not in merged_state:
+                merged_state[field_name] = field_type
+            elif merged_state[field_name] != field_type:
+                logger.warning(f"State field '{field_name}' type mismatch: {merged_state[field_name]} vs {field_type}")
+
+        # Map subgraph node to its entry point
+        subgraph_entry_point = subgraph_def.get('entry_point')
+        if subgraph_entry_point:
+            node_mapping[subgraph_node_id] = subgraph_entry_point
+            logger.debug(f"Mapped subgraph node '{subgraph_node_id}' to entry point '{subgraph_entry_point}'")
+
+        # Add subgraph nodes without prefixing (keep original IDs)
+        for sub_node in subgraph_def.get('nodes', []):
+            # Keep original node ID - no prefixing
+            new_node = copy.deepcopy(sub_node)
+            merged_nodes.append(new_node)
+
+        # Handle the original subgraph node's transition - apply it to nodes that end with END
+        original_transition = subgraph_node.get('transition')
+        if original_transition and original_transition != 'END' and original_transition != END:
+            # Find nodes in this subgraph that have END transitions and update them
+            for node in merged_nodes:
+                # Check if this is a node from the current subgraph by checking if it was just added
+                # and has an END transition
+                if node.get('transition') == 'END' and node in subgraph_def.get('nodes', []):
+                    node['transition'] = original_transition
+
+        # Merge interrupts without prefixing (keep original names)
+        for interrupt in subgraph_def.get('interrupt_before', []):
+            merged_interrupts_before.add(interrupt)  # No prefixing
+        for interrupt in subgraph_def.get('interrupt_after', []):
+            merged_interrupts_after.add(interrupt)  # No prefixing
+
+    # Handle entry point - keep parent's unless it's a subgraph node
+    entry_point = parent_def.get('entry_point')
+    logger.debug(f"Original entry point: {entry_point}")
+    logger.debug(f"Node mapping: {node_mapping}")
+    if entry_point in node_mapping:
+        # Parent entry point is a subgraph, redirect to subgraph's entry point
+        old_entry_point = entry_point
+        entry_point = node_mapping[entry_point]
+        logger.debug(f"Entry point changed from {old_entry_point} to {entry_point}")
+    else:
+        logger.debug(f"Entry point {entry_point} not in node mapping, keeping as-is")
+
+    # Rewrite transitions in regular nodes that point to subgraph nodes
+    for node in merged_nodes:
+        # Handle direct transitions
+        if 'transition' in node:
+            transition = node['transition']
+            if transition in node_mapping:
+                node['transition'] = node_mapping[transition]
+
+        # Handle conditional transitions
+        if 'condition' in node:
+            condition = node['condition']
+            if 'conditional_outputs' in condition:
+                new_outputs = []
+                for output in condition['conditional_outputs']:
+                    if output in node_mapping:
+                        new_outputs.append(node_mapping[output])
+                    else:
+                        new_outputs.append(output)
+                condition['conditional_outputs'] = new_outputs
+
+            if 'default_output' in condition:
+                default = condition['default_output']
+                if default in node_mapping:
+                    condition['default_output'] = node_mapping[default]
+
+            # Update condition_definition Jinja2 template to replace subgraph node references
+            if 'condition_definition' in condition:
+                condition_definition = condition['condition_definition']
+                # Replace subgraph node references in the Jinja2 template
+                for subgraph_node_id, subgraph_entry_point in node_mapping.items():
+                    condition_definition = condition_definition.replace(subgraph_node_id, subgraph_entry_point)
+                condition['condition_definition'] = condition_definition
+
+        # Handle decision nodes
+        if 'decision' in node:
+            decision = node['decision']
+            # Update decision.nodes list to replace subgraph node references
+            if 'nodes' in decision:
+                new_nodes = []
+                for decision_node in decision['nodes']:
+                    if decision_node in node_mapping:
+                        new_nodes.append(node_mapping[decision_node])
+                    else:
+                        new_nodes.append(decision_node)
+                decision['nodes'] = new_nodes
+
+            # Update decision.default_output to replace subgraph node references
+            if 'default_output' in decision:
+                default_output = decision['default_output']
+                if default_output in node_mapping:
+                    decision['default_output'] = node_mapping[default_output]
+
+    # Build final flattened definition
+    flattened = {
+        'name': parent_def.get('name', 'FlattenedGraph'),
+        'state': merged_state,
+        'nodes': merged_nodes,
+        'entry_point': entry_point,
+        '_flattened': True,
+        '_all_tools': all_tools  # Store tools for later collection
+    }
+
+    # Add interrupts if present
+    if merged_interrupts_before:
+        flattened['interrupt_before'] = list(merged_interrupts_before)
+    if merged_interrupts_after:
+        flattened['interrupt_after'] = list(merged_interrupts_after)
+
+    return flattened
+
+
+def detect_and_flatten_subgraphs(yaml_schema: str) -> tuple[str, list]:
+    """
+    Detect subgraphs in YAML and flatten them if found.
+
+    Returns:
+        tuple: (flattened_yaml_string, collected_tools)
+    """
+    # Parse to check for subgraphs
+    schema_dict = yaml.safe_load(yaml_schema)
+    subgraph_nodes = [
+        node for node in schema_dict.get('nodes', [])
+        if node.get('type') == 'subgraph'
+    ]
+
+    if not subgraph_nodes:
+        return yaml_schema, []
+
+    # Check if all required subgraphs are available in registry
+    missing_subgraphs = []
+    for node in subgraph_nodes:
+        # Support both 'tool' and 'subgraph' fields for subgraph name
+        # Don't clean the string - registry keys use original names
+        subgraph_name = node.get('tool') or node.get('subgraph')
+        if subgraph_name and subgraph_name not in SUBGRAPH_REGISTRY:
+            missing_subgraphs.append(subgraph_name)
+
+    if missing_subgraphs:
+        logger.warning(f"Cannot flatten - missing subgraphs: {missing_subgraphs}")
+        return yaml_schema, []
+
+    # Flatten the graph
+    flattened_def = merge_subgraphs(yaml_schema, SUBGRAPH_REGISTRY)
+
+    # Extract tools
+    all_tools = flattened_def.pop('_all_tools', [])
+
+    # Convert back to YAML
+    flattened_yaml = yaml.dump(flattened_def, default_flow_style=False)
+
+    return flattened_yaml, all_tools
+

alita_sdk/toolkits/subgraph.py

@@ -0,0 +1,53 @@
+from typing import List, Any
+
+from langgraph.graph.state import CompiledStateGraph
+
+from ..langchain.langraph_agent import create_graph, SUBGRAPH_REGISTRY
+from ..utils.utils import clean_string
+
+
+class SubgraphToolkit:
+
+    @staticmethod
+    def get_toolkit(
+        client: Any,
+        application_id: int,
+        application_version_id: int,
+        llm,
+        app_api_key: str,
+        selected_tools: list[str] = []
+    ) -> List[CompiledStateGraph]:
+        from .tools import get_tools
+        # from langgraph.checkpoint.memory import MemorySaver
+
+        app_details = client.get_app_details(application_id)
+        version_details = client.get_app_version_details(application_id, application_version_id)
+        tools = get_tools(version_details['tools'], alita_client=client, llm=llm)
+
+        # Get the subgraph name
+        subgraph_name = app_details.get("name")
+        
+        # Populate the registry for flattening approach
+        SUBGRAPH_REGISTRY[subgraph_name] = {
+            'yaml': version_details['instructions'],
+            'tools': tools,
+            'flattened': False
+        }
+        
+        # For backward compatibility, still create a compiled graph stub
+        # This is mainly used for identification in the parent graph's tools list
+        graph = create_graph(
+            client=llm,
+            tools=tools,
+            yaml_schema=version_details['instructions'],
+            debug=False,
+            store=None,
+            memory=None,
+            for_subgraph=True,  # compile as raw subgraph
+        )
+        
+        # Tag the graph stub for parent lookup
+        graph.name = clean_string(subgraph_name)
+        
+        # Return the compiled graph stub for backward compatibility
+        return [graph]

alita_sdk/toolkits/tools.py

@@ -1,14 +1,14 @@
 import logging
 
-from alita_tools import get_tools as alita_tools
 from alita_tools import get_toolkits as alita_toolkits
+from alita_tools import get_tools as alita_tools
 
-from .prompt import PromptToolkit
-from .datasource import DatasourcesToolkit
 from .application import ApplicationToolkit
 from .artifact import ArtifactToolkit
+from .datasource import DatasourcesToolkit
+from .prompt import PromptToolkit
+from .subgraph import SubgraphToolkit
 from .vectorstore import VectorStoreToolkit
-
 ## Community tools and toolkits
 from ..community.analysis.jira_analyse import AnalyseJira
 from ..community.browseruse import BrowserUseToolkit
@@ -35,7 +35,7 @@ def get_toolkits():
     return  core_toolkits + community_toolkits + alita_toolkits()
 
 
-def get_tools(tools_list: list, alita: 'AlitaClient', llm: 'LLMLikeObject') -> list:
+def get_tools(tools_list: list, alita_client, llm) -> list:
     prompts = []
     tools = []
 
@@ -47,33 +47,43 @@ def get_tools(tools_list: list, alita: 'AlitaClient', llm: 'LLMLikeObject') -> l
             ])
         elif tool['type'] == 'datasource':
             tools.extend(DatasourcesToolkit.get_toolkit(
-                alita,
+                alita_client,
                 datasource_ids=[int(tool['settings']['datasource_id'])],
                 selected_tools=tool['settings']['selected_tools'],
                 toolkit_name=tool.get('toolkit_name', '') or tool.get('name', '')
             ).get_tools())
         elif tool['type'] == 'application':
             tools.extend(ApplicationToolkit.get_toolkit(
-                alita,
+                alita_client,
                 application_id=int(tool['settings']['application_id']),
                 application_version_id=int(tool['settings']['application_version_id']),
-                app_api_key=alita.auth_token,
+                app_api_key=alita_client.auth_token,
                 selected_tools=[]
             ).get_tools())
+        elif tool['type'] == 'subgraph':
+            # static get_toolkit returns a list of CompiledStateGraph stubs
+            tools.extend(SubgraphToolkit.get_toolkit(
+                alita_client,
+                application_id=int(tool['settings']['application_id']),
+                application_version_id=int(tool['settings']['application_version_id']),
+                app_api_key=alita_client.auth_token,
+                selected_tools=[],
+                llm=llm
+            ))
         elif tool['type'] == 'artifact':
             tools.extend(ArtifactToolkit.get_toolkit(
-                client=alita,
+                client=alita_client,
                 bucket=tool['settings']['bucket'],
                 toolkit_name=tool.get('toolkit_name', ''),
                 selected_tools=tool['settings'].get('selected_tools', [])
             ).get_tools())
         if tool['type'] == 'analyse_jira':
             tools.extend(AnalyseJira.get_toolkit(
-                client=alita, 
+                client=alita_client,
                 **tool['settings']).get_tools())
         if tool['type'] == 'browser_use':
             tools.extend(BrowserUseToolkit.get_toolkit(
-                client=alita, 
+                client=alita_client,
                 llm=llm,
                 toolkit_name=tool.get('toolkit_name', ''),
                 **tool['settings']).get_tools())
@@ -83,9 +93,9 @@ def get_tools(tools_list: list, alita: 'AlitaClient', llm: 'LLMLikeObject') -> l
                 toolkit_name=tool.get('toolkit_name', ''),
                 **tool['settings']).get_tools())
     if len(prompts) > 0:
-        tools += PromptToolkit.get_toolkit(alita, prompts).get_tools()
-    tools += alita_tools(tools_list, alita, llm)
-    tools += _mcp_tools(tools_list, alita)
+        tools += PromptToolkit.get_toolkit(alita_client, prompts).get_tools()
+    tools += alita_tools(tools_list, alita_client, llm)
+    tools += _mcp_tools(tools_list, alita_client)
     return tools
 
 

alita_sdk/tools/tool.py

@@ -10,6 +10,7 @@ from langchain_core.tools import BaseTool
 from langchain_core.utils.function_calling import convert_to_openai_tool
 from pydantic import ValidationError, BaseModel, create_model
 
+from .application import Application
 from ..langchain.utils import _extract_json
 
 logger = logging.getLogger(__name__)
@@ -74,8 +75,9 @@ Anwer must be JSON only extractable by JSON.LOADS."""
             ))
         ]
         if self.structured_output:
-            # cut defaults from schema
-            fields = {name: (field.annotation, ...) for name, field in self.tool.args_schema.model_fields.items()}
+            # cut defaults from schema and remove chat_history for application as a tool
+            fields = {name: (field.annotation, ...) for name, field
+                      in self.tool.args_schema.model_fields.items() if name != 'chat_history'}
             input_schema = create_model('NewModel', **fields)
 
             llm = self.client.with_structured_output(input_schema)
@@ -87,6 +89,10 @@ Anwer must be JSON only extractable by JSON.LOADS."""
             result = _extract_json(completion.content.strip())
             logger.info(f"ToolNode tool params: {result}")
         try:
+            # handler for application added as a tool
+            if isinstance(self.tool, Application):
+                # set empty chat history
+                result['chat_history'] = None
             tool_result = self.tool.invoke(result, config=config, kwargs=kwargs)
             dispatch_custom_event(
                 "on_tool_node", {

{alita_sdk-0.3.125.dist-info → alita_sdk-0.3.127.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alita_sdk
-Version: 0.3.125
+Version: 0.3.127
 Summary: SDK for building langchain agents using resouces 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>
 Project-URL: Homepage, https://projectalita.ai

{alita_sdk-0.3.125.dist-info → alita_sdk-0.3.127.dist-info}/RECORD

@@ -15,11 +15,11 @@ alita_sdk/community/analysis/jira_analyse/api_wrapper.py,sha256=JqGSxg_3x0ErzII3
 alita_sdk/community/browseruse/__init__.py,sha256=uAxPZEX7ihpt8HtcGDFrzTNv9WcklT1wG1ItTwUO8y4,3601
 alita_sdk/community/browseruse/api_wrapper.py,sha256=Y05NKWfTROPmBxe8ZFIELSGBX5v3RTNP30OTO2Tj8uI,10838
 alita_sdk/langchain/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-alita_sdk/langchain/assistant.py,sha256=V0MpZG9IQRlKMr1SfAabVbUsIp-gNPO9A1SWxuFikNY,5930
+alita_sdk/langchain/assistant.py,sha256=J_xhwbNl934BgDKSpAMC9a1u6v03DZQcTYaamCztEPk,6272
 alita_sdk/langchain/chat_message_template.py,sha256=kPz8W2BG6IMyITFDA5oeb5BxVRkHEVZhuiGl4MBZKdc,2176
 alita_sdk/langchain/constants.py,sha256=eHVJ_beJNTf1WJo4yq7KMK64fxsRvs3lKc34QCXSbpk,3319
 alita_sdk/langchain/indexer.py,sha256=0ENHy5EOhThnAiYFc7QAsaTNp9rr8hDV_hTK8ahbatk,37592
-alita_sdk/langchain/langraph_agent.py,sha256=f9rGk6QGQbfbGudwpM5ax9yS-xDlElFqGAOsZbGvrtI,20919
+alita_sdk/langchain/langraph_agent.py,sha256=PrD_9XEX7_LDOT_SuohW_nhqLMlzc14xmByHPrO0V6E,37951
 alita_sdk/langchain/mixedAgentParser.py,sha256=M256lvtsL3YtYflBCEp-rWKrKtcY1dJIyRGVv7KW9ME,2611
 alita_sdk/langchain/mixedAgentRenderes.py,sha256=asBtKqm88QhZRILditjYICwFVKF5KfO38hu2O-WrSWE,5964
 alita_sdk/langchain/utils.py,sha256=Npferkn10dvdksnKzLJLBI5bNGQyVWTBwqp3vQtUqmY,6631
@@ -68,7 +68,8 @@ alita_sdk/toolkits/application.py,sha256=LrxbBV05lkRP3_WtKGBKtMdoQHXVY-_AtFr1cUu
 alita_sdk/toolkits/artifact.py,sha256=7zb17vhJ3CigeTqvzQ4VNBsU5UOCJqAwz7fOJGMYqXw,2348
 alita_sdk/toolkits/datasource.py,sha256=v3FQu8Gmvq7gAGAnFEbA8qofyUhh98rxgIjY6GHBfyI,2494
 alita_sdk/toolkits/prompt.py,sha256=WIpTkkVYWqIqOWR_LlSWz3ug8uO9tm5jJ7aZYdiGRn0,1192
-alita_sdk/toolkits/tools.py,sha256=RFMJ2bYNotPNmz6-clUdAakuIyrunSA16nFZ1gDFSF0,5273
+alita_sdk/toolkits/subgraph.py,sha256=ZYqI4yVLbEPAjCR8dpXbjbL2ipX598Hk3fL6AgaqFD4,1758
+alita_sdk/toolkits/tools.py,sha256=gk3nvQBdab3QM8v93ff2nrN4ZfcT779yae2RygkTl8s,5834
 alita_sdk/toolkits/vectorstore.py,sha256=di08-CRl0KJ9xSZ8_24VVnPZy58iLqHtXW8vuF29P64,2893
 alita_sdk/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 alita_sdk/tools/application.py,sha256=UJlYd3Sub10LpAoKkKEpvd4miWyrS-yYE5NKyqx-H4Q,2194
@@ -84,7 +85,7 @@ alita_sdk/tools/mcp_server_tool.py,sha256=xcH9AiqfR2TYrwJ3Ixw-_A7XDodtJCnwmq1Ssi
 alita_sdk/tools/pgvector_search.py,sha256=NN2BGAnq4SsDHIhUcFZ8d_dbEOM8QwB0UwpsWCYruXU,11692
 alita_sdk/tools/prompt.py,sha256=nJafb_e5aOM1Rr3qGFCR-SKziU9uCsiP2okIMs9PppM,741
 alita_sdk/tools/router.py,sha256=wCvZjVkdXK9dMMeEerrgKf5M790RudH68pDortnHSz0,1517
-alita_sdk/tools/tool.py,sha256=jFRq8BeC55NwpgdpsqGk_Y3tZL4YKN0rE7sVS5OE3yg,5092
+alita_sdk/tools/tool.py,sha256=f2ULDU4PU4PlLgygT_lsInLgNROJeWUNXLe0i0uOcqI,5419
 alita_sdk/tools/vectorstore.py,sha256=F-DoHxPa4UVsKB-FEd-wWa59QGQifKMwcSNcZ5WZOKc,23496
 alita_sdk/utils/AlitaCallback.py,sha256=cvpDhR4QLVCNQci6CO6TEUrUVDZU9_CRSwzcHGm3SGw,7356
 alita_sdk/utils/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -92,10 +93,10 @@ alita_sdk/utils/evaluate.py,sha256=iM1P8gzBLHTuSCe85_Ng_h30m52hFuGuhNXJ7kB1tgI,1
 alita_sdk/utils/logging.py,sha256=hBE3qAzmcLMdamMp2YRXwOOK9P4lmNaNhM76kntVljs,3124
 alita_sdk/utils/streamlit.py,sha256=zp8owZwHI3HZplhcExJf6R3-APtWx-z6s5jznT2hY_k,29124
 alita_sdk/utils/utils.py,sha256=dM8whOJAuFJFe19qJ69-FLzrUp6d2G-G6L7d4ss2XqM,346
-alita_sdk-0.3.125.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+alita_sdk-0.3.127.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
 tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 tests/test_jira_analysis.py,sha256=I0cErH5R_dHVyutpXrM1QEo7jfBuKWTmDQvJBPjx18I,3281
-alita_sdk-0.3.125.dist-info/METADATA,sha256=raIYIJIfySOwIA5jp0DHo4UlVizFOhLpWwLwx9AhQi8,7075
-alita_sdk-0.3.125.dist-info/WHEEL,sha256=zaaOINJESkSfm_4HQVc5ssNzHCPXhJm0kEUakpsEHaU,91
-alita_sdk-0.3.125.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
-alita_sdk-0.3.125.dist-info/RECORD,,
+alita_sdk-0.3.127.dist-info/METADATA,sha256=Ox_VkvvGHqTNfe_wFqkVXU0etHQmW92EziEoEM5D158,7075
+alita_sdk-0.3.127.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+alita_sdk-0.3.127.dist-info/top_level.txt,sha256=SWRhxB7Et3cOy3RkE5hR7OIRnHoo3K8EXzoiNlkfOmc,25
+alita_sdk-0.3.127.dist-info/RECORD,,

{alita_sdk-0.3.125.dist-info → alita_sdk-0.3.127.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.8.0)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any