universal-mcp 0.1.24rc2__py3-none-any.whl → 0.1.24rc4__py3-none-any.whl

universal_mcp/utils/testing.py

@@ -1,9 +1,44 @@
+import os
+from dataclasses import dataclass
+
+from langchain_core.messages import AIMessage, HumanMessage
+from langgraph.prebuilt import create_react_agent
 from loguru import logger
+from pydantic import BaseModel, SecretStr
+
+from universal_mcp.agentr import AgentrIntegration
+from universal_mcp.agentr.client import AgentrClient
+from universal_mcp.applications import APIApplication, BaseApplication
+from universal_mcp.tools import Tool, ToolManager
+from universal_mcp.types import ToolFormat
+
+
+class ValidateResult(BaseModel):
+    success: bool
+    reasoning: str
+
+
+def check_application_instance(app_instance: BaseApplication, app_name: str):
+    """
+    Performs a series of assertions to validate an application instance and its tools.
 
-from universal_mcp.tools.tools import Tool
+    This function checks for the following:
+    - The application instance is not None.
+    - The application instance's name matches the expected application name.
+    - The application has at least one tool.
+    - Each tool has a non-None name with a valid length (1-47 characters).
+    - Each tool has a non-None description.
+    - All tool names are unique within the application.
+    - The application has at least one tool tagged as "important".
 
+    Args:
+        app_instance: The application instance to check. Must be an instance of BaseApplication.
+        app_name: The expected name of the application.
+
+    Raises:
+        AssertionError: If any of the validation checks fail.
+    """
 
-def check_application_instance(app_instance, app_name):
     assert app_instance is not None, f"Application object is None for {app_name}"
     assert app_instance.name == app_name, (
         f"Application instance name '{app_instance.name}' does not match expected name '{app_name}'"
@@ -29,3 +64,156 @@ def check_application_instance(app_instance, app_name):
         if "important" in tool.tags:
             important_tools.append(tool.name)
     assert len(important_tools) > 0, f"No important tools found for {app_name}"
+
+
+@dataclass
+class AutomationTestCase:
+    """Generic test case for automation testing."""
+
+    app: str
+    app_instance: APIApplication | None = None
+    tools: list[str] | None = None
+    tasks: list[str] | None = None
+    validate_query: str | None = None
+
+
+def create_agentr_client(app_name: str) -> AgentrClient:
+    """
+    Create an AgentrClient with appropriate API key and base URL.
+
+    Args:
+        app_name: Name of the application (used for app-specific environment variables)
+
+    Returns:
+        AgentrClient instance
+    """
+    api_key = os.environ.get(f"{app_name.upper()}_API_KEY") or os.environ.get("AGENTR_API_KEY")
+    base_url = os.environ.get(f"{app_name.upper()}_BASE_URL") or os.environ.get(
+        "AGENTR_BASE_URL", "https://api.agentr.dev"
+    )
+    return AgentrClient(api_key=api_key, base_url=base_url)
+
+
+def create_integration(app_name: str) -> AgentrIntegration:
+    """
+    Create an AgentRIntegration instance with appropriate client.
+
+    Args:
+        app_name: Name of the application
+
+    Returns:
+        AgentRIntegration instance
+    """
+    client = create_agentr_client(app_name)
+    return AgentrIntegration(name=app_name, client=client)
+
+
+def create_app_with_integration(app_name: str, app_class: type[APIApplication]) -> APIApplication:
+    """
+    Create an application instance with integration.
+
+    Args:
+        app_name: Name of the application
+        app_class: Class of the application to instantiate
+
+    Returns:
+        Application instance with integration
+    """
+    integration = create_integration(app_name)
+    return app_class(integration=integration)
+
+
+def load_app_with_integration(app_name: str, app_class: type[APIApplication]) -> APIApplication:
+    """
+    Load application instance with real integration.
+
+    Args:
+        app_name: Name of the application
+        app_class: Class of the application to instantiate
+
+    Returns:
+        Instantiated application with integration
+    """
+    integration = create_integration(app_name)
+    return app_class(integration=integration)
+
+
+async def execute_automation_test(test_case: AutomationTestCase, app_instance: APIApplication | None = None) -> None:
+    """
+    Execute an automation test case using LangGraph ReAct agent.
+
+    Args:
+        test_case: Test case to execute
+        app_instance: The application instance to test (optional if provided in test_case)
+    """
+    tool_manager = ToolManager()
+
+    if app_instance is None:
+        app_instance = test_case.app_instance
+        if app_instance is None:
+            raise ValueError("No app_instance provided in test_case or as parameter")
+
+    all_tools = app_instance.list_tools()
+    logger.info(f"Available tools from app: {[getattr(t, '__name__', str(t)) for t in all_tools]}")
+
+    tool_manager.register_tools_from_app(app_instance)
+
+    all_registered = tool_manager.get_tools_by_app(app_name=app_instance.name)
+    logger.info(f"All registered tools: {[t.name for t in all_registered]}")
+
+    if test_case.tools:
+        tools = tool_manager.list_tools(
+            format=ToolFormat.LANGCHAIN, app_name=app_instance.name, tool_names=test_case.tools
+        )
+    else:
+        tools = tool_manager.list_tools(format=ToolFormat.LANGCHAIN, app_name=app_instance.name)
+
+    logger.info(f"Tools for test: {[tool.name for tool in tools]}")
+
+    azure_endpoint = os.environ.get("AZURE_OPENAI_ENDPOINT")
+    azure_api_key = os.environ.get("AZURE_OPENAI_API_KEY")
+    azure_deployment = os.environ.get("AZURE_OPENAI_DEPLOYMENT", "o4-mini")
+    api_version = os.environ.get("AZURE_OPENAI_API_VERSION", "2025-03-01-preview")
+
+    if not azure_endpoint or not azure_api_key:
+        raise ValueError(
+            "Azure OpenAI credentials not found. Please set AZURE_OPENAI_ENDPOINT and AZURE_OPENAI_API_KEY environment variables."
+        )
+
+    from langchain_openai import AzureChatOpenAI
+
+    llm = AzureChatOpenAI(
+        azure_endpoint=azure_endpoint,
+        azure_deployment=azure_deployment,
+        api_key=SecretStr(azure_api_key) if azure_api_key else None,
+        api_version=api_version,
+    )
+    logger.info(f"Using Azure OpenAI with deployment: {azure_deployment}")
+
+    agent = create_react_agent(
+        model=llm,
+        tools=tools,
+    )
+
+    messages = []
+    for task in test_case.tasks or []:
+        try:
+            messages.append(HumanMessage(content=task))
+            response = await agent.ainvoke({"messages": messages})
+            messages.append(AIMessage(content=response["messages"][-1].content))
+            logger.info(f"Task: {task}")
+            logger.info(f"Response: {response['messages'][-1].content}")
+            logger.info("---")
+        except Exception as e:
+            logger.error(f"Error: {e}")
+            import traceback
+
+            traceback.print_exc()
+            raise AssertionError(f"Task execution failed: {e}") from e
+
+    if test_case.validate_query:
+        messages.append(HumanMessage(content=test_case.validate_query))
+        structured_llm = llm.with_structured_output(ValidateResult)
+        result = await structured_llm.ainvoke(messages)
+        logger.info(f"Validation result: {result}")
+        assert result.success, f"Validation failed: {result.reasoning}"

{universal_mcp-0.1.24rc2.dist-info → universal_mcp-0.1.24rc4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: universal-mcp
-Version: 0.1.24rc2
+Version: 0.1.24rc4
 Summary: Universal MCP acts as a middle ware for your API applications. It can store your credentials, authorize, enable disable apps on the fly and much more.
 Author-email: Manoj Bajaj <manojbajaj95@gmail.com>
 License: MIT
@@ -8,17 +8,26 @@ License-File: LICENSE
 Requires-Python: >=3.11
 Requires-Dist: black>=25.1.0
 Requires-Dist: cookiecutter>=2.6.0
-Requires-Dist: gql[all]>=3.5.2
+Requires-Dist: gql[all]==4.0.0
 Requires-Dist: jinja2>=3.1.3
 Requires-Dist: jsonref>=1.1.0
 Requires-Dist: keyring>=25.6.0
+Requires-Dist: langchain-mcp-adapters>=0.1.9
+Requires-Dist: langchain-openai>=0.3.27
+Requires-Dist: langgraph-cli[inmem]>=0.3.4
+Requires-Dist: langgraph>=0.5.2
+Requires-Dist: langsmith>=0.4.5
 Requires-Dist: loguru>=0.7.3
-Requires-Dist: mcp>=1.9.3
+Requires-Dist: mcp>=1.10.0
+Requires-Dist: mkdocs-material>=9.6.15
+Requires-Dist: mkdocs>=1.6.1
 Requires-Dist: posthog>=3.24.0
 Requires-Dist: pydantic-settings>=2.8.1
 Requires-Dist: pydantic>=2.11.1
 Requires-Dist: pyyaml>=6.0.2
 Requires-Dist: rich>=14.0.0
+Requires-Dist: streamlit>=1.46.1
+Requires-Dist: ty>=0.0.1a17
 Requires-Dist: typer>=0.15.2
 Provides-Extra: dev
 Requires-Dist: litellm>=1.30.7; extra == 'dev'
@@ -28,6 +37,11 @@ Requires-Dist: pyright>=1.1.398; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.26.0; extra == 'dev'
 Requires-Dist: pytest>=8.3.5; extra == 'dev'
 Requires-Dist: ruff>=0.11.4; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-glightbox>=0.4.0; extra == 'docs'
+Requires-Dist: mkdocs-material[imaging]>=9.5.45; extra == 'docs'
+Requires-Dist: mkdocs>=1.6.1; extra == 'docs'
+Requires-Dist: mkdocstrings-python>=1.12.2; extra == 'docs'
 Description-Content-Type: text/markdown
 
 # Universal MCP

universal_mcp-0.1.24rc4.dist-info/RECORD

@@ -0,0 +1,71 @@
+universal_mcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/analytics.py,sha256=RzS88HSvJRGMjdJeLHnOgWzfKSb1jVnvOcD7NHqfERw,3733
+universal_mcp/cli.py,sha256=pPnIWLhSrLV9ukI8YAg2znehCR3VovhEkmh8XkRT3MU,2505
+universal_mcp/config.py,sha256=pkKs0gST65umzmNEvjHiOAtmiBaaICi45WG4Z0My0ak,11983
+universal_mcp/exceptions.py,sha256=Uen8UFgLHGlSwXgRUyF-nhqTwdiBuL3okgBVRV2AgtA,2150
+universal_mcp/logger.py,sha256=VmH_83efpErLEDTJqz55Dp0dioTXfGvMBLZUx5smOLc,2116
+universal_mcp/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/types.py,sha256=dVK7uSMuhvx5Xk6L7GGdjeaAIKiEwQskTmaVFwIS8LQ,176
+universal_mcp/agentr/README.md,sha256=xXM8JzPyrM2__pGhxHrGEUn9uP2y2bdF00wwcQtBUCI,6441
+universal_mcp/agentr/__init__.py,sha256=ogOhH_OJwkoUZu_2nQJc7-vEGmYQxEjOE511-6ubrX0,217
+universal_mcp/agentr/agentr.py,sha256=JfawuREfXAyeNUE7o58DzTPhmQXuwsB_Da7c1Gf3Qxw,1059
+universal_mcp/agentr/client.py,sha256=oyF6VKq56UMVf5L1WnFTMSZ85W8Qcy-5HZ5XOGiIELM,4139
+universal_mcp/agentr/integration.py,sha256=V5GjqocqS02tRoI8MeV9PL6m-BzejwBzgJhOHo4MxAE,4212
+universal_mcp/agentr/registry.py,sha256=b9sr5JyT3HLj3e7GFpdXpT7ofGwLQc--y8k2DqF5dE0,3542
+universal_mcp/agentr/server.py,sha256=bIPmHMiKKwnUYnxmfZVRh1thcn7Rytm_-bNiXTfANzc,2098
+universal_mcp/agents/__init__.py,sha256=vgixOLTCcCmSweENV7GSAuOPyHXlE4XAbvOXyr4MrRA,185
+universal_mcp/agents/auto.py,sha256=o__71BCOHSfaj7Xt0PhsamVXdeP4o7irhtmu1q6-3Fo,25336
+universal_mcp/agents/base.py,sha256=U5JtpOopmUi73qcxtY9T2qJpYD7e6c62iVlIr3m5Chc,3430
+universal_mcp/agents/cli.py,sha256=7GdRBpu9rhZPiC2vaNQXWI7K-0yCnvdlmE0IFpvy2Gk,539
+universal_mcp/agents/hil.py,sha256=CTgX7CoFEyTFIaNaL-id2WALOPd0VBb79pHkQK8quM8,3671
+universal_mcp/agents/llm.py,sha256=YNxN43bVhGfdYs09yPkdkGCKJkj-2UNqkB1EFmtnUS4,309
+universal_mcp/agents/react.py,sha256=6L--LcuU5Ityi2UiZSYJWgp-lXGkxvpsx8mjvpoNRBQ,2021
+universal_mcp/agents/simple.py,sha256=UfmQIIff--_Y0DQ6oivRciHqSZvRqy_qwQn_UYVzYy8,1146
+universal_mcp/agents/utils.py,sha256=7kwFpD0Rv6JqHG-LlNCVwSu_xRX-N119mUmiBroHJL4,4109
+universal_mcp/agents/codeact/__init__.py,sha256=5D_I3lI_3tWjZERRoFav_bPe9UDaJ53pDzZYtyixg3E,10097
+universal_mcp/agents/codeact/sandbox.py,sha256=lGRzhuXTHCB1qauuOI3bH1-fPTsyL6Lf9EmMIz4C2xQ,1039
+universal_mcp/agents/codeact/test.py,sha256=bva-KkBNbGZn2f9nmmo9SNPQnY24Ni5gLHhJ5I0cm0k,481
+universal_mcp/agents/codeact/utils.py,sha256=VuMvLTxBBh3pgaJk8RWj5AK8XZFF-1gnZJ6jFLeM_CI,1690
+universal_mcp/applications/__init__.py,sha256=HrCnGdAT7w4puw2_VulBfjOLku9D5DuMaOwAuQzu6nI,2067
+universal_mcp/applications/application.py,sha256=pGF9Rb2D6qzlaSwlcfZ-dNqPtsLkQTqL3jpsRuJ6-qE,23835
+universal_mcp/applications/sample/app.py,sha256=E0JwaWD7qytwawb_iWc1pBnJ-Te7MMtab4MxOOebLdc,8972
+universal_mcp/client/oauth.py,sha256=O00zOUfQxINaruFU2zt-64DIR1_mAqrY8ykLQo-teJU,8679
+universal_mcp/client/token_store.py,sha256=6VAzjzJG49wYvmEDqksFvb-fVqdjHIKWv7yYyh_AuF8,3912
+universal_mcp/client/transport.py,sha256=xgAKBJ1-yCcTtl9cxzJgRn6to5Y9EvCwLc_WpDck3Dg,11838
+universal_mcp/integrations/__init__.py,sha256=tfzLyPEPly5tfIcT8K6-oKCr_MEFGxOROHy_NeVy0KM,200
+universal_mcp/integrations/integration.py,sha256=H-hOoDHqk78A4Fi_TGN7OOFS7PDfqXK_nedH8iSz-6A,16459
+universal_mcp/servers/__init__.py,sha256=speBb_E94UJa4A6Fv8RHFeoJ7cR-q2bCMtKV7R21P5w,142
+universal_mcp/servers/server.py,sha256=qHeHm4UFVUr8TAailbEkWGq7EdlOASkOevY_0lyrWWs,5882
+universal_mcp/stores/__init__.py,sha256=quvuwhZnpiSLuojf0NfmBx2xpaCulv3fbKtKaSCEmuM,603
+universal_mcp/stores/store.py,sha256=yWbEGZb53z3fpVyqGWbes63z1CtIzC_IuM49OXy__UY,10137
+universal_mcp/tools/__init__.py,sha256=jC8hsqfTdtn32yU57AVFUXiU3ZmUOCfCERSCaNEIH7E,395
+universal_mcp/tools/adapters.py,sha256=YJ2oqgc8JgmtsdRRtvO-PO0Q0bKqTJ4Y3J6yxlESoTo,3947
+universal_mcp/tools/docstring_parser.py,sha256=efEOE-ME7G5Jbbzpn7pN2xNuyu2M5zfZ1Tqu1lRB0Gk,8392
+universal_mcp/tools/func_metadata.py,sha256=F4jd--hoZWKPBbZihVtluYKUsIdXdq4a0VWRgMl5k-Q,10838
+universal_mcp/tools/manager.py,sha256=MajVskIptgXv1uZzwnSRycj1TSi7nhn4ebNSRkSSEDs,10455
+universal_mcp/tools/registry.py,sha256=XsmVZL1rY5XgIBPTmvKKBWFLAvB3d9LfYMb11b4wSPI,1169
+universal_mcp/tools/tools.py,sha256=1Q8bKiqj1E_-swvjmNHv16Orpd4p_HQtMKGxfqPmoPI,4570
+universal_mcp/utils/__init__.py,sha256=8wi4PGWu-SrFjNJ8U7fr2iFJ1ktqlDmSKj1xYd7KSDc,41
+universal_mcp/utils/common.py,sha256=3aJK3AnBkmYf-dbsFLaEu_dGuXQ0Qi2HuqYTueLVhXQ,10968
+universal_mcp/utils/installation.py,sha256=PU_GfHPqzkumKk-xG4L9CkBzSmABxmchwblZkx-zY-I,7204
+universal_mcp/utils/prompts.py,sha256=FJhqE0gPXDzYHS8gOjAVrdqVxc9X12ESnpd4C3jDSMI,27547
+universal_mcp/utils/singleton.py,sha256=RoOiKxBOAhp0TK1QaMDYi-8GjRcy2Vh-bAOuIAcYan0,775
+universal_mcp/utils/testing.py,sha256=J857Xt5K-hMxTc8UNJWlkzLbca1zObjwNhNXzYGxBHI,8009
+universal_mcp/utils/openapi/__inti__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+universal_mcp/utils/openapi/api_generator.py,sha256=892AWoOCzzvFHVfSpEBg1m4LFRnWMmOSeY0DgLDW0fU,6960
+universal_mcp/utils/openapi/api_splitter.py,sha256=io7fV-E8hUIR4NxFlakqydbgrQF6aBAnZHPMlpxw-wc,20967
+universal_mcp/utils/openapi/cli.py,sha256=az5ObS74R-MmDCOZ1PHTJVKZJrHnsBOAweOUa7A-GqA,25918
+universal_mcp/utils/openapi/docgen.py,sha256=DNmwlhg_-TRrHa74epyErMTRjV2nutfCQ7seb_Rq5hE,21366
+universal_mcp/utils/openapi/filters.py,sha256=96FajO5nLbvjNPy2A1HvSS9jqpzMDHd4q_QTP-DIsPI,3842
+universal_mcp/utils/openapi/openapi.py,sha256=0Pn_ugkEwL0eMtctjc0XDMPZdB3SBOqza_J6BK8i_SY,62165
+universal_mcp/utils/openapi/postprocessor.py,sha256=NKvpXi73INRXxj1KOu8Ph3loWGICx2Uyy2Q8uOOqBoc,12177
+universal_mcp/utils/openapi/preprocessor.py,sha256=r4n0WQI__OzPL8FTza7jxiM4EYeZwa-3tvEJaJYZC44,63081
+universal_mcp/utils/openapi/readme.py,sha256=R2Jp7DUXYNsXPDV6eFTkLiy7MXbSULUj1vHh4O_nB4c,2974
+universal_mcp/utils/openapi/test_generator.py,sha256=h44gQXEXmrw4pD3-XNHKB7T9c2lDomqrJxVO6oszCqM,12186
+universal_mcp/utils/templates/README.md.j2,sha256=Mrm181YX-o_-WEfKs01Bi2RJy43rBiq2j6fTtbWgbTA,401
+universal_mcp/utils/templates/api_client.py.j2,sha256=972Im7LNUAq3yZTfwDcgivnb-b8u6_JLKWXwoIwXXXQ,908
+universal_mcp-0.1.24rc4.dist-info/METADATA,sha256=q3DM_RctCJdHxfeY2CwcRiH5VuESYHr7sb_GB-c4vRw,3116
+universal_mcp-0.1.24rc4.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+universal_mcp-0.1.24rc4.dist-info/entry_points.txt,sha256=QlBrVKmA2jIM0q-C-3TQMNJTTWOsOFQvgedBq2rZTS8,56
+universal_mcp-0.1.24rc4.dist-info/licenses/LICENSE,sha256=NweDZVPslBAZFzlgByF158b85GR0f5_tLQgq1NS48To,1063
+universal_mcp-0.1.24rc4.dist-info/RECORD,,

universal_mcp/applications/sample_tool_app.py

@@ -1,80 +0,0 @@
-import datetime
-
-from universal_mcp.applications.application import BaseApplication
-
-
-class SampleToolApp(BaseApplication):
-    """A sample application providing basic utility tools."""
-
-    def __init__(self):
-        """Initializes the SampleToolApp with the name 'sample_tool_app'."""
-        super().__init__("sample_tool_app")
-
-    def get_current_time(self):
-        """Get the current system time as a formatted string.
-
-        Returns:
-            str: The current time in the format 'YYYY-MM-DD HH:MM:SS'.
-        """
-        return datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
-
-    def get_current_date(self):
-        """Get the current system date as a formatted string.
-
-        Returns:
-            str: The current date in the format 'YYYY-MM-DD'.
-        """
-        return datetime.datetime.now().strftime("%Y-%m-%d")
-
-    def calculate(self, expression: str):
-        """Safely evaluate a mathematical expression.
-
-        Args:
-            expression (str): The mathematical expression to evaluate.
-
-        Returns:
-            str: The result of the calculation, or an error message if evaluation fails.
-        """
-        try:
-            # Safe evaluation of mathematical expressions
-            result = eval(expression, {"__builtins__": {}}, {})
-            return f"Result: {result}"
-        except Exception as e:
-            return f"Error in calculation: {str(e)}"
-
-    def file_operations(self, operation: str, filename: str, content: str = ""):
-        """Perform file read or write operations.
-
-        Args:
-            operation (str): The operation to perform, either 'read' or 'write'.
-            filename (str): The name of the file to operate on.
-            content (str, optional): The content to write to the file (used only for 'write'). Defaults to "".
-
-        Returns:
-            str: The result of the file operation, or an error message if the operation fails.
-        """
-        try:
-            if operation == "read":
-                with open(filename) as f:
-                    return f"File content:\n{f.read()}"
-            elif operation == "write":
-                with open(filename, "w") as f:
-                    f.write(content)
-                return f"Successfully wrote to {filename}"
-            else:
-                return "Invalid operation. Use 'read' or 'write'"
-        except Exception as e:
-            return f"File operation error: {str(e)}"
-
-    def list_tools(self):
-        """List all available tool methods in this application.
-
-        Returns:
-            list: A list of callable tool methods.
-        """
-        return [
-            self.get_current_time,
-            self.get_current_date,
-            self.calculate,
-            self.file_operations,
-        ]

universal_mcp/client/agents/__init__.py

@@ -1,4 +0,0 @@
-from .base import AgentType, BaseAgent
-from .react import ReActAgent
-
-__all__ = ["AgentType", "BaseAgent", "ReActAgent"]

universal_mcp/client/agents/base.py

@@ -1,38 +0,0 @@
-# agents/base.py
-from abc import ABC, abstractmethod
-from enum import Enum
-from typing import Any
-
-from pydantic import BaseModel
-
-from universal_mcp.tools.manager import ToolManager
-
-
-class AgentType(Enum):
-    REACT = "react"
-    CODEACT = "codeact"
-    SIMPLE = "simple"
-
-
-class AgentResponse(BaseModel):
-    thought: str | None = None
-    action: str | None = None
-    action_input: dict[str, Any] | None = None
-    observation: str | None = None
-    answer: str | None = None
-    finished: bool = False
-
-
-class BaseAgent(ABC):
-    def __init__(self, name: str, instructions: str, model: str, debug: bool = False):
-        self.name = name
-        self.instructions = instructions
-        self.model = model
-        self.conversation_history: list[dict[str, Any]] = []
-
-    @abstractmethod
-    def process_step(self, user_input: str, tool_manager: ToolManager):
-        pass
-
-    def reset_conversation(self):
-        self.conversation_history = []

universal_mcp/client/agents/llm.py

@@ -1,115 +0,0 @@
-import json
-from typing import Any
-
-from loguru import logger
-from openai import OpenAI
-from openai.types.chat import (
-    ChatCompletion,
-    ChatCompletionMessage,
-    ChatCompletionToolParam,
-)
-
-from universal_mcp.tools.adapters import ToolFormat
-from universal_mcp.tools.manager import ToolManager
-
-
-class LLMClient:
-    def __init__(self, model: str):
-        self.model = model
-        self.client = OpenAI()
-        logger.info(f"LLMClient initialized with model: {self.model}")
-
-    async def generate_response(
-        self,
-        messages: list[dict[str, str]],
-        tools: list[ChatCompletionToolParam] | None = None,
-        temperature: float = 0.7,
-        max_tokens: int = 1000,
-    ) -> ChatCompletionMessage:
-        """Generate response using OpenAI with native tool calling"""
-        try:
-            logger.debug(f"Generating response with messages: {messages}")
-            kwargs = {"model": self.model, "messages": messages, "temperature": temperature, "max_tokens": max_tokens}
-            if tools:
-                kwargs["tools"] = tools
-                kwargs["tool_choice"] = "auto"
-                logger.debug(f"Using tools: {tools}")
-            response: ChatCompletion = self.client.chat.completions.create(**kwargs)
-            logger.debug(f"OpenAI response: {response}")
-            choice = response.choices[0]
-            message: ChatCompletionMessage = choice.message
-            logger.info(f"Generated message: {message}")
-            return message
-        except Exception as e:
-            logger.error(f"Error in generate_response: {e}")
-            raise e
-
-    async def handle_tool_calls(
-        self, tool_calls: list[ChatCompletionToolParam], tool_manager: ToolManager
-    ) -> list[dict[str, Any]]:
-        """Handle tool calls"""
-        messages: list[dict[str, Any]] = []
-        for tool_call in tool_calls:
-            tool_name = tool_call.function.name
-            tool_args = tool_call.function.arguments
-            logger.info(f"Handling tool call: {tool_name} with args: {tool_args}")
-            tool_result = await tool_manager.call_tool(tool_name, tool_args)
-            logger.debug(f"Tool result for {tool_name}: {tool_result}")
-            messages.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(tool_result)})
-        return messages
-
-    async def generate_response_with_tool_results(
-        self, messages: list[dict[str, str]], tool_manager: ToolManager, max_iterations: int = 5
-    ) -> ChatCompletionMessage:
-        """Handle complete tool calling conversation loop using OpenAI"""
-        conversation = messages.copy()
-        iteration = 0
-        tools = tool_manager.list_tools(format=ToolFormat.OPENAI)
-        logger.info(f"Starting tool calling loop with max_iterations={max_iterations}")
-
-        while iteration < max_iterations:
-            iteration += 1
-            logger.info(f"Iteration {iteration}: Generating response with conversation: {conversation}")
-
-            # Generate response with tools
-            response = await self.generate_response(conversation, tools)
-
-            # If no tool calls, return the response
-            tool_calls = response.tool_calls
-            if not tool_calls:
-                logger.info("No tool calls detected, returning response.")
-                return response
-
-            logger.info(f"Tool calls detected: {tool_calls}")
-
-            # Add assistant message with tool calls
-            assistant_msg = {"role": "assistant", "content": response.content}
-            if tool_calls:
-                assistant_msg["tool_calls"] = tool_calls
-            conversation.append(assistant_msg)
-
-            # Execute tool calls and add results
-            for tool_call in tool_calls:
-                function = tool_call.function
-                tool_name = function.name
-                arguments = function.arguments
-                logger.info(f"Executing tool: {tool_name} with arguments: {arguments}")
-                try:
-                    tool_args = json.loads(arguments)
-                except Exception as e:
-                    logger.warning(f"Failed to parse tool arguments as JSON: {arguments}. Error: {e}")
-                    tool_args = {"query": arguments}
-                # Execute the tool
-                try:
-                    tool_result = await tool_manager.call_tool(tool_name, tool_args)
-                    logger.debug(f"Tool result for {tool_name}: {tool_result}")
-                except Exception as e:
-                    logger.error(f"Error executing tool {tool_name}: {e}")
-                    tool_result = f"Error executing tool {tool_name}: {e}"
-                # Add tool result to conversation
-                conversation.append({"role": "tool", "tool_call_id": tool_call.id, "content": str(tool_result)})
-            # Continue the conversation loop
-
-        logger.info("Max iterations reached or tool loop complete. Generating final response.")
-        # Final response after tool execution
-        return await self.generate_response(conversation)

universal_mcp/client/agents/react.py

@@ -1,67 +0,0 @@
-from loguru import logger
-
-from universal_mcp.tools.manager import ToolManager
-
-from .base import BaseAgent
-from .llm import LLMClient
-
-
-class ReActAgent(BaseAgent):
-    def __init__(self, name: str, instructions: str, model: str):
-        super().__init__(name, instructions, model)
-        self.llm_client = LLMClient(model)
-        self.max_iterations = 10
-        logger.debug(f"Initialized ReActAgent: name={name}, model={model}")
-
-    def _build_system_message(self) -> str:
-        system_message = f"""You are {self.name}. {self.instructions}
-
-You have access to various tools that can help you answer questions and complete tasks. When you need to use a tool:
-
-1. Think about what information you need
-2. Call the appropriate tool with the right parameters
-3. Use the tool results to provide a comprehensive answer
-
-Always explain your reasoning and be thorough in your responses. If you need to use multiple tools to answer a question completely, do so."""
-        logger.debug(f"System message built: {system_message}")
-        return system_message
-
-    def _build_messages(self, user_input: str) -> list[dict[str, str]]:
-        """Build message history for the conversation"""
-        messages = [{"role": "system", "content": self._build_system_message()}]
-
-        # Add conversation history
-        for entry in self.conversation_history:
-            messages.append({"role": "user", "content": entry["human"]})
-            messages.append({"role": "assistant", "content": entry["assistant"]})
-
-        # Add current user input
-        messages.append({"role": "user", "content": user_input})
-
-        logger.debug(f"Built messages for user_input='{user_input}': {messages}")
-        return messages
-
-    async def process_step(self, user_input: str, tool_manager: ToolManager) -> str:
-        """Process user input using native tool calling"""
-
-        logger.info(f"Processing user input: {user_input}")
-
-        # Build conversation messages
-        messages = self._build_messages(user_input)
-
-        # Use native tool calling with conversation loop
-        try:
-            response = await self.llm_client.generate_response_with_tool_results(
-                messages, tool_manager, self.max_iterations
-            )
-            final_answer = response.content
-            logger.info(f"LLM response received: {final_answer}")
-        except Exception as e:
-            logger.error(f"Error during LLM response generation: {e}")
-            raise
-
-        # Store in conversation history
-        self.conversation_history.append({"human": user_input, "assistant": final_answer})
-        logger.debug(f"Updated conversation history: {self.conversation_history[-1]}")
-
-        return final_answer