lfx-nightly 0.1.13.dev0__py3-none-any.whl → 0.2.0.dev26__py3-none-any.whl

lfx/components/agents/cuga_agent.py

@@ -1,1013 +0,0 @@
-import asyncio
-import json
-import os
-import re
-import traceback
-import uuid
-from collections.abc import AsyncIterator
-from typing import TYPE_CHECKING, Any, cast
-
-from langchain_core.agents import AgentFinish
-from langchain_core.messages import AIMessage, HumanMessage
-from langchain_core.tools import StructuredTool
-from langflow.field_typing import Tool
-from langflow.io import BoolInput, DropdownInput, IntInput, MultilineInput, Output, TableInput
-
-# from langflow.logging import logger
-from langflow.schema.data import Data
-from langflow.schema.dotdict import dotdict
-from langflow.schema.message import Message
-from langflow.schema.table import EditMode
-from pydantic import ValidationError
-
-from lfx.base.agents.events import ExceptionWithMessageError
-from lfx.base.models.model_input_constants import (
-    ALL_PROVIDER_FIELDS,
-    MODEL_DYNAMIC_UPDATE_FIELDS,
-    MODEL_PROVIDERS,
-    MODEL_PROVIDERS_DICT,
-    MODELS_METADATA,
-)
-from lfx.base.models.model_utils import get_model_name
-from lfx.components.agents.agent import LCToolsAgentComponent
-from lfx.components.helpers.current_date import CurrentDateComponent
-from lfx.components.helpers.memory import MemoryComponent
-from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComponent
-from lfx.custom.custom_component.component import _get_component_toolkit
-from lfx.custom.utils import update_component_build_config
-from lfx.helpers.base_model import build_model_from_schema
-from lfx.log.logger import logger
-
-if TYPE_CHECKING:
-    from langflow.schema.log import SendMessageFunctionType
-
-
-def set_advanced_true(component_input):
-    """Set the advanced flag to True for a component input.
-
-    Args:
-        component_input: The component input to modify
-
-    Returns:
-        The modified component input with advanced=True
-    """
-    component_input.advanced = True
-    return component_input
-
-
-MODEL_PROVIDERS_LIST = ["OpenAI"]
-
-
-class CugaComponent(ToolCallingAgentComponent):
-    """Cuga Agent Component for advanced AI task execution.
-
-    The Cuga component is an advanced AI agent that can execute complex tasks using
-    various tools, browser automation, and structured output generation. It supports
-    custom policies, web applications, and API interactions.
-
-    Attributes:
-        display_name: Human-readable name for the component
-        description: Brief description of the component's purpose
-        documentation: URL to component documentation
-        icon: Icon identifier for the UI
-        beta: Whether the component is in beta status
-        name: Internal component name
-    """
-
-    display_name: str = "Cuga"
-    description: str = "Define the Cuga agent's policies, then assign it a task."
-    documentation: str = "https://docs.langflow.org/agents"
-    icon = "bot"
-    beta = True
-    name = "Cuga"
-
-    memory_inputs = [set_advanced_true(component_input) for component_input in MemoryComponent().inputs]
-
-    # Filter out json_mode from OpenAI inputs since we handle structured output differently
-    openai_inputs_filtered = [
-        input_field
-        for input_field in MODEL_PROVIDERS_DICT["OpenAI"]["inputs"]
-        if not (hasattr(input_field, "name") and input_field.name == "json_mode")
-    ]
-
-    inputs = [
-        DropdownInput(
-            name="agent_llm",
-            display_name="Model Provider",
-            info="The provider of the language model that the agent will use to generate responses.",
-            options=[*MODEL_PROVIDERS_LIST, "Custom"],
-            value="OpenAI",
-            real_time_refresh=True,
-            input_types=[],
-            options_metadata=[MODELS_METADATA[key] for key in MODEL_PROVIDERS_LIST] + [{"icon": "brain"}],
-        ),
-        *openai_inputs_filtered,
-        MultilineInput(
-            name="policies",
-            display_name="Policies",
-            info=(
-                "Custom instructions or policies for the agent to adhere to during its operation.\n"
-                "Example:\n"
-                "# Plan\n"
-                "< planning instructions e.g. which tools and when to use>\n"
-                "# Answer\n"
-                "< final answer instructions how to answer>"
-            ),
-            value="",
-            advanced=False,
-        ),
-        IntInput(
-            name="n_messages",
-            display_name="Number of Chat History Messages",
-            value=100,
-            info="Number of chat history messages to retrieve.",
-            advanced=True,
-            show=True,
-        ),
-        MultilineInput(
-            name="format_instructions",
-            display_name="Output Format Instructions",
-            info="Generic Template for structured output formatting. Valid only with Structured response.",
-            value=(
-                "You are an AI that extracts structured JSON objects from unstructured text. "
-                "Use a predefined schema with expected types (str, int, float, bool, dict). "
-                "Extract ALL relevant instances that match the schema - if multiple patterns exist, capture them all. "
-                "Fill missing or ambiguous values with defaults: null for missing values. "
-                "Remove exact duplicates but keep variations that have different field values. "
-                "Always return valid JSON in the expected format, never throw errors. "
-                "If multiple objects can be extracted, return them all in the structured format."
-            ),
-            advanced=True,
-        ),
-        TableInput(
-            name="output_schema",
-            display_name="Output Schema",
-            info=(
-                "Schema Validation: Define the structure and data types for structured output. "
-                "No validation if no output schema."
-            ),
-            advanced=True,
-            required=False,
-            value=[],
-            table_schema=[
-                {
-                    "name": "name",
-                    "display_name": "Name",
-                    "type": "str",
-                    "description": "Specify the name of the output field.",
-                    "default": "field",
-                    "edit_mode": EditMode.INLINE,
-                },
-                {
-                    "name": "description",
-                    "display_name": "Description",
-                    "type": "str",
-                    "description": "Describe the purpose of the output field.",
-                    "default": "description of field",
-                    "edit_mode": EditMode.POPOVER,
-                },
-                {
-                    "name": "type",
-                    "display_name": "Type",
-                    "type": "str",
-                    "edit_mode": EditMode.INLINE,
-                    "description": ("Indicate the data type of the output field (e.g., str, int, float, bool, dict)."),
-                    "options": ["str", "int", "float", "bool", "dict"],
-                    "default": "str",
-                },
-                {
-                    "name": "multiple",
-                    "display_name": "As List",
-                    "type": "boolean",
-                    "description": "Set to True if this output field should be a list of the specified type.",
-                    "default": "False",
-                    "edit_mode": EditMode.INLINE,
-                },
-            ],
-        ),
-        *LCToolsAgentComponent._base_inputs,
-        BoolInput(
-            name="add_current_date_tool",
-            display_name="Current Date",
-            advanced=True,
-            info="If true, will add a tool to the agent that returns the current date.",
-            value=True,
-        ),
-        BoolInput(
-            name="browser_enabled",
-            display_name="Enable Browser",
-            info="Toggle to enable a built-in browser tool for web scraping and searching.",
-            value=False,
-            advanced=False,
-        ),
-        MultilineInput(
-            name="web_apps",
-            display_name="Web applications",
-            info=(
-                "Define a list of web applications that cuga will open when enable browser is true. "
-                "Currently only supports one web application. Example: https://example.com"
-            ),
-            value="",
-            advanced=False,
-        ),
-        BoolInput(
-            name="API",
-            display_name="Enable API Sub-agent",
-            info="Toggle to enable a built-in sub-agent specialized for API interactions.",
-            value=False,
-            advanced=True,
-        ),
-    ]
-    outputs = [
-        Output(name="response", display_name="Response", method="message_response"),
-        Output(name="structured_response", display_name="Structured Response", method="json_response", tool_mode=False),
-    ]
-
-    async def call_agent(
-        self, current_input: str, tools: list[Tool], history_messages: list[Message], llm
-    ) -> AsyncIterator[dict[str, Any]]:
-        """Execute the Cuga agent with the given input and tools.
-
-        This method initializes and runs the Cuga agent, processing the input through
-        the agent's workflow and yielding events for real-time monitoring.
-
-        Args:
-            current_input: The user input to process
-            tools: List of available tools for the agent
-            history_messages: Previous conversation history
-            llm: The language model instance to use
-
-        Yields:
-            dict: Agent events including tool usage, thinking, and final results
-
-        Raises:
-            ValueError: If there's an error in agent initialization
-            TypeError: If there's a type error in processing
-            RuntimeError: If there's a runtime error during execution
-            ConnectionError: If there's a connection issue
-        """
-        yield {
-            "event": "on_chain_start",
-            "run_id": str(uuid.uuid4()),
-            "name": "CUGA_initializing",
-            "data": {"input": {"input": current_input, "chat_history": []}},
-        }
-        logger.debug(f"LLM MODEL TYPE: {type(llm)}")
-        if current_input:
-            try:
-                from cuga.config import settings as cuga_settings
-
-                logger.info("Updating cuga settings programmatically")
-                cuga_settings.set("advanced_features.registry", False)  # noqa: FBT003
-
-                if self.browser_enabled:
-                    logger.info("browser_enabled is true, setting mode to hybrid")
-                    cuga_settings.set("advanced_features.mode", "hybrid")
-                    cuga_settings.set("advanced_features.use_vision", False)  # noqa: FBT003
-                else:
-                    logger.info("browser_enabled is false, setting mode to api")
-                    cuga_settings.set("advanced_features.mode", "api")
-
-                logger.info(f"Cuga settings updated - MODE: {cuga_settings.get('advanced_features.mode')}")
-            except (ImportError, AttributeError) as e:
-                logger.warning(f"Could not update cuga settings: {e}")
-                os.environ["DYNACONF_ADVANCED_FEATURES__REGISTRY"] = "false"
-                if self.browser_enabled:
-                    logger.info("browser_enabled is true, setting env to hybrid")
-                    os.environ["DYNACONF_ADVANCED_FEATURES__MODE"] = "hybrid"
-                    os.environ["DYNACONF_ADVANCED_FEATURES__USE_VISION"] = "false"
-                else:
-                    logger.info("browser_enabled is false, setting env to api")
-                    os.environ["DYNACONF_ADVANCED_FEATURES__MODE"] = "api"
-
-            from cuga.backend.activity_tracker.tracker import ActivityTracker
-            from cuga.backend.cuga_graph.utils.agent_loop import StreamEvent
-            from cuga.backend.cuga_graph.utils.controller import (
-                AgentRunner as CugaAgent,
-            )
-            from cuga.backend.cuga_graph.utils.controller import (
-                ExperimentResult as AgentResult,
-            )
-            from cuga.backend.llm.models import LLMManager
-            from cuga.configurations.instructions_manager import InstructionsManager
-
-            llm_manager = LLMManager()
-            llm_manager.set_llm(llm)
-            instructions_manager = InstructionsManager()
-            if self.policies:
-                logger.info(f"policies are: {self.policies}")
-                instructions_manager.set_instructions_from_one_file(self.policies)
-            tracker = ActivityTracker()
-            tracker.set_tools(tools)
-            cuga_agent = CugaAgent(browser_enabled=self.browser_enabled)
-            if self.browser_enabled:
-                await cuga_agent.initialize_freemode_env(start_url=self.web_apps.strip(), interface_mode="browser_only")
-            else:
-                await cuga_agent.initialize_appworld_env()
-        yield {
-            "event": "on_chain_start",
-            "run_id": str(uuid.uuid4()),
-            "name": "CUGA_thinking...",
-            "data": {"input": {"input": current_input, "chat_history": []}},
-        }
-        logger.info(f"[CUGA] current web apps are {self.web_apps}")
-        logger.info(f"[CUGA] Processing input: {current_input}")
-        try:
-            # Convert history to LangChain format for the event
-            lc_messages = []
-            for msg in history_messages:
-                if hasattr(msg, "sender") and msg.sender == "Human":
-                    lc_messages.append(HumanMessage(content=msg.text))
-                else:
-                    lc_messages.append(AIMessage(content=msg.text))
-
-            await asyncio.sleep(0.5)
-
-            tools_used = []
-
-            # Simulate browser tool usage
-            if getattr(self, "BROWSER", False) and any(
-                word in current_input.lower() for word in ["search", "web", "browse"]
-            ):
-                tool_run_id = str(uuid.uuid4())
-
-                yield {
-                    "event": "on_tool_start",
-                    "run_id": tool_run_id,
-                    "name": "BrowserTool",
-                    "data": {"input": {"query": current_input}},
-                }
-                await asyncio.sleep(0.3)
-
-                yield {
-                    "event": "on_tool_end",
-                    "run_id": tool_run_id,
-                    "name": "BrowserTool",
-                    "data": {"output": "Simulated web search results for: " + current_input},
-                }
-                tools_used.append("Performed web search")
-
-            # 2. Build final response
-            response_parts = []
-
-            response_parts.append(f"Processed input: '{current_input}'")
-            response_parts.append(f"Available tools: {len(tools)}")
-            # final_response = "CUGA Agent Response:\n" + "\n".join(response_parts)
-            last_event: StreamEvent = None
-            tool_run_id = None
-            # 3. Chain end event with AgentFinish
-            async for event in cuga_agent.run_task_generic_yield(eval_mode=False, goal=current_input):
-                logger.debug(f"recieved event {event}")
-                if last_event is not None and tool_run_id is not None:
-                    logger.debug(f"last event {last_event}")
-                    try:
-                        # TODO: Extract data
-                        data_dict = json.loads(last_event.data)
-                    except json.JSONDecodeError:
-                        data_dict = last_event.data
-                    if last_event.name == "CodeAgent":
-                        data_dict = data_dict["code"]
-                    yield {
-                        "event": "on_tool_end",
-                        "run_id": tool_run_id,
-                        "name": last_event.name,
-                        "data": {"output": data_dict},
-                    }
-                if isinstance(event, StreamEvent):
-                    tool_run_id = str(uuid.uuid4())
-                    last_event = StreamEvent(name=event.name, data=event.data)
-                    tool_event = {
-                        "event": "on_tool_start",
-                        "run_id": tool_run_id,
-                        "name": event.name,
-                        "data": {"input": {}},
-                    }
-                    logger.debug(f"[CUGA] Yielding tool_start event: {event.name}")
-                    yield tool_event
-
-                if isinstance(event, AgentResult):
-                    task_result = event
-                    end_event = {
-                        "event": "on_chain_end",
-                        "run_id": str(uuid.uuid4()),
-                        "name": "CugaAgent",
-                        "data": {"output": AgentFinish(return_values={"output": task_result.answer}, log="")},
-                    }
-                    answer_preview = task_result.answer[:100] if task_result.answer else "None"
-                    logger.info(f"[CUGA] Yielding chain_end event with answer: {answer_preview}...")
-                    yield end_event
-            # task_result: AgentResult = await cuga_agent.run_task_generic_yield(
-            #     eval_mode=False, goal=current_input, on_progress=on_progress
-            # )
-
-        except (ValueError, TypeError, RuntimeError, ConnectionError) as e:
-            logger.error(f"An error occurred: {e!s}")
-            logger.error(f"Traceback: {traceback.format_exc()}")
-            error_msg = f"CUGA Agent error: {e!s}"
-            logger.error(f"[CUGA] Error occurred: {error_msg}")
-
-            # Emit error event
-            yield {
-                "event": "on_chain_error",
-                "run_id": str(uuid.uuid4()),
-                "name": "CugaAgent",
-                "data": {"error": error_msg},
-            }
-
-    async def message_response(self) -> Message:
-        """Generate a message response using the Cuga agent.
-
-        This method processes the input through the Cuga agent and returns a structured
-        message response. It handles agent initialization, tool setup, and event processing.
-
-        Returns:
-            Message: The agent's response message
-
-        Raises:
-            Exception: If there's an error during agent execution
-        """
-        logger.info("[CUGA] Starting Cuga agent run for message_response.")
-        logger.info(f"[CUGA] Agent input value: {self.input_value}")
-
-        # Validate input is not empty
-        if not self.input_value or not str(self.input_value).strip():
-            msg = "Message cannot be empty. Please provide a valid message."
-            raise ValueError(msg)
-
-        try:
-            llm_model, self.chat_history, self.tools = await self.get_agent_requirements()
-
-            # Create agent message for event processing
-            from lfx.schema.content_block import ContentBlock
-            from lfx.schema.message import MESSAGE_SENDER_AI
-
-            agent_message = Message(
-                sender=MESSAGE_SENDER_AI,
-                sender_name="Cuga",
-                properties={"icon": "Bot", "state": "partial"},
-                content_blocks=[ContentBlock(title="Agent Steps", contents=[])],
-                session_id=self.graph.session_id,
-            )
-
-            # Get input text
-            input_text = self.input_value.text if hasattr(self.input_value, "text") else str(self.input_value)
-
-            # Create event iterator from call_agent
-            event_iterator = self.call_agent(
-                current_input=input_text, tools=self.tools or [], history_messages=self.chat_history, llm=llm_model
-            )
-
-            # Process events using the existing event processing system
-            from lfx.base.agents.events import process_agent_events
-
-            # Create a wrapper that forces DB updates for event handlers
-            # This ensures the UI can see loading steps in real-time via polling
-            async def force_db_update_send_message(message, id_=None, *, skip_db_update=False):  # noqa: ARG001
-                # Always persist to DB so polling-based UI shows loading steps in real-time
-                content_blocks_len = len(message.content_blocks[0].contents) if message.content_blocks else 0
-                logger.debug(
-                    f"[CUGA] Sending message update - state: {message.properties.state}, "
-                    f"content_blocks: {content_blocks_len}"
-                )
-                result = await self.send_message(message, id_=id_, skip_db_update=False)
-                logger.debug(f"[CUGA] Message saved to DB with ID: {result.id if result else 'None'}")
-                return result
-
-            result = await process_agent_events(
-                event_iterator, agent_message, cast("SendMessageFunctionType", force_db_update_send_message)
-            )
-
-            logger.info("[CUGA] Agent run finished successfully.")
-            logger.info(f"[CUGA] Agent output: {result}")
-
-            # Store result for potential JSON output
-            self._agent_result = result
-
-        except Exception as e:
-            logger.error(f"[CUGA] Error in message_response: {e}")
-            logger.error(f"An error occurred: {e!s}")
-            logger.error(f"Traceback: {traceback.format_exc()}")
-
-            # Check if error is related to Playwright installation
-            error_str = str(e).lower()
-            if "playwright install" in error_str:
-                msg = (
-                    "Playwright is not installed. Please install Playwright Chromium using: "
-                    "uv run -m playwright install chromium"
-                )
-                raise ValueError(msg) from e
-
-            raise
-        else:
-            return result
-
-    async def get_agent_requirements(self):
-        """Get the agent requirements for the Cuga agent.
-
-        This method retrieves and configures all necessary components for the agent
-        including the language model, chat history, and tools.
-
-        Returns:
-            tuple: A tuple containing (llm_model, chat_history, tools)
-
-        Raises:
-            ValueError: If no language model is selected or if there's an error
-                in model initialization
-        """
-        llm_model, display_name = await self.get_llm()
-        if llm_model is None:
-            msg = "No language model selected. Please choose a model to proceed."
-            raise ValueError(msg)
-        self.model_name = get_model_name(llm_model, display_name=display_name)
-
-        # Get memory data
-        self.chat_history = await self.get_memory_data()
-        if isinstance(self.chat_history, Message):
-            self.chat_history = [self.chat_history]
-
-        # Add current date tool if enabled
-        if self.add_current_date_tool:
-            if not isinstance(self.tools, list):
-                self.tools = []
-            current_date_tool = (await CurrentDateComponent(**self.get_base_args()).to_toolkit()).pop(0)
-            if not isinstance(current_date_tool, StructuredTool):
-                msg = "CurrentDateComponent must be converted to a StructuredTool"
-                raise TypeError(msg)
-            self.tools.append(current_date_tool)
-
-        # --- ADDED LOGGING START ---
-        logger.info("[CUGA] Retrieved agent requirements: LLM, chat history, and tools.")
-        logger.info(f"[CUGA] LLM model: {self.model_name}")
-        logger.info(f"[CUGA] Number of chat history messages: {len(self.chat_history)}")
-        logger.info(f"[CUGA] Tools available: {[tool.name for tool in self.tools]}")
-        logger.info(f"[CUGA] metadata: {[tool.metadata for tool in self.tools]}")
-        # --- ADDED LOGGING END ---
-
-        return llm_model, self.chat_history, self.tools
-
-    def _preprocess_schema(self, schema):
-        """Preprocess schema to ensure correct data types for build_model_from_schema.
-
-        This method validates and normalizes the output schema to ensure it's compatible
-        with the Pydantic model building process.
-
-        Args:
-            schema: List of schema field definitions
-
-        Returns:
-            list: Processed schema with validated data types
-        """
-        processed_schema = []
-        for field in schema:
-            processed_field = {
-                "name": str(field.get("name", "field")),
-                "type": str(field.get("type", "str")),
-                "description": str(field.get("description", "")),
-                "multiple": field.get("multiple", False),
-            }
-            # Ensure multiple is handled correctly
-            if isinstance(processed_field["multiple"], str):
-                processed_field["multiple"] = processed_field["multiple"].lower() in ["true", "1", "t", "y", "yes"]
-            processed_schema.append(processed_field)
-        return processed_schema
-
-    async def build_structured_output_base(self, content: str):
-        """Build structured output with optional BaseModel validation.
-
-        This method parses JSON content from the agent response and optionally validates
-        it against a provided schema using Pydantic models.
-
-        Args:
-            content: The raw content from the agent response
-
-        Returns:
-            dict or list: Parsed and optionally validated JSON data
-        """
-        # --- ADDED LOGGING START ---
-        logger.info(f"[CUGA] Attempting to build structured output from content: {content}")
-        # --- ADDED LOGGING END ---
-
-        json_pattern = r"\{.*\}"
-        schema_error_msg = "Try setting an output schema"
-
-        # Try to parse content as JSON first
-        json_data = None
-        try:
-            json_data = json.loads(content)
-        except json.JSONDecodeError:
-            json_match = re.search(json_pattern, content, re.DOTALL)
-            if json_match:
-                try:
-                    json_data = json.loads(json_match.group())
-                except json.JSONDecodeError:
-                    logger.warning("[CUGA] Could not parse content as JSON even with regex match.")
-                    return {"content": content, "error": schema_error_msg}
-            else:
-                logger.warning("[CUGA] No JSON pattern found in the content.")
-                return {"content": content, "error": schema_error_msg}
-
-        # If no output schema provided, return parsed JSON without validation
-        if not hasattr(self, "output_schema") or not self.output_schema or len(self.output_schema) == 0:
-            logger.info("[CUGA] No output schema provided. Returning parsed JSON without validation.")
-            return json_data
-
-        # Use BaseModel validation with schema
-        try:
-            logger.info("[CUGA] Output schema detected. Validating structured output against schema.")
-            processed_schema = self._preprocess_schema(self.output_schema)
-            output_model = build_model_from_schema(processed_schema)
-
-            # Validate against the schema
-            if isinstance(json_data, list):
-                # Multiple objects
-                validated_objects = []
-                for item in json_data:
-                    try:
-                        validated_obj = output_model.model_validate(item)
-                        validated_objects.append(validated_obj.model_dump())
-                    except ValidationError as e:
-                        await logger.aerror(f"[CUGA] Validation error for item: {e}")
-                        validated_objects.append({"data": item, "validation_error": str(e)})
-                return validated_objects
-
-            # Single object
-            try:
-                validated_obj = output_model.model_validate(json_data)
-                return [validated_obj.model_dump()]
-            except ValidationError as e:
-                await logger.aerror(f"[CUGA] Validation error: {e}")
-                return [{"data": json_data, "validation_error": str(e)}]
-
-        except (TypeError, ValueError) as e:
-            await logger.aerror(f"[CUGA] Error building structured output: {e}")
-            return json_data
-
-    async def json_response(self) -> Data:
-        """Convert agent response to structured JSON Data output with schema validation.
-
-        This method generates a structured JSON response by combining system instructions,
-        format instructions, and schema information, then processing the agent's response
-        through structured output validation.
-
-        Returns:
-            Data: Structured data object containing the validated JSON response
-
-        Raises:
-            ExceptionWithMessageError: If there's an error in structured processing
-            ValueError: If there's a validation error
-            TypeError: If there's a type error in processing
-        """
-        # --- ADDED LOGGING START ---
-        logger.info("[CUGA] Starting Cuga agent run for json_response.")
-        logger.info(f"[CUGA] Agent input value: {self.input_value}")
-        # --- ADDED LOGGING END ---
-
-        try:
-            system_components = []
-
-            # 1. Agent Instructions
-            agent_instructions = getattr(self, "instructions", "") or ""
-            if agent_instructions:
-                system_components.append(f"{agent_instructions}")
-
-            # 3. Format Instructions
-            format_instructions = getattr(self, "format_instructions", "") or ""
-            if format_instructions:
-                system_components.append(f"Format instructions: {format_instructions}")
-
-            # 4. Schema Information
-            if hasattr(self, "output_schema") and self.output_schema and len(self.output_schema) > 0:
-                try:
-                    processed_schema = self._preprocess_schema(self.output_schema)
-                    output_model = build_model_from_schema(processed_schema)
-                    schema_dict = output_model.model_json_schema()
-                    schema_info = (
-                        "You are given some text that may include format instructions, "
-                        "explanations, or other content alongside a JSON schema.\n\n"
-                        "Your task:\n"
-                        "- Extract only the JSON schema.\n"
-                        "- Return it as valid JSON.\n"
-                        "- Do not include format instructions, explanations, or extra text.\n\n"
-                        "Input:\n"
-                        f"{json.dumps(schema_dict, indent=2)}\n\n"
-                        "Output (only JSON schema):"
-                    )
-                    system_components.append(schema_info)
-                except (ValidationError, ValueError, TypeError, KeyError) as e:
-                    await logger.aerror(f"[CUGA] Could not build schema for prompt: {e}", exc_info=True)
-
-            # Combine all components
-            combined_instructions = "\n\n".join(system_components) if system_components else ""
-
-            llm_model, self.chat_history, self.tools = await self.get_agent_requirements()
-
-            # Use call_agent for structured response
-            input_text = self.input_value.text if hasattr(self.input_value, "text") else str(self.input_value)
-
-            # Modify the input to include structured output requirements
-            structured_input = (
-                f"{combined_instructions}\n\nUser Input: {input_text}\n\nPlease provide a structured JSON response."
-            )
-
-            logger.info(f"[CUGA] Combined system prompt for structured agent: {combined_instructions}")
-
-            content = await self.call_agent(
-                current_input=structured_input,
-                tools=self.tools or [],
-                history_messages=self.chat_history,
-                llm=llm_model,
-            )
-
-            logger.info(f"[CUGA] Structured agent result: {content}")
-
-        except (ExceptionWithMessageError, ValueError, TypeError, NotImplementedError, AttributeError) as e:
-            await logger.aerror(f"[CUGA] Error with structured agent: {e}")
-            content_str = "No content returned from Cuga agent"
-            return Data(data={"content": content_str, "error": str(e)})
-
-        # Process with structured output validation
-        try:
-            structured_output = await self.build_structured_output_base(content)
-
-            # Handle different output formats
-            if isinstance(structured_output, list) and structured_output:
-                if len(structured_output) == 1:
-                    logger.info("[CUGA] Structured output is a single object in a list.")
-                    logger.info(f"[CUGA] Final structured output: {structured_output[0]}")
-                    return Data(data=structured_output[0])
-                logger.info("[CUGA] Structured output is a list of multiple objects.")
-                logger.info(f"[CUGA] Final structured output: {structured_output}")
-                return Data(data={"results": structured_output})
-            if isinstance(structured_output, dict):
-                logger.info("[CUGA] Structured output is a single dictionary.")
-                logger.info(f"[CUGA] Final structured output: {structured_output}")
-                return Data(data=structured_output)
-            logger.info("[CUGA] Structured output is not a list or dictionary. Returning raw content.")
-            logger.info(f"[CUGA] Final output content: {content}")
-            return Data(data={"content": content})
-
-        except (ValueError, TypeError) as e:
-            await logger.aerror(f"[CUGA] Error in structured output processing: {e}")
-            return Data(data={"content": content, "error": str(e)})
-
-    async def get_memory_data(self):
-        """Retrieve chat history messages.
-
-        This method fetches the conversation history from memory, excluding the current
-        input message to avoid duplication.
-
-        Returns:
-            list: List of Message objects representing the chat history
-        """
-        logger.info("[CUGA] Retrieving chat history messages.")
-        messages = (
-            await MemoryComponent(**self.get_base_args())
-            .set(session_id=self.graph.session_id, order="Ascending", n_messages=self.n_messages)
-            .retrieve_messages()
-        )
-        return [
-            message for message in messages if getattr(message, "id", None) != getattr(self.input_value, "id", None)
-        ]
-
-    async def get_llm(self):
-        """Get language model for the Cuga agent.
-
-        This method initializes and configures the language model based on the
-        selected provider and parameters.
-
-        Returns:
-            tuple: A tuple containing (llm_model, display_name)
-
-        Raises:
-            ValueError: If the model provider is invalid or model initialization fails
-        """
-        logger.info("[CUGA] Getting language model for the agent.")
-        logger.info(f"[CUGA] Requested LLM provider: {self.agent_llm}")
-
-        if not isinstance(self.agent_llm, str):
-            logger.info("[CUGA] Agent LLM is already a model instance.")
-            return self.agent_llm, None
-
-        try:
-            provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-            if not provider_info:
-                msg = f"Invalid model provider: {self.agent_llm}"
-                raise ValueError(msg)
-
-            component_class = provider_info.get("component_class")
-            display_name = component_class.display_name
-            inputs = provider_info.get("inputs")
-            prefix = provider_info.get("prefix", "")
-            logger.info(f"[CUGA] Successfully built LLM model from provider: {self.agent_llm}")
-            return self._build_llm_model(component_class, inputs, prefix), display_name
-
-        except (AttributeError, ValueError, TypeError, RuntimeError) as e:
-            await logger.aerror(f"[CUGA] Error building {self.agent_llm} language model: {e!s}")
-            msg = f"Failed to initialize language model: {e!s}"
-            raise ValueError(msg) from e
-
-    def _build_llm_model(self, component, inputs, prefix=""):
-        """Build LLM model with parameters.
-
-        This method constructs a language model instance using the provided component
-        class and input parameters.
-
-        Args:
-            component: The LLM component class to instantiate
-            inputs: List of input field definitions
-            prefix: Optional prefix for parameter names
-
-        Returns:
-            The configured LLM model instance
-        """
-        model_kwargs = {}
-        for input_ in inputs:
-            if hasattr(self, f"{prefix}{input_.name}"):
-                model_kwargs[input_.name] = getattr(self, f"{prefix}{input_.name}")
-        return component.set(**model_kwargs).build_model()
-
-    def set_component_params(self, component):
-        """Set component parameters based on provider.
-
-        This method configures component parameters according to the selected
-        model provider's requirements.
-
-        Args:
-            component: The component to configure
-
-        Returns:
-            The configured component
-        """
-        provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-        if provider_info:
-            inputs = provider_info.get("inputs")
-            prefix = provider_info.get("prefix")
-            model_kwargs = {}
-            for input_ in inputs:
-                if hasattr(self, f"{prefix}{input_.name}"):
-                    model_kwargs[input_.name] = getattr(self, f"{prefix}{input_.name}")
-            return component.set(**model_kwargs)
-        return component
-
-    def delete_fields(self, build_config: dotdict, fields: dict | list[str]) -> None:
-        """Delete specified fields from build_config.
-
-        This method removes unwanted fields from the build configuration.
-
-        Args:
-            build_config: The build configuration dictionary
-            fields: Fields to remove (can be dict or list of strings)
-        """
-        for field in fields:
-            build_config.pop(field, None)
-
-    def update_input_types(self, build_config: dotdict) -> dotdict:
-        """Update input types for all fields in build_config.
-
-        This method ensures all fields in the build configuration have proper
-        input types defined.
-
-        Args:
-            build_config: The build configuration to update
-
-        Returns:
-            dotdict: Updated build configuration with input types
-        """
-        for key, value in build_config.items():
-            if isinstance(value, dict):
-                if value.get("input_types") is None:
-                    build_config[key]["input_types"] = []
-            elif hasattr(value, "input_types") and value.input_types is None:
-                value.input_types = []
-        return build_config
-
-    async def update_build_config(
-        self, build_config: dotdict, field_value: str, field_name: str | None = None
-    ) -> dotdict:
-        """Update build configuration based on field changes.
-
-        This method dynamically updates the component's build configuration when
-        certain fields change, particularly the model provider selection.
-
-        Args:
-            build_config: The current build configuration
-            field_value: The new value for the field
-            field_name: The name of the field being changed
-
-        Returns:
-            dotdict: Updated build configuration
-
-        Raises:
-            ValueError: If required keys are missing from the configuration
-        """
-        if field_name in ("agent_llm",):
-            build_config["agent_llm"]["value"] = field_value
-            provider_info = MODEL_PROVIDERS_DICT.get(field_value)
-            if provider_info:
-                component_class = provider_info.get("component_class")
-                if component_class and hasattr(component_class, "update_build_config"):
-                    build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
-                    )
-
-            provider_configs: dict[str, tuple[dict, list[dict]]] = {
-                provider: (
-                    MODEL_PROVIDERS_DICT[provider]["fields"],
-                    [
-                        MODEL_PROVIDERS_DICT[other_provider]["fields"]
-                        for other_provider in MODEL_PROVIDERS_DICT
-                        if other_provider != provider
-                    ],
-                )
-                for provider in MODEL_PROVIDERS_DICT
-            }
-            if field_value in provider_configs:
-                fields_to_add, fields_to_delete = provider_configs[field_value]
-
-                # Delete fields from other providers
-                for fields in fields_to_delete:
-                    self.delete_fields(build_config, fields)
-
-                # Add provider-specific fields
-                if field_value == "OpenAI" and not any(field in build_config for field in fields_to_add):
-                    build_config.update(fields_to_add)
-                else:
-                    build_config.update(fields_to_add)
-                build_config["agent_llm"]["input_types"] = []
-            elif field_value == "Custom":
-                # Delete all provider fields
-                self.delete_fields(build_config, ALL_PROVIDER_FIELDS)
-                # Update with custom component
-                custom_component = DropdownInput(
-                    name="agent_llm",
-                    display_name="Language Model",
-                    options=[*sorted(MODEL_PROVIDERS), "Custom"],
-                    value="Custom",
-                    real_time_refresh=True,
-                    input_types=["LanguageModel"],
-                    options_metadata=[MODELS_METADATA[key] for key in sorted(MODELS_METADATA.keys())]
-                    + [{"icon": "brain"}],
-                )
-                build_config.update({"agent_llm": custom_component.to_dict()})
-
-            # Update input types for all fields
-            build_config = self.update_input_types(build_config)
-
-            # Validate required keys
-            default_keys = [
-                "code",
-                "_type",
-                "agent_llm",
-                "tools",
-                "input_value",
-                "add_current_date_tool",
-                "policies",
-                "agent_description",
-                "max_iterations",
-                "handle_parsing_errors",
-                "verbose",
-            ]
-            missing_keys = [key for key in default_keys if key not in build_config]
-            if missing_keys:
-                msg = f"Missing required keys in build_config: {missing_keys}"
-                raise ValueError(msg)
-
-        if (
-            isinstance(self.agent_llm, str)
-            and self.agent_llm in MODEL_PROVIDERS_DICT
-            and field_name in MODEL_DYNAMIC_UPDATE_FIELDS
-        ):
-            provider_info = MODEL_PROVIDERS_DICT.get(self.agent_llm)
-            if provider_info:
-                component_class = provider_info.get("component_class")
-                component_class = self.set_component_params(component_class)
-                prefix = provider_info.get("prefix")
-                if component_class and hasattr(component_class, "update_build_config"):
-                    if isinstance(field_name, str) and isinstance(prefix, str):
-                        field_name = field_name.replace(prefix, "")
-                    build_config = await update_component_build_config(
-                        component_class, build_config, field_value, "model_name"
-                    )
-        return dotdict({k: v.to_dict() if hasattr(v, "to_dict") else v for k, v in build_config.items()})
-
-    async def _get_tools(self) -> list[Tool]:
-        """Build agent tools.
-
-        This method constructs the list of tools available to the Cuga agent,
-        including component tools and any additional configured tools.
-
-        Returns:
-            list[Tool]: List of available tools for the agent
-        """
-        logger.info("[CUGA] Building agent tools.")
-        component_toolkit = _get_component_toolkit()
-        tools_names = self._build_tools_names()
-        agent_description = self.get_tool_description()
-        description = f"{agent_description}{tools_names}"
-        tools = component_toolkit(component=self).get_tools(
-            tool_name="Call_CugaAgent", tool_description=description, callbacks=self.get_langchain_callbacks()
-        )
-        if hasattr(self, "tools_metadata"):
-            tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
-        logger.info(f"[CUGA] Tools built: {[tool.name for tool in tools]}")
-        return tools