lfx-nightly 0.1.13.dev9__py3-none-any.whl → 0.1.13.dev11__py3-none-any.whl

lfx/base/agents/agent.py

@@ -6,12 +6,12 @@ from typing import TYPE_CHECKING, cast
 from langchain.agents import AgentExecutor, BaseMultiActionAgent, BaseSingleActionAgent
 from langchain.agents.agent import RunnableAgent
 from langchain.callbacks.base import BaseCallbackHandler
-from langchain_core.messages import HumanMessage
+from langchain_core.messages import BaseMessage, HumanMessage
 from langchain_core.runnables import Runnable
 
 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.agents.utils import get_chat_output_sender_name
 from lfx.custom.custom_component.component import Component, _get_component_toolkit
 from lfx.field_typing import Tool
 from lfx.inputs.inputs import InputTypes, MultilineInput
@@ -20,14 +20,13 @@ 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.log import OnTokenFunctionType
 from lfx.schema.message import Message
 from lfx.template.field.base import Output
 from lfx.utils.constants import MESSAGE_SENDER_AI
 
 if TYPE_CHECKING:
-    from langchain_core.messages import BaseMessage
-
-    from lfx.schema.log import SendMessageFunctionType
+    from lfx.schema.log import OnTokenFunctionType, SendMessageFunctionType
 
 
 DEFAULT_TOOLS_DESCRIPTION = "A helpful assistant with access to the following tools:"
@@ -126,6 +125,24 @@ class LCAgentComponent(Component):
         # might be overridden in subclasses
         return None
 
+    def _data_to_messages_skip_empty(self, data: list[Data]) -> list[BaseMessage]:
+        """Convert data to messages, filtering only empty text while preserving non-text content.
+
+        Note: added to fix issue with certain providers failing when given empty text as input.
+        """
+        messages = []
+        for value in data:
+            # Only skip if the message has a text attribute that is empty/whitespace
+            text = getattr(value, "text", None)
+            if isinstance(text, str) and not text.strip():
+                # Skip only messages with empty/whitespace-only text strings
+                continue
+
+            lc_message = value.to_lc_message()
+            messages.append(lc_message)
+
+        return messages
+
     async def run_agent(
         self,
         agent: Runnable | BaseSingleActionAgent | BaseMultiActionAgent | AgentExecutor,
@@ -145,57 +162,64 @@ class LCAgentComponent(Component):
                 max_iterations=max_iterations,
             )
         # 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 = None
+        if isinstance(self.input_value, Message):
             lc_message = self.input_value.to_lc_message()
-            input_text = lc_message.content if hasattr(lc_message, "content") else str(lc_message)
+            input_dict: dict[str, str | list[BaseMessage] | BaseMessage] = {"input": lc_message}
         else:
-            lc_message = None
-            input_text = self.input_value
+            input_dict = {"input": 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
 
+        if hasattr(self, "chat_history") and self.chat_history:
+            if isinstance(self.chat_history, Data):
+                input_dict["chat_history"] = self._data_to_messages_skip_empty([self.chat_history])
+            elif 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"] = self._data_to_messages_skip_empty(self.chat_history)
+            elif all(isinstance(m, Message) for m in self.chat_history):
+                input_dict["chat_history"] = self._data_to_messages_skip_empty([m.to_data() for m in self.chat_history])
+
+        # Handle multimodal input (images + text)
+        # Note: Agent input must be a string, so we extract text and move images to chat_history
+        if lc_message is not None and hasattr(lc_message, "content") and isinstance(lc_message.content, list):
+            # Extract images and text from the text content items
             image_dicts = [item for item in lc_message.content if item.get("type") == "image"]
-            text_items = [item for item in lc_message.content if item.get("type") != "image"]
+            text_content = [item for item in lc_message.content if item.get("type") != "image"]
 
-            # Extract text content from remaining items
-            if text_items:
-                # If there are text items, extract their text content
-                input_text = " ".join(item.get("text", "") for item in text_items if item.get("type") == "text").strip()
+            text_strings = [
+                item.get("text", "")
+                for item in text_content
+                if item.get("type") == "text" and item.get("text", "").strip()
+            ]
 
-            # If input_text is still a list or empty, provide a default
-            if isinstance(input_text, list) or not input_text:
-                input_text = "Process the provided images."
+            # Set input to concatenated text or empty string
+            input_dict["input"] = " ".join(text_strings) if text_strings else ""
+
+            # If input is still a list or empty, provide a default
+            if isinstance(input_dict["input"], list) or not input_dict["input"]:
+                input_dict["input"] = "Process the provided images."
 
             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]
 
-        # Final safety check: ensure input_text is never empty (prevents Anthropic API errors)
-        if not input_text or (isinstance(input_text, (list, str)) and not str(input_text).strip()):
-            input_text = "Continue the conversation."
-        # Ensure the agent input is a string
-        if not isinstance(input_text, str):
-            input_text = " ".join(map(str, input_text)) if isinstance(input_text, list) else str(input_text)
-        input_dict["input"] = input_text
+        # Final safety check: ensure input is never empty (prevents Anthropic API errors)
+        current_input = input_dict.get("input", "")
+        if isinstance(current_input, list):
+            current_input = " ".join(map(str, current_input))
+        elif not isinstance(current_input, str):
+            current_input = str(current_input)
+
+        if not current_input.strip():
+            input_dict["input"] = "Continue the conversation."
+        else:
+            input_dict["input"] = current_input
+
         if hasattr(self, "graph"):
             session_id = self.graph.session_id
         elif hasattr(self, "_session_id"):
@@ -204,7 +228,6 @@ class LCAgentComponent(Component):
             session_id = None
 
         sender_name = get_chat_output_sender_name(self) or self.display_name or "AI"
-
         agent_message = Message(
             sender=MESSAGE_SENDER_AI,
             sender_name=sender_name,
@@ -212,6 +235,13 @@ class LCAgentComponent(Component):
             content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
             session_id=session_id or uuid.uuid4(),
         )
+
+        # Create token callback if event_manager is available
+        # This wraps the event_manager's on_token method to match OnTokenFunctionType Protocol
+        on_token_callback: OnTokenFunctionType | None = None
+        if self._event_manager:
+            on_token_callback = cast("OnTokenFunctionType", self._event_manager.on_token)
+
         try:
             result = await process_agent_events(
                 runnable.astream_events(
@@ -222,6 +252,7 @@ class LCAgentComponent(Component):
                 ),
                 agent_message,
                 cast("SendMessageFunctionType", self.send_message),
+                on_token_callback,
             )
         except ExceptionWithMessageError as e:
             if hasattr(e, "agent_message") and hasattr(e.agent_message, "id"):

lfx/base/agents/events.py

@@ -1,4 +1,5 @@
 # Add helper functions for each event type
+import asyncio
 from collections.abc import AsyncIterator
 from time import perf_counter
 from typing import Any, Protocol
@@ -9,7 +10,7 @@ from typing_extensions import TypedDict
 
 from lfx.schema.content_block import ContentBlock
 from lfx.schema.content_types import TextContent, ToolContent
-from lfx.schema.log import SendMessageFunctionType
+from lfx.schema.log import OnTokenFunctionType, SendMessageFunctionType
 from lfx.schema.message import Message
 
 
@@ -53,7 +54,14 @@ def _calculate_duration(start_time: float) -> int:
 
 
 async def handle_on_chain_start(
-    event: dict[str, Any], agent_message: Message, send_message_method: SendMessageFunctionType, start_time: float
+    event: dict[str, Any],
+    agent_message: Message,
+    send_message_callback: SendMessageFunctionType,
+    send_token_callback: OnTokenFunctionType | None,  # noqa: ARG001
+    start_time: float,
+    *,
+    had_streaming: bool = False,  # noqa: ARG001
+    message_id: str | None = None,  # noqa: ARG001
 ) -> tuple[Message, float]:
     # Create content blocks if they don't exist
     if not agent_message.content_blocks:
@@ -80,7 +88,7 @@ async def handle_on_chain_start(
                 header={"title": "Input", "icon": "MessageSquare"},
             )
             agent_message.content_blocks[0].contents.append(text_content)
-            agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+            agent_message = await send_message_callback(message=agent_message, skip_db_update=True)
             start_time = perf_counter()
     return agent_message, start_time
 
@@ -101,15 +109,23 @@ def _extract_output_text(output: str | list) -> str:
             if isinstance(item, dict):
                 if "text" in item:
                     return item["text"] or ""
-                # If the item's type is "tool_use", return an empty string.
-                if item.get("type") == "tool_use":
-                    return ""
-                # Handle items with only 'index' key (from ChatBedrockConverse)
-                if "index" in item and len(item) == 1:
-                    return ""
-                # This is a workaround to deal with function calling by Anthropic
-                if "partial_json" in item:
+                if "content" in item:
+                    return str(item["content"])
+                if "message" in item:
+                    return str(item["message"])
+
+                # Special case handling for non-text-like dicts
+                if (
+                    item.get("type") == "tool_use"  # Handle tool use items
+                    or ("index" in item and len(item) == 1)  # Handle index-only items
+                    or "partial_json" in item  # Handle partial json items
+                    # Handle index-only items
+                    or ("index" in item and not any(k in item for k in ("text", "content", "message")))
+                    # Handle other metadata-only chunks that don't contain meaningful text
+                    or not any(key in item for key in ["text", "content", "message"])
+                ):
                     return ""
+
                 # For any other dict format, return empty string
                 return ""
             # For any other single item type (not str or dict), return empty string
@@ -133,7 +149,14 @@ def _extract_output_text(output: str | list) -> str:
 
 
 async def handle_on_chain_end(
-    event: dict[str, Any], agent_message: Message, send_message_method: SendMessageFunctionType, start_time: float
+    event: dict[str, Any],
+    agent_message: Message,
+    send_message_callback: SendMessageFunctionType,
+    send_token_callback: OnTokenFunctionType | None,  # noqa: ARG001
+    start_time: float,
+    *,
+    had_streaming: bool = False,
+    message_id: str | None = None,  # noqa: ARG001
 ) -> tuple[Message, float]:
     data_output = event["data"].get("output")
     if data_output and isinstance(data_output, AgentFinish) and data_output.return_values.get("output"):
@@ -151,7 +174,11 @@ async def handle_on_chain_end(
                 header={"title": "Output", "icon": "MessageSquare"},
             )
             agent_message.content_blocks[0].contents.append(text_content)
-        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+
+        # Only send final message if we didn't have streaming chunks
+        # If we had streaming, frontend already accumulated the chunks
+        if not had_streaming:
+            agent_message = await send_message_callback(message=agent_message)
         start_time = perf_counter()
     return agent_message, start_time
 
@@ -160,7 +187,7 @@ async def handle_on_tool_start(
     event: dict[str, Any],
     agent_message: Message,
     tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
+    send_message_callback: SendMessageFunctionType,
     start_time: float,
 ) -> tuple[Message, float]:
     tool_name = event["name"]
@@ -190,7 +217,7 @@ async def handle_on_tool_start(
     tool_blocks_map[tool_key] = tool_content
     agent_message.content_blocks[0].contents.append(tool_content)
 
-    agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+    agent_message = await send_message_callback(message=agent_message, skip_db_update=True)
     if agent_message.content_blocks and agent_message.content_blocks[0].contents:
         tool_blocks_map[tool_key] = agent_message.content_blocks[0].contents[-1]
     return agent_message, new_start_time
@@ -200,7 +227,7 @@ async def handle_on_tool_end(
     event: dict[str, Any],
     agent_message: Message,
     tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
+    send_message_callback: SendMessageFunctionType,
     start_time: float,
 ) -> tuple[Message, float]:
     run_id = event.get("run_id", "")
@@ -209,8 +236,8 @@ async def handle_on_tool_end(
     tool_content = tool_blocks_map.get(tool_key)
 
     if tool_content and isinstance(tool_content, ToolContent):
-        # Call send_message_method first to get the updated message structure
-        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+        # Call send_message_callback first to get the updated message structure
+        agent_message = await send_message_callback(message=agent_message, skip_db_update=True)
         new_start_time = perf_counter()
 
         # Now find and update the tool content in the current message
@@ -246,7 +273,7 @@ async def handle_on_tool_error(
     event: dict[str, Any],
     agent_message: Message,
     tool_blocks_map: dict[str, ToolContent],
-    send_message_method: SendMessageFunctionType,
+    send_message_callback: SendMessageFunctionType,
     start_time: float,
 ) -> tuple[Message, float]:
     run_id = event.get("run_id", "")
@@ -258,7 +285,7 @@ async def handle_on_tool_error(
         tool_content.error = event["data"].get("error", "Unknown error")
         tool_content.duration = _calculate_duration(start_time)
         tool_content.header = {"title": f"Error using **{tool_content.name}**", "icon": "Hammer"}
-        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+        agent_message = await send_message_callback(message=agent_message, skip_db_update=True)
         start_time = perf_counter()
     return agent_message, start_time
 
@@ -266,8 +293,12 @@ async def handle_on_tool_error(
 async def handle_on_chain_stream(
     event: dict[str, Any],
     agent_message: Message,
-    send_message_method: SendMessageFunctionType,
+    send_message_callback: SendMessageFunctionType,  # noqa: ARG001
+    send_token_callback: OnTokenFunctionType | None,
     start_time: float,
+    *,
+    had_streaming: bool = False,  # noqa: ARG001
+    message_id: str | None = None,
 ) -> tuple[Message, float]:
     data_chunk = event["data"].get("chunk", {})
     if isinstance(data_chunk, dict) and data_chunk.get("output"):
@@ -275,15 +306,26 @@ async def handle_on_chain_stream(
         if output and isinstance(output, str | list):
             agent_message.text = _extract_output_text(output)
         agent_message.properties.state = "complete"
-        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+        # Don't call send_message_callback here - we must update in place
+        # in order to keep the message id consistent throughout the stream.
+        # The final message will be sent after the loop completes
         start_time = perf_counter()
     elif isinstance(data_chunk, AIMessageChunk):
         output_text = _extract_output_text(data_chunk.content)
-        if output_text and isinstance(agent_message.text, str):
-            agent_message.text += output_text
-            agent_message.properties.state = "partial"
-            agent_message = await send_message_method(message=agent_message, skip_db_update=True)
+        # For streaming, send token event if callback is available
+        # Note: we should expect the callback, but we keep it optional for backwards compatibility
+        # as of v1.6.5
+        if output_text and output_text.strip() and send_token_callback and message_id:
+            await asyncio.to_thread(
+                send_token_callback,
+                data={
+                    "chunk": output_text,
+                    "id": str(message_id),
+                },
+            )
+
         if not agent_message.text:
+            # Starts the timer when the first message is starting to be generated
             start_time = perf_counter()
     return agent_message, start_time
 
@@ -294,7 +336,7 @@ class ToolEventHandler(Protocol):
         event: dict[str, Any],
         agent_message: Message,
         tool_blocks_map: dict[str, ContentBlock],
-        send_message_method: SendMessageFunctionType,
+        send_message_callback: SendMessageFunctionType,
         start_time: float,
     ) -> tuple[Message, float]: ...
 
@@ -304,8 +346,12 @@ class ChainEventHandler(Protocol):
         self,
         event: dict[str, Any],
         agent_message: Message,
-        send_message_method: SendMessageFunctionType,
+        send_message_callback: SendMessageFunctionType,
+        send_token_callback: OnTokenFunctionType | None,
         start_time: float,
+        *,
+        had_streaming: bool = False,
+        message_id: str | None = None,
     ) -> tuple[Message, float]: ...
 
 
@@ -329,7 +375,8 @@ TOOL_EVENT_HANDLERS: dict[str, ToolEventHandler] = {
 async def process_agent_events(
     agent_executor: AsyncIterator[dict[str, Any]],
     agent_message: Message,
-    send_message_method: SendMessageFunctionType,
+    send_message_callback: SendMessageFunctionType,
+    send_token_callback: OnTokenFunctionType | None = None,
 ) -> Message:
     """Process agent events and return the final output."""
     if isinstance(agent_message.properties, dict):
@@ -337,26 +384,46 @@ async def process_agent_events(
     else:
         agent_message.properties.icon = "Bot"
         agent_message.properties.state = "partial"
-    # Store the initial message
-    agent_message = await send_message_method(message=agent_message)
+    # Store the initial message and capture the message id
+    agent_message = await send_message_callback(message=agent_message)
+    # Capture the original message id - this must stay consistent throughout if streaming
+    initial_message_id = agent_message.id
     try:
         # Create a mapping of run_ids to tool contents
         tool_blocks_map: dict[str, ToolContent] = {}
+        had_streaming = False
         start_time = perf_counter()
+
         async for event in agent_executor:
             if event["event"] in TOOL_EVENT_HANDLERS:
                 tool_handler = TOOL_EVENT_HANDLERS[event["event"]]
                 # Use skip_db_update=True during streaming to avoid DB round-trips
                 agent_message, start_time = await tool_handler(
-                    event, agent_message, tool_blocks_map, send_message_method, start_time
+                    event, agent_message, tool_blocks_map, send_message_callback, start_time
                 )
             elif event["event"] in CHAIN_EVENT_HANDLERS:
                 chain_handler = CHAIN_EVENT_HANDLERS[event["event"]]
-                # Use skip_db_update=True during streaming to avoid DB round-trips
-                agent_message, start_time = await chain_handler(event, agent_message, send_message_method, start_time)
+
+                # Check if this is a streaming event
+                if event["event"] in ("on_chain_stream", "on_chat_model_stream"):
+                    had_streaming = True
+                    agent_message, start_time = await chain_handler(
+                        event,
+                        agent_message,
+                        send_message_callback,
+                        send_token_callback,
+                        start_time,
+                        had_streaming=had_streaming,
+                        message_id=initial_message_id,
+                    )
+                else:
+                    agent_message, start_time = await chain_handler(
+                        event, agent_message, send_message_callback, None, start_time, had_streaming=had_streaming
+                    )
+
         agent_message.properties.state = "complete"
         # Final DB update with the complete message (skip_db_update=False by default)
-        agent_message = await send_message_method(message=agent_message)
+        agent_message = await send_message_callback(message=agent_message)
     except Exception as e:
         raise ExceptionWithMessageError(agent_message, str(e)) from e
     return await Message.create(**agent_message.model_dump())

lfx/components/models/embedding_model.py

@@ -31,7 +31,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
         DropdownInput(
             name="provider",
             display_name="Model Provider",
-            options=["OpenAI", "Ollama", "WatsonX"],
+            options=["OpenAI", "Ollama", "IBM watsonx.ai"],
             value="OpenAI",
             info="Select the embedding model provider",
             real_time_refresh=True,
@@ -62,7 +62,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
         MessageTextInput(
             name="project_id",
             display_name="Project ID",
-            info="Watson AI Project ID (required for WatsonX)",
+            info="IBM watsonx.ai Project ID (required for IBM watsonx.ai)",
             show=False,
         ),
         IntInput(
@@ -128,7 +128,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 **model_kwargs,
             )
 
-        if provider == "WatsonX":
+        if provider == "IBM watsonx.ai":
             try:
                 from langchain_ibm import WatsonxEmbeddings
             except ImportError:
@@ -136,13 +136,13 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 raise ImportError(msg) from None
 
             if not api_key:
-                msg = "Watson AI API key is required when using WatsonX provider"
+                msg = "IBM watsonx.ai API key is required when using IBM watsonx.ai provider"
                 raise ValueError(msg)
 
             project_id = self.project_id
 
             if not project_id:
-                msg = "Project ID is required for WatsonX"
+                msg = "Project ID is required for IBM watsonx.ai provider"
                 raise ValueError(msg)
 
             params = {
@@ -167,6 +167,7 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 build_config["api_key"]["required"] = True
                 build_config["api_key"]["show"] = True
                 build_config["api_base"]["display_name"] = "OpenAI API Base URL"
+                build_config["api_base"]["advanced"] = True
                 build_config["project_id"]["show"] = False
 
             elif field_value == "Ollama":
@@ -177,16 +178,18 @@ class EmbeddingModelComponent(LCEmbeddingsModel):
                 build_config["api_key"]["show"] = False
                 build_config["api_base"]["display_name"] = "Ollama Base URL"
                 build_config["api_base"]["value"] = "http://localhost:11434"
+                build_config["api_base"]["advanced"] = True
                 build_config["project_id"]["show"] = False
 
-            elif field_value == "WatsonX":
+            elif field_value == "IBM watsonx.ai":
                 build_config["model"]["options"] = WATSONX_EMBEDDING_MODEL_NAMES
                 build_config["model"]["value"] = WATSONX_EMBEDDING_MODEL_NAMES[0]
-                build_config["api_key"]["display_name"] = "Watson AI API Key"
+                build_config["api_key"]["display_name"] = "IBM watsonx.ai API Key"
                 build_config["api_key"]["required"] = True
                 build_config["api_key"]["show"] = True
-                build_config["api_base"]["display_name"] = "Watson AI URL"
+                build_config["api_base"]["display_name"] = "IBM watsonx.ai URL"
                 build_config["api_base"]["value"] = "https://us-south.ml.cloud.ibm.com"
+                build_config["api_base"]["advanced"] = False
                 build_config["project_id"]["show"] = True
 
         return build_config

{lfx_nightly-0.1.13.dev9.dist-info → lfx_nightly-0.1.13.dev11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.13.dev9
+Version: 0.1.13.dev11
 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.dev9.dist-info → lfx_nightly-0.1.13.dev11.dist-info}/RECORD

@@ -4,16 +4,16 @@ 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=G1dvQ4NRtFCXk3_Hgphhc3Ox-CC4uggtcQnKRy4_jGQ,3572328
+lfx/_assets/component_index.json,sha256=5u7MEm93Yt_-xBeIa5pRTGAor8cRFcUMetsV9O5Q2HY,3572648
 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
-lfx/base/agents/agent.py,sha256=RwUGi1GLua6VEt57Xks6cZygSd9MPoOddsa42FNaB_g,14108
+lfx/base/agents/agent.py,sha256=uKp5OSNxGbKa-fyZLfHl68f1ZntS49LFLNN49OGcnnY,15199
 lfx/base/agents/callback.py,sha256=mjlT9ukBMVrfjYrHsJowqpY4g9hVGBVBIYhncLWr3tQ,3692
 lfx/base/agents/context.py,sha256=u0wboX1aRR22Ia8gY14WF12RjhE0Rxv9hPBiixT9DtQ,3916
 lfx/base/agents/default_prompts.py,sha256=tUjfczwt4D5R1KozNOl1uSL2V2rSCZeUMS-cfV4Gwn0,955
 lfx/base/agents/errors.py,sha256=4QY1AqSWZaOjq-iQRYH_aeCfH_hWECLQkiwybNXz66U,531
-lfx/base/agents/events.py,sha256=jOhfGf_za5IYMvxRMvi1qqU0gw9b1imvDCOQP3r3wlo,14598
+lfx/base/agents/events.py,sha256=wk5sEsAkFbZxx_UUYYSvzWwocmAQZzfFlxKVAb_QSQ8,17170
 lfx/base/agents/utils.py,sha256=VEAVYC6oOadjKeZ-cUS-1OOCnWW69FhpcGWzjvR4uZ8,7161
 lfx/base/agents/crewai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/agents/crewai/crew.py,sha256=TN1JyLXMpJc2yPH3tokhFmxKKYoJ4lMvmG19DmpKfeY,7953
@@ -416,7 +416,7 @@ lfx/components/mistral/__init__.py,sha256=EABXqA45Tz50vZRmhEisbIIPEcRCvV9j-Y9Hf2
 lfx/components/mistral/mistral.py,sha256=4heAlIFEeq_ljUZDPpNGyK_VRkWjwCfPbBaQK1mV4NY,3718
 lfx/components/mistral/mistral_embeddings.py,sha256=QuqS_S3yHWCacs-Nc3qalpUsb-OACRWFZenUtCD_rLQ,1963
 lfx/components/models/__init__.py,sha256=hhfj70MkcRATzAjJnntAg1A4E7kHlQn8GT0bizkB7L4,1113
-lfx/components/models/embedding_model.py,sha256=Tk-P9K5DanE0YuXauWMW_nOi08rnAaspiqJHbNYjoeA,7543
+lfx/components/models/embedding_model.py,sha256=Q38BxC4xklLOAxS1Vam0EGP0g6cu0Dm7-uf679XImAc,7795
 lfx/components/models/language_model.py,sha256=TA24DMAXrlruY3mNsfI9qGltfQ2h9cQpxe8DW8HLdeE,5992
 lfx/components/mongodb/__init__.py,sha256=nFOQgiIvDnWGiWDSqZ0ERQme5DpA-cQgzybUiqXQtGw,953
 lfx/components/mongodb/mongodb_atlas.py,sha256=OlAstNMToHuvGI-8djkiGr7kdGBr927O0SE5cnVd0O0,8594
@@ -730,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.dev9.dist-info/METADATA,sha256=zT2mu9Kd1fxFLKHjFAbb27fdhn9i4defm2zEVhYw1Yc,8289
-lfx_nightly-0.1.13.dev9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.13.dev9.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.13.dev9.dist-info/RECORD,,
+lfx_nightly-0.1.13.dev11.dist-info/METADATA,sha256=dherVA7JNlTrOnZxoaISknodoQzPGMe-n4Q3Szv43bw,8290
+lfx_nightly-0.1.13.dev11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.13.dev11.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.13.dev11.dist-info/RECORD,,