lfx-nightly 0.1.12.dev32__py3-none-any.whl → 0.1.12.dev34__py3-none-any.whl

lfx/base/agents/events.py

@@ -80,7 +80,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)
+            agent_message = await send_message_method(message=agent_message, skip_db_update=True)
             start_time = perf_counter()
     return agent_message, start_time
 
@@ -151,7 +151,7 @@ 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)
+        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
         start_time = perf_counter()
     return agent_message, start_time
 
@@ -190,7 +190,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)
+    agent_message = await send_message_method(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
@@ -210,7 +210,7 @@ async def handle_on_tool_end(
 
     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)
+        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
         new_start_time = perf_counter()
 
         # Now find and update the tool content in the current message
@@ -258,7 +258,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)
+        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
         start_time = perf_counter()
     return agent_message, start_time
 
@@ -275,14 +275,14 @@ 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)
+        agent_message = await send_message_method(message=agent_message, skip_db_update=True)
         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)
+            agent_message = await send_message_method(message=agent_message, skip_db_update=True)
         if not agent_message.text:
             start_time = perf_counter()
     return agent_message, start_time
@@ -346,13 +346,17 @@ async def process_agent_events(
         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
                 )
             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)
         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)
     except Exception as e:
         raise ExceptionWithMessageError(agent_message, str(e)) from e
     return await Message.create(**agent_message.model_dump())

lfx/base/mcp/util.py

@@ -28,8 +28,12 @@ HTTP_ERROR_STATUS_CODE = httpx_codes.BAD_REQUEST  # HTTP status code for client
 
 # HTTP status codes used in validation
 HTTP_NOT_FOUND = 404
+HTTP_METHOD_NOT_ALLOWED = 405
+HTTP_NOT_ACCEPTABLE = 406
 HTTP_BAD_REQUEST = 400
 HTTP_INTERNAL_SERVER_ERROR = 500
+HTTP_UNAUTHORIZED = 401
+HTTP_FORBIDDEN = 403
 
 # MCP Session Manager constants
 settings = get_settings_service().settings
@@ -378,8 +382,8 @@ def _validate_node_installation(command: str) -> str:
 
 async def _validate_connection_params(mode: str, command: str | None = None, url: str | None = None) -> None:
     """Validate connection parameters based on mode."""
-    if mode not in ["Stdio", "SSE"]:
-        msg = f"Invalid mode: {mode}. Must be either 'Stdio' or 'SSE'"
+    if mode not in ["Stdio", "Streamable_HTTP", "SSE"]:
+        msg = f"Invalid mode: {mode}. Must be either 'Stdio', 'Streamable_HTTP', or 'SSE'"
         raise ValueError(msg)
 
     if mode == "Stdio" and not command:
@@ -387,8 +391,8 @@ async def _validate_connection_params(mode: str, command: str | None = None, url
         raise ValueError(msg)
     if mode == "Stdio" and command:
         _validate_node_installation(command)
-    if mode == "SSE" and not url:
-        msg = "URL is required for SSE mode"
+    if mode in ["Streamable_HTTP", "SSE"] and not url:
+        msg = f"URL is required for {mode} mode"
         raise ValueError(msg)
 
 
@@ -400,6 +404,7 @@ class MCPSessionManager:
     2. Maximum session limits per server to prevent resource exhaustion
     3. Idle timeout for automatic session cleanup
     4. Periodic cleanup of stale sessions
+    5. Transport preference caching to avoid retrying failed transports
     """
 
     def __init__(self):
@@ -410,6 +415,9 @@ class MCPSessionManager:
         self._context_to_session: dict[str, tuple[str, str]] = {}
         # Reference count for each active (server_key, session_id)
         self._session_refcount: dict[tuple[str, str], int] = {}
+        # Cache which transport works for each server to avoid retrying failed transports
+        # server_key -> "streamable_http" | "sse"
+        self._transport_preference: dict[str, str] = {}
         self._cleanup_task = None
         self._start_cleanup_task()
 
@@ -467,15 +475,16 @@ class MCPSessionManager:
                 env_str = str(sorted((connection_params.env or {}).items()))
                 key_input = f"{command_str}|{env_str}"
                 return f"stdio_{hash(key_input)}"
-        elif transport_type == "sse" and (isinstance(connection_params, dict) and "url" in connection_params):
+        elif transport_type == "streamable_http" and (
+            isinstance(connection_params, dict) and "url" in connection_params
+        ):
             # Include URL and headers for uniqueness
             url = connection_params["url"]
             headers = str(sorted((connection_params.get("headers", {})).items()))
             key_input = f"{url}|{headers}"
-            return f"sse_{hash(key_input)}"
+            return f"streamable_http_{hash(key_input)}"
 
         # Fallback to a generic key
-        # TODO: add option for streamable HTTP in future.
         return f"{transport_type}_{hash(str(connection_params))}"
 
     async def _validate_session_connectivity(self, session) -> bool:
@@ -525,7 +534,7 @@ class MCPSessionManager:
         """Get or create a session with improved reuse strategy.
 
         The key insight is that we should reuse sessions based on the server
-        identity (command + args for stdio, URL for SSE) rather than the context_id.
+        identity (command + args for stdio, URL for Streamable HTTP) rather than the context_id.
         This prevents creating a new subprocess for each unique context.
         """
         server_key = self._get_server_key(connection_params, transport_type)
@@ -578,17 +587,24 @@ class MCPSessionManager:
 
         if transport_type == "stdio":
             session, task = await self._create_stdio_session(session_id, connection_params)
-        elif transport_type == "sse":
-            session, task = await self._create_sse_session(session_id, connection_params)
+            actual_transport = "stdio"
+        elif transport_type == "streamable_http":
+            # Pass the cached transport preference if available
+            preferred_transport = self._transport_preference.get(server_key)
+            session, task, actual_transport = await self._create_streamable_http_session(
+                session_id, connection_params, preferred_transport
+            )
+            # Cache the transport that worked for future connections
+            self._transport_preference[server_key] = actual_transport
         else:
             msg = f"Unknown transport type: {transport_type}"
             raise ValueError(msg)
 
-        # Store session info
+        # Store session info with the actual transport used
         sessions[session_id] = {
             "session": session,
             "task": task,
-            "type": transport_type,
+            "type": actual_transport,
             "last_used": asyncio.get_event_loop().time(),
         }
 
@@ -634,9 +650,9 @@ class MCPSessionManager:
         self._background_tasks.add(task)
         task.add_done_callback(self._background_tasks.discard)
 
-        # Wait for session to be ready
+        # Wait for session to be ready (use longer timeout for remote connections)
         try:
-            session = await asyncio.wait_for(session_future, timeout=10.0)
+            session = await asyncio.wait_for(session_future, timeout=30.0)
         except asyncio.TimeoutError as timeout_err:
             # Clean up the failed task
             if not task.done():
@@ -652,50 +668,136 @@ class MCPSessionManager:
 
         return session, task
 
-    async def _create_sse_session(self, session_id: str, connection_params):
-        """Create a new SSE session as a background task to avoid context issues."""
+    async def _create_streamable_http_session(
+        self, session_id: str, connection_params, preferred_transport: str | None = None
+    ):
+        """Create a new Streamable HTTP session with SSE fallback as a background task to avoid context issues.
+
+        Args:
+            session_id: Unique identifier for this session
+            connection_params: Connection parameters including URL, headers, timeouts
+            preferred_transport: If set to "sse", skip Streamable HTTP and go directly to SSE
+
+        Returns:
+            tuple: (session, task, transport_used) where transport_used is "streamable_http" or "sse"
+        """
         import asyncio
 
         from mcp.client.sse import sse_client
+        from mcp.client.streamable_http import streamablehttp_client
 
         # Create a future to get the session
         session_future: asyncio.Future[ClientSession] = asyncio.Future()
+        # Track which transport succeeded
+        used_transport: list[str] = []
 
         async def session_task():
             """Background task that keeps the session alive."""
-            try:
-                async with sse_client(
-                    connection_params["url"],
-                    connection_params["headers"],
-                    connection_params["timeout_seconds"],
-                    connection_params["sse_read_timeout_seconds"],
-                ) as (read, write):
-                    session = ClientSession(read, write)
-                    async with session:
-                        await session.initialize()
-                        # Signal that session is ready
-                        session_future.set_result(session)
+            streamable_error = None
 
-                        # Keep the session alive until cancelled
-                        import anyio
+            # Skip Streamable HTTP if we know SSE works for this server
+            if preferred_transport != "sse":
+                # Try Streamable HTTP first with a quick timeout
+                try:
+                    await logger.adebug(f"Attempting Streamable HTTP connection for session {session_id}")
+                    # Use a shorter timeout for the initial connection attempt (2 seconds)
+                    async with streamablehttp_client(
+                        url=connection_params["url"],
+                        headers=connection_params["headers"],
+                        timeout=connection_params["timeout_seconds"],
+                    ) as (read, write, _):
+                        session = ClientSession(read, write)
+                        async with session:
+                            # Initialize with a timeout to fail fast
+                            await asyncio.wait_for(session.initialize(), timeout=2.0)
+                            used_transport.append("streamable_http")
+                            await logger.ainfo(f"Session {session_id} connected via Streamable HTTP")
+                            # Signal that session is ready
+                            session_future.set_result(session)
+
+                            # Keep the session alive until cancelled
+                            import anyio
+
+                            event = anyio.Event()
+                            try:
+                                await event.wait()
+                            except asyncio.CancelledError:
+                                await logger.ainfo(f"Session {session_id} (Streamable HTTP) is shutting down")
+                except (asyncio.TimeoutError, Exception) as e:  # noqa: BLE001
+                    # If Streamable HTTP fails or times out, try SSE as fallback immediately
+                    streamable_error = e
+                    error_type = "timed out" if isinstance(e, asyncio.TimeoutError) else "failed"
+                    await logger.awarning(
+                        f"Streamable HTTP {error_type} for session {session_id}: {e}. Falling back to SSE..."
+                    )
+            else:
+                await logger.adebug(f"Skipping Streamable HTTP for session {session_id}, using cached SSE preference")
 
-                        event = anyio.Event()
-                        try:
-                            await event.wait()
-                        except asyncio.CancelledError:
-                            await logger.ainfo(f"Session {session_id} is shutting down")
-            except Exception as e:  # noqa: BLE001
-                if not session_future.done():
-                    session_future.set_exception(e)
+            # Try SSE if Streamable HTTP failed or if SSE is preferred
+            if streamable_error is not None or preferred_transport == "sse":
+                try:
+                    await logger.adebug(f"Attempting SSE connection for session {session_id}")
+                    # Extract SSE read timeout from connection params, default to 30s if not present
+                    sse_read_timeout = connection_params.get("sse_read_timeout_seconds", 30)
+
+                    async with sse_client(
+                        connection_params["url"],
+                        connection_params["headers"],
+                        connection_params["timeout_seconds"],
+                        sse_read_timeout,
+                    ) as (read, write):
+                        session = ClientSession(read, write)
+                        async with session:
+                            await session.initialize()
+                            used_transport.append("sse")
+                            fallback_msg = " (fallback)" if streamable_error else " (preferred)"
+                            await logger.ainfo(f"Session {session_id} connected via SSE{fallback_msg}")
+                            # Signal that session is ready
+                            if not session_future.done():
+                                session_future.set_result(session)
+
+                            # Keep the session alive until cancelled
+                            import anyio
+
+                            event = anyio.Event()
+                            try:
+                                await event.wait()
+                            except asyncio.CancelledError:
+                                await logger.ainfo(f"Session {session_id} (SSE) is shutting down")
+                except Exception as sse_error:  # noqa: BLE001
+                    # Both transports failed (or just SSE if it was preferred)
+                    if streamable_error:
+                        await logger.aerror(
+                            f"Both Streamable HTTP and SSE failed for session {session_id}. "
+                            f"Streamable HTTP error: {streamable_error}. SSE error: {sse_error}"
+                        )
+                        if not session_future.done():
+                            session_future.set_exception(
+                                ValueError(
+                                    f"Failed to connect via Streamable HTTP ({streamable_error}) or SSE ({sse_error})"
+                                )
+                            )
+                    else:
+                        await logger.aerror(f"SSE connection failed for session {session_id}: {sse_error}")
+                        if not session_future.done():
+                            session_future.set_exception(ValueError(f"Failed to connect via SSE: {sse_error}"))
 
         # Start the background task
         task = asyncio.create_task(session_task())
         self._background_tasks.add(task)
         task.add_done_callback(self._background_tasks.discard)
 
-        # Wait for session to be ready
+        # Wait for session to be ready (use longer timeout for remote connections)
         try:
-            session = await asyncio.wait_for(session_future, timeout=10.0)
+            session = await asyncio.wait_for(session_future, timeout=30.0)
+            # Log which transport was used
+            if used_transport:
+                transport_used = used_transport[0]
+                await logger.ainfo(f"Session {session_id} successfully established using {transport_used}")
+                return session, task, transport_used
+            # This shouldn't happen, but handle it just in case
+            msg = f"Session {session_id} established but transport not recorded"
+            raise ValueError(msg)
         except asyncio.TimeoutError as timeout_err:
             # Clean up the failed task
             if not task.done():
@@ -705,12 +807,10 @@ class MCPSessionManager:
                 with contextlib.suppress(asyncio.CancelledError):
                     await task
             self._background_tasks.discard(task)
-            msg = f"Timeout waiting for SSE session {session_id} to initialize"
+            msg = f"Timeout waiting for Streamable HTTP/SSE session {session_id} to initialize"
             await logger.aerror(msg)
             raise ValueError(msg) from timeout_err
 
-        return session, task
-
     async def _cleanup_session_by_id(self, server_key: str, session_id: str):
         """Clean up a specific session by server key and session ID."""
         if server_key not in self.sessions_by_server:
@@ -1056,7 +1156,7 @@ class MCPStdioClient:
         await self.disconnect()
 
 
-class MCPSseClient:
+class MCPStreamableHttpClient:
     def __init__(self, component_cache=None):
         self.session: ClientSession | None = None
         self._connection_params = None
@@ -1080,67 +1180,15 @@ class MCPSseClient:
             self._component_cache.set("mcp_session_manager", session_manager)
         return session_manager
 
-    async def validate_url(self, url: str | None, headers: dict[str, str] | None = None) -> tuple[bool, str]:
-        """Validate the SSE URL before attempting connection."""
+    async def validate_url(self, url: str | None) -> tuple[bool, str]:
+        """Validate the Streamable HTTP URL before attempting connection."""
         try:
             parsed = urlparse(url)
             if not parsed.scheme or not parsed.netloc:
                 return False, "Invalid URL format. Must include scheme (http/https) and host."
-
-            async with httpx.AsyncClient() as client:
-                try:
-                    # For SSE endpoints, try a GET request with short timeout
-                    # Many SSE servers don't support HEAD requests and return 404
-                    response = await client.get(
-                        url, timeout=2.0, headers={"Accept": "text/event-stream", **(headers or {})}
-                    )
-
-                    # For SSE, we expect the server to either:
-                    # 1. Start streaming (200)
-                    # 2. Return 404 if HEAD/GET without proper SSE handshake is not supported
-                    # 3. Return other status codes that we should handle gracefully
-
-                    # Don't fail on 404 since many SSE endpoints return this for non-SSE requests
-                    if response.status_code == HTTP_NOT_FOUND:
-                        # This is likely an SSE endpoint that doesn't support regular GET
-                        # Let the actual SSE connection attempt handle this
-                        return True, ""
-
-                    # Fail on client errors except 404, but allow server errors and redirects
-                    if (
-                        HTTP_BAD_REQUEST <= response.status_code < HTTP_INTERNAL_SERVER_ERROR
-                        and response.status_code != HTTP_NOT_FOUND
-                    ):
-                        return False, f"Server returned client error status: {response.status_code}"
-
-                except httpx.TimeoutException:
-                    # Timeout on a short request might indicate the server is trying to stream
-                    # This is actually expected behavior for SSE endpoints
-                    return True, ""
-                except httpx.NetworkError:
-                    return False, "Network error. Could not reach the server."
-                else:
-                    return True, ""
-
-        except (httpx.HTTPError, ValueError, OSError) as e:
+        except (ValueError, OSError) as e:
             return False, f"URL validation error: {e!s}"
-
-    async def pre_check_redirect(self, url: str | None, headers: dict[str, str] | None = None) -> str | None:
-        """Check for redirects and return the final URL."""
-        if url is None:
-            return url
-        try:
-            async with httpx.AsyncClient(follow_redirects=False) as client:
-                # Use GET with SSE headers instead of HEAD since many SSE servers don't support HEAD
-                response = await client.get(
-                    url, timeout=2.0, headers={"Accept": "text/event-stream", **(headers or {})}
-                )
-                if response.status_code == httpx.codes.TEMPORARY_REDIRECT:
-                    return response.headers.get("Location", url)
-                # Don't treat 404 as an error here - let the main connection handle it
-        except (httpx.RequestError, httpx.HTTPError) as e:
-            await logger.awarning(f"Error checking redirects: {e}")
-        return url
+        return True, ""
 
     async def _connect_to_server(
         self,
@@ -1149,27 +1197,31 @@ class MCPSseClient:
         timeout_seconds: int = 30,
         sse_read_timeout_seconds: int = 30,
     ) -> list[StructuredTool]:
-        """Connect to MCP server using SSE transport (SDK style)."""
+        """Connect to MCP server using Streamable HTTP transport with SSE fallback (SDK style)."""
         # Validate and sanitize headers early
         validated_headers = _process_headers(headers)
 
         if url is None:
-            msg = "URL is required for SSE mode"
+            msg = "URL is required for StreamableHTTP or SSE mode"
             raise ValueError(msg)
-        is_valid, error_msg = await self.validate_url(url, validated_headers)
-        if not is_valid:
-            msg = f"Invalid SSE URL ({url}): {error_msg}"
-            raise ValueError(msg)
-
-        url = await self.pre_check_redirect(url, validated_headers)
 
-        # Store connection parameters for later use in run_tool
-        self._connection_params = {
-            "url": url,
-            "headers": validated_headers,
-            "timeout_seconds": timeout_seconds,
-            "sse_read_timeout_seconds": sse_read_timeout_seconds,
-        }
+        # Only validate URL if we don't have a cached session
+        # This avoids expensive HTTP validation calls when reusing sessions
+        if not self._connected or not self._connection_params:
+            is_valid, error_msg = await self.validate_url(url)
+            if not is_valid:
+                msg = f"Invalid Streamable HTTP or SSE URL ({url}): {error_msg}"
+                raise ValueError(msg)
+            # Store connection parameters for later use in run_tool
+            # Include SSE read timeout for fallback
+            self._connection_params = {
+                "url": url,
+                "headers": validated_headers,
+                "timeout_seconds": timeout_seconds,
+                "sse_read_timeout_seconds": sse_read_timeout_seconds,
+            }
+        elif headers:
+            self._connection_params["headers"] = validated_headers
 
         # If no session context is set, create a default one
         if not self._session_context:
@@ -1177,18 +1229,21 @@ class MCPSseClient:
             import uuid
 
             param_hash = uuid.uuid4().hex[:8]
-            self._session_context = f"default_sse_{param_hash}"
+            self._session_context = f"default_http_{param_hash}"
 
-        # Get or create a persistent session
+        # Get or create a persistent session (will try Streamable HTTP, then SSE fallback)
         session = await self._get_or_create_session()
         response = await session.list_tools()
         self._connected = True
         return response.tools
 
-    async def connect_to_server(self, url: str, headers: dict[str, str] | None = None) -> list[StructuredTool]:
-        """Connect to MCP server using SSE transport (SDK style)."""
+    async def connect_to_server(
+        self, url: str, headers: dict[str, str] | None = None, sse_read_timeout_seconds: int = 30
+    ) -> list[StructuredTool]:
+        """Connect to MCP server using Streamable HTTP with SSE fallback transport (SDK style)."""
         return await asyncio.wait_for(
-            self._connect_to_server(url, headers), timeout=get_settings_service().settings.mcp_server_timeout
+            self._connect_to_server(url, headers, sse_read_timeout_seconds=sse_read_timeout_seconds),
+            timeout=get_settings_service().settings.mcp_server_timeout,
         )
 
     def set_session_context(self, context_id: str):
@@ -1204,12 +1259,14 @@ class MCPSseClient:
         # Use cached session manager to get/create persistent session
         session_manager = self._get_session_manager()
         # Cache session so we can access server-assigned session_id later for DELETE
-        self.session = await session_manager.get_session(self._session_context, self._connection_params, "sse")
+        self.session = await session_manager.get_session(
+            self._session_context, self._connection_params, "streamable_http"
+        )
         return self.session
 
     async def _terminate_remote_session(self) -> None:
         """Attempt to explicitly terminate the remote MCP session via HTTP DELETE (best-effort)."""
-        # Only relevant for SSE transport
+        # Only relevant for Streamable HTTP or SSE transport
         if not self._connection_params or "url" not in self._connection_params:
             return
 
@@ -1255,7 +1312,7 @@ class MCPSseClient:
             import uuid
 
             param_hash = uuid.uuid4().hex[:8]
-            self._session_context = f"default_sse_{param_hash}"
+            self._session_context = f"default_http_{param_hash}"
 
         max_retries = 2
         last_error_type = None
@@ -1326,7 +1383,7 @@ class MCPSseClient:
                     await logger.aerror(msg)
                     # Clean up failed session from cache
                     if self._session_context and self._component_cache:
-                        cache_key = f"mcp_session_sse_{self._session_context}"
+                        cache_key = f"mcp_session_http_{self._session_context}"
                         self._component_cache.delete(cache_key)
                     self._connected = False
                     raise ValueError(msg) from e
@@ -1364,11 +1421,17 @@ class MCPSseClient:
         await self.disconnect()
 
 
+# Backward compatibility: MCPSseClient is now an alias for MCPStreamableHttpClient
+# The new client supports both Streamable HTTP and SSE with automatic fallback
+MCPSseClient = MCPStreamableHttpClient
+
+
 async def update_tools(
     server_name: str,
     server_config: dict,
     mcp_stdio_client: MCPStdioClient | None = None,
-    mcp_sse_client: MCPSseClient | None = None,
+    mcp_streamable_http_client: MCPStreamableHttpClient | None = None,
+    mcp_sse_client: MCPStreamableHttpClient | None = None,  # Backward compatibility
 ) -> tuple[str, list[StructuredTool], dict[str, StructuredTool]]:
     """Fetch server config and update available tools."""
     if server_config is None:
@@ -1377,11 +1440,17 @@ async def update_tools(
         return "", [], {}
     if mcp_stdio_client is None:
         mcp_stdio_client = MCPStdioClient()
-    if mcp_sse_client is None:
-        mcp_sse_client = MCPSseClient()
+
+    # Backward compatibility: accept mcp_sse_client parameter
+    if mcp_streamable_http_client is None:
+        mcp_streamable_http_client = mcp_sse_client if mcp_sse_client is not None else MCPStreamableHttpClient()
 
     # Fetch server config from backend
-    mode = "Stdio" if "command" in server_config else "SSE" if "url" in server_config else ""
+    # Determine mode from config, defaulting to Streamable_HTTP if URL present
+    mode = server_config.get("mode", "")
+    if not mode:
+        mode = "Stdio" if "command" in server_config else "Streamable_HTTP" if "url" in server_config else ""
+
     command = server_config.get("command", "")
     url = server_config.get("url", "")
     tools = []
@@ -1394,7 +1463,7 @@ async def update_tools(
         raise
 
     # Determine connection type and parameters
-    client: MCPStdioClient | MCPSseClient | None = None
+    client: MCPStdioClient | MCPStreamableHttpClient | None = None
     if mode == "Stdio":
         # Stdio connection
         args = server_config.get("args", [])
@@ -1402,10 +1471,10 @@ async def update_tools(
         full_command = " ".join([command, *args])
         tools = await mcp_stdio_client.connect_to_server(full_command, env)
         client = mcp_stdio_client
-    elif mode == "SSE":
-        # SSE connection
-        tools = await mcp_sse_client.connect_to_server(url, headers=headers)
-        client = mcp_sse_client
+    elif mode in ["Streamable_HTTP", "SSE"]:
+        # Streamable HTTP connection with SSE fallback
+        tools = await mcp_streamable_http_client.connect_to_server(url, headers=headers)
+        client = mcp_streamable_http_client
     else:
         logger.error(f"Invalid MCP server mode for '{server_name}': {mode}")
         return "", [], {}

lfx/base/models/model.py

@@ -229,7 +229,7 @@ class LCModelComponent(Component):
                             system_message_added = True
                         runnable = prompt | runnable
                     else:
-                        messages.append(input_value.to_lc_message())
+                        messages.append(input_value.to_lc_message(self.name))
             else:
                 messages.append(HumanMessage(content=input_value))
 

lfx/components/agents/mcp_component.py

@@ -7,7 +7,12 @@ from typing import Any
 from langchain_core.tools import StructuredTool  # noqa: TC002
 
 from lfx.base.agents.utils import maybe_unflatten_dict, safe_cache_get, safe_cache_set
-from lfx.base.mcp.util import MCPSseClient, MCPStdioClient, create_input_schema_from_json_schema, update_tools
+from lfx.base.mcp.util import (
+    MCPStdioClient,
+    MCPStreamableHttpClient,
+    create_input_schema_from_json_schema,
+    update_tools,
+)
 from lfx.custom.custom_component.component_with_cache import ComponentWithCache
 from lfx.inputs.inputs import InputTypes  # noqa: TC001
 from lfx.io import BoolInput, DropdownInput, McpInput, MessageTextInput, Output
@@ -32,7 +37,9 @@ class MCPToolsComponent(ComponentWithCache):
 
         # Initialize clients with access to the component cache
         self.stdio_client: MCPStdioClient = MCPStdioClient(component_cache=self._shared_component_cache)
-        self.sse_client: MCPSseClient = MCPSseClient(component_cache=self._shared_component_cache)
+        self.streamable_http_client: MCPStreamableHttpClient = MCPStreamableHttpClient(
+            component_cache=self._shared_component_cache
+        )
 
     def _ensure_cache_structure(self):
         """Ensure the cache has the required structure."""
@@ -207,7 +214,7 @@ class MCPToolsComponent(ComponentWithCache):
                 server_name=server_name,
                 server_config=server_config,
                 mcp_stdio_client=self.stdio_client,
-                mcp_sse_client=self.sse_client,
+                mcp_streamable_http_client=self.streamable_http_client,
             )
 
             self.tool_names = [tool.name for tool in tool_list if hasattr(tool, "name")]
@@ -496,7 +503,7 @@ class MCPToolsComponent(ComponentWithCache):
                 session_context = self._get_session_context()
                 if session_context:
                     self.stdio_client.set_session_context(session_context)
-                    self.sse_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]

lfx/components/nvidia/nvidia.py

@@ -24,11 +24,8 @@ class NVIDIAModelComponent(LCModelComponent):
     except ImportError as e:
         msg = "Please install langchain-nvidia-ai-endpoints to use the NVIDIA model."
         raise ImportError(msg) from e
-    except Exception:  # noqa: BLE001
-        logger.warning(
-            "Failed to connect to NVIDIA API. Model list may be unavailable."
-            " Please check your internet connection and API credentials."
-        )
+    except Exception as e:  # noqa: BLE001
+        logger.warning(f"Failed to fetch NVIDIA models during initialization: {e}. Model list will be unavailable.")
         all_models = []
 
     inputs = [

lfx/components/ollama/ollama.py

@@ -32,8 +32,8 @@ class ChatOllamaComponent(LCModelComponent):
         MessageTextInput(
             name="base_url",
             display_name="Base URL",
-            info="Endpoint of the Ollama API.",
-            value="",
+            info="Endpoint of the Ollama API. Defaults to http://localhost:11434 .",
+            value="http://localhost:11434",
             real_time_refresh=True,
         ),
         DropdownInput(
@@ -157,6 +157,18 @@ class ChatOllamaComponent(LCModelComponent):
             mirostat_tau = self.mirostat_tau
 
         transformed_base_url = transform_localhost_url(self.base_url)
+
+        # Check if URL contains /v1 suffix (OpenAI-compatible mode)
+        if transformed_base_url and transformed_base_url.rstrip("/").endswith("/v1"):
+            # Strip /v1 suffix and log warning
+            transformed_base_url = transformed_base_url.rstrip("/").removesuffix("/v1")
+            logger.warning(
+                "Detected '/v1' suffix in base URL. The Ollama component uses the native Ollama API, "
+                "not the OpenAI-compatible API. The '/v1' suffix has been automatically removed. "
+                "If you want to use the OpenAI-compatible API, please use the OpenAI component instead. "
+                "Learn more at https://docs.ollama.com/openai#openai-compatibility"
+            )
+
         # Mapping system settings to their corresponding values
         llm_params = {
             "base_url": transformed_base_url,
@@ -190,8 +202,8 @@ class ChatOllamaComponent(LCModelComponent):
             output = ChatOllama(**llm_params)
         except Exception as e:
             msg = (
-                "Unable to connect to the Ollama API. ",
-                "Please verify the base URL, ensure the relevant Ollama model is pulled, and try again.",
+                "Unable to connect to the Ollama API. "
+                "Please verify the base URL, ensure the relevant Ollama model is pulled, and try again."
             )
             raise ValueError(msg) from e
 
@@ -201,6 +213,12 @@ class ChatOllamaComponent(LCModelComponent):
         try:
             async with httpx.AsyncClient() as client:
                 url = transform_localhost_url(url)
+                if not url:
+                    return False
+                # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+                url = url.rstrip("/").removesuffix("/v1")
+                if not url.endswith("/"):
+                    url = url + "/"
                 return (await client.get(urljoin(url, "api/tags"))).status_code == HTTP_STATUS_OK
         except httpx.RequestError:
             return False
@@ -224,9 +242,6 @@ class ChatOllamaComponent(LCModelComponent):
                     build_config["mirostat_eta"]["value"] = 0.1
                     build_config["mirostat_tau"]["value"] = 5
 
-        if field_name in {"base_url", "model_name"} and not await self.is_valid_ollama_url(self.base_url):
-            msg = "Ollama is not running on the provided base URL. Please start Ollama and try again."
-            raise ValueError(msg)
         if field_name in {"model_name", "base_url", "tool_model_enabled"}:
             if await self.is_valid_ollama_url(self.base_url):
                 tool_model_enabled = build_config["tool_model_enabled"].get("value", False) or self.tool_model_enabled
@@ -264,8 +279,10 @@ class ChatOllamaComponent(LCModelComponent):
                 names cannot be retrieved.
         """
         try:
-            # Normalize the base URL to avoid the repeated "/" at the end
-            base_url = base_url_value.rstrip("/") + "/"
+            # Strip /v1 suffix if present, as Ollama API endpoints are at root level
+            base_url = base_url_value.rstrip("/").removesuffix("/v1")
+            if not base_url.endswith("/"):
+                base_url = base_url + "/"
             base_url = transform_localhost_url(base_url)
 
             # Ollama REST API to return models

lfx/custom/custom_component/component.py

@@ -1548,7 +1548,16 @@ class Component(CustomComponent):
         if not message.sender_name:
             message.sender_name = MESSAGE_SENDER_NAME_AI
 
-    async def send_message(self, message: Message, id_: str | None = None):
+    async def send_message(self, message: Message, id_: str | None = None, *, skip_db_update: bool = False):
+        """Send a message with optional database update control.
+
+        Args:
+            message: The message to send
+            id_: Optional message ID
+            skip_db_update: If True, only update in-memory and send event, skip DB write.
+                           Useful during streaming to avoid excessive DB round-trips.
+                           Note: This assumes the message already exists in the database with message.id set.
+        """
         if self._should_skip_message(message):
             return message
 
@@ -1558,26 +1567,37 @@ class Component(CustomComponent):
         # Ensure required fields for message storage are set
         self._ensure_message_required_fields(message)
 
-        stored_message = await self._store_message(message)
+        # If skip_db_update is True and message already has an ID, skip the DB write
+        # This path is used during agent streaming to avoid excessive DB round-trips
+        if skip_db_update and message.id:
+            # Create a fresh Message instance for consistency with normal flow
+            stored_message = await Message.create(**message.model_dump())
+            self._stored_message_id = stored_message.id
+            # Still send the event to update the client in real-time
+            # Note: If this fails, we don't need DB cleanup since we didn't write to DB
+            await self._send_message_event(stored_message, id_=id_)
+        else:
+            # Normal flow: store/update in database
+            stored_message = await self._store_message(message)
 
-        self._stored_message_id = stored_message.id
-        try:
-            complete_message = ""
-            if (
-                self._should_stream_message(stored_message, message)
-                and message is not None
-                and isinstance(message.text, AsyncIterator | Iterator)
-            ):
-                complete_message = await self._stream_message(message.text, stored_message)
-                stored_message.text = complete_message
-                stored_message = await self._update_stored_message(stored_message)
-            else:
-                # Only send message event for non-streaming messages
-                await self._send_message_event(stored_message, id_=id_)
-        except Exception:
-            # remove the message from the database
-            await delete_message(stored_message.id)
-            raise
+            self._stored_message_id = stored_message.id
+            try:
+                complete_message = ""
+                if (
+                    self._should_stream_message(stored_message, message)
+                    and message is not None
+                    and isinstance(message.text, AsyncIterator | Iterator)
+                ):
+                    complete_message = await self._stream_message(message.text, stored_message)
+                    stored_message.text = complete_message
+                    stored_message = await self._update_stored_message(stored_message)
+                else:
+                    # Only send message event for non-streaming messages
+                    await self._send_message_event(stored_message, id_=id_)
+            except Exception:
+                # remove the message from the database
+                await delete_message(stored_message.id)
+                raise
         self.status = stored_message
         return stored_message
 

lfx/interface/components.py

@@ -95,8 +95,10 @@ def _process_single_module(modname: str) -> tuple[str, dict] | None:
     """
     try:
         module = importlib.import_module(modname)
-    except (ImportError, AttributeError) as e:
-        logger.error(f"Error importing module {modname}: {e}", exc_info=True)
+    except Exception as e:  # noqa: BLE001
+        # Catch all exceptions during import to prevent component failures from crashing startup
+        # TODO: Surface these errors to the UI in a friendly manner
+        logger.error(f"Failed to import module {modname}: {e}", exc_info=True)
         return None
     # Extract the top-level subpackage name after "langflow.components."
     # e.g., "langflow.components.Notion.add_content_to_page" -> "Notion"

lfx/schema/log.py

@@ -34,6 +34,7 @@ class SendMessageFunctionType(Protocol):
         id_: str | None = None,
         *,
         allow_markdown: bool = True,
+        skip_db_update: bool = False,
     ) -> Message: ...
 
 

lfx/schema/message.py

@@ -121,9 +121,13 @@ class Message(Data):
 
     def to_lc_message(
         self,
+        model_name: str | None = None,
     ) -> BaseMessage:
         """Converts the Data to a BaseMessage.
 
+        Args:
+            model_name: The model name to use for conversion. Optional.
+
         Returns:
             BaseMessage: The converted BaseMessage.
         """
@@ -139,7 +143,7 @@ class Message(Data):
         if self.sender == MESSAGE_SENDER_USER or not self.sender:
             if self.files:
                 contents = [{"type": "text", "text": text}]
-                file_contents = self.get_file_content_dicts()
+                file_contents = self.get_file_content_dicts(model_name)
                 contents.extend(file_contents)
                 human_message = HumanMessage(content=contents)
             else:
@@ -197,7 +201,7 @@ class Message(Data):
         return value
 
     # Keep this async method for backwards compatibility
-    def get_file_content_dicts(self):
+    def get_file_content_dicts(self, model_name: str | None = None):
         content_dicts = []
         try:
             files = get_file_paths(self.files)
@@ -209,7 +213,7 @@ class Message(Data):
             if isinstance(file, Image):
                 content_dicts.append(file.to_content_dict())
             else:
-                content_dicts.append(create_image_content_dict(file))
+                content_dicts.append(create_image_content_dict(file, None, model_name))
         return content_dicts
 
     def load_lc_prompt(self):

lfx/utils/image.py

@@ -56,12 +56,15 @@ def create_data_url(image_path: str | Path, mime_type: str | None = None) -> str
 
 
 @lru_cache(maxsize=50)
-def create_image_content_dict(image_path: str | Path, mime_type: str | None = None) -> dict:
+def create_image_content_dict(
+    image_path: str | Path, mime_type: str | None = None, model_name: str | None = None
+) -> dict:
     """Create a content dictionary for multimodal inputs from an image file.
 
     Args:
         image_path: Path to the image file
         mime_type: MIME type of the image. If None, will be auto-detected
+        model_name: Optional model parameter to determine content dict structure
 
     Returns:
         Content dictionary with type and image_url fields
@@ -70,4 +73,7 @@ def create_image_content_dict(image_path: str | Path, mime_type: str | None = No
         FileNotFoundError: If the image file doesn't exist
     """
     data_url = create_data_url(image_path, mime_type)
+
+    if model_name == "OllamaModel":
+        return {"type": "image_url", "source_type": "url", "image_url": data_url}
     return {"type": "image", "source_type": "url", "url": data_url}

{lfx_nightly-0.1.12.dev32.dist-info → lfx_nightly-0.1.12.dev34.dist-info}/METADATA

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

@@ -12,7 +12,7 @@ lfx/base/agents/callback.py,sha256=mjlT9ukBMVrfjYrHsJowqpY4g9hVGBVBIYhncLWr3tQ,3
 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=oMIrTi6-5AhL_NBY3XSH24Yt1adjDBXgSPeIaedSEIQ,14126
+lfx/base/agents/events.py,sha256=jOhfGf_za5IYMvxRMvi1qqU0gw9b1imvDCOQP3r3wlo,14598
 lfx/base/agents/utils.py,sha256=OcmtZx4BTFTyq2A3rta3WoJn98UzEYdEXoRLs8-mTVo,6511
 lfx/base/agents/crewai/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/agents/crewai/crew.py,sha256=TN1JyLXMpJc2yPH3tokhFmxKKYoJ4lMvmG19DmpKfeY,7953
@@ -52,7 +52,7 @@ lfx/base/langwatch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuF
 lfx/base/langwatch/utils.py,sha256=N7rH3sRwgmNQzG0pKjj4wr_ans_drwtvkx4BQt-B0WA,457
 lfx/base/mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/mcp/constants.py,sha256=-1XnJxejlqm9zs1R91qGtOeX-_F1ZpdHVzCIqUCvhgE,62
-lfx/base/mcp/util.py,sha256=RbsZ8HPuN04aTNaGUgojHCUaMVWos_rhOP554wv4Fg0,64603
+lfx/base/mcp/util.py,sha256=rHi-wC8tuUWCiI65AylJNE7dmO59K71R_W-ruN3MO50,69164
 lfx/base/memory/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/base/memory/memory.py,sha256=kZ-aZoHvRW4PJAgY1LUt5UBj7YXbos_aVBPGjC1EFCY,1835
 lfx/base/memory/model.py,sha256=2oDORZV_l-DHLx9j9--wYprQUIYKOb8aTJpXmR1qOLw,1330
@@ -63,7 +63,7 @@ lfx/base/models/aws_constants.py,sha256=-Fa7T3wJqBaZhs80ATRgZP6yZ0Nsd1YYdZv9SfqT
 lfx/base/models/chat_result.py,sha256=-MypS6_GKXOqWevtk0xwtrsEO4mIgpPAt7-EML5n0vA,2756
 lfx/base/models/google_generative_ai_constants.py,sha256=EuFd77ZrrSr6YtSKtmEaq0Nfa4y45AbDe_cz_18nReE,2564
 lfx/base/models/groq_constants.py,sha256=WOMpYRwJVrZavsi7zGJwRHJX8ZBvdtILUOmBFv0QIPQ,5536
-lfx/base/models/model.py,sha256=Z-qAzfzQoGILvskF60fIvjfiwPq27OtHSVHDTPNwbHE,15315
+lfx/base/models/model.py,sha256=nJgExAvMJ5WMxCqC__Jc1GdkgJag4yrwC9nFtPEVupM,15324
 lfx/base/models/model_input_constants.py,sha256=WrnkAmMTk4cMjjLgBzRffJDzow7LWRpfc5GsgdRxvU4,10748
 lfx/base/models/model_metadata.py,sha256=tNFPiRqBJ0WPKdNEqBxuoKk0n8H_h0J--bCV5pk9k4o,1325
 lfx/base/models/model_utils.py,sha256=RwXUSIw5gdRakQ-VGbLI1iT0CeeWrVSNTgUQIrrc6uE,474
@@ -111,7 +111,7 @@ lfx/components/agentql/__init__.py,sha256=Erl669Dzsk-SegsDPWTtkKbprMXVuv8UTCo5RE
 lfx/components/agentql/agentql_api.py,sha256=N94yEK7ZuQCIsFBlr_8dqrJY-K1-KNb6QEEYfDIsDME,5569
 lfx/components/agents/__init__.py,sha256=u1PH9Ui0dUgTdTZVP7cdVysCv4extdusKS_brcbE7Eg,1049
 lfx/components/agents/agent.py,sha256=gUZ5RTgf_6G8Yi6QnQRuC4qn1rh2eeIF9MHQL8G-D3k,26592
-lfx/components/agents/mcp_component.py,sha256=dW0eENDKz8esIShOooDEL48r3J3GoI1h0tuqIPLSnR4,25462
+lfx/components/agents/mcp_component.py,sha256=mE2HvbHcdkuWWylxmaNNZobbtgBRktOOakeGwUYs7Qs,25586
 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
@@ -400,7 +400,7 @@ lfx/components/notdiamond/notdiamond.py,sha256=om6_UB9n5rt1T-yXxgMFBPBEP2tJtnGC2
 lfx/components/novita/__init__.py,sha256=i8RrVPX00S3RupAlZ078-mdGB7VHwvpdnL7IfsWWPIo,937
 lfx/components/novita/novita.py,sha256=IULE3StkQwECxOR3HMJsEyE7cN5hwslxovvhMmquuNo,4368
 lfx/components/nvidia/__init__.py,sha256=Phf45VUW7An5LnauqpB-lIRVwwBiQawZkoWbqBjQnWE,1756
-lfx/components/nvidia/nvidia.py,sha256=Z5EomVSAzV_fqtgSKw4kO2ko59IIoXiQat8cgfpTlks,6180
+lfx/components/nvidia/nvidia.py,sha256=Ej8WbpJD5fWAtFsMa4qUiK1Xu6igL6SQYwM0hk5mPGo,6116
 lfx/components/nvidia/nvidia_embedding.py,sha256=D97QOAgtZEzwHvBmDDShTmZhDAyN2SRbfb71515ib-g,2658
 lfx/components/nvidia/nvidia_ingest.py,sha256=_wxmYNmRQ2kBfAxaXLykBIlKFXVGXEsTY22spVeoCCI,12065
 lfx/components/nvidia/nvidia_rerank.py,sha256=zzl2skHxf2oXINDZBmG8-GbkTkc6EWtyMjyV8pVRAm4,2293
@@ -408,7 +408,7 @@ lfx/components/nvidia/system_assist.py,sha256=G8cgsLQxRBBnUt49_Uzxt7cdTNplVAzUlD
 lfx/components/olivya/__init__.py,sha256=ilZR88huL3vnQHO27g4jsUkyIYSgN7RPOq8Corbi6xA,67
 lfx/components/olivya/olivya.py,sha256=PDmsn8dBdSwAZUM2QGTyTwxGWsINCKaYR4yTjE-4lIQ,4192
 lfx/components/ollama/__init__.py,sha256=fau8QcWs_eHO2MmtQ4coiKj9CzFA9X4hqFf541ekgXk,1068
-lfx/components/ollama/ollama.py,sha256=eWSRR7lypH82Eb6px2JhPlJCfzDz33MCqgFoOXFbofE,13012
+lfx/components/ollama/ollama.py,sha256=KSaBAdgyh1xmkIvVcBHRVwFwzBtR7wPkH4j3dlJnPC4,13946
 lfx/components/ollama/ollama_embeddings.py,sha256=nvg-JQvue6j7tcrbbPeq1U_-LUj1MKawWbXxnnvJlWM,3976
 lfx/components/openai/__init__.py,sha256=G4Fgw4pmmDohdIOmzaeSCGijzKjyqFXNJPLwlcUDZ3w,1113
 lfx/components/openai/openai.py,sha256=imWO1tTJ0tTLqax1v5bNBPCRINTj2f2wN8j5G-a07GI,4505
@@ -563,7 +563,7 @@ lfx/custom/code_parser/__init__.py,sha256=qIwZQdEp1z7ldn0z-GY44wmwRaywN3L6VPoPt6
 lfx/custom/code_parser/code_parser.py,sha256=QAqsp4QF607319dClK60BsaiwZLV55n0xeGR-DthSoE,14280
 lfx/custom/custom_component/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 lfx/custom/custom_component/base_component.py,sha256=Pxi-qCocrGIwcG0x5fu-7ty1Py71bl_KG9Fku5SeO_M,4053
-lfx/custom/custom_component/component.py,sha256=MeYIPYab-68yarGX_IK0Fac8bGGPa1jlW5pv5P6IJ2E,74518
+lfx/custom/custom_component/component.py,sha256=6BIJxp6M8y1wCVUTGoQveYVDzeMDnuqcItcJpua_UUk,75795
 lfx/custom/custom_component/component_with_cache.py,sha256=por6CiPL3EHdLp_DvfI7qz1n4tc1KkqMOJNbsxoqVaI,313
 lfx/custom/custom_component/custom_component.py,sha256=u330P-UbRXKeO-ughl2rCyvEbgdq-igTNFYEoKQLJzI,22306
 lfx/custom/directory_reader/__init__.py,sha256=eFjlhKjpt2Kha_sJ2EqWofLRbpvfOTjvDSCpdpaTqWk,77
@@ -612,7 +612,7 @@ lfx/inputs/input_mixin.py,sha256=r23bPxWb1Fo81kFU02a2KUGfPLNUhE6K9q1Zw4LH4Qw,108
 lfx/inputs/inputs.py,sha256=y-SwcZhlEuVgLsOa2_x7wraUCaoZ3EV7_jrON9yuqPw,26220
 lfx/inputs/validators.py,sha256=i_PyQHQUmNpeS-_jRJNNsP3WlTPMkCJk2iFmFt3_ijw,505
 lfx/interface/__init__.py,sha256=hlivcb8kMhU_V8VeXClNfz5fRyF-u5PZZMXkgu0U5a0,211
-lfx/interface/components.py,sha256=ud7F5wPoXkQDcqbDbf71uxHT5Bd6uNZVNzB3LTT8vLc,19896
+lfx/interface/components.py,sha256=BotYhF246Ixm41AQb2aD5OJ7G8dIX_uE_55ZOrI4C70,20058
 lfx/interface/listing.py,sha256=fCpnp1F4foldTEbt1sQcF2HNqsaUZZ5uEyIe_FDL42c,711
 lfx/interface/run.py,sha256=m2u9r7K-v_FIe19GpwPUoaCeOMhA1iqp1k7Cy5G75uE,743
 lfx/interface/utils.py,sha256=qKi2HRg-QgeI3hmXLMtG6DHBbaQPuVMW5-o9lcN7j0Q,3790
@@ -644,8 +644,8 @@ lfx/schema/encoders.py,sha256=7vlWHZnZuDv1UVuP9X7Xn8srP1HZqLygOmkps3EJyY0,332
 lfx/schema/graph.py,sha256=o7qXhHZT4lEwjJZtlg4k9SNPgmMVZsZsclBbe8v_y6Y,1313
 lfx/schema/image.py,sha256=WdaOT3bjkJaG28RpgmurtfcnOG7Hr2phZ27YXH25uHA,5970
 lfx/schema/json_schema.py,sha256=UzMRSSAiLewJpf7B0XY4jPnPt0iskf61QUBxPdyiYys,6871
-lfx/schema/log.py,sha256=xbwSvJKmT1U8kxqIcV8BYgJxtu8Q6ntJKF8cIeksPEo,1943
-lfx/schema/message.py,sha256=Fg83OjS67qJYCevqt_5JcBu9xXkh1WY6S6DBLAvT62g,18076
+lfx/schema/log.py,sha256=TISQa44D4pL_-AOw9p0nOPV-7s6Phl-0yrpuZihhEsU,1981
+lfx/schema/message.py,sha256=mHHTX9OCHCGpA4goniQXF7I2UqEOy744ZFS4LMzNrYk,18261
 lfx/schema/openai_responses_schemas.py,sha256=drMCAlliefHfGRojBTMepPwk4DyEGh67naWvMPD10Sw,2596
 lfx/schema/properties.py,sha256=ZRY6FUDfqpc5wQ-bi-ZuUUrusF9t-pt9fQa_FNPpia0,1356
 lfx/schema/schema.py,sha256=XbIuvD64EdVljP1V32tsEL-ETXOQSFipMDaiMGzYttM,5079
@@ -712,14 +712,14 @@ lfx/utils/constants.py,sha256=4M8i93bROuQ7zmeKgfdNW85Znw7JFrK8KiagcDBpMRc,7036
 lfx/utils/data_structure.py,sha256=xU3JNa_4jcGOVa_ctfMxiImEj6dKQQPE_zZsTAyy2T4,6888
 lfx/utils/exceptions.py,sha256=RgIkI4uBssJsJUnuhluNGDSzdcuW5fnxPLhGfXYU9Uc,973
 lfx/utils/helpers.py,sha256=0LE0barnVp-8Y5cCoDRzhDzesvXqgiT7IXP6vtTSyGE,889
-lfx/utils/image.py,sha256=wMWBEI1gW3cFlQcio3mWgfHBaOw1uoAnqNmEacE_8xo,2133
+lfx/utils/image.py,sha256=W9boQgz4WH3GOgLrYaRDz2CbX5Za8pzi044X3EKvYbI,2370
 lfx/utils/lazy_load.py,sha256=UDtXi8N7NT9r-FRGxsLUfDtGU_X8yqt-RQqgpc9TqAw,394
 lfx/utils/request_utils.py,sha256=A6vmwpr7f3ZUxHg6Sz2-BdUUsyAwg84-7N_DNoPC8_Q,518
 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.12.dev32.dist-info/METADATA,sha256=DPD5eQw6AfyD9J53ik2oQhNr-1XcmWuI63rddrAuD5k,8290
-lfx_nightly-0.1.12.dev32.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-lfx_nightly-0.1.12.dev32.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
-lfx_nightly-0.1.12.dev32.dist-info/RECORD,,
+lfx_nightly-0.1.12.dev34.dist-info/METADATA,sha256=gNTSkSXCMVTO-NThZUB9QYis4SFNxIME5n0h_BBMJFY,8290
+lfx_nightly-0.1.12.dev34.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+lfx_nightly-0.1.12.dev34.dist-info/entry_points.txt,sha256=1724p3RHDQRT2CKx_QRzEIa7sFuSVO0Ux70YfXfoMT4,42
+lfx_nightly-0.1.12.dev34.dist-info/RECORD,,