swiftmcp 0.0.1__py3-none-any.whl

swiftmcp/core/tools/http_tool/ssrf_proxy.py

@@ -0,0 +1,167 @@
+"""
+Proxy requests to avoid SSRF
+"""
+import logging
+import os
+import time
+from typing import Any, Dict
+
+import httpx
+
+# Configuration
+SSRF_PROXY_ALL_URL = os.getenv('SSRF_PROXY_ALL_URL', '')
+SSRF_PROXY_HTTP_URL = os.getenv('SSRF_PROXY_HTTP_URL', '')
+SSRF_PROXY_HTTPS_URL = os.getenv('SSRF_PROXY_HTTPS_URL', '')
+SSRF_DEFAULT_MAX_RETRIES = int(os.getenv('SSRF_DEFAULT_MAX_RETRIES', '3'))
+
+# Proxy configuration
+proxies = {
+    'http://': SSRF_PROXY_HTTP_URL,
+    'https://': SSRF_PROXY_HTTPS_URL
+} if SSRF_PROXY_HTTP_URL and SSRF_PROXY_HTTPS_URL else None
+
+# Retry configuration
+BACKOFF_FACTOR = 0.5
+STATUS_FORCELIST = [429, 500, 502, 503, 504]
+
+
+def make_request(method: str, url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make HTTP request with retry logic.
+    
+    Args:
+        method: HTTP method
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+        
+    Raises:
+        Exception: If maximum retries exceeded
+    """
+    # Handle redirect parameter name change between libraries
+    if "allow_redirects" in kwargs:
+        allow_redirects = kwargs.pop("allow_redirects")
+        if "follow_redirects" not in kwargs:
+            kwargs["follow_redirects"] = allow_redirects
+
+    retries = 0
+    while retries <= max_retries:
+        try:
+            # Make request based on proxy configuration
+            if SSRF_PROXY_ALL_URL:
+                response = httpx.request(method=method, url=url, proxy=SSRF_PROXY_ALL_URL, **kwargs)
+            elif proxies:
+                response = httpx.request(method=method, url=url, proxies=proxies, **kwargs)
+            else:
+                response = httpx.request(method=method, url=url, **kwargs)
+
+            # Check if we should retry based on status code
+            if response.status_code not in STATUS_FORCELIST:
+                return response
+            else:
+                logging.warning(
+                    f"Received status code {response.status_code} for URL {url} which is in the force list"
+                )
+
+        except httpx.RequestError as e:
+            logging.warning(f"Request to URL {url} failed on attempt {retries + 1}: {e}")
+
+        # Wait before retry with exponential backoff
+        retries += 1
+        if retries <= max_retries:
+            time.sleep(BACKOFF_FACTOR * (2 ** (retries - 1)))
+
+    raise Exception(f"Reached maximum retries ({max_retries}) for URL {url}")
+
+
+def get(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make GET request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('GET', url, max_retries=max_retries, **kwargs)
+
+
+def post(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make POST request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('POST', url, max_retries=max_retries, **kwargs)
+
+
+def put(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make PUT request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('PUT', url, max_retries=max_retries, **kwargs)
+
+
+def patch(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make PATCH request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('PATCH', url, max_retries=max_retries, **kwargs)
+
+
+def delete(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make DELETE request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('DELETE', url, max_retries=max_retries, **kwargs)
+
+
+def head(url: str, max_retries: int = SSRF_DEFAULT_MAX_RETRIES, **kwargs) -> httpx.Response:
+    """
+    Make HEAD request.
+    
+    Args:
+        url: Request URL
+        max_retries: Maximum number of retries
+        **kwargs: Additional arguments for the request
+        
+    Returns:
+        HTTP response
+    """
+    return make_request('HEAD', url, max_retries=max_retries, **kwargs)

swiftmcp/core/tools/http_tool/tool_bundle.py

@@ -0,0 +1,30 @@
+from typing import Optional, List, Dict, Any
+
+from pydantic import BaseModel
+
+from .tool_entities import ToolParameter
+
+
+class ApiToolBundle(BaseModel):
+    """
+    This class is used to store the schema information of an API based tool, 
+    such as the URL, the method, the parameters, etc.
+    """
+    # Server URL
+    server_url: str
+    # HTTP method
+    method: str
+    # Summary/description of the operation
+    summary: Optional[str] = None
+    # Operation ID
+    operation_id: str
+    # Input parameters
+    parameters: Optional[List[ToolParameter]] = None
+    # Return values
+    returns: Optional[List[ToolParameter]] = None
+    # Author of the tool
+    author: str = ""
+    # Icon for the tool
+    icon: Optional[str] = None
+    # OpenAPI operation definition
+    openapi: Dict[str, Any]

swiftmcp/core/tools/http_tool/tool_entities.py

@@ -0,0 +1,122 @@
+from enum import Enum
+from typing import Any, Optional, Union, List
+
+from pydantic import BaseModel, Field, field_validator
+
+
+class MultilingualText(BaseModel):
+    """
+    Supports multiple languages with fallback to English.
+    """
+    zh_Hans: Optional[str] = None
+    en_US: str
+
+    def __init__(self, **data):
+        super().__init__(**data)
+        if not self.zh_Hans:
+            self.zh_Hans = self.en_US
+            
+    def to_dict(self) -> dict:
+        return {
+            'zh_Hans': self.zh_Hans,
+            'en_US': self.en_US,
+        }
+
+
+class ToolParameterOption(BaseModel):
+    """Option for SELECT type parameters"""
+    value: str = Field(..., description="The value of the option")
+    label: MultilingualText = Field(..., description="The label of the option")
+
+    @field_validator('value', mode='before')
+    @classmethod
+    def transform_id_to_str(cls, value) -> str:
+        """Convert value to string if needed"""
+        if not isinstance(value, str):
+            return str(value)
+        else:
+            return value
+
+
+class ToolParameter(BaseModel):
+    """Defines a parameter for a tool"""
+    
+    class ToolParameterType(str, Enum):
+        """Supported parameter types"""
+        STRING = "string"
+        NUMBER = "number"
+        BOOLEAN = "boolean"
+        SELECT = "select"
+        SECRET_INPUT = "secret-input"
+        FILE = "file"
+        INT = "int"
+        BOOL = "bool"
+        FLOAT = "float"
+
+    class ToolParameterForm(Enum):
+        """When the parameter value should be provided"""
+        SCHEMA = "schema"  # Set while adding tool
+        FORM = "form"      # Set before invoking tool
+        LLM = "llm"        # Set by LLM
+
+    # Parameter name
+    name: str = Field(..., description="The name of the parameter")
+    # Label presented to the user
+    label: MultilingualText = Field(..., description="The label presented to the user")
+    # Description presented to the user
+    human_description: Optional[MultilingualText] = Field(None, description="The description presented to the user")
+    # Placeholder text for input fields
+    placeholder: Optional[MultilingualText] = Field(None, description="The placeholder presented to the user")
+    # Parameter type
+    type: ToolParameterType = Field(..., description="The type of the parameter")
+    # When the parameter should be set
+    form: ToolParameterForm = Field(..., description="The form of the parameter, schema/form/llm")
+    # Description for LLM
+    llm_description: Optional[str] = None
+    # Whether the parameter is required
+    required: bool = False
+    # Default value
+    default: Optional[Union[float, int, str]] = None
+    # Minimum allowed value (for numeric types)
+    min: Optional[Union[float, int]] = None
+    # Maximum allowed value (for numeric types)
+    max: Optional[Union[float, int]] = None
+    # Options for SELECT type parameters
+    options: Optional[List[ToolParameterOption]] = None
+
+    @classmethod
+    def get_simple_instance(cls, name: str, llm_description: str, param_type: ToolParameterType,
+                            required: bool, options: Optional[List[str]] = None) -> 'ToolParameter':
+        """
+        Create a simple tool parameter.
+        
+        Args:
+            name: The name of the parameter
+            llm_description: The description presented to the LLM
+            param_type: The type of the parameter
+            required: If the parameter is required
+            options: The options of the parameter (for SELECT type)
+            
+        Returns:
+            A new ToolParameter instance
+        """
+        # Convert options to ToolParameterOption objects
+        param_options = None
+        if options:
+            param_options = [
+                ToolParameterOption(
+                    value=option, 
+                    label=MultilingualText(en_US=option, zh_Hans=option)
+                ) for option in options
+            ]
+            
+        return cls(
+            name=name,
+            label=MultilingualText(en_US='', zh_Hans=''),
+            human_description=MultilingualText(en_US='', zh_Hans=''),
+            type=param_type,
+            form=cls.ToolParameterForm.LLM,
+            llm_description=llm_description,
+            required=required,
+            options=param_options,
+        )

swiftmcp/core/tools/mcp_tool/mcp_tool.py

@@ -0,0 +1,52 @@
+# -*- coding: utf-8 -*-
+# Copyright (c) 2025 yaqiang.sun.
+# This source code is licensed under the license found in the LICENSE file
+# in the root directory of this source tree.
+#########################################################################
+# Author: yaqiangsun
+# Created Time: 2025/08/29 17:37:59
+########################################################################
+
+
+from pydantic import BaseModel
+from typing import Any, Literal, cast
+
+
+from mcp.server.fastmcp import FastMCP as FastMCP1x
+import pydantic_core
+import fastmcp
+from fastmcp import Client
+from fastmcp.server.server import FastMCP
+from fastmcp.utilities.inspect import (
+    FastMCPInfo,
+    ToolInfo,
+    inspect_fastmcp
+)
+import json
+
+
+class MCPTool(object):
+    def __init__(self,mcp: FastMCP[Any]
+                 ):
+        self.mcp = mcp
+        pass
+    async def inspect_tools(self) -> list[ToolInfo]:
+        mcp_info =  await inspect_fastmcp(self.mcp)
+        return mcp_info.tools
+    async def get_tools_names(self) -> list[str]:
+        tools = await self.inspect_tools()
+        return [tool.name for tool in tools]
+    async def get_tool(self, tool_name: str) -> ToolInfo:
+        tools = await self.inspect_tools()
+        for tool_info in tools:
+            if tool_info.name == tool_name:
+                return tool_info
+        return None
+    async def get_tool_json(self,tool:ToolInfo) -> dict:
+        return tool.__dict__
+    async def restore_tool(self, tool_json:ToolInfo) -> ToolInfo:
+        tool = ToolInfo(**tool_json)
+        return tool
+
+
+    

swiftmcp/utils/file_db.py

@@ -0,0 +1,75 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+# Copyright (c) 2024 yaqiang.sun.
+# This source code is licensed under the license found in the LICENSE file
+# in the root directory of this source tree.
+#########################################################################
+# Author: yaqiangsun
+# Created Time: 2024/09/09 17:22:40
+########################################################################
+
+
+import json
+import yaml
+from miniolite.FileSQLite import FileSQLite
+
+class AgentFileDB(object):
+    def __init__(self,db_path="tmp/test.db"):
+        pass
+        # initalize the database
+        self.file_db = FileSQLite(db_path)
+    def create_folder(self):
+        # create folder
+        self.file_db.force_add_folder("/data/flows")
+        self.file_db.force_add_folder("/data/flows_simple")
+        self.file_db.force_add_folder("/data/tools")
+        self.file_db.force_add_folder("/data/tools_simple")
+    create_folder()
+
+
+    def delete_file(self,path):
+        self.file_db.delete_file(path)
+
+    def list_file(self,path):
+        name_list = self.file_db.list_files(path)
+        return name_list
+
+    def write_json(self,json_obj,file_path):
+        json_str = json.dumps(json_obj)
+        self.file_db.add_file(file_path,content=json_str)
+        pass
+
+    def read_json(self,path):
+        try:
+            file = self.file_db.read_file(path)
+            data = json.loads(file)
+        except (FileNotFoundError, json.JSONDecodeError):
+            # 如果文件不存在或为空，则初始化为空列表/字典
+            data = {}
+        return data
+
+    def write_yml(self,json_obj,file_path):
+        json_str = json.dumps(json_obj)
+        self.file_db.add_file(file_path,content=json_str)
+    def load_yaml_file(self,file_path: str, ignore_error: bool = True):
+        
+        file = self.file_db.read_file(file_path)
+        try:
+            yaml_content = yaml.safe_load(file)
+            if not yaml_content:
+                raise ValueError(f'YAML file {file_path} is empty')
+            return yaml_content
+        except Exception as e:
+            raise ValueError(f'Failed to load YAML file {file_path}: {e}')
+
+if __name__ == "__main__":
+    agent_db = AgentFileDB()
+    json_obj = {
+        "demo":"test"
+    }
+    agent_db.create_folder()
+    # write_json(json_obj=json_obj,file_path="/data/tools/out.json")
+    data = agent_db.read_json(path="/data/tools/out.json")
+    print(data)
+
+    pass

swiftmcp-0.0.1.dist-info/METADATA

@@ -0,0 +1,18 @@
+Metadata-Version: 2.4
+Name: swiftmcp
+Version: 0.0.1
+Summary: multimoda MCP framework
+Home-page: https://github.com/yaqiangsun/SwiftMCP
+Author: Yaqiang Sun
+Author-email: Yaqiang Sun <sunyaking@163.com>
+License: GPL-3.0
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: author
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: requires-python
+
+# SwiftMCP
+SwiftMCP: multimoda MCP framework

swiftmcp-0.0.1.dist-info/RECORD

@@ -0,0 +1,20 @@
+swiftmcp/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+swiftmcp/cli/main.py,sha256=-RVObk7J3lqAJUIlM5hDC564ZdVfIxsppSLHXu1CnRA,1220
+swiftmcp/cli/proxy_serve.py,sha256=24DIFTjAXM-Q2KQFV1-klyH3_A8x87EiSDiVAH0pgJo,1200
+swiftmcp/core/composition/mcp_composition.py,sha256=EF3wVjDXQKr_Q01WD3bU974OVxJfYuWQEQFbJYroa-8,1844
+swiftmcp/core/openapi/openapi2mcp.py,sha256=siOVVJvXKkDDjU00ZNQ_ofXKA3QDYt7OOCFm_MAvs8Y,1496
+swiftmcp/core/proxy/mcp_proxy.py,sha256=ZCl4pyZ2hlm_kR8EAmFYSwMDzf1bR4yrAt8Z2XAUQ9A,761
+swiftmcp/core/tools/http_tool/api_tool.py,sha256=uXIBlyD8putFB4_8t2lkDw7Gdajxk4_yg9-I9QZvWig,10721
+swiftmcp/core/tools/http_tool/parser.py,sha256=0GFAcEOHeHRyfSRBUArFCOoF_Tsogf5I-7alCpcAhFk,21501
+swiftmcp/core/tools/http_tool/ssrf_proxy.py,sha256=Pnw4zAKb-P0olDluqrdUTEUr12wUFbsHZsojQGG6u2s,4887
+swiftmcp/core/tools/http_tool/tool_bundle.py,sha256=Jb79BlN6gbRY5bdxXhSbDiSlVsdiYJDVeogmIjwmBnk,799
+swiftmcp/core/tools/http_tool/tool_entities.py,sha256=TkZEQmpF1R4q9vWLmgze8DPxahFukr2e7wHCikKLAVw,4302
+swiftmcp/core/tools/mcp_tool/mcp_tool.py,sha256=6wBvhwqVCoPL5FP2e0cS_MlzKFTivSFW9Ye1XEs-MPg,1556
+swiftmcp/utils/file_db.py,sha256=AR6HCIQa2i7qyvUZ3AuFyD3LAti2ap6m6cZSDPz_WCs,2436
+swiftmcp-0.0.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+swiftmcp-0.0.1.dist-info/METADATA,sha256=UT3LghucE02RNYOfjqBX0mk9t9t09pezzy47iHVxM68,432
+swiftmcp-0.0.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+swiftmcp-0.0.1.dist-info/entry_points.txt,sha256=UbHiFJOH8od4ttDl0zZP6V7bxVPZVmvtCr09W4x2FMQ,56
+swiftmcp-0.0.1.dist-info/top_level.txt,sha256=5ZqHG227k0vTAEQiUfQzQEU-PsGUmHhR9Smyz4JdnrQ,9
+swiftmcp-0.0.1.dist-info/zip-safe,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+swiftmcp-0.0.1.dist-info/RECORD,,

swiftmcp-0.0.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

swiftmcp-0.0.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+swiftmcp = swiftmcp.cli.main:cli_main