lfx-nightly 0.2.0.dev41__py3-none-any.whl → 0.3.0.dev3__py3-none-any.whl

lfx/components/files_and_knowledge/save_file.py

@@ -1,6 +1,7 @@
 import json
 from collections.abc import AsyncIterator, Iterator
 from pathlib import Path
+from typing import Any
 
 import orjson
 import pandas as pd
@@ -13,6 +14,15 @@ from lfx.io import BoolInput, DropdownInput, HandleInput, SecretStrInput, StrInp
 from lfx.schema import Data, DataFrame, Message
 from lfx.services.deps import get_settings_service, get_storage_service, session_scope
 from lfx.template.field.base import Output
+from lfx.utils.validate_cloud import is_astra_cloud_environment
+
+
+def _get_storage_location_options():
+    """Get storage location options, filtering out Local if in Astra cloud environment."""
+    all_options = [{"name": "AWS", "icon": "Amazon"}, {"name": "Google Drive", "icon": "google"}]
+    if is_astra_cloud_environment():
+        return all_options
+    return [{"name": "Local", "icon": "hard-drive"}, *all_options]
 
 
 class SaveToFileComponent(Component):
@@ -49,11 +59,7 @@ class SaveToFileComponent(Component):
             display_name="Storage Location",
             placeholder="Select Location",
             info="Choose where to save the file.",
-            options=[
-                {"name": "Local", "icon": "hard-drive"},
-                {"name": "AWS", "icon": "Amazon"},
-                {"name": "Google Drive", "icon": "google"},
-            ],
+            options=_get_storage_location_options(),
             real_time_refresh=True,
             limit=1,
         ),
@@ -116,6 +122,7 @@ class SaveToFileComponent(Component):
             info="AWS Access key ID.",
             show=False,
             advanced=True,
+            required=True,
         ),
         SecretStrInput(
             name="aws_secret_access_key",
@@ -123,6 +130,7 @@ class SaveToFileComponent(Component):
             info="AWS Secret Key.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="bucket_name",
@@ -130,6 +138,7 @@ class SaveToFileComponent(Component):
             info="Enter the name of the S3 bucket.",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="aws_region",
@@ -152,6 +161,7 @@ class SaveToFileComponent(Component):
             info="Your Google Cloud Platform service account JSON key as a secret string (complete JSON content).",
             show=False,
             advanced=True,
+            required=True,
         ),
         StrInput(
             name="folder_id",
@@ -170,6 +180,12 @@ class SaveToFileComponent(Component):
 
     def update_build_config(self, build_config, field_value, field_name=None):
         """Update build configuration to show/hide fields based on storage location selection."""
+        # Update options dynamically based on cloud environment
+        # This ensures options are refreshed when build_config is updated
+        if "storage_location" in build_config:
+            updated_options = _get_storage_location_options()
+            build_config["storage_location"]["options"] = updated_options
+
         if field_name != "storage_location":
             return build_config
 
@@ -224,12 +240,14 @@ class SaveToFileComponent(Component):
                 for f_name in aws_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
             elif location == "Google Drive":
                 gdrive_fields = ["gdrive_format", "service_account_key", "folder_id"]
                 for f_name in gdrive_fields:
                     if f_name in build_config:
                         build_config[f_name]["show"] = True
+                        build_config[f_name]["advanced"] = False
 
         return build_config
 
@@ -249,6 +267,11 @@ class SaveToFileComponent(Component):
             msg = "Storage location must be selected."
             raise ValueError(msg)
 
+        # Check if Local storage is disabled in cloud environment
+        if storage_location == "Local" and is_astra_cloud_environment():
+            msg = "Local storage is not available in cloud environment. Please use AWS or Google Drive."
+            raise ValueError(msg)
+
         # Route to appropriate save method based on storage location
         if storage_location == "Local":
             return await self._save_to_local()
@@ -540,32 +563,67 @@ class SaveToFileComponent(Component):
 
     async def _save_to_aws(self) -> Message:
         """Save file to AWS S3 using S3 functionality."""
+        import os
+
+        import boto3
+
+        from lfx.base.data.cloud_storage_utils import create_s3_client, validate_aws_credentials
+
+        # Get AWS credentials from component inputs or fall back to environment variables
+        aws_access_key_id = getattr(self, "aws_access_key_id", None)
+        if aws_access_key_id and hasattr(aws_access_key_id, "get_secret_value"):
+            aws_access_key_id = aws_access_key_id.get_secret_value()
+        if not aws_access_key_id:
+            aws_access_key_id = os.getenv("AWS_ACCESS_KEY_ID")
+
+        aws_secret_access_key = getattr(self, "aws_secret_access_key", None)
+        if aws_secret_access_key and hasattr(aws_secret_access_key, "get_secret_value"):
+            aws_secret_access_key = aws_secret_access_key.get_secret_value()
+        if not aws_secret_access_key:
+            aws_secret_access_key = os.getenv("AWS_SECRET_ACCESS_KEY")
+
+        bucket_name = getattr(self, "bucket_name", None)
+        if not bucket_name:
+            # Try to get from storage service settings
+            settings = get_settings_service().settings
+            bucket_name = settings.object_storage_bucket_name
+
         # Validate AWS credentials
-        if not getattr(self, "aws_access_key_id", None):
-            msg = "AWS Access Key ID is required for S3 storage"
+        if not aws_access_key_id:
+            msg = (
+                "AWS Access Key ID is required for S3 storage. Provide it as a component input "
+                "or set AWS_ACCESS_KEY_ID environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "aws_secret_access_key", None):
-            msg = "AWS Secret Key is required for S3 storage"
+        if not aws_secret_access_key:
+            msg = (
+                "AWS Secret Key is required for S3 storage. Provide it as a component input "
+                "or set AWS_SECRET_ACCESS_KEY environment variable."
+            )
             raise ValueError(msg)
-        if not getattr(self, "bucket_name", None):
-            msg = "S3 Bucket Name is required for S3 storage"
+        if not bucket_name:
+            msg = (
+                "S3 Bucket Name is required for S3 storage. Provide it as a component input "
+                "or set LANGFLOW_OBJECT_STORAGE_BUCKET_NAME environment variable."
+            )
             raise ValueError(msg)
 
-        # Use S3 upload functionality
-        try:
-            import boto3
-        except ImportError as e:
-            msg = "boto3 is not installed. Please install it using `uv pip install boto3`."
-            raise ImportError(msg) from e
+        # Validate AWS credentials
+        validate_aws_credentials(self)
 
         # Create S3 client
-        client_config = {
-            "aws_access_key_id": self.aws_access_key_id,
-            "aws_secret_access_key": self.aws_secret_access_key,
+        s3_client = create_s3_client(self)
+        client_config: dict[str, Any] = {
+            "aws_access_key_id": str(aws_access_key_id),
+            "aws_secret_access_key": str(aws_secret_access_key),
         }
 
-        if hasattr(self, "aws_region") and self.aws_region:
-            client_config["region_name"] = self.aws_region
+        # Get region from component input, environment variable, or settings
+        aws_region = getattr(self, "aws_region", None)
+        if not aws_region:
+            aws_region = os.getenv("AWS_DEFAULT_REGION") or os.getenv("AWS_REGION")
+        if aws_region:
+            client_config["region_name"] = str(aws_region)
 
         s3_client = boto3.client("s3", **client_config)
 
@@ -589,8 +647,8 @@ class SaveToFileComponent(Component):
 
         try:
             # Upload to S3
-            s3_client.upload_file(temp_file_path, self.bucket_name, file_path)
-            s3_url = f"s3://{self.bucket_name}/{file_path}"
+            s3_client.upload_file(temp_file_path, bucket_name, file_path)
+            s3_url = f"s3://{bucket_name}/{file_path}"
             return Message(text=f"File successfully uploaded to {s3_url}")
         finally:
             # Clean up temp file
@@ -599,6 +657,12 @@ class SaveToFileComponent(Component):
 
     async def _save_to_google_drive(self) -> Message:
         """Save file to Google Drive using Google Drive functionality."""
+        import tempfile
+
+        from googleapiclient.http import MediaFileUpload
+
+        from lfx.base.data.cloud_storage_utils import create_google_drive_service
+
         # Validate Google Drive credentials
         if not getattr(self, "service_account_key", None):
             msg = "GCP Credentials Secret Key is required for Google Drive storage"
@@ -607,71 +671,10 @@ class SaveToFileComponent(Component):
             msg = "Google Drive Folder ID is required for Google Drive storage"
             raise ValueError(msg)
 
-        # Use Google Drive upload functionality
-        try:
-            import json
-            import tempfile
-
-            from google.oauth2 import service_account
-            from googleapiclient.discovery import build
-            from googleapiclient.http import MediaFileUpload
-        except ImportError as e:
-            msg = "Google API client libraries are not installed. Please install them."
-            raise ImportError(msg) from e
-
-        # Parse credentials with multiple fallback strategies
-        credentials_dict = None
-        parse_errors = []
-
-        # Strategy 1: Parse as-is with strict=False to allow control characters
-        try:
-            credentials_dict = json.loads(self.service_account_key, strict=False)
-        except json.JSONDecodeError as e:
-            parse_errors.append(f"Standard parse: {e!s}")
-
-        # Strategy 2: Strip whitespace and try again
-        if credentials_dict is None:
-            try:
-                cleaned_key = self.service_account_key.strip()
-                credentials_dict = json.loads(cleaned_key, strict=False)
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Stripped parse: {e!s}")
-
-        # Strategy 3: Check if it's double-encoded (JSON string of a JSON string)
-        if credentials_dict is None:
-            try:
-                decoded_once = json.loads(self.service_account_key, strict=False)
-                if isinstance(decoded_once, str):
-                    credentials_dict = json.loads(decoded_once, strict=False)
-                else:
-                    credentials_dict = decoded_once
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Double-encoded parse: {e!s}")
-
-        # Strategy 4: Try to fix common issues with newlines in the private_key field
-        if credentials_dict is None:
-            try:
-                # Replace literal \n with actual newlines which is common in pasted JSON
-                fixed_key = self.service_account_key.replace("\\n", "\n")
-                credentials_dict = json.loads(fixed_key, strict=False)
-            except json.JSONDecodeError as e:
-                parse_errors.append(f"Newline-fixed parse: {e!s}")
-
-        if credentials_dict is None:
-            error_details = "; ".join(parse_errors)
-            msg = (
-                f"Unable to parse service account key JSON. Tried multiple strategies: {error_details}. "
-                "Please ensure you've copied the entire JSON content from your service account key file. "
-                "The JSON should start with '{' and contain fields like 'type', 'project_id', 'private_key', etc."
-            )
-            raise ValueError(msg)
-
-        # Create Google Drive service with appropriate scopes
-        # Use drive scope for folder access, file scope is too restrictive for folder verification
-        credentials = service_account.Credentials.from_service_account_info(
-            credentials_dict, scopes=["https://www.googleapis.com/auth/drive"]
+        # Create Google Drive service with full drive scope (needed for folder operations)
+        drive_service, credentials = create_google_drive_service(
+            self.service_account_key, scopes=["https://www.googleapis.com/auth/drive"], return_credentials=True
         )
-        drive_service = build("drive", "v3", credentials=credentials)
 
         # Extract content and format
         content = self._extract_content_for_upload()

lfx/components/langchain_utilities/ibm_granite_handler.py

@@ -0,0 +1,211 @@
+"""IBM WatsonX-specific tool calling logic.
+
+This module contains all the specialized handling for IBM WatsonX models
+which have different tool calling behavior compared to other LLMs.
+
+The tool calling issues affect ALL models on the WatsonX platform,
+not just Granite models. This includes:
+- meta-llama models
+- mistral models
+- granite models
+- any other model running through WatsonX
+"""
+
+import re
+
+from langchain.agents.format_scratchpad.tools import format_to_tool_messages
+from langchain.agents.output_parsers.tools import ToolsAgentOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.runnables import RunnableLambda
+
+from lfx.log.logger import logger
+
+# Pattern to detect placeholder usage in tool arguments
+PLACEHOLDER_PATTERN = re.compile(
+    r"<[^>]*(?:result|value|output|response|data|from|extract|previous|current|date|input|query|search|tool)[^>]*>",
+    re.IGNORECASE,
+)
+
+
+def is_watsonx_model(llm) -> bool:
+    """Check if the LLM is an IBM WatsonX model (any model, not just Granite).
+
+    This detects the provider (WatsonX) rather than a specific model,
+    since tool calling issues affect all models on the WatsonX platform.
+    """
+    # Check class name for WatsonX (e.g., ChatWatsonx)
+    class_name = type(llm).__name__.lower()
+    if "watsonx" in class_name:
+        return True
+
+    # Fallback: check module name (e.g., langchain_ibm)
+    module_name = getattr(type(llm), "__module__", "").lower()
+    return "watsonx" in module_name or "langchain_ibm" in module_name
+
+
+def is_granite_model(llm) -> bool:
+    """Check if the LLM is an IBM Granite model.
+
+    DEPRECATED: Use is_watsonx_model() instead.
+    Kept for backwards compatibility.
+    """
+    model_id = getattr(llm, "model_id", getattr(llm, "model_name", ""))
+    return "granite" in str(model_id).lower()
+
+
+def _get_tool_schema_description(tool) -> str:
+    """Extract a brief description of the tool's expected parameters.
+
+    Returns empty string if schema extraction fails (graceful degradation).
+    """
+    if not hasattr(tool, "args_schema") or not tool.args_schema:
+        return ""
+
+    schema = tool.args_schema
+    if not hasattr(schema, "model_fields"):
+        return ""
+
+    try:
+        fields = schema.model_fields
+        params = []
+        for name, field in fields.items():
+            required = field.is_required() if hasattr(field, "is_required") else True
+            req_str = "(required)" if required else "(optional)"
+            params.append(f"{name} {req_str}")
+        return f"Parameters: {', '.join(params)}" if params else ""
+    except (AttributeError, TypeError) as e:
+        logger.debug(f"Could not extract schema for tool {getattr(tool, 'name', 'unknown')}: {e}")
+        return ""
+
+
+def get_enhanced_system_prompt(base_prompt: str, tools: list) -> str:
+    """Enhance system prompt for WatsonX models with tool usage instructions."""
+    if not tools or len(tools) <= 1:
+        return base_prompt
+
+    # Build detailed tool descriptions with their parameters
+    tool_descriptions = []
+    for t in tools:
+        schema_desc = _get_tool_schema_description(t)
+        if schema_desc:
+            tool_descriptions.append(f"- {t.name}: {schema_desc}")
+        else:
+            tool_descriptions.append(f"- {t.name}")
+
+    tools_section = "\n".join(tool_descriptions)
+
+    # Note: "one tool at a time" is a WatsonX platform limitation, not a design choice.
+    # WatsonX models don't reliably support parallel tool calls.
+    enhancement = f"""
+
+TOOL USAGE GUIDELINES:
+
+1. ALWAYS call tools when you need information - never say "I cannot" or "I don't have access".
+2. Call one tool at a time, then use its result before calling another tool.
+3. Use ACTUAL values in tool arguments - never use placeholder syntax like <result-from-...>.
+4. Each tool has specific parameters - use the correct ones for each tool.
+
+AVAILABLE TOOLS:
+{tools_section}"""
+
+    return base_prompt + enhancement
+
+
+def detect_placeholder_in_args(tool_calls: list) -> tuple[bool, str | None]:
+    """Detect if any tool call contains placeholder syntax in its arguments."""
+    if not tool_calls:
+        return False, None
+
+    for tool_call in tool_calls:
+        args = tool_call.get("args", {})
+        if isinstance(args, dict):
+            for key, value in args.items():
+                if isinstance(value, str) and PLACEHOLDER_PATTERN.search(value):
+                    tool_name = tool_call.get("name", "unknown")
+                    logger.warning(f"[IBM WatsonX] Detected placeholder: {tool_name}.{key}={value}")
+                    return True, value
+        elif isinstance(args, str) and PLACEHOLDER_PATTERN.search(args):
+            logger.warning(f"[IBM WatsonX] Detected placeholder in args: {args}")
+            return True, args
+    return False, None
+
+
+def _limit_to_single_tool_call(llm_response):
+    """Limit response to single tool call (WatsonX platform limitation)."""
+    if not hasattr(llm_response, "tool_calls") or not llm_response.tool_calls:
+        return llm_response
+
+    if len(llm_response.tool_calls) > 1:
+        logger.debug(f"[WatsonX] Limiting {len(llm_response.tool_calls)} tool calls to 1")
+        llm_response.tool_calls = [llm_response.tool_calls[0]]
+
+    return llm_response
+
+
+def _handle_placeholder_in_response(llm_response, messages, llm_auto):
+    """Re-invoke with corrective message if placeholder syntax detected."""
+    if not hasattr(llm_response, "tool_calls") or not llm_response.tool_calls:
+        return llm_response
+
+    has_placeholder, _ = detect_placeholder_in_args(llm_response.tool_calls)
+    if not has_placeholder:
+        return llm_response
+
+    logger.warning("[WatsonX] Placeholder detected, requesting actual values")
+    from langchain_core.messages import SystemMessage
+
+    corrective_msg = SystemMessage(
+        content="Provide your final answer using the actual values from previous tool results."
+    )
+    messages_list = list(messages.messages) if hasattr(messages, "messages") else list(messages)
+    messages_list.append(corrective_msg)
+    return llm_auto.invoke(messages_list)
+
+
+def create_granite_agent(llm, tools: list, prompt: ChatPromptTemplate, forced_iterations: int = 2):
+    """Create a tool calling agent for IBM WatsonX/Granite models.
+
+    Why this exists: WatsonX models have platform-specific tool calling behavior:
+    - With tool_choice='auto': Models often describe tools in text instead of calling them
+    - With tool_choice='required': Models can't provide final answers (causes infinite loops)
+    - Models only reliably support single tool calls per turn
+
+    Solution: Dynamic switching between 'required' (to force tool use) and 'auto' (to allow answers).
+
+    Args:
+        llm: WatsonX language model instance
+        tools: Available tools for the agent
+        prompt: Chat prompt template
+        forced_iterations: Iterations to force tool_choice='required' before allowing 'auto'
+
+    Returns:
+        Runnable agent chain compatible with AgentExecutor
+    """
+    if not hasattr(llm, "bind_tools"):
+        msg = "WatsonX handler requires a language model with bind_tools support."
+        raise ValueError(msg)
+
+    llm_required = llm.bind_tools(tools or [], tool_choice="required")
+    llm_auto = llm.bind_tools(tools or [], tool_choice="auto")
+
+    def invoke(inputs: dict):
+        intermediate_steps = inputs.get("intermediate_steps", [])
+        num_steps = len(intermediate_steps)
+
+        scratchpad = format_to_tool_messages(intermediate_steps)
+        messages = prompt.invoke({**inputs, "agent_scratchpad": scratchpad})
+
+        # Use 'required' for first N iterations, then 'auto' to allow final answers
+        use_required = num_steps < forced_iterations
+        llm_to_use = llm_required if use_required else llm_auto
+        logger.debug(f"[WatsonX] Step {num_steps + 1}, tool_choice={'required' if use_required else 'auto'}")
+
+        response = llm_to_use.invoke(messages)
+        response = _limit_to_single_tool_call(response)
+        return _handle_placeholder_in_response(response, messages, llm_auto)
+
+    return RunnableLambda(invoke) | ToolsAgentOutputParser()
+
+
+# Alias for backwards compatibility
+create_watsonx_agent = create_granite_agent

lfx/components/langchain_utilities/tool_calling.py

@@ -2,6 +2,13 @@ from langchain.agents import create_tool_calling_agent
 from langchain_core.prompts import ChatPromptTemplate
 
 from lfx.base.agents.agent import LCToolsAgentComponent
+
+# IBM Granite-specific logic is in a separate file
+from lfx.components.langchain_utilities.ibm_granite_handler import (
+    create_granite_agent,
+    get_enhanced_system_prompt,
+    is_granite_model,
+)
 from lfx.inputs.inputs import (
     DataInput,
     HandleInput,
@@ -44,15 +51,39 @@ class ToolCallingAgentComponent(LCToolsAgentComponent):
         return self.chat_history
 
     def create_agent_runnable(self):
-        messages = [
-            ("system", "{system_prompt}"),
-            ("placeholder", "{chat_history}"),
-            ("human", "{input}"),
-            ("placeholder", "{agent_scratchpad}"),
-        ]
+        messages = []
+
+        # Use local variable to avoid mutating component state on repeated calls
+        effective_system_prompt = self.system_prompt or ""
+
+        # Enhance prompt for IBM Granite models (they need explicit tool usage instructions)
+        if is_granite_model(self.llm) and self.tools:
+            effective_system_prompt = get_enhanced_system_prompt(effective_system_prompt, self.tools)
+            # Store enhanced prompt for use in agent.py without mutating original
+            self._effective_system_prompt = effective_system_prompt
+
+        # Only include system message if system_prompt is provided and not empty
+        if effective_system_prompt.strip():
+            messages.append(("system", "{system_prompt}"))
+
+        messages.extend(
+            [
+                ("placeholder", "{chat_history}"),
+                ("human", "{input}"),
+                ("placeholder", "{agent_scratchpad}"),
+            ]
+        )
+
         prompt = ChatPromptTemplate.from_messages(messages)
         self.validate_tool_names()
+
         try:
+            # Use IBM Granite-specific agent if detected
+            # Other WatsonX models (Llama, Mistral, etc.) use default behavior
+            if is_granite_model(self.llm) and self.tools:
+                return create_granite_agent(self.llm, self.tools, prompt)
+
+            # Default behavior for other models (including non-Granite WatsonX models)
             return create_tool_calling_agent(self.llm, self.tools or [], prompt)
         except NotImplementedError as e:
             message = f"{self.display_name} does not support tool calling. Please try using a compatible model."

lfx/components/llm_operations/batch_run.py

@@ -4,8 +4,13 @@ from typing import TYPE_CHECKING, Any, cast
 
 import toml  # type: ignore[import-untyped]
 
+from lfx.base.models.unified_models import (
+    get_language_model_options,
+    get_model_classes,
+    update_model_options_in_build_config,
+)
 from lfx.custom.custom_component.component import Component
-from lfx.io import BoolInput, DataFrameInput, HandleInput, MessageTextInput, MultilineInput, Output
+from lfx.io import BoolInput, DataFrameInput, MessageTextInput, ModelInput, MultilineInput, Output, SecretStrInput
 from lfx.log.logger import logger
 from lfx.schema.dataframe import DataFrame
 
@@ -20,13 +25,20 @@ class BatchRunComponent(Component):
     icon = "List"
 
     inputs = [
-        HandleInput(
+        ModelInput(
             name="model",
             display_name="Language Model",
-            info="Connect the 'Language Model' output from your LLM component here.",
-            input_types=["LanguageModel"],
+            info="Select your model provider",
+            real_time_refresh=True,
             required=True,
         ),
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="Model Provider API key",
+            real_time_refresh=True,
+            advanced=True,
+        ),
         MultilineInput(
             name="system_message",
             display_name="Instructions",
@@ -76,6 +88,17 @@ class BatchRunComponent(Component):
         ),
     ]
 
+    def update_build_config(self, build_config: dict, field_value: str, field_name: str | None = None):
+        """Dynamically update build config with user-filtered model options."""
+        return update_model_options_in_build_config(
+            component=self,
+            build_config=build_config,
+            cache_key_prefix="language_model_options",
+            get_options_func=get_language_model_options,
+            field_name=field_name,
+            field_value=field_value,
+        )
+
     def _format_row_as_toml(self, row: dict[str, Any]) -> str:
         """Convert a dictionary (row) into a TOML-formatted string."""
         formatted_dict = {str(col): {"value": str(val)} for col, val in row.items()}
@@ -111,20 +134,43 @@ class BatchRunComponent(Component):
             }
 
     async def run_batch(self) -> DataFrame:
-        """Process each row in df[column_name] with the language model asynchronously.
-
-        Returns:
-            DataFrame: A new DataFrame containing:
-                - All original columns
-                - The model's response column (customizable name)
-                - 'batch_index' column for processing order
-                - 'metadata' (optional)
-
-        Raises:
-            ValueError: If the specified column is not found in the DataFrame
-            TypeError: If the model is not compatible or input types are wrong
-        """
-        model: Runnable = self.model
+        """Process each row in df[column_name] with the language model asynchronously."""
+        # Check if model is already an instance (for testing) or needs to be instantiated
+        if isinstance(self.model, list):
+            # Extract model configuration
+            model_selection = self.model[0]
+            model_name = model_selection.get("name")
+            provider = model_selection.get("provider")
+            metadata = model_selection.get("metadata", {})
+
+            # Get model class and parameters from metadata
+            model_class = get_model_classes().get(metadata.get("model_class"))
+            if model_class is None:
+                msg = f"No model class defined for {model_name}"
+                raise ValueError(msg)
+
+            api_key_param = metadata.get("api_key_param", "api_key")
+            model_name_param = metadata.get("model_name_param", "model")
+
+            # Get API key from global variables
+            from lfx.base.models.unified_models import get_api_key_for_provider
+
+            api_key = get_api_key_for_provider(self.user_id, provider, self.api_key)
+
+            if not api_key and provider != "Ollama":
+                msg = f"{provider} API key is required. Please configure it globally."
+                raise ValueError(msg)
+
+            # Instantiate the model
+            kwargs = {
+                model_name_param: model_name,
+                api_key_param: api_key,
+            }
+            model: Runnable = model_class(**kwargs)
+        else:
+            # Model is already an instance (typically in tests)
+            model = self.model
+
         system_msg = self.system_message or ""
         df: DataFrame = self.df
         col_name = self.column_name or ""