lfx-nightly 0.1.13.dev6__py3-none-any.whl → 0.1.13.dev8__py3-none-any.whl

lfx/components/agents/__init__.py

@@ -6,6 +6,7 @@ from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
     from lfx.components.agents.agent import AgentComponent
+    from lfx.components.agents.altk_agent import ALTKAgentComponent
     from lfx.components.agents.cuga_agent import CugaComponent
     from lfx.components.agents.mcp_component import MCPToolsComponent
 
@@ -13,9 +14,10 @@ _dynamic_imports = {
     "AgentComponent": "agent",
     "CugaComponent": "cuga_agent",
     "MCPToolsComponent": "mcp_component",
+    "ALTKAgentComponent": "altk_agent",
 }
 
-__all__ = ["AgentComponent", "CugaComponent", "MCPToolsComponent"]
+__all__ = ["ALTKAgentComponent", "AgentComponent", "CugaComponent", "MCPToolsComponent"]
 
 
 def __getattr__(attr_name: str) -> Any:

lfx/components/agents/altk_agent.py

@@ -0,0 +1,366 @@
+import ast
+import json
+import uuid
+from collections.abc import Sequence
+from typing import TYPE_CHECKING, Any, cast
+
+from altk.core.llm import get_llm
+from altk.core.toolkit import AgentPhase
+from altk.post_tool.code_generation.code_generation import (
+    CodeGenerationComponent,
+    CodeGenerationComponentConfig,
+)
+from altk.post_tool.core.toolkit import CodeGenerationRunInput
+from langchain.agents import AgentExecutor, BaseMultiActionAgent, BaseSingleActionAgent
+from langchain_anthropic.chat_models import ChatAnthropic
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain_core.messages import BaseMessage, HumanMessage
+from langchain_core.runnables import Runnable, RunnableBinding
+from langchain_core.tools import BaseTool
+from langchain_openai.chat_models.base import ChatOpenAI
+from pydantic import Field
+
+from lfx.base.agents.callback import AgentAsyncHandler
+from lfx.base.agents.events import ExceptionWithMessageError, process_agent_events
+from lfx.base.agents.utils import data_to_messages, get_chat_output_sender_name
+from lfx.base.models.model_input_constants import (
+    MODEL_PROVIDERS_DICT,
+    MODELS_METADATA,
+)
+from lfx.components.agents import AgentComponent
+from lfx.inputs.inputs import BoolInput
+from lfx.io import DropdownInput, IntInput, Output
+from lfx.log.logger import logger
+from lfx.memory import delete_message
+from lfx.schema.content_block import ContentBlock
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+from lfx.utils.constants import MESSAGE_SENDER_AI
+
+if TYPE_CHECKING:
+    from lfx.schema.log import SendMessageFunctionType
+
+
+def set_advanced_true(component_input):
+    component_input.advanced = True
+    return component_input
+
+
+MODEL_PROVIDERS_LIST = ["Anthropic", "OpenAI"]
+INPUT_NAMES_TO_BE_OVERRIDDEN = ["agent_llm"]
+
+
+def get_parent_agent_inputs():
+    return [
+        input_field for input_field in AgentComponent.inputs if input_field.name not in INPUT_NAMES_TO_BE_OVERRIDDEN
+    ]
+
+
+class PostToolProcessor(BaseTool):
+    """A tool output processor to process tool outputs.
+
+    This wrapper intercepts the tool execution output and
+    if the tool output is a JSON, it invokes an ALTK component
+    to extract information from the JSON by generating Python code.
+    """
+
+    name: str = Field(...)
+    description: str = Field(...)
+    wrapped_tool: BaseTool = Field(...)
+    user_query: str = Field(...)
+    agent: Runnable | BaseSingleActionAgent | BaseMultiActionAgent | AgentExecutor = Field(...)
+    response_processing_size_threshold: int = Field(...)
+
+    def __init__(
+        self, wrapped_tool: BaseTool, user_query: str, agent, response_processing_size_threshold: int, **kwargs
+    ):
+        super().__init__(
+            name=wrapped_tool.name,
+            description=wrapped_tool.description,
+            wrapped_tool=wrapped_tool,
+            user_query=user_query,
+            agent=agent,
+            response_processing_size_threshold=response_processing_size_threshold,
+            **kwargs,
+        )
+
+    def _execute_tool(self, *args, **kwargs) -> str:
+        """Execute the wrapped tool with proper error handling."""
+        try:
+            # Try with config parameter first (newer LangChain versions)
+            if hasattr(self.wrapped_tool, "_run"):
+                # Ensure config is provided for StructuredTool
+                if "config" not in kwargs:
+                    kwargs["config"] = {}
+                return self.wrapped_tool._run(*args, **kwargs)  # noqa: SLF001
+            return self.wrapped_tool.run(*args, **kwargs)
+        except TypeError as e:
+            if "config" in str(e):
+                # Fallback: try without config for older tools
+                kwargs.pop("config", None)
+                if hasattr(self.wrapped_tool, "_run"):
+                    return self.wrapped_tool._run(*args, **kwargs)  # noqa: SLF001
+                return self.wrapped_tool.run(*args, **kwargs)
+            raise
+
+    def _run(self, *args: Any, **kwargs: Any) -> str:
+        # Run the wrapped tool
+        result = self._execute_tool(*args, **kwargs)
+
+        # Run postprocessing and return the output
+        return self.process_tool_response(result)
+
+    def _get_tool_response_str(self, tool_response) -> str | None:
+        if isinstance(tool_response, str):
+            tool_response_str = tool_response
+        elif isinstance(tool_response, Data):
+            tool_response_str = str(tool_response.data)
+        elif isinstance(tool_response, list) and all(isinstance(item, Data) for item in tool_response):
+            # get only the first element, not 100% sure if it should be the first or the last
+            tool_response_str = str(tool_response[0].data)
+        elif isinstance(tool_response, (dict, list)):
+            tool_response_str = str(tool_response)
+        else:
+            tool_response_str = None
+        return tool_response_str
+
+    def _get_altk_llm_object(self) -> Any:
+        # Extract the LLM model and map it to altk model inputs
+        llm_object: BaseChatModel | None = None
+        steps = getattr(self.agent, "steps", None)
+        if steps:
+            for step in steps:
+                if isinstance(step, RunnableBinding) and isinstance(step.bound, BaseChatModel):
+                    llm_object = step.bound
+                    break
+        if isinstance(llm_object, ChatAnthropic):
+            # litellm needs the prefix to the model name for anthropic
+            model_name = f"anthropic/{llm_object.model}"
+            api_key = llm_object.anthropic_api_key.get_secret_value()
+            llm_client = get_llm("litellm")
+            llm_client_obj = llm_client(model_name=model_name, api_key=api_key)
+        elif isinstance(llm_object, ChatOpenAI):
+            model_name = llm_object.model_name
+            api_key = llm_object.openai_api_key.get_secret_value()
+            llm_client = get_llm("openai.sync")
+            llm_client_obj = llm_client(model=model_name, api_key=api_key)
+        else:
+            logger.info("ALTK currently only supports OpenAI and Anthropic models through Langflow.")
+            llm_client_obj = None
+
+        return llm_client_obj
+
+    def process_tool_response(self, tool_response: str, **_kwargs):
+        logger.info("Calling process_tool_response of PostToolProcessor")
+        tool_response_str = self._get_tool_response_str(tool_response)
+
+        try:
+            tool_response_json = ast.literal_eval(tool_response_str)
+            if not isinstance(tool_response_json, (list, dict)):
+                tool_response_json = None
+        except (json.JSONDecodeError, TypeError) as e:
+            logger.info(
+                f"An error in converting the tool response to json, this will skip the code generation component: {e}"
+            )
+            tool_response_json = None
+
+        if tool_response_json is not None and len(str(tool_response_json)) > self.response_processing_size_threshold:
+            llm_client_obj = self._get_altk_llm_object()
+            if llm_client_obj is not None:
+                config = CodeGenerationComponentConfig(llm_client=llm_client_obj, use_docker_sandbox=False)
+
+                middleware = CodeGenerationComponent(config=config)
+                input_data = CodeGenerationRunInput(
+                    messages=[], nl_query=self.user_query, tool_response=tool_response_json
+                )
+                output = None
+                try:
+                    output = middleware.process(input_data, AgentPhase.RUNTIME)
+                except Exception as e:  # noqa: BLE001
+                    logger.error(f"Exception in executing CodeGenerationComponent: {e}")
+                logger.info(f"Output of CodeGenerationComponent: {output.result}")
+                return output.result
+        return tool_response
+
+
+class ALTKAgentComponent(AgentComponent):
+    """An advanced tool calling agent.
+
+    The ALTKAgent is an advanced AI agent that enhances the tool calling capabilities of LLMs
+    by performing special checks and processing around tool calls.
+    It uses components from the Agent Lifecycle ToolKit (https://github.com/AgentToolkit/agent-lifecycle-toolkit)
+    """
+
+    display_name: str = "ALTK Agent"
+    description: str = "Agent with enhanced tool calling capabilities. For more information on ALTK, visit https://github.com/AgentToolkit/agent-lifecycle-toolkit"
+    documentation: str = "https://docs.langflow.org/agents"
+    icon = "bot"
+    beta = True
+    name = "ALTKAgent"
+
+    # Filter out json_mode from OpenAI inputs since we handle structured output differently
+    if "OpenAI" in MODEL_PROVIDERS_DICT:
+        openai_inputs_filtered = [
+            input_field
+            for input_field in MODEL_PROVIDERS_DICT["OpenAI"]["inputs"]
+            if not (hasattr(input_field, "name") and input_field.name == "json_mode")
+        ]
+    else:
+        openai_inputs_filtered = []
+
+    inputs = [
+        DropdownInput(
+            name="agent_llm",
+            display_name="Model Provider",
+            info="The provider of the language model that the agent will use to generate responses.",
+            options=[*MODEL_PROVIDERS_LIST],
+            value="OpenAI",
+            real_time_refresh=True,
+            refresh_button=False,
+            input_types=[],
+            options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST if key in MODELS_METADATA],
+        ),
+        *get_parent_agent_inputs(),
+        BoolInput(
+            name="enable_post_tool_reflection",
+            display_name="Post Tool JSON Processing",
+            info="If true, it passes the tool output to a json processing (if json) step.",
+            value=True,
+        ),
+        # Post Tool Processing is applied only when the number of characters in the response
+        # exceed the following threshold
+        IntInput(
+            name="response_processing_size_threshold",
+            display_name="Response Processing Size Threshold",
+            value=100,
+            info="Tool output is post-processed only if the response length exceeds a specified character threshold.",
+            advanced=True,
+            show=True,
+        ),
+    ]
+    outputs = [
+        Output(name="response", display_name="Response", method="message_response"),
+    ]
+
+    def update_runnable_instance(
+        self, agent: AgentExecutor, runnable: AgentExecutor, tools: Sequence[BaseTool]
+    ) -> AgentExecutor:
+        user_query = self.input_value.get_text() if hasattr(self.input_value, "get_text") else self.input_value
+        if self.enable_post_tool_reflection:
+            wrapped_tools = [
+                PostToolProcessor(
+                    wrapped_tool=tool,
+                    user_query=user_query,
+                    agent=agent,
+                    response_processing_size_threshold=self.response_processing_size_threshold,
+                )
+                if not isinstance(tool, PostToolProcessor)
+                else tool
+                for tool in tools
+            ]
+        else:
+            wrapped_tools = tools
+
+        runnable.tools = wrapped_tools
+
+        return runnable
+
+    async def run_agent(
+        self,
+        agent: Runnable | BaseSingleActionAgent | BaseMultiActionAgent | AgentExecutor,
+    ) -> Message:
+        if isinstance(agent, AgentExecutor):
+            runnable = agent
+        else:
+            # note the tools are not required to run the agent, hence the validation removed.
+            handle_parsing_errors = hasattr(self, "handle_parsing_errors") and self.handle_parsing_errors
+            verbose = hasattr(self, "verbose") and self.verbose
+            max_iterations = hasattr(self, "max_iterations") and self.max_iterations
+            runnable = AgentExecutor.from_agent_and_tools(
+                agent=agent,
+                tools=self.tools or [],
+                handle_parsing_errors=handle_parsing_errors,
+                verbose=verbose,
+                max_iterations=max_iterations,
+            )
+        runnable = self.update_runnable_instance(agent, runnable, self.tools)
+
+        # Convert input_value to proper format for agent
+        if hasattr(self.input_value, "to_lc_message") and callable(self.input_value.to_lc_message):
+            lc_message = self.input_value.to_lc_message()
+            input_text = lc_message.content if hasattr(lc_message, "content") else str(lc_message)
+        else:
+            lc_message = None
+            input_text = self.input_value
+
+        input_dict: dict[str, str | list[BaseMessage]] = {}
+        if hasattr(self, "system_prompt"):
+            input_dict["system_prompt"] = self.system_prompt
+        if hasattr(self, "chat_history") and self.chat_history:
+            if (
+                hasattr(self.chat_history, "to_data")
+                and callable(self.chat_history.to_data)
+                and self.chat_history.__class__.__name__ == "Data"
+            ):
+                input_dict["chat_history"] = data_to_messages(self.chat_history)
+            # Handle both lfx.schema.message.Message and langflow.schema.message.Message types
+            if all(hasattr(m, "to_data") and callable(m.to_data) and "text" in m.data for m in self.chat_history):
+                input_dict["chat_history"] = data_to_messages(self.chat_history)
+            if all(isinstance(m, Message) for m in self.chat_history):
+                input_dict["chat_history"] = data_to_messages([m.to_data() for m in self.chat_history])
+        if hasattr(lc_message, "content") and isinstance(lc_message.content, list):
+            # ! Because the input has to be a string, we must pass the images in the chat_history
+
+            image_dicts = [item for item in lc_message.content if item.get("type") == "image"]
+            lc_message.content = [item for item in lc_message.content if item.get("type") != "image"]
+
+            if "chat_history" not in input_dict:
+                input_dict["chat_history"] = []
+            if isinstance(input_dict["chat_history"], list):
+                input_dict["chat_history"].extend(HumanMessage(content=[image_dict]) for image_dict in image_dicts)
+            else:
+                input_dict["chat_history"] = [HumanMessage(content=[image_dict]) for image_dict in image_dicts]
+        input_dict["input"] = input_text
+        if hasattr(self, "graph"):
+            session_id = self.graph.session_id
+        elif hasattr(self, "_session_id"):
+            session_id = self._session_id
+        else:
+            session_id = None
+
+        try:
+            sender_name = get_chat_output_sender_name(self)
+        except AttributeError:
+            sender_name = self.display_name or "AI"
+
+        agent_message = Message(
+            sender=MESSAGE_SENDER_AI,
+            sender_name=sender_name,
+            properties={"icon": "Bot", "state": "partial"},
+            content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
+            session_id=session_id or uuid.uuid4(),
+        )
+        try:
+            result = await process_agent_events(
+                runnable.astream_events(
+                    input_dict,
+                    config={"callbacks": [AgentAsyncHandler(self.log), *self.get_langchain_callbacks()]},
+                    version="v2",
+                ),
+                agent_message,
+                cast("SendMessageFunctionType", self.send_message),
+            )
+        except ExceptionWithMessageError as e:
+            if hasattr(e, "agent_message") and hasattr(e.agent_message, "id"):
+                msg_id = e.agent_message.id
+                await delete_message(id_=msg_id)
+            await self._send_message_event(e.agent_message, category="remove_message")
+            logger.error(f"ExceptionWithMessageError: {e}")
+            raise
+        except Exception as e:
+            # Log or handle any other exceptions
+            logger.error(f"Error: {e}")
+            raise
+
+        self.status = result
+        return result

lfx/components/agents/mcp_component.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import asyncio
+import json
 import uuid
 from typing import Any
 
@@ -520,7 +521,6 @@ class MCPToolsComponent(ComponentWithCache):
                 if session_context:
                     self.stdio_client.set_session_context(session_context)
                     self.streamable_http_client.set_session_context(session_context)
-
                 exec_tool = self._tool_cache[self.tool]
                 tool_args = self.get_inputs_for_all_tools(self.tools)[self.tool]
                 kwargs = {}
@@ -535,11 +535,14 @@ class MCPToolsComponent(ComponentWithCache):
                 unflattened_kwargs = maybe_unflatten_dict(kwargs)
 
                 output = await exec_tool.coroutine(**unflattened_kwargs)
-
                 tool_content = []
                 for item in output.content:
                     item_dict = item.model_dump()
+                    item_dict = self.process_output_item(item_dict)
                     tool_content.append(item_dict)
+
+                if isinstance(tool_content, list) and all(isinstance(x, dict) for x in tool_content):
+                    return DataFrame(tool_content)
                 return DataFrame(data=tool_content)
             return DataFrame(data=[{"error": "You must select a tool"}])
         except Exception as e:
@@ -547,6 +550,17 @@ class MCPToolsComponent(ComponentWithCache):
             await logger.aexception(msg)
             raise ValueError(msg) from e
 
+    def process_output_item(self, item_dict):
+        """Process the output of a tool."""
+        if item_dict.get("type") == "text":
+            text = item_dict.get("text")
+            try:
+                return json.loads(text)
+                # convert it to dict
+            except json.JSONDecodeError:
+                return item_dict
+        return item_dict
+
     def _get_session_context(self) -> str | None:
         """Get the Langflow session ID for MCP session caching."""
         # Try to get session ID from the component's execution context

lfx/components/processing/structured_output.py

@@ -11,6 +11,7 @@ from lfx.io import (
     Output,
     TableInput,
 )
+from lfx.log.logger import logger
 from lfx.schema.data import Data
 from lfx.schema.dataframe import DataFrame
 from lfx.schema.table import EditMode
@@ -136,30 +137,27 @@ class StructuredOutputComponent(Component):
             raise ValueError(msg)
 
         output_model_ = build_model_from_schema(self.output_schema)
-
         output_model = create_model(
             schema_name,
             __doc__=f"A list of {schema_name}.",
-            objects=(list[output_model_], Field(description=f"A list of {schema_name}.")),  # type: ignore[valid-type]
+            objects=(
+                list[output_model_],
+                Field(
+                    description=f"A list of {schema_name}.",  # type: ignore[valid-type]
+                    min_length=1,  # help ensure non-empty output
+                ),
+            ),
         )
-
-        try:
-            llm_with_structured_output = create_extractor(self.llm, tools=[output_model])
-        except NotImplementedError as exc:
-            msg = f"{self.llm.__class__.__name__} does not support structured output."
-            raise TypeError(msg) from exc
-
+        # Tracing config
         config_dict = {
             "run_name": self.display_name,
             "project_name": self.get_project_name(),
             "callbacks": self.get_langchain_callbacks(),
         }
-        result = get_chat_result(
-            runnable=llm_with_structured_output,
-            system_message=self.system_prompt,
-            input_value=self.input_value,
-            config=config_dict,
-        )
+        # Generate structured output using Trustcall first, then fallback to Langchain if it fails
+        result = self._extract_output_with_trustcall(output_model, config_dict)
+        if result is None:
+            result = self._extract_output_with_langchain(output_model, config_dict)
 
         # OPTIMIZATION NOTE: Simplified processing based on trustcall response structure
         # Handle non-dict responses (shouldn't happen with trustcall, but defensive)
@@ -173,8 +171,9 @@ class StructuredOutputComponent(Component):
 
         # Convert BaseModel to dict (creates the "objects" key)
         first_response = responses[0]
-        structured_data = first_response.model_dump() if isinstance(first_response, BaseModel) else first_response
-
+        structured_data = first_response
+        if isinstance(first_response, BaseModel):
+            structured_data = first_response.model_dump()
         # Extract the objects array (guaranteed to exist due to our Pydantic model structure)
         return structured_data.get("objects", structured_data)
 
@@ -204,3 +203,42 @@ class StructuredOutputComponent(Component):
             # Multiple outputs - convert to DataFrame directly
             return DataFrame(output)
         return DataFrame()
+
+    def _extract_output_with_trustcall(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = create_extractor(self.llm, tools=[schema], tool_choice=schema.__name__)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+        except Exception as e:  # noqa: BLE001
+            logger.warning(
+                f"Trustcall extraction failed, falling back to Langchain: {e} "
+                "(Note: This may not be an error—some models or configurations do not support tool calling. "
+                "Falling back is normal in such cases.)"
+            )
+            return None
+        return result or None  # langchain fallback is used if error occurs or the result is empty
+
+    def _extract_output_with_langchain(self, schema: BaseModel, config_dict: dict) -> list[BaseModel] | None:
+        try:
+            llm_with_structured_output = self.llm.with_structured_output(schema)
+            result = get_chat_result(
+                runnable=llm_with_structured_output,
+                system_message=self.system_prompt,
+                input_value=self.input_value,
+                config=config_dict,
+            )
+            if isinstance(result, BaseModel):
+                result = result.model_dump()
+                result = result.get("objects", result)
+        except Exception as fallback_error:
+            msg = (
+                f"Model does not support tool calling (trustcall failed) "
+                f"and fallback with_structured_output also failed: {fallback_error}"
+            )
+            raise ValueError(msg) from fallback_error
+
+        return result or None

{lfx_nightly-0.1.13.dev6.dist-info → lfx_nightly-0.1.13.dev8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.13.dev6
+Version: 0.1.13.dev8
 Summary: Langflow Executor - A lightweight CLI tool for executing and serving Langflow AI flows
 Author-email: Gabriel Luiz Freitas Almeida <gabriel@langflow.org>
 Requires-Python: <3.14,>=3.10

{lfx_nightly-0.1.13.dev6.dist-info → lfx_nightly-0.1.13.dev8.dist-info}/RECORD

@@ -4,7 +4,7 @@ lfx/constants.py,sha256=Ert_SpwXhutgcTKEvtDArtkONXgyE5x68opMoQfukMA,203
 lfx/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/settings.py,sha256=wnx4zkOLQ8mvampYsnnvVV9GvEnRUuWQpKFSbFTCIp4,181
 lfx/type_extraction.py,sha256=eCZNl9nAQivKdaPv_9BK71N0JV9Rtr--veAht0dnQ4A,2921
-lfx/_assets/component_index.json,sha256=2hSLAb9KQz76HrOJ6qanuKq_sdO7QBEROA6qTcrhocg,3525354
+lfx/_assets/component_index.json,sha256=iFhI2IAaOrFMIB-NI1GrezFq6uTRjP83yqSIaGpgUbM,3558913
 lfx/base/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/constants.py,sha256=v9vo0Ifg8RxDu__XqgGzIXHlsnUFyWM-SSux0uHHoz8,1187
 lfx/base/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -115,10 +115,11 @@ lfx/components/Notion/search.py,sha256=WEDYbNotXdlgTXrmRtpZ9_proiOJl1zouNPRpFllg
 lfx/components/Notion/update_page_property.py,sha256=tgmPMbD1eX58dQQNXv1w5FzDec7QwFiBuOqh4RazoJ0,4541
 lfx/components/agentql/__init__.py,sha256=Erl669Dzsk-SegsDPWTtkKbprMXVuv8UTCo5REzZGTc,56
 lfx/components/agentql/agentql_api.py,sha256=N94yEK7ZuQCIsFBlr_8dqrJY-K1-KNb6QEEYfDIsDME,5569
-lfx/components/agents/__init__.py,sha256=UBu5kO9hp8yFyxTU-u9KHN9zTSoHhJSYdKtRuT5ig9c,1164
+lfx/components/agents/__init__.py,sha256=O5ng90Dn9mSlpCdeGPXM4tvdWYVfEMv_7PGDKShyBKg,1294
 lfx/components/agents/agent.py,sha256=-pGSOYS-2pHoYq5VyNdDCnkQVzVz52as4hdF_BB1hVI,26993
+lfx/components/agents/altk_agent.py,sha256=D_ChOwqYao0QZBfiLpiMVoMOgCwzcb_q0MIPDULLHW8,15939
 lfx/components/agents/cuga_agent.py,sha256=JNi4MsSziTJQI3z_0KGzNWxm5RDaMk_W9zcTW2KcTtI,44499
-lfx/components/agents/mcp_component.py,sha256=I8xAV7qGy67uV_4R6lrM4f6EOa9cFPQZDIcP3tiMuYk,26208
+lfx/components/agents/mcp_component.py,sha256=gbEzi-hZMqVmIGO5DjJDOlmpisPkylOSZSGgaDjiQLY,26809
 lfx/components/aiml/__init__.py,sha256=DNKB-HMFGFYmsdkON-s8557ttgBXVXADmS-BcuSQiIQ,1087
 lfx/components/aiml/aiml.py,sha256=23Ineg1ajlCoqXgWgp50I20OnQbaleRNsw1c6IzPu3A,3877
 lfx/components/aiml/aiml_embeddings.py,sha256=2uNwORuj55mxn2SfLbh7oAIfjuXwHbsnOqRjfMtQRqc,1095
@@ -476,7 +477,7 @@ lfx/components/processing/python_repl_core.py,sha256=6kOu64pWyBwBpTqOTM9LPnSsnTX
 lfx/components/processing/regex.py,sha256=9n171_Ze--5gpKFJJyJlYafuEOwbPQPiyjhdLY3SUrY,2689
 lfx/components/processing/select_data.py,sha256=BRK9mM5NuHveCrMOyIXjzzpEsNMEiA7oQXvk1DZLHM4,1788
 lfx/components/processing/split_text.py,sha256=8oZ-_aYfjxEdzFFr2reKeBVPjMrAeAauZiQkM9J7Syc,5293
-lfx/components/processing/structured_output.py,sha256=pbGwTZ_MCRwfpNY55zKDrSCw1fFYosL11QVNkZZndz8,8125
+lfx/components/processing/structured_output.py,sha256=mtjY2PwWKjAFYd4CYOo1Nbxv4umVTYgj6O9xszbN2IA,10015
 lfx/components/processing/update_data.py,sha256=0HkK86ybp0vWc_KKMWD0j0dnaxS6zQMOjAY8lLwNkr4,6090
 lfx/components/prototypes/__init__.py,sha256=uJRmThNAq6Tr_mBppcD95dV07WkOF6BYdy-zq7uXUhY,1061
 lfx/components/prototypes/python_function.py,sha256=fafYVqVFqusIkJP4jgmHMZnwgVkYdhYBmD51Dtst9Z4,2419
@@ -729,7 +730,7 @@ lfx/utils/schemas.py,sha256=NbOtVQBrn4d0BAu-0H_eCTZI2CXkKZlRY37XCSmuJwc,3865
 lfx/utils/util.py,sha256=Ww85wbr1-vjh2pXVtmTqoUVr6MXAW8S7eDx_Ys6HpE8,20696
 lfx/utils/util_strings.py,sha256=nU_IcdphNaj6bAPbjeL-c1cInQPfTBit8mp5Y57lwQk,1686
 lfx/utils/version.py,sha256=cHpbO0OJD2JQAvVaTH_6ibYeFbHJV0QDHs_YXXZ-bT8,671
-lfx_nightly-0.1.13.dev6.dist-info/METADATA,sha256=G8E7qLd-Yt5CTSxEj4UZfnKxu-68wkV1Xi2X5cdbCdM,8289
-lfx_nightly-0.1.13.dev6.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.13.dev6.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.13.dev6.dist-info/RECORD,,
+lfx_nightly-0.1.13.dev8.dist-info/METADATA,sha256=OuXsV_znOj-UTr--bes0-v4clOA1MVVgLl2ygj8ok94,8289
+lfx_nightly-0.1.13.dev8.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.13.dev8.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.13.dev8.dist-info/RECORD,,