eah-langflow-comp 0.1.0__tar.gz

eah_langflow_comp-0.1.0/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: eah_langflow_comp
+Version: 0.1.0
+Summary: A Python package for AI-powered workflows
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: langflow<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.0.260; extra == "dev"
+
+# EAH AI Flow
+
+A Python package for AI-powered workflows.
+
+## Installation
+
+```bash
+pip install eah_langflow_comp
+```
+
+## Usage
+
+```python
+from eah_langflow_comp import AgentComponent
+```
+
+## License
+
+MIT

eah_langflow_comp-0.1.0/README.md

@@ -0,0 +1,19 @@
+# EAH AI Flow
+
+A Python package for AI-powered workflows.
+
+## Installation
+
+```bash
+pip install eah_langflow_comp
+```
+
+## Usage
+
+```python
+from eah_langflow_comp import AgentComponent
+```
+
+## License
+
+MIT

eah_langflow_comp-0.1.0/eah_langflow_comp.egg-info/PKG-INFO

@@ -0,0 +1,41 @@
+Metadata-Version: 2.4
+Name: eah_langflow_comp
+Version: 0.1.0
+Summary: A Python package for AI-powered workflows
+Author-email: Your Name <your.email@example.com>
+License: MIT
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+Requires-Dist: langflow<2.0.0,>=1.0.0
+Provides-Extra: dev
+Requires-Dist: pytest>=7.0; extra == "dev"
+Requires-Dist: black>=23.0; extra == "dev"
+Requires-Dist: ruff>=0.0.260; extra == "dev"
+
+# EAH AI Flow
+
+A Python package for AI-powered workflows.
+
+## Installation
+
+```bash
+pip install eah_langflow_comp
+```
+
+## Usage
+
+```python
+from eah_langflow_comp import AgentComponent
+```
+
+## License
+
+MIT

eah_langflow_comp-0.1.0/eah_langflow_comp.egg-info/SOURCES.txt

@@ -0,0 +1,11 @@
+README.md
+pyproject.toml
+eah_langflow_comp.egg-info/PKG-INFO
+eah_langflow_comp.egg-info/SOURCES.txt
+eah_langflow_comp.egg-info/dependency_links.txt
+eah_langflow_comp.egg-info/requires.txt
+eah_langflow_comp.egg-info/top_level.txt
+src/custom_agent_comp.py
+src/custom_base_agent_comp.py
+src/custom_mcp_comp.py
+src/message_2_text.py

eah_langflow_comp-0.1.0/eah_langflow_comp.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

eah_langflow_comp-0.1.0/eah_langflow_comp.egg-info/requires.txt

@@ -0,0 +1,6 @@
+langflow<2.0.0,>=1.0.0
+
+[dev]
+pytest>=7.0
+black>=23.0
+ruff>=0.0.260

eah_langflow_comp-0.1.0/eah_langflow_comp.egg-info/top_level.txt

@@ -0,0 +1 @@
+src

eah_langflow_comp-0.1.0/pyproject.toml

@@ -0,0 +1,46 @@
+[build-system]
+requires = ["setuptools>=68.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "eah_langflow_comp"
+version = "0.1.0"
+description = "A Python package for AI-powered workflows"
+readme = "README.md"
+requires-python = ">=3.8"
+license = {text = "MIT"}
+authors = [
+    {name = "Your Name", email = "your.email@example.com"}
+]
+classifiers = [
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+]
+dependencies = [
+    "langflow>=1.0.0,<2.0.0",  # 限定版本范围，避免兼容性问题
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "black>=23.0",
+    "ruff>=0.0.260",
+]
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["src*"]
+
+[tool.black]
+line-length = 88
+target-version = ['py38']
+
+[tool.ruff]
+line-length = 88
+target-version = "py38"

eah_langflow_comp-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

eah_langflow_comp-0.1.0/src/custom_agent_comp.py

@@ -0,0 +1,72 @@
+from lfx.base.agents.events import ExceptionWithMessageError
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.message import Message
+from .custom_base_agent_comp import BaseAgentComponent
+
+
+class AgentComponent(BaseAgentComponent):
+    """在 BaseAgentComponent 基础上，为使用含前置下划线参数名的 MCP tool 提供兼容支持。
+
+    重写的方法
+    ----------
+    message_response  -- 全程激活 json_schema create_model patch
+    json_response     -- 同上
+    """
+
+    display_name: str = "Agent(custom)"
+    description: str = "Define the agent's instructions, then enter a task to complete using tools."
+    documentation: str = "https://docs.langflow.org/agents"
+    icon = "bot"
+    beta = False
+    name = "Agent"
+
+    # ------------------------------------------------------------------
+    # MCP patch 工具方法
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _apply_pydantic_patch() -> list[tuple]:
+        """确保 lfx.schema.json_schema.create_model patch 已安装（幂等）。
+
+        patch 将 MCP tool args_schema 中前置下划线字段名改为 field_xxx，
+        使 Pydantic v2 能正常构建 model，不抛 NameError。
+        返回空列表（patch 是进程级永久 patch，无需还原）。
+        """
+        try:
+            import lfx.schema.json_schema as _js  # noqa: PLC2701
+            if not getattr(_js, "_mcp_create_model_patched", False):
+                from langflow.eah_langflow_comp.src.custom_mcp_comp import CustomMCPToolsComponent  # noqa: PLC2701
+                CustomMCPToolsComponent._install_json_schema_create_model_patch()
+        except Exception:
+            pass
+        return []
+
+    @staticmethod
+    def _restore_pydantic_patch(patches: list[tuple]) -> None:
+        pass  # no-op：patch 是进程级永久 patch
+
+    # ------------------------------------------------------------------
+    # 重写父类方法：在 agent 生命周期内保持 patch 激活
+    # ------------------------------------------------------------------
+
+    async def message_response(self) -> Message:
+        """重写：全程激活 MCP json_schema patch 后再运行 agent。"""
+        patches = self._apply_pydantic_patch()
+        try:
+            return await super().message_response()
+        except (ValueError, TypeError, KeyError, ExceptionWithMessageError):
+            raise
+        except Exception as e:
+            await logger.aerror(f"Unexpected error: {e!s}")
+            raise
+        finally:
+            self._restore_pydantic_patch(patches)
+
+    async def json_response(self) -> Data:
+        """重写：全程激活 MCP json_schema patch 后再运行结构化输出 agent。"""
+        patches = self._apply_pydantic_patch()
+        try:
+            return await super().json_response()
+        finally:
+            self._restore_pydantic_patch(patches)

eah_langflow_comp-0.1.0/src/custom_base_agent_comp.py

@@ -0,0 +1,441 @@
+import json
+import re
+
+from langchain.agents import create_tool_calling_agent
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_core.tools import StructuredTool, Tool
+from pydantic import ValidationError
+
+from lfx.base.agents.agent import LCToolsAgentComponent
+from lfx.base.agents.events import ExceptionWithMessageError
+from lfx.base.models.model_utils import get_model_name
+from lfx.components.helpers import CurrentDateComponent
+from lfx.components.langchain_utilities.tool_calling import ToolCallingAgentComponent
+from lfx.components.models_and_agents.memory import MemoryComponent
+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.inputs.inputs import BoolInput, SecretStrInput, StrInput
+from lfx.io import DropdownInput, IntInput, MessageTextInput, MultilineInput, Output, TableInput, SliderInput
+from lfx.field_typing.range_spec import RangeSpec
+from lfx.log.logger import logger
+from lfx.schema.data import Data
+from lfx.schema.dotdict import dotdict
+from lfx.schema.message import Message
+from lfx.schema.table import EditMode
+from langchain_openai import ChatOpenAI
+
+
+def set_advanced_true(component_input):
+    component_input.advanced = True
+    return component_input
+
+
+class BaseAgentComponent(LCToolsAgentComponent):
+    display_name: str = "Base Agent(custom)"
+    description: str = "Define the agent's instructions, then enter a task to complete using tools."
+    documentation: str = "https://docs.langflow.org/agents"
+    icon = "bot"
+    beta = False
+    name = "BaseAgent"
+
+    memory_inputs = [set_advanced_true(component_input) for component_input in MemoryComponent().inputs]
+
+    inputs = [
+        SecretStrInput(
+            name="api_key",
+            display_name="API Key",
+            info="The API key to use for the model.",
+            required=True,
+        ),
+        StrInput(
+            name="base_url",
+            display_name="Base URL",
+            info="The base URL of the API.",
+            required=True,
+            show=True,
+        ),
+        IntInput(
+            name="max_output_tokens",
+            display_name="Max Output Tokens",
+            info="The maximum number of tokens to generate.",
+            show=False,
+        ),
+        SliderInput(
+            name="temperature",
+            display_name="Temperature",
+            value=0.1,
+            info="Controls randomness in responses",
+            range_spec=RangeSpec(min=0, max=1, step=0.01),
+            advanced=True,
+        ),
+        StrInput(
+            name="model_name",
+            display_name="Model Name",
+            info="The name of the model to use.",
+            required=True,
+            show=True,
+        ),
+        MultilineInput(
+            name="system_prompt",
+            display_name="Agent Instructions",
+            info="System Prompt: Initial instructions and context provided to guide the agent's behavior.",
+            value="You are a helpful assistant that can use tools to answer questions and perform tasks.",
+            advanced=False,
+        ),
+        MessageTextInput(
+            name="context_id",
+            display_name="Context ID",
+            info="The context ID of the chat. Adds an extra layer to the local memory.",
+            value="",
+            advanced=True,
+        ),
+        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,
+        ),
+        *LCToolsAgentComponent.get_base_inputs(),
+        # removed memory inputs from agent component
+        # *memory_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,
+        ),
+    ]
+    outputs = [
+        Output(name="response", display_name="Response", method="message_response"),
+    ]
+
+    async def get_agent_requirements(self):
+        """Get the agent requirements for the agent."""
+        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()
+        await logger.adebug(f"Retrieved {len(self.chat_history)} chat history messages")
+        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):  # type: ignore[has-type]
+                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)
+
+        # Set shared callbacks for tracing the tools used by the agent
+        self.set_tools_callbacks(self.tools, self._get_shared_callbacks())
+
+        return llm_model, self.chat_history, self.tools
+
+    async def message_response(self) -> Message:
+        try:
+            llm_model, self.chat_history, self.tools = await self.get_agent_requirements()
+            # Set up and run agent
+            self.set(
+                llm=llm_model,
+                tools=self.tools or [],
+                chat_history=self.chat_history,
+                input_value=self.input_value,
+                system_prompt=self.system_prompt,
+            )
+            agent = self.create_agent_runnable()
+            result = await self.run_agent(agent)
+
+            # Store result for potential JSON output
+            self._agent_result = result
+
+        except (ValueError, TypeError, KeyError) as e:
+            await logger.aerror(f"{type(e).__name__}: {e!s}")
+            raise
+        except ExceptionWithMessageError as e:
+            await logger.aerror(f"ExceptionWithMessageError occurred: {e}")
+            raise
+        # Avoid catching blind Exception; let truly unexpected exceptions propagate
+        except Exception as e:
+            await logger.aerror(f"Unexpected error: {e!s}")
+            raise
+        else:
+            return result
+
+    def _preprocess_schema(self, schema):
+        """Preprocess schema to ensure correct data types for build_model_from_schema."""
+        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."""
+        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:
+                    return {"content": content, "error": schema_error_msg}
+            else:
+                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:
+            return json_data
+
+        # Use BaseModel validation with schema
+        try:
+            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"Validation error for item: {e}")
+                        # Include invalid items with error info
+                        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()]  # Return as list for consistency
+            except ValidationError as e:
+                await logger.aerror(f"Validation error: {e}")
+                return [{"data": json_data, "validation_error": str(e)}]
+
+        except (TypeError, ValueError) as e:
+            await logger.aerror(f"Error building structured output: {e}")
+            # Fallback to parsed JSON without validation
+            return json_data
+
+    async def json_response(self) -> Data:
+        """Convert agent response to structured JSON Data output with schema validation."""
+        # Always use structured chat agent for JSON response mode for better JSON formatting
+        try:
+            system_components = []
+
+            # 1. Agent Instructions (system_prompt)
+            agent_instructions = getattr(self, "system_prompt", "") or ""
+            if agent_instructions:
+                system_components.append(f"{agent_instructions}")
+
+            # 2. Format Instructions
+            format_instructions = getattr(self, "format_instructions", "") or ""
+            if format_instructions:
+                system_components.append(f"Format instructions: {format_instructions}")
+
+            # 3. Schema Information from BaseModel
+            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"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()
+            self.set(
+                llm=llm_model,
+                tools=self.tools or [],
+                chat_history=self.chat_history,
+                input_value=self.input_value,
+                system_prompt=combined_instructions,
+            )
+
+            # Create and run structured chat agent
+            try:
+                structured_agent = self.create_agent_runnable()
+            except (NotImplementedError, ValueError, TypeError) as e:
+                await logger.aerror(f"Error with structured chat agent: {e}")
+                raise
+            try:
+                result = await self.run_agent(structured_agent)
+            except (
+                ExceptionWithMessageError,
+                ValueError,
+                TypeError,
+                RuntimeError,
+            ) as e:
+                await logger.aerror(f"Error with structured agent result: {e}")
+                raise
+            # Extract content from structured agent result
+            if hasattr(result, "content"):
+                content = result.content
+            elif hasattr(result, "text"):
+                content = result.text
+            else:
+                content = str(result)
+
+        except (
+            ExceptionWithMessageError,
+            ValueError,
+            TypeError,
+            NotImplementedError,
+            AttributeError,
+        ) as e:
+            await logger.aerror(f"Error with structured chat agent: {e}")
+            # Fallback to regular agent
+            content_str = "No content returned from 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:
+                    return Data(data=structured_output[0])
+                return Data(data={"results": structured_output})
+            if isinstance(structured_output, dict):
+                return Data(data=structured_output)
+            return Data(data={"content": content})
+
+        except (ValueError, TypeError) as e:
+            await logger.aerror(f"Error in structured output processing: {e}")
+            return Data(data={"content": content, "error": str(e)})
+
+    async def get_memory_data(self):
+        # TODO: This is a temporary fix to avoid message duplication. We should develop a function for this.
+        messages = (
+            await MemoryComponent(**self.get_base_args())
+            .set(
+                session_id=self.graph.session_id,
+                context_id=self.context_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):
+        try:
+            return ChatOpenAI(
+                temperature=self.temperature,
+                model=self.model_name,
+                api_key=self.api_key,
+                base_url=self.base_url,
+            ), "OpenAI"
+
+        except (AttributeError, ValueError, TypeError, RuntimeError) as e:
+            await logger.aerror(f"Error building language model: {e!s}")
+            msg = f"Failed to initialize language model: {e!s}"
+            raise ValueError(msg) from e
+
+    def create_agent_runnable(self):
+        """Create the tool-calling agent.
+        
+        Returns:
+            A runnable agent that can use tools to complete tasks.
+        """
+        messages = [
+            ("system", "{system_prompt}"),
+            ("placeholder", "{chat_history}"),
+            ("human", "{input}"),
+            ("placeholder", "{agent_scratchpad}"),
+        ]
+        prompt = ChatPromptTemplate.from_messages(messages)
+        self.validate_tool_names()
+        try:
+            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."
+            raise NotImplementedError(message) from e
+
+
+    async def update_build_config(
+        self, build_config: dotdict, field_value: str, field_name: str | None = None
+    ) -> dotdict:
+        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]:
+        component_toolkit = get_component_toolkit()
+        tools_names = self._build_tools_names()
+        agent_description = self.get_tool_description()
+        # TODO: Agent Description Depreciated Feature to be removed
+        description = f"{agent_description}{tools_names}"
+
+        tools = component_toolkit(component=self).get_tools(
+            tool_name="Call_Agent",
+            tool_description=description,
+            # here we do not use the shared callbacks as we are exposing the agent as a tool
+            callbacks=self.get_langchain_callbacks(),
+        )
+        if hasattr(self, "tools_metadata"):
+            tools = component_toolkit(component=self, metadata=self.tools_metadata).update_tools_metadata(tools=tools)
+
+        return tools

eah_langflow_comp-0.1.0/src/custom_mcp_comp.py

@@ -0,0 +1,377 @@
+from __future__ import annotations
+
+import copy
+import functools
+import json
+
+from lfx.base.mcp.util import create_input_schema_from_json_schema, update_tools
+from lfx.components.models_and_agents.mcp_component import MCPToolsComponent
+from lfx.io.schema import flatten_schema, schema_to_langflow_inputs
+from lfx.log.logger import logger
+from lfx.schema.dataframe import DataFrame
+from lfx.schema.message import Message
+from lfx.base.agents.utils import maybe_unflatten_dict
+
+
+class CustomMCPToolsComponent(MCPToolsComponent):
+    """MCP Tools 组件的扩展版本。
+
+    在 MCPToolsComponent 基础上，额外处理 MCP server 返回的 tool 参数名中
+    含有前置下划线（如 ``_param``）的场景。
+
+    Pydantic v2 禁止以 ``_`` 开头的字段名，因此在构建 args_schema 时会报错。
+    本组件通过在 ``lfx.schema.json_schema`` 模块的 ``create_model`` 上安装
+    一次性字段名净化 patch 来绕过该限制，并在调用 MCP server 时还原原始名。
+
+    重写的方法
+    ----------
+    _validate_schema_inputs   -- 净化 schema 后再生成 LangFlow 输入
+    get_inputs_for_all_tools  -- 净化 schema 后再生成 LangFlow 输入
+    update_tool_list          -- 通过 _safe_update_tools 加载 tools
+    build_output              -- 执行时还原字段名映射
+    """
+
+    display_name = "Custom MCP Tools"
+    name = "CustomMCPTools"
+
+    # ------------------------------------------------------------------
+    # 字段名净化工具方法
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _sanitize_field_name(name: str) -> str:
+        """将前置下划线字段名改为 ``field_xxx`` 形式。"""
+        if name.startswith("_"):
+            return "field" + name
+        return name
+
+    @staticmethod
+    def _build_field_name_mapping(schema_dict: dict) -> dict[str, str]:
+        """构建 净化名 -> 原始名 的映射表。"""
+        mapping = {}
+        for field_name in schema_dict.get("properties", {}):
+            sanitized = CustomMCPToolsComponent._sanitize_field_name(field_name)
+            if sanitized != field_name:
+                mapping[sanitized] = field_name
+        return mapping
+
+    @staticmethod
+    def _sanitize_schema_dict(schema_dict: dict) -> dict:
+        """返回将 properties 中前置下划线字段名替换后的 schema 副本。"""
+        schema_copy = copy.deepcopy(schema_dict)
+        new_props = {}
+        for k, v in schema_copy.get("properties", {}).items():
+            new_props[CustomMCPToolsComponent._sanitize_field_name(k)] = v
+        schema_copy["properties"] = new_props
+        if "required" in schema_copy:
+            schema_copy["required"] = [
+                CustomMCPToolsComponent._sanitize_field_name(f)
+                for f in schema_copy["required"]
+            ]
+        return schema_copy
+
+    # ------------------------------------------------------------------
+    # json_schema.create_model 一次性 patch
+    # ------------------------------------------------------------------
+
+    @staticmethod
+    def _install_json_schema_create_model_patch() -> None:
+        """在 lfx.schema.json_schema 模块的 create_model 上安装净化 patch（幂等）。
+
+        该 patch 将字段名 ``_xxx`` 改为 ``field_xxx`` 再传给 Pydantic，
+        并在生成的 model class 上附加 ``__mcp_field_name_map__``（净化名->原始名），
+        供 coroutine 包装器还原参数名时使用。
+        """
+        try:
+            import lfx.schema.json_schema as _js  # noqa: PLC2701
+
+            if getattr(_js, "_mcp_create_model_patched", False):
+                return
+
+            _orig = _js.create_model
+
+            def _sanitized_create_model(__model_name: str, **field_definitions):
+                renamed: dict = {}
+                key_map: dict = {}
+                for k, v in field_definitions.items():
+                    if k.startswith("_") and not k.startswith("__"):
+                        new_k = "field" + k
+                        renamed[new_k] = v
+                        key_map[new_k] = k
+                    else:
+                        renamed[k] = v
+                model_cls = _orig(__model_name, **renamed)
+                if key_map:
+                    model_cls.__mcp_field_name_map__ = key_map
+                return model_cls
+
+            _js.create_model = _sanitized_create_model
+            _js._mcp_create_model_patched = True  # type: ignore[attr-defined]
+        except Exception:
+            pass
+
+    # ------------------------------------------------------------------
+    # 安全加载 tools
+    # ------------------------------------------------------------------
+
+    async def _safe_update_tools(self, server_name: str, server_config: dict):
+        """安装 patch 后调用 update_tools，并为 coroutine 添加参数名还原包装。"""
+        self._install_json_schema_create_model_patch()
+        try:
+            result = await update_tools(
+                server_name=server_name,
+                server_config=server_config,
+                mcp_stdio_client=self.stdio_client,
+                mcp_streamable_http_client=self.streamable_http_client,
+            )
+            if result is not None and len(result) == 3:
+                _, tool_list, tool_cache = result
+                self._wrap_tool_cache_coroutines(tool_cache)
+            return result
+        except Exception as e:
+            err_msg = str(e)
+            if "leading underscores" not in err_msg:
+                raise
+            await logger.awarning(
+                f"MCP tool schema still has leading-underscore field names "
+                f"for server '{server_name}': {err_msg}"
+            )
+            return None, [], {}
+
+    def _wrap_tool_cache_coroutines(self, tool_cache: dict) -> None:
+        """给 tool_cache 中每个 tool 的 coroutine 包装参数名还原逻辑。
+
+        ``create_model`` patch 把 ``_foo`` 改为 ``field_foo``，LLM 按净化后
+        的字段名传参；此包装器在调用真实 coroutine 前把参数名还原为原始名，
+        确保 MCP server 收到正确的参数。
+        """
+        for _tool_name, exec_tool in list(tool_cache.items()):
+            original_coroutine = getattr(exec_tool, "coroutine", None)
+            if original_coroutine is None:
+                continue
+            if getattr(original_coroutine, "_mcp_field_remapped", False):
+                continue
+
+            args_schema = getattr(exec_tool, "args_schema", None)
+            field_name_map: dict = getattr(args_schema, "__mcp_field_name_map__", {})
+            if not field_name_map:
+                continue
+
+            @functools.wraps(original_coroutine)
+            async def _remapped_coroutine(
+                *args,
+                _orig=original_coroutine,
+                _fmap=field_name_map,
+                **kwargs,
+            ):
+                restored = {_fmap.get(k, k): v for k, v in kwargs.items()}
+                return await _orig(*args, **restored)
+
+            _remapped_coroutine._mcp_field_remapped = True
+            exec_tool.coroutine = _remapped_coroutine
+
+    # ------------------------------------------------------------------
+    # 重写父类方法
+    # ------------------------------------------------------------------
+
+    async def _validate_schema_inputs(self, tool_obj):
+        """重写：净化 schema 字段名后再生成 LangFlow 输入，并记录字段名映射。"""
+        try:
+            if not tool_obj or not hasattr(tool_obj, "args_schema"):
+                raise ValueError("Invalid tool object or missing input schema")
+
+            raw_schema = tool_obj.args_schema.schema()
+            sanitized_schema = self._sanitize_schema_dict(raw_schema)
+
+            # 记录净化名->原始名映射，供 build_output 还原
+            mapping = self._build_field_name_mapping(raw_schema)
+            if mapping:
+                if not hasattr(self, "_tool_field_name_mapping"):
+                    self._tool_field_name_mapping = {}
+                self._tool_field_name_mapping[tool_obj.name] = mapping
+
+            flat_schema = flatten_schema(sanitized_schema)
+            input_schema = create_input_schema_from_json_schema(flat_schema)
+            if not input_schema:
+                raise ValueError(f"Empty input schema for tool '{tool_obj.name}'")
+
+            schema_inputs = schema_to_langflow_inputs(input_schema)
+            if not schema_inputs:
+                await logger.awarning(f"No input parameters defined for tool '{tool_obj.name}'")
+                return []
+
+        except Exception as e:
+            msg = f"Error validating schema inputs: {e!s}"
+            await logger.aexception(msg)
+            raise ValueError(msg) from e
+        else:
+            return schema_inputs
+
+    def get_inputs_for_all_tools(self, tools: list) -> dict:
+        """重写：净化 schema 字段名后再生成 LangFlow 输入。"""
+        inputs = {}
+        for tool in tools:
+            if not tool or not hasattr(tool, "name"):
+                continue
+            try:
+                raw_schema = tool.args_schema.schema()
+                sanitized_schema = self._sanitize_schema_dict(raw_schema)
+                flat_schema = flatten_schema(sanitized_schema)
+                input_schema = create_input_schema_from_json_schema(flat_schema)
+                inputs[tool.name] = schema_to_langflow_inputs(input_schema)
+            except (AttributeError, ValueError, TypeError, KeyError) as e:
+                logger.exception(f"Error getting inputs for tool {getattr(tool, 'name', 'unknown')}: {e!s}")
+                continue
+        return inputs
+
+    async def update_tool_list(self, mcp_server_value=None):
+        """重写：将内部的 ``update_tools`` 调用替换为 ``_safe_update_tools``。"""
+        from lfx.base.agents.utils import safe_cache_get, safe_cache_set
+        import asyncio
+
+        mcp_server = mcp_server_value if mcp_server_value is not None else getattr(self, "mcp_server", None)
+        server_name = None
+        server_config_from_value = None
+        if isinstance(mcp_server, dict):
+            server_name = mcp_server.get("name")
+            server_config_from_value = mcp_server.get("config")
+        else:
+            server_name = mcp_server
+        if not server_name:
+            self.tools = []
+            return [], {"name": server_name, "config": server_config_from_value}
+
+        use_cache = getattr(self, "use_cache", False)
+
+        cached = None
+        if use_cache:
+            servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+            cached = servers_cache.get(server_name) if isinstance(servers_cache, dict) else None
+
+        if cached is not None:
+            try:
+                self.tools = cached["tools"]
+                self.tool_names = cached["tool_names"]
+                self._tool_cache = cached["tool_cache"]
+                server_config_from_value = cached["config"]
+            except (TypeError, KeyError, AttributeError) as e:
+                await logger.awarning(f"Unable to use cached data for MCP Server {server_name}: {e}")
+                current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                if isinstance(current_servers_cache, dict) and server_name in current_servers_cache:
+                    current_servers_cache.pop(server_name)
+                    safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
+            else:
+                return self.tools, {"name": server_name, "config": server_config_from_value}
+
+        try:
+            try:
+                from langflow.api.v2.mcp import get_server
+                from langflow.services.database.models.user.crud import get_user_by_id
+            except ImportError as e:
+                raise ImportError(
+                    "Langflow MCP server functionality is not available. "
+                    "This feature requires the full Langflow installation."
+                ) from e
+
+            from lfx.services.deps import get_settings_service, get_storage_service, session_scope
+
+            async with session_scope() as db:
+                if not self.user_id:
+                    raise ValueError("User ID is required for fetching MCP tools.")
+                current_user = await get_user_by_id(db, self.user_id)
+                server_config = await get_server(
+                    server_name,
+                    current_user,
+                    db,
+                    storage_service=get_storage_service(),
+                    settings_service=get_settings_service(),
+                )
+
+            if not server_config and server_config_from_value:
+                server_config = server_config_from_value
+            if not server_config:
+                self.tools = []
+                return [], {"name": server_name, "config": server_config}
+
+            if "verify_ssl" not in server_config:
+                server_config["verify_ssl"] = getattr(self, "verify_ssl", True)
+
+            # ↓ 关键：使用 _safe_update_tools 替代直接调用 update_tools
+            _, tool_list, tool_cache = await self._safe_update_tools(
+                server_name=server_name,
+                server_config=server_config,
+            )
+
+            self.tool_names = [tool.name for tool in tool_list if hasattr(tool, "name")]
+            self._tool_cache = tool_cache
+            self.tools = tool_list
+
+            if use_cache:
+                current_servers_cache = safe_cache_get(self._shared_component_cache, "servers", {})
+                if isinstance(current_servers_cache, dict):
+                    current_servers_cache[server_name] = {
+                        "tools": tool_list,
+                        "tool_names": self.tool_names,
+                        "tool_cache": tool_cache,
+                        "config": server_config,
+                    }
+                    safe_cache_set(self._shared_component_cache, "servers", current_servers_cache)
+
+        except (TimeoutError, asyncio.TimeoutError) as e:
+            msg = f"Timeout updating tool list: {e!s}"
+            await logger.aexception(msg)
+            raise TimeoutError(msg) from e
+        except Exception as e:
+            msg = f"Error updating tool list: {e!s}"
+            await logger.aexception(msg)
+            raise ValueError(msg) from e
+        else:
+            return tool_list, {"name": server_name, "config": server_config}
+
+    async def build_output(self) -> DataFrame:
+        """重写：执行 tool 时将净化字段名还原为原始名再传给 MCP server。"""
+        try:
+            self.tools, _ = await self.update_tool_list()
+            if self.tool != "":
+                session_context = self._get_session_context()
+                if session_context:
+                    self.stdio_client.set_session_context(session_context)
+                    self.streamable_http_client.set_session_context(session_context)
+
+                exec_tool = self._tool_cache[self.tool]
+                tool_args = self.get_inputs_for_all_tools(self.tools)[self.tool]
+
+                # 收集用户填写的参数（字段名为净化后的名，如 field_param）
+                kwargs = {}
+                for arg in tool_args:
+                    value = getattr(self, arg.name, None)
+                    if value is not None:
+                        kwargs[arg.name] = value.text if isinstance(value, Message) else value
+
+                # 若 args_schema 携带映射表（由 create_model patch 写入），优先使用；
+                # 否则退回到 _tool_field_name_mapping（由 _validate_schema_inputs 写入）
+                args_schema = getattr(exec_tool, "args_schema", None)
+                field_name_map: dict = getattr(args_schema, "__mcp_field_name_map__", {})
+                if not field_name_map and hasattr(self, "_tool_field_name_mapping"):
+                    field_name_map = self._tool_field_name_mapping.get(self.tool, {})
+
+                if field_name_map:
+                    kwargs = {field_name_map.get(k, k): v for k, v in kwargs.items()}
+
+                unflattened_kwargs = maybe_unflatten_dict(kwargs)
+                output = await exec_tool.coroutine(**unflattened_kwargs)
+
+                tool_content = []
+                for item in output.content:
+                    item_dict = item.model_dump()
+                    item_dict = self.process_output_item(item_dict)
+                    tool_content.append(item_dict)
+
+                if isinstance(tool_content, list) and all(isinstance(x, dict) for x in tool_content):
+                    return DataFrame(tool_content)
+                return DataFrame(data=tool_content)
+            return DataFrame(data=[{"error": "You must select a tool"}])
+        except Exception as e:
+            msg = f"Error in build_output: {e!s}"
+            await logger.aexception(msg)
+            raise ValueError(msg) from e

eah_langflow_comp-0.1.0/src/message_2_text.py

@@ -0,0 +1,29 @@
+from lfx.custom.custom_component.component import Component
+from lfx.io import MessageTextInput, Output
+from lfx.schema.message import Message
+
+
+class Message2TextComponent(Component):
+    display_name: str = "Message to Text"
+    description: str = "Convert a message to a text prompt template."
+    icon = "braces"
+    name = "Message to Text"
+    priority = 0  # Set priority to 0 to make it appear first
+
+    inputs = [
+        MessageTextInput(
+            name="message",
+            display_name="message",
+            tool_mode=True,
+        ),
+    ]
+
+    outputs = [
+        Output(display_name="Text", name="text", method="build_text"),
+    ]
+
+    async def build_text(self) -> Message:
+        return self.message
+
+   
+