lfx-nightly 0.1.12.dev42__py3-none-any.whl → 0.2.0.dev0__py3-none-any.whl

lfx/components/openrouter/openrouter.py

@@ -1,6 +1,3 @@
-from collections import defaultdict
-from typing import Any
-
 import httpx
 from langchain_openai import ChatOpenAI
 from pydantic.v1 import SecretStr
@@ -8,13 +5,7 @@ from pydantic.v1 import SecretStr
 from lfx.base.models.model import LCModelComponent
 from lfx.field_typing import LanguageModel
 from lfx.field_typing.range_spec import RangeSpec
-from lfx.inputs.inputs import (
-    DropdownInput,
-    IntInput,
-    SecretStrInput,
-    SliderInput,
-    StrInput,
-)
+from lfx.inputs.inputs import DropdownInput, IntInput, SecretStrInput, SliderInput, StrInput
 
 
 class OpenRouterComponent(LCModelComponent):
@@ -28,36 +19,13 @@ class OpenRouterComponent(LCModelComponent):
 
     inputs = [
         *LCModelComponent.get_base_inputs(),
-        SecretStrInput(
-            name="api_key", display_name="OpenRouter API Key", required=True, info="Your OpenRouter API key"
-        ),
-        StrInput(
-            name="site_url",
-            display_name="Site URL",
-            info="Your site URL for OpenRouter rankings",
-            advanced=True,
-        ),
-        StrInput(
-            name="app_name",
-            display_name="App Name",
-            info="Your app name for OpenRouter rankings",
-            advanced=True,
-        ),
-        DropdownInput(
-            name="provider",
-            display_name="Provider",
-            info="The AI model provider",
-            options=["Loading providers..."],
-            value="Loading providers...",
-            real_time_refresh=True,
-            required=True,
-        ),
+        SecretStrInput(name="api_key", display_name="API Key", required=True),
         DropdownInput(
             name="model_name",
             display_name="Model",
-            info="The model to use for chat completion",
-            options=["Select a provider first"],
-            value="Select a provider first",
+            options=[],
+            value="",
+            refresh_button=True,
             real_time_refresh=True,
             required=True,
         ),
@@ -66,137 +34,71 @@ class OpenRouterComponent(LCModelComponent):
             display_name="Temperature",
             value=0.7,
             range_spec=RangeSpec(min=0, max=2, step=0.01),
-            info="Controls randomness. Lower values are more deterministic, higher values are more creative.",
-            advanced=True,
-        ),
-        IntInput(
-            name="max_tokens",
-            display_name="Max Tokens",
-            info="Maximum number of tokens to generate",
             advanced=True,
         ),
+        IntInput(name="max_tokens", display_name="Max Tokens", advanced=True),
+        StrInput(name="site_url", display_name="Site URL", advanced=True),
+        StrInput(name="app_name", display_name="App Name", advanced=True),
     ]
 
-    def fetch_models(self) -> dict[str, list]:
-        """Fetch available models from OpenRouter API and organize them by provider."""
-        url = "https://openrouter.ai/api/v1/models"
-
+    def fetch_models(self) -> list[dict]:
+        """Fetch available models from OpenRouter."""
         try:
-            with httpx.Client() as client:
-                response = client.get(url)
-                response.raise_for_status()
-
-                models_data = response.json().get("data", [])
-                provider_models = defaultdict(list)
-
-                for model in models_data:
-                    model_id = model.get("id", "")
-                    if "/" in model_id:
-                        provider = model_id.split("/")[0].title()
-                        provider_models[provider].append(
-                            {
-                                "id": model_id,
-                                "name": model.get("name", ""),
-                                "description": model.get("description", ""),
-                                "context_length": model.get("context_length", 0),
-                            }
-                        )
-
-                return dict(provider_models)
-
-        except httpx.HTTPError as e:
-            self.log(f"Error fetching models: {e!s}")
-            return {"Error": [{"id": "error", "name": f"Error fetching models: {e!s}"}]}
+            response = httpx.get("https://openrouter.ai/api/v1/models", timeout=10.0)
+            response.raise_for_status()
+            models = response.json().get("data", [])
+            return sorted(
+                [
+                    {
+                        "id": m["id"],
+                        "name": m.get("name", m["id"]),
+                        "context": m.get("context_length", 0),
+                    }
+                    for m in models
+                    if m.get("id")
+                ],
+                key=lambda x: x["name"],
+            )
+        except (httpx.RequestError, httpx.HTTPStatusError) as e:
+            self.log(f"Error fetching models: {e}")
+            return []
+
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:  # noqa: ARG002
+        """Update model options."""
+        models = self.fetch_models()
+        if models:
+            build_config["model_name"]["options"] = [m["id"] for m in models]
+            build_config["model_name"]["tooltips"] = {m["id"]: f"{m['name']} ({m['context']:,} tokens)" for m in models}
+        else:
+            build_config["model_name"]["options"] = ["Failed to load models"]
+            build_config["model_name"]["value"] = "Failed to load models"
+        return build_config
 
     def build_model(self) -> LanguageModel:
-        """Build and return the OpenRouter language model."""
-        model_not_selected = "Please select a model"
-        api_key_required = "API key is required"
-
-        if not self.model_name or self.model_name == "Select a provider first":
-            raise ValueError(model_not_selected)
-
+        """Build the OpenRouter model."""
         if not self.api_key:
-            raise ValueError(api_key_required)
-
-        api_key = SecretStr(self.api_key).get_secret_value()
+            msg = "API key is required"
+            raise ValueError(msg)
+        if not self.model_name or self.model_name == "Loading...":
+            msg = "Please select a model"
+            raise ValueError(msg)
 
-        # Build base configuration
-        kwargs: dict[str, Any] = {
+        kwargs = {
             "model": self.model_name,
-            "openai_api_key": api_key,
+            "openai_api_key": SecretStr(self.api_key).get_secret_value(),
             "openai_api_base": "https://openrouter.ai/api/v1",
             "temperature": self.temperature if self.temperature is not None else 0.7,
         }
 
-        # Add optional parameters
         if self.max_tokens:
-            kwargs["max_tokens"] = self.max_tokens
+            kwargs["max_tokens"] = int(self.max_tokens)
 
         headers = {}
         if self.site_url:
             headers["HTTP-Referer"] = self.site_url
         if self.app_name:
             headers["X-Title"] = self.app_name
-
         if headers:
             kwargs["default_headers"] = headers
 
-        try:
-            return ChatOpenAI(**kwargs)
-        except (ValueError, httpx.HTTPError) as err:
-            error_msg = f"Failed to build model: {err!s}"
-            self.log(error_msg)
-            raise ValueError(error_msg) from err
-
-    def _get_exception_message(self, e: Exception) -> str | None:
-        """Get a message from an OpenRouter exception.
-
-        Args:
-            e (Exception): The exception to get the message from.
-
-        Returns:
-            str | None: The message from the exception, or None if no specific message can be extracted.
-        """
-        try:
-            from openai import BadRequestError
-
-            if isinstance(e, BadRequestError):
-                message = e.body.get("message")
-                if message:
-                    return message
-        except ImportError:
-            pass
-        return None
-
-    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None) -> dict:
-        """Update build configuration based on field updates."""
-        try:
-            if field_name is None or field_name == "provider":
-                provider_models = self.fetch_models()
-                build_config["provider"]["options"] = sorted(provider_models.keys())
-                if build_config["provider"]["value"] not in provider_models:
-                    build_config["provider"]["value"] = build_config["provider"]["options"][0]
-
-            if field_name == "provider" and field_value in self.fetch_models():
-                provider_models = self.fetch_models()
-                models = provider_models[field_value]
-
-                build_config["model_name"]["options"] = [model["id"] for model in models]
-                if models:
-                    build_config["model_name"]["value"] = models[0]["id"]
-
-                tooltips = {
-                    model["id"]: (f"{model['name']}\nContext Length: {model['context_length']}\n{model['description']}")
-                    for model in models
-                }
-                build_config["model_name"]["tooltips"] = tooltips
-
-        except httpx.HTTPError as e:
-            self.log(f"Error updating build config: {e!s}")
-            build_config["provider"]["options"] = ["Error loading providers"]
-            build_config["provider"]["value"] = "Error loading providers"
-            build_config["model_name"]["options"] = ["Error loading models"]
-            build_config["model_name"]["value"] = "Error loading models"
-
-        return build_config
+        return ChatOpenAI(**kwargs)

lfx/components/processing/parser.py

@@ -122,7 +122,12 @@ class ParserComponent(Component):
                 formatted_text = self.pattern.format(**row.to_dict())
                 lines.append(formatted_text)
         elif data is not None:
-            formatted_text = self.pattern.format(**data.data)
+            # Use format_map with a dict that returns default_value for missing keys
+            class DefaultDict(dict):
+                def __missing__(self, key):
+                    return data.default_value or ""
+
+            formatted_text = self.pattern.format_map(DefaultDict(data.data))
             lines.append(formatted_text)
 
         combined_text = self.sep.join(lines)

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/components/vectorstores/__init__.py

@@ -5,20 +5,14 @@ from typing import TYPE_CHECKING, Any
 from lfx.components._importing import import_mod
 
 if TYPE_CHECKING:
-    from .astradb import AstraDBVectorStoreComponent
     from .local_db import LocalDBComponent
-    from .mongodb_atlas import MongoVectorStoreComponent
 
 _dynamic_imports = {
     "LocalDBComponent": "local_db",
-    "AstraDBVectorStoreComponent": "astradb",
-    "MongoVectorStoreComponent": "mongodb_atlas",
 }
 
 __all__ = [
-    "AstraDBVectorStoreComponent",
     "LocalDBComponent",
-    "MongoVectorStoreComponent",
 ]
 
 

lfx/custom/custom_component/component.py

@@ -154,7 +154,7 @@ class Component(CustomComponent):
             self.trace_type = "chain"
 
         # Setup inputs and outputs
-        self._reset_all_output_values()
+        self.reset_all_output_values()
         if self.inputs is not None:
             self.map_inputs(self.inputs)
         self.map_outputs()
@@ -330,7 +330,8 @@ class Component(CustomComponent):
     def set_event_manager(self, event_manager: EventManager | None = None) -> None:
         self._event_manager = event_manager
 
-    def _reset_all_output_values(self) -> None:
+    def reset_all_output_values(self) -> None:
+        """Reset all output values to UNDEFINED."""
         if isinstance(self._outputs_map, dict):
             for output in self._outputs_map.values():
                 output.value = UNDEFINED

lfx/field_typing/constants.py

@@ -209,6 +209,7 @@ from lfx.io import (
     TableInput,
 )
 from lfx.schema.data import Data
+from lfx.schema.dataframe import DataFrame
 """
 
 if importlib.util.find_spec("langchain") is not None:

lfx/graph/edge/base.py

@@ -63,8 +63,8 @@ class Edge:
             # target_param is documents
             if isinstance(self._target_handle, str):
                 self.target_param = self._target_handle.split("|")[1]
-                self.source_handle = None
-                self.target_handle = None
+                self.source_handle = None  # type: ignore[assignment]
+                self.target_handle = None  # type: ignore[assignment]
             else:
                 msg = "Target handle is not a string"
                 raise ValueError(msg)

lfx/graph/graph/base.py

@@ -402,7 +402,7 @@ class Graph:
         for vertex in self.vertices:
             if vertex.custom_component is None:
                 continue
-            vertex.custom_component._reset_all_output_values()
+            vertex.custom_component.reset_all_output_values()
 
     def start(
         self,

lfx/graph/graph/schema.py

@@ -4,11 +4,12 @@ from typing import TYPE_CHECKING, NamedTuple, Protocol
 
 from typing_extensions import NotRequired, TypedDict
 
+from lfx.graph.edge.schema import EdgeData
+from lfx.graph.vertex.schema import NodeData
+
 if TYPE_CHECKING:
-    from lfx.graph.edge.schema import EdgeData
     from lfx.graph.schema import ResultData
     from lfx.graph.vertex.base import Vertex
-    from lfx.graph.vertex.schema import NodeData
     from lfx.schema.log import LoggableType
 
 

lfx/graph/vertex/vertex_types.py

@@ -65,7 +65,7 @@ class ComponentVertex(Vertex):
                 self.built_object, self.artifacts = result
             elif len(result) == 3:  # noqa: PLR2004
                 self.custom_component, self.built_object, self.artifacts = result
-                self.logs = self.custom_component._output_logs
+                self.logs = self.custom_component.get_output_logs()
                 for key in self.artifacts:
                     if self.artifacts_raw is None:
                         self.artifacts_raw = {}

lfx/io/schema.py

@@ -137,6 +137,12 @@ def schema_to_langflow_inputs(schema: type[BaseModel]) -> list[InputTypes]:
 
         is_list = False
 
+        # Handle unparameterized list (e.g., coming from nullable array schemas)
+        # Treat it as a list of strings for input purposes
+        if ann is list:
+            is_list = True
+            ann = str
+
         if get_origin(ann) is list:
             is_list = True
             ann = get_args(ann)[0]

lfx/memory/stubs.py

@@ -165,6 +165,7 @@ async def aget_messages(
     sender: str | None = None,  # noqa: ARG001
     sender_name: str | None = None,  # noqa: ARG001
     session_id: str | UUID | None = None,  # noqa: ARG001
+    context_id: str | UUID | None = None,  # noqa: ARG001
     order_by: str | None = "timestamp",  # noqa: ARG001
     order: str | None = "DESC",  # noqa: ARG001
     flow_id: UUID | None = None,  # noqa: ARG001
@@ -176,6 +177,7 @@ async def aget_messages(
         sender (Optional[str]): The sender of the messages (e.g., "Machine" or "User")
         sender_name (Optional[str]): The name of the sender.
         session_id (Optional[str]): The session ID associated with the messages.
+        context_id (Optional[str]): The context ID associated with the messages.
         order_by (Optional[str]): The field to order the messages by. Defaults to "timestamp".
         order (Optional[str]): The order in which to retrieve the messages. Defaults to "DESC".
         flow_id (Optional[UUID]): The flow ID associated with the messages.
@@ -200,6 +202,7 @@ def get_messages(
     sender: str | None = None,
     sender_name: str | None = None,
     session_id: str | UUID | None = None,
+    context_id: str | UUID | None = None,
     order_by: str | None = "timestamp",
     order: str | None = "DESC",
     flow_id: UUID | None = None,
@@ -209,33 +212,49 @@ def get_messages(
 
     DEPRECATED: Use `aget_messages` instead.
     """
-    return run_until_complete(aget_messages(sender, sender_name, session_id, order_by, order, flow_id, limit))
+    return run_until_complete(
+        aget_messages(
+            sender,
+            sender_name,
+            session_id,
+            context_id,
+            order_by,
+            order,
+            flow_id,
+            limit,
+        )
+    )
 
 
-async def adelete_messages(session_id: str) -> None:
-    """Delete messages from the memory based on the provided session ID.
+async def adelete_messages(session_id: str | None = None, context_id: str | None = None) -> None:
+    """Delete messages from the memory based on the provided session or context ID.
 
     Args:
         session_id (str): The session ID associated with the messages to delete.
+        context_id (str): The context ID associated with the messages to delete.
     """
+    if not session_id and not context_id:
+        msg = "Either session_id or context_id must be provided to delete messages."
+        raise ValueError(msg)
+
     async with session_scope() as session:
         try:
             # In a real implementation, this would delete from database
             # For now, this is a no-op since we're using NoopSession
-            await session.delete(session_id)
+            await session.delete(session_id or context_id)  # type: ignore  # noqa: PGH003
             await session.commit()
-            logger.debug(f"Messages deleted for session: {session_id}")
+            logger.debug(f"Messages deleted for session: {session_id or context_id}")
         except Exception as e:
             logger.exception(f"Error deleting messages: {e}")
             raise
 
 
-def delete_messages(session_id: str) -> None:
+def delete_messages(session_id: str | None = None, context_id: str | None = None) -> None:
     """DEPRECATED - Delete messages based on the provided session ID.
 
     DEPRECATED: Use `adelete_messages` instead.
     """
-    return run_until_complete(adelete_messages(session_id))
+    return run_until_complete(adelete_messages(session_id, context_id))
 
 
 async def aadd_messages(messages: Message | list[Message]) -> list[Message]:

lfx/schema/message.py

@@ -40,6 +40,7 @@ class Message(Data):
     sender_name: str | None = None
     files: list[str | Image] | None = Field(default=[])
     session_id: str | UUID | None = Field(default="")
+    context_id: str | UUID | None = Field(default="")
     timestamp: Annotated[str, timestamp_to_str_validator] = Field(
         default_factory=lambda: datetime.now(timezone.utc).strftime("%Y-%m-%d %H:%M:%S %Z")
     )
@@ -188,6 +189,7 @@ class Message(Data):
             sender_name=data.sender_name,
             files=data.files,
             session_id=data.session_id,
+            context_id=data.context_id,
             timestamp=data.timestamp,
             flow_id=data.flow_id,
             error=data.error,
@@ -326,6 +328,7 @@ class MessageResponse(DefaultModel):
     sender: str
     sender_name: str
     session_id: str
+    context_id: str | None = None
     text: str
     files: list[str] = []
     edit: bool
@@ -383,6 +386,7 @@ class MessageResponse(DefaultModel):
             sender_name=message.sender_name,
             text=message.text,
             session_id=message.session_id,
+            context_id=message.context_id,
             files=message.files or [],
             timestamp=message.timestamp,
             flow_id=flow_id,
@@ -433,6 +437,7 @@ class ErrorMessage(Message):
         self,
         exception: BaseException,
         session_id: str | None = None,
+        context_id: str | None = None,
         source: Source | None = None,
         trace_name: str | None = None,
         flow_id: UUID | str | None = None,
@@ -451,6 +456,7 @@ class ErrorMessage(Message):
 
         super().__init__(
             session_id=session_id,
+            context_id=context_id,
             sender=source.display_name if source else None,
             sender_name=source.display_name if source else None,
             text=plain_reason,

lfx/schema/schema.py

@@ -149,6 +149,11 @@ class InputValueRequest(BaseModel):
         description="Defines on which components the input value should be applied. "
         "'any' applies to all input components.",
     )
+    client_request_time: int | None = Field(
+        None,
+        description="Client-side timestamp in milliseconds when the request was initiated. "
+        "Used to calculate accurate end-to-end duration.",
+    )
 
     # add an example
     model_config = ConfigDict(

lfx/services/settings/constants.py

@@ -31,4 +31,5 @@ VARIABLES_TO_GET_FROM_ENVIRONMENT = [
     "AWS_SECRET_ACCESS_KEY",
     "NOVITA_API_KEY",
     "TAVILY_API_KEY",
+    "COMETAPI_KEY",
 ]

{lfx_nightly-0.1.12.dev42.dist-info → lfx_nightly-0.2.0.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: lfx-nightly
-Version: 0.1.12.dev42
+Version: 0.2.0.dev0
 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