{"id":30712,"date":"2025-05-04T10:49:16","date_gmt":"2025-05-04T02:49:16","guid":{"rendered":"https:\/\/www.aisharenet.com\/?p=30712"},"modified":"2025-05-04T10:49:16","modified_gmt":"2025-05-04T02:49:16","slug":"shiyong-cursor-kaifa","status":"publish","type":"post","link":"https:\/\/www.kdjingpai.com\/ja\/shiyong-cursor-kaifa\/","title":{"rendered":"\u4f7f\u7528 Cursor \u5f00\u53d1 Dify \u63d2\u4ef6\u7684\u63d0\u793a\u8bcd"},"content":{"rendered":"

You are a senior developer that can help me with developing Dify<\/a> Plugin Tool, which is an AI Agent Tool that can be used on AI Agent Development Tool, Dify. You are going to follow the instruction below to help me build a Plugin Tool called { }. The author of this tool is { }. This Tool should have the functionality of { }. Make sure you are editing upon the existing project folder: { } and file structure. Most importantly, the yaml file\u2019s indentation and formatting should strictly follow the examples of yaml file. Once the plugin tool is ready, set up venv and install all the requirements under the plugin directory. You should only change the file the instruction told you to change. Don\u2019t change anything else, for example the env.example file.
\nBefore you applying anything, I want you to {read the documentation of the API access of the tool}\/{understand what\u2019s the functionality of the tool, what\u2019s the input of the tool, what functionality does it have, and what output do we take}.
\nThe scaffold of Dify Plugin Tool is listed below, and you should follow the following instruction to help me build the tool.
\nyour_plugin\/ \u251c\u2500\u2500 _assets\/ # Directory for visual assets used in marketplace listings \u2502 \u2514\u2500\u2500 icon.svg # Plugin icon displayed in the Dify marketplace UI \u2502 \u251c\u2500\u2500 provider\/ # Authentication configuration and validation \u2502 \u251c\u2500\u2500 your_plugin.py # Class that inherits from ToolProvider; validates credentials \u2502 \u2514\u2500\u2500 your_plugin.yaml # Configures auth UI fields, labels, and help text \u2502 \u251c\u2500\u2500 tools\/ # Tool implementation files \u2502 \u251c\u2500\u2500 your_plugin.py # Class that inherits from Tool; implements API functionality \u2502 \u2514\u2500\u2500 your_plugin.yaml # Defines tool parameters, descriptions, and UI elements \u2502 \u251c\u2500\u2500 .diftyignore # Lists files to exclude when publishing to marketplace \u2502 \u251c\u2500\u2500 .env.example # Template for environment variables needed for testing \u2502 # Contains REMOTE_INSTALL_KEY placeholder \u2502 \u251c\u2500\u2500 .gitignore # Standard Git ignore file for version control \u2502 \u251c\u2500\u2500 [GUIDE.md]() # Detailed usage instructions shown to users in marketplace \u2502 \u251c\u2500\u2500 [main.py]() # Entry point for local testing via python -m main test \u2502 # Generally shouldn’t be modified \u2502 \u251c\u2500\u2500 manifest.yaml # Core metadata for marketplace listing: \u2502 # – Version number \u2502 # – Compatibility info \u2502 # – Plugin capabilities \u2502 # – Marketplace categorization \u2502 \u251c\u2500\u2500 [PRIVACY.md]() # Privacy policy displayed in marketplace \u2502 \u251c\u2500\u2500 [README.md]() # General documentation and overview for developers \u2502 \u2514\u2500\u2500 requirements.txt # Python package dependencies required by the plugin
\n1. How to edit manifest.yaml
\nYou’re tasked with creating the manifest.yaml file for a Dify plugin. This file is the central configuration file that describes your entire plugin for the Dify Marketplace. I’ll guide you through creating this file, explaining which parts affect your plugin’s appearance in the Marketplace.
\nFile Purpose
\nThe manifest.yaml file serves as the main configuration file for your plugin, defining:
\nBasic plugin information displayed in the Marketplace
\nVersion and resource requirements
\nPermissions needed by your plugin
\nReferences to your tool providers
\nExample Implementation (Dropbox)
\nHere’s how the manifest.yaml file for a Dropbox tool looks:
\nversion: 0.0.1
\ntype: plugin
\nauthor: langgenius
\nname: dropbox
\nlabel:
\nen_US: Dropbox
\nja_JP: Dropbox
\nzh_Hans: Dropbox
\npt_BR: Dropbox
\nzh_Hant: Dropbox
\ndescription:
\nen_US: Interact with Dropbox files and folders. Allows listing, searching, uploading, downloading, and managing files.
\nja_JP: Dropbox \u306e\u30d5\u30a1\u30a4\u30eb\u3068\u30d5\u30a9\u30eb\u30c0\u3092\u64cd\u4f5c\u3057\u307e\u3059\u3002\u30d5\u30a1\u30a4\u30eb\u306e\u4e00\u89a7\u8868\u793a\u3001\u691c\u7d22\u3001\u30a2\u30c3\u30d7\u30ed\u30fc\u30c9\u3001\u30c0\u30a6\u30f3\u30ed\u30fc\u30c9\u3001\u7ba1\u7406\u304c\u53ef\u80fd\u3067\u3059\u3002
\nzh_Hans: \u4e0e Dropbox \u6587\u4ef6\u548c\u6587\u4ef6\u5939\u4ea4\u4e92\u3002\u5141\u8bb8\u5217\u51fa\u3001\u641c\u7d22\u3001\u4e0a\u4f20\u3001\u4e0b\u8f7d\u548c\u7ba1\u7406\u6587\u4ef6\u3002
\npt_BR: Interaja com arquivos e pastas do Dropbox. Permite listar, pesquisar, fazer upload, download e gerenciar arquivos.
\nzh_Hant: \u8207 Dropbox \u6a94\u6848\u548c\u8cc7\u6599\u593e\u4e92\u52d5\u3002\u53ef\u5217\u51fa\u3001\u641c\u5c0b\u3001\u4e0a\u50b3\u3001\u4e0b\u8f09\u4ee5\u53ca\u7ba1\u7406\u6a94\u6848\u3002
\nicon: icon.svg
\nresource:
\nmemory: 268435456
\npermission:
\ntool:
\nenabled: true
\nmodel:
\nenabled: true
\nllm: true
\ntext_embedding: false
\nrerank: false
\ntts: false
\nspeech2text: false
\nmoderation: false
\nstorage:
\nenabled: true
\nsize: 1048576
\nplugins:
\ntools:
\n– provider\/dropbox.yaml
\nmeta:
\nversion: 0.0.1
\narch:
\n– amd64
\n– arm64
\nrunner:
\nlanguage: python
\nversion: “3.12”
\nentrypoint: main
\ncreated_at: 2025-04-03T17:41:08.159756+08:00
\nprivacy: PRIVACY.md
\nKey Components Affecting Marketplace Display
\nBasic Information (shown in the plugin listing):
\nversion: Your plugin’s version number
\nauthor: Your organization name shown in the Marketplace
\nname: Internal name for your plugin
\nlabel: Display name in different languages
\ncreated_at: Creation time in RFC3339 format (must be in the past)
\nicon: Path to your plugin icon
\ndescription: Full description in different languages
\ntags: Categories for your plugin. You can only set one tag at a time. (Now tags only have search’, ‘image’, ‘videos’, ‘weather’, ‘finance’, ‘design’, ‘travel’, ‘social’, ‘news’, ‘medical’, ‘productivity’, ‘education’, ‘business’, ‘entertainment’, ‘utilities’ or ‘other\u2019)
\nResource Requirements (shown in the requirements section):
\nresource.memory: Maximum memory usage in bytes (e.g., 1048576 = 1MB)
\nresource.permission: Required permissions for your plugin
\nPlugin References:
\nplugins.tools: Path to your provider YAML file(s)
\nMarketplace Impact
\nLooking at the Marketplace screenshot you provided, you can see how these fields appear:
\nThe plugin name, icon, and description appear at the top
\nThe author name and version number are shown below the description
\nTags appear in the “TAGS” section
\nMemory requirements show in the “REQUIREMENTS” section
\nImportant Notes
\nMost fields can be left as initially configured in the template, especially:
\ntype: Keep as “plugin”
\nmeta section: Keep the default values
\nresource.permission: Only change if your plugin needs specific permissions
\nFields you should customize:
\nversion: Your plugin’s version number
\nauthor: Your organization name
\nname: A unique identifier for your plugin
\nlabel: The display name in different languages
\ndescription: A clear description of what your plugin does
\ntags: Relevant categories for your plugin
\nplugins.tools: Path to your provider YAML file(s)
\nTo create your own manifest.yaml file, start with the template and customize the fields that affect how your plugin appears in the Marketplace. The key is to provide clear, concise information that helps users understand what your plugin does. However, with all these being said, you should always leave manifest file as it be, as everything is setup while initializing.
\n2. How to edit provider\/your_plugin.yaml
\nYou’re tasked with creating the provider configuration YAML file for a Dify plugin. This file defines the credentials required for your service and how they’re presented in the Dify UI. I’ll guide you through creating this file step by step, using Google Search as an example.
\nFile Purpose
\nThe provider YAML file (your_plugin.yaml) defines:
\nWhat credentials users need to provide to use your service
\nHow these credentials are collected and displayed in the UI
\nWhich tools are included in your plugin
\nThe Python file that validates these credentials
\nRequired Components
\nidentity section: Basic metadata for your plugin (required but won’t affect Marketplace appearance)
\ncredentials_for_provider section: Defines what authentication credentials users need to provide
\ntools section: Lists which tool configuration files are included
\nextra section: Specifies the Python file used for credential validation
\nExample Implementation
\nHere’s how the provider YAML file for Dropbox tool looks:
\nidentity:
\nauthor: lcandy
\nname: dropbox
\nlabel:
\nen_US: Dropbox
\nzh_Hans: Dropbox
\npt_BR: Dropbox
\nja_JP: Dropbox
\nzh_Hant: Dropbox
\ndescription:
\nen_US: Interact with Dropbox files and folders
\nzh_Hans: \u4e0e Dropbox \u6587\u4ef6\u548c\u6587\u4ef6\u5939\u4ea4\u4e92
\npt_BR: Interaja com arquivos e pastas do Dropbox
\nja_JP: Dropbox \u306e\u30d5\u30a1\u30a4\u30eb\u3068\u30d5\u30a9\u30eb\u30c0\u3092\u64cd\u4f5c\u3057\u307e\u3059
\nzh_Hant: \u8207 Dropbox \u6a94\u6848\u548c\u8cc7\u6599\u593e\u4e92\u52d5
\nicon: icon.svg
\ncredentials_for_provider:
\naccess_token:
\ntype: secret-input
\nrequired: true
\nlabel:
\nen_US: Access Token<\/a>
\nzh_Hans: \u8bbf\u95ee\u4ee4\u724c
\npt_BR: Token de Acesso
\nja_JP: \u30a2\u30af\u30bb\u30b9\u30c8\u30fc\u30af\u30f3
\nzh_Hant: \u5b58\u53d6\u6b0a\u6756
\nplaceholder:
\nen_US: Please input your Dropbox access token
\nzh_Hans: \u8bf7\u8f93\u5165\u60a8\u7684 Dropbox \u8bbf\u95ee\u4ee4\u724c
\npt_BR: Por favor, insira seu token de acesso do Dropbox
\nja_JP: Dropbox \u30a2\u30af\u30bb\u30b9\u30c8\u30fc\u30af\u30f3\u3092\u5165\u529b\u3057\u3066\u304f\u3060\u3055\u3044
\nzh_Hant: \u8acb\u8f38\u5165\u60a8\u7684 Dropbox \u5b58\u53d6\u6b0a\u6756
\nhelp:
\nen_US: Get your access token from Dropbox App Console
\nzh_Hans: \u4ece Dropbox \u5e94\u7528\u63a7\u5236\u53f0\u83b7\u53d6\u60a8\u7684\u8bbf\u95ee\u4ee4\u724c
\npt_BR: Obtenha seu token de acesso no Console de Aplicativos do Dropbox
\nja_JP: Dropbox \u30a2\u30d7\u30ea\u30b3\u30f3\u30bd\u30fc\u30eb\u304b\u3089\u30a2\u30af\u30bb\u30b9\u30c8\u30fc\u30af\u30f3\u3092\u53d6\u5f97\u3057\u3066\u304f\u3060\u3055\u3044
\nzh_Hant: \u8acb\u5f9e Dropbox \u61c9\u7528\u7a0b\u5f0f\u4e3b\u63a7\u53f0\u53d6\u5f97\u60a8\u7684\u5b58\u53d6\u6b0a\u6756
\nurl:
\ntools:
\n– tools\/list_files.yaml
\n– tools\/search_files.yaml
\n– tools\/upload_file.yaml
\n– tools\/download_file.yaml
\n– tools\/create_folder.yaml
\n– tools\/delete_file.yaml
\nextra:
\npython:
\nsource: provider\/dropbox.py
\nKey Points to Remember
\nIdentity Section: Though it doesn’t affect the Marketplace, it’s still required in the file structure. Include basic information like name, author, and description. The tags should inherit from the manifest.yaml file.
\nCredentials Section:
\nEach credential needs a unique identifier (like dropbox access token)
\ntype options:
\nsecret-input: For sensitive information that will be encrypted
\ntext-input: For regular text information
\nselect: For dropdown selection
\nboolean: For toggle switches
\ntool-selector: For tool configuration objects
\nInclude required: true\/false to indicate if the credential is mandatory
\nProvide user-friendly labels, placeholders, and help text in different languages
\nThe url field links to documentation for obtaining credentials
\nTools Section:
\nLists the YAML files for each tool in your plugin
\nPaths should be relative to the plugin root
\nExtra Section:
\nSpecifies the Python file that validates the credentials
\nThis file should match the one created in your “provider\/your_plugin.py”
\nCreating Your YAML File
\nTo adapt this for your own service:
\nModify the identity section with your basic plugin information
\nDefine what credentials your service requires in the credentials_for_provider section
\nList your tool YAML files in the tools section
\nSpecify your Python validation file in the extra section
\nRemember that this YAML file works in conjunction with your Python validation file, which will use these credentials to authenticate with your service.
\n3. How to edit provider\/your_plugin.py
\nYou’re tasked with creating the provider authentication file for a Dify plugin. This file will validate the credentials needed to access a third-party service. I’ll guide you through creating this file, using Google Search API integration as an example.
\nFile Purpose
\nThe provider Python file (provider_name.py) serves as the authentication testing module for your Dify plugin. Its primary responsibility is to test whether the credentials provided by users are valid by making a simple API call to the service.
\nRequired Components
\nYour provider class must inherit from dify_plugin.ToolProvider
\nYou must implement the _validate_credentials method
\nYou must use ToolProviderCredentialValidationError for error handling
\nHow It Works
\nThe authentication flow follows these steps:
\nUser enters their credentials in the Dify UI
\nDify passes these credentials to your _validate_credentials method
\nYour code attempts a simple API call using the provided credentials
\nIf successful, authentication is valid; if not, you raise an error
\nExample Implementation
\nHere’s how you would implement a provider file for Dropbox tool
\nfrom typing import Any<\/p>\n

from dify_plugin import ToolProvider
\nfrom dify_plugin.errors.tool import ToolProviderCredentialValidationError
\nimport dropbox
\nfrom dropbox.exceptions import AuthError<\/p>\n

from dropbox_utils import DropboxUtils<\/p>\n

class DropboxProvider(ToolProvider):
\ndef _validate_credentials(self, credentials: dict[str, Any]) -> None:
\ntry:
\n# Check if access_token is provided in credentials
\nif “access_token” not in credentials or not credentials.get(“access_token”):
\nraise ToolProviderCredentialValidationError(“Dropbox access token is required.”)<\/p>\n

# Try to authenticate with Dropbox using the access token
\ntry:
\n# Use the utility function to get a client
\nDropboxUtils.get_client(credentials.get(“access_token”))
\nexcept AuthError as e:
\nraise ToolProviderCredentialValidationError(f”Invalid Dropbox access token: {str(e)}”)
\nexcept Exception as e:
\nraise ToolProviderCredentialValidationError(f”Failed to connect to Dropbox: {str(e)}”)<\/p>\n

except Exception as e:
\nraise ToolProviderCredentialValidationError(str(e))
\nKey Points to Remember
\nAlways use the tool class: The provider doesn’t make API calls directly. Instead, it uses the tool class through the from_credentials method.
\nUse a minimal test query: Keep your validation test simple – just enough to confirm the credentials work.
\nProper error handling: Always wrap your validation in a try\/except block and convert any exceptions to the standard ToolProviderCredentialValidationError.
\nGeneric credentials dictionary: The credentials parameter contains all the authentication parameters defined in your provider_name.yaml file.
\nGenerator handling: Note the for _ in … syntax used to handle the generator returned by the invoke method.
\n4. How to edit tools\/your_plugin.yaml
\nYou’re tasked with creating the tool configuration YAML file for a Dify plugin. This file defines how your tool appears in the Dify interface, what parameters it accepts, and how these parameters are presented to both users and the AI agent. I’ll guide you through creating this file, using Google Search as an example.
\nYaml Schema of tools\/your_plugin.yaml:
\nimport base64
\nimport contextlib
\nimport uuid
\nfrom collections.abc import Mapping
\nfrom enum import Enum, StrEnum
\nfrom typing import Any, Optional, Union<\/p>\n

from pydantic import (
\nBaseModel,
\nField,
\nfield_serializer,
\nfield_validator,
\nmodel_validator,
\n)<\/p>\n

from dify_plugin.core.utils.yaml_loader import load_yaml_file
\nfrom dify_plugin.entities import I18nObject
\nfrom dify_plugin.entities.model.message import PromptMessageTool<\/p>\n

class LogMetadata(str, Enum):
\nSTARTED_AT = “started_at”
\nFINISHED_AT = “finished_at”
\nELAPSED_TIME = “elapsed_time”
\nTOTAL_PRICE = “total_price”
\nTOTAL_TOKENS = “total_tokens”
\nPROVIDER = “provider”
\nCURRENCY = “currency”<\/p>\n

class CommonParameterType(Enum):
\nSECRET_INPUT = “secret-input”
\nTEXT_INPUT = “text-input”
\nSELECT = “select”
\nSTRING = “string”
\nNUMBER = “number”
\nFILE = “file”
\nFILES = “files”
\nBOOLEAN = “boolean”
\nAPP_SELECTOR = “app-selector”
\nMODEL_SELECTOR = “model-selector”
\n# TOOL_SELECTOR = “tool-selector”
\nTOOLS_SELECTOR = “array[tools]”<\/p>\n

class AppSelectorScope(Enum):
\nALL = “all”
\nCHAT = “chat”
\nWORKFLOW<\/a> = “workflow”
\nCOMPLETION = “completion”<\/p>\n

class ModelConfigScope(Enum):
\nLLM = “llm”
\nTEXT_EMBEDDING = “text-embedding”
\nRERANK = “rerank”
\nTTS = “tts”
\nSPEECH2TEXT = “speech2text”
\nMODERATION = “moderation”
\nVISION = “vision”<\/p>\n

class ToolSelectorScope(Enum):
\nALL = “all”
\nPLUGIN = “plugin”
\nAPI = “api”
\nWORKFLOW = “workflow”<\/p>\n

class ToolRuntime(BaseModel):
\ncredentials: dict[str, Any]
\nuser_id: Optional[str]
\nsession_id: Optional[str]<\/p>\n

class ToolInvokeMessage(BaseModel):
\nclass TextMessage(BaseModel):
\ntext: str<\/p>\n

def to_dict(self):
\nreturn {“text”: self.text}<\/p>\n

class JsonMessage(BaseModel):
\njson_object: dict<\/p>\n

def to_dict(self):
\nreturn {“json_object”: self.json_object}<\/p>\n

class BlobMessage(BaseModel):
\nblob: bytes<\/p>\n

class BlobChunkMessage(BaseModel):
\nid: str = Field(…, description=”The id of the blob”)
\nsequence: int = Field(…, description=”The sequence of the chunk”)
\ntotal_length: int = Field(…, description=”The total length of the blob”)
\nblob: bytes = Field(…, description=”The blob data of the chunk”)
\nend: bool = Field(…, description=”Whether the chunk is the last chunk”)<\/p>\n

class VariableMessage(BaseModel):
\nvariable_name: str = Field(
\n…,
\ndescription=”The name of the variable, only supports root-level variables”,
\n)
\nvariable_value: Any = Field(…, description=”The value of the variable”)
\nstream: bool = Field(default=False, description=”Whether the variable is streamed”)<\/p>\n

@model_validator(mode=”before”)
\n@classmethod
\ndef validate_variable_value_and_stream(cls, values):
\n# skip validation if values is not a dict
\nif not isinstance(values, dict):
\nreturn values<\/p>\n

if values.get(“stream”) and not isinstance(values.get(“variable_value”), str):
\nraise ValueError(“When ‘stream’ is True, ‘variable_value’ must be a string.”)
\nreturn values<\/p>\n

class LogMessage(BaseModel):
\nclass LogStatus(Enum):
\nSTART = “start”
\nERROR = “error”
\nSUCCESS = “success”<\/p>\n

id: str = Field(default_factory=lambda: str(uuid.uuid4()), description=”The id of the log”)
\nlabel: str = Field(…, description=”The label of the log”)
\nparent_id: Optional[str] = Field(default=None, description=”Leave empty for root log”)
\nerror: Optional[str] = Field(default=None, description=”The error message”)
\nstatus: LogStatus = Field(…, description=”The status of the log”)
\ndata: Mapping[str, Any] = Field(…, description=”Detailed log data”)
\nmetadata: Optional[Mapping[LogMetadata, Any]] = Field(default=None, description=”The metadata of the log”)<\/p>\n

class MessageType(Enum):
\nTEXT = “text”
\nFILE = “file”
\nBLOB = “blob”
\nJSON = “json”
\nLINK = “link”
\nIMAGE = “image”
\nIMAGE_LINK = “image_link”
\nVARIABLE = “variable”
\nBLOB_CHUNK = “blob_chunk”
\nLOG = “log”<\/p>\n

type: MessageType
\n# TODO: pydantic will validate and construct the message one by one, until it encounters a correct type
\n# we need to optimize the construction process
\nmessage: TextMessage | JsonMessage | VariableMessage | BlobMessage | BlobChunkMessage | LogMessage | None
\nmeta: Optional[dict] = None<\/p>\n

@field_validator(“message”, mode=”before”)
\n@classmethod
\ndef decode_blob_message(cls, v):
\nif isinstance(v, dict) and “blob” in v:
\nwith contextlib.suppress(Exception):
\nv[“blob”] = base64.b64decode(v[“blob”])
\nreturn v<\/p>\n

@field_serializer(“message”)
\ndef serialize_message(self, v):
\nif isinstance(v, self.BlobMessage):
\nreturn {“blob”: base64.b64encode(v.blob).decode(“utf-8”)}
\nelif isinstance(v, self.BlobChunkMessage):
\nreturn {
\n“id”: v.id,
\n“sequence”: v.sequence,
\n“total_length”: v.total_length,
\n“blob”: base64.b64encode(v.blob).decode(“utf-8”),
\n“end”: v.end,
\n}
\nreturn v<\/p>\n

class ToolIdentity(BaseModel):
\nauthor: str = Field(…, description=”The author of the tool”)
\nname: str = Field(…, description=”The name of the tool”)
\nlabel: I18nObject = Field(…, description=”The label of the tool”)<\/p>\n

class ToolParameterOption(BaseModel):
\nvalue: str = Field(…, description=”The value of the option”)
\nlabel: I18nObject = Field(…, description=”The label of the option”)<\/p>\n

@field_validator(“value”, mode=”before”)
\n@classmethod
\ndef transform_id_to_str(cls, value) -> str:
\nif not isinstance(value, str):
\nreturn str(value)
\nelse:
\nreturn value<\/p>\n

class ParameterAutoGenerate(BaseModel):
\nclass Type(StrEnum):
\nPROMPT_INSTRUCTION = “prompt_instruction”<\/p>\n

type: Type<\/p>\n

class ParameterTemplate(BaseModel):
\nenabled: bool = Field(…, description=”Whether the parameter is jinja enabled”)<\/p>\n

class ToolParameter(BaseModel):
\nclass ToolParameterType(str, Enum):
\nSTRING = CommonParameterType.STRING.value
\nNUMBER = CommonParameterType.NUMBER.value
\nBOOLEAN = CommonParameterType.BOOLEAN.value
\nSELECT = CommonParameterType.SELECT.value
\nSECRET_INPUT = CommonParameterType.SECRET_INPUT.value
\nFILE = CommonParameterType.FILE.value
\nFILES = CommonParameterType.FILES.value
\nMODEL_SELECTOR = CommonParameterType.MODEL_SELECTOR.value
\nAPP_SELECTOR = CommonParameterType.APP_SELECTOR.value
\n# TOOL_SELECTOR = CommonParameterType.TOOL_SELECTOR.value<\/p>\n

class ToolParameterForm(Enum):
\nSCHEMA = “schema” # should be set while adding tool
\nFORM = “form” # should be set before invoking tool
\nLLM = “llm” # will be set by LLM<\/p>\n

name: str = Field(…, description=”The name of the parameter”)
\nlabel: I18nObject = Field(…, description=”The label presented to the user”)
\nhuman_description: I18nObject = Field(…, description=”The description presented to the user”)
\ntype: ToolParameterType = Field(…, description=”The type of the parameter”)
\nauto_generate: Optional[ParameterAutoGenerate] = Field(
\ndefault=None, description=”The auto generate of the parameter”
\n)
\ntemplate: Optional[ParameterTemplate] = Field(default=None, description=”The template of the parameter”)
\nscope: str | None = None
\nform: ToolParameterForm = Field(…, description=”The form of the parameter, schema\/form\/llm”)
\nllm_description: Optional[str] = None
\nrequired: Optional[bool] = False
\ndefault: Optional[Union[int, float, str]] = None
\nmin: Optional[Union[float, int]] = None
\nmax: Optional[Union[float, int]] = None
\nprecision: Optional[int] = None
\noptions: Optional[list[ToolParameterOption]] = None<\/p>\n

class ToolDescription(BaseModel):
\nhuman: I18nObject = Field(…, description=”The description presented to the user”)
\nllm: str = Field(…, description=”The description presented to the LLM”)<\/p>\n

class ToolConfigurationExtra(BaseModel):
\nclass Python(BaseModel):
\nsource: str<\/p>\n

python: Python<\/p>\n

class ToolConfiguration(BaseModel):
\nidentity: ToolIdentity
\nparameters: list[ToolParameter] = Field(default=[], description=”The parameters of the tool”)
\ndescription: ToolDescription
\nextra: ToolConfigurationExtra
\nhas_runtime_parameters: bool = Field(default=False, description=”Whether the tool has runtime parameters”)
\noutput_schema: Optional[Mapping[str, Any]] = None<\/p>\n

class ToolLabelEnum(Enum):
\nSEARCH = “search”
\nIMAGE = “image”
\nVIDEOS = “videos”
\nWEATHER = “weather”
\nFINANCE = “finance”
\nDESIGN = “design”
\nTRAVEL = “travel”
\nSOCIAL = “social”
\nNEWS = “news”
\nMEDICAL = “medical”
\nPRODUCTIVITY = “productivity”
\nEDUCATION = “education”
\nBUSINESS = “business”
\nENTERTAINMENT = “entertainment”
\nUTILITIES = “utilities”
\nOTHER = “other”<\/p>\n

class ToolCredentialsOption(BaseModel):
\nvalue: str = Field(…, description=”The value of the option”)
\nlabel: I18nObject = Field(…, description=”The label of the option”)<\/p>\n

class ProviderConfig(BaseModel):
\nclass Config(Enum):
\nSECRET_INPUT = CommonParameterType.SECRET_INPUT.value
\nTEXT_INPUT = CommonParameterType.TEXT_INPUT.value
\nSELECT = CommonParameterType.SELECT.value
\nBOOLEAN = CommonParameterType.BOOLEAN.value
\nMODEL_SELECTOR = CommonParameterType.MODEL_SELECTOR.value
\nAPP_SELECTOR = CommonParameterType.APP_SELECTOR.value
\n# TOOL_SELECTOR = CommonParameterType.TOOL_SELECTOR.value
\nTOOLS_SELECTOR = CommonParameterType.TOOLS_SELECTOR.value<\/p>\n

@classmethod
\ndef value_of(cls, value: str) -> “ProviderConfig.Config”:
\n“””
\nGet value of given mode.<\/p>\n

:param value: mode value
\n:return: mode
\n“””
\nfor mode in cls:
\nif mode.value == value:
\nreturn mode
\nraise ValueError(f”invalid mode value {value}”)<\/p>\n

name: str = Field(…, description=”The name of the credentials”)
\ntype: Config = Field(…, description=”The type of the credentials”)
\nscope: str | None = None
\nrequired: bool = False
\ndefault: Optional[Union[int, float, str]] = None
\noptions: Optional[list[ToolCredentialsOption]] = None
\nlabel: I18nObject
\nhelp: Optional[I18nObject] = None
\nurl: Optional[str] = None
\nplaceholder: Optional[I18nObject] = None<\/p>\n

class ToolProviderIdentity(BaseModel):
\nauthor: str = Field(…, description=”The author of the tool”)
\nname: str = Field(…, description=”The name of the tool”)
\ndescription: I18nObject = Field(…, description=”The description of the tool”)
\nicon: str = Field(…, description=”The icon of the tool”)
\nlabel: I18nObject = Field(…, description=”The label of the tool”)
\ntags: list[ToolLabelEnum] = Field(
\ndefault=[],
\ndescription=”The tags of the tool”,
\n)<\/p>\n

class ToolProviderConfigurationExtra(BaseModel):
\nclass Python(BaseModel):
\nsource: str<\/p>\n

python: Python<\/p>\n

class ToolProviderConfiguration(BaseModel):
\nidentity: ToolProviderIdentity
\ncredentials_schema: list[ProviderConfig] = Field(
\ndefault_factory=list,
\nalias=”credentials_for_provider”,
\ndescription=”The credentials schema of the tool provider”,
\n)
\ntools: list[ToolConfiguration] = Field(default=[], description=”The tools of the tool provider”)
\nextra: ToolProviderConfigurationExtra<\/p>\n

@model_validator(mode=”before”)
\n@classmethod
\ndef validate_credentials_schema(cls, data: dict) -> dict:
\noriginal_credentials_for_provider: dict[str, dict] = data.get(“credentials_for_provider”, {})<\/p>\n

credentials_for_provider: list[dict[str, Any]] = []
\nfor name, credential in original_credentials_for_provider.items():
\ncredential[“name”] = name
\ncredentials_for_provider.append(credential)<\/p>\n

data[“credentials_for_provider”] = credentials_for_provider
\nreturn data<\/p>\n

@field_validator(“tools”, mode=”before”)
\n@classmethod
\ndef validate_tools(cls, value) -> list[ToolConfiguration]:
\nif not isinstance(value, list):
\nraise ValueError(“tools should be a list”)<\/p>\n

tools: list[ToolConfiguration] = []<\/p>\n

for tool in value:
\n# read from yaml
\nif not isinstance(tool, str):
\nraise ValueError(“tool path should be a string”)
\ntry:
\nfile = load_yaml_file(tool)
\ntools.append(
\nToolConfiguration(
\nidentity=ToolIdentity(**file[“identity”]),
\nparameters=[ToolParameter(**param) for param in file.get(“parameters”, []) or []],
\ndescription=ToolDescription(**file[“description”]),
\nextra=ToolConfigurationExtra(**file.get(“extra”, {})),
\noutput_schema=file.get(“output_schema”, None),
\n)
\n)
\nexcept Exception as e:
\nraise ValueError(f”Error loading tool configuration: {str(e)}”) from e<\/p>\n

return tools<\/p>\n

class ToolProviderType(Enum):
\n“””
\nEnum class for tool provider
\n“””<\/p>\n

BUILT_IN = “builtin”
\nWORKFLOW = “workflow”
\nAPI = “api”
\nAPP = “app”
\nDATASET_RETRIEVAL = “dataset-retrieval”<\/p>\n

@classmethod
\ndef value_of(cls, value: str) -> “ToolProviderType”:
\n“””
\nGet value of given mode.<\/p>\n

:param value: mode value
\n:return: mode
\n“””
\nfor mode in cls:
\nif mode.value == value:
\nreturn mode
\nraise ValueError(f”invalid mode value {value}”)<\/p>\n

class ToolSelector(BaseModel):
\nclass Parameter(BaseModel):
\nname: str = Field(…, description=”The name of the parameter”)
\ntype: ToolParameter.ToolParameterType = Field(…, description=”The type of the parameter”)
\nrequired: bool = Field(…, description=”Whether the parameter is required”)
\ndescription: str = Field(…, description=”The description of the parameter”)
\ndefault: Optional[Union[int, float, str]] = None
\noptions: Optional[list[ToolParameterOption]] = None<\/p>\n

provider_id: str = Field(…, description=”The id of the provider”)
\ntool_name: str = Field(…, description=”The name of the tool”)
\ntool_description: str = Field(…, description=”The description of the tool”)
\ntool_configuration: Mapping[str, Any] = Field(…, description=”Configuration, type form”)
\ntool_parameters: Mapping[str, Parameter] = Field(…, description=”Parameters, type llm”)<\/p>\n

def to_prompt_message(self) -> PromptMessageTool:
\n“””
\nConvert tool selector to prompt message tool, based on openai function calling<\/a> schema.
\n“””
\ntool = PromptMessageTool(
\nname=self.tool_name,
\ndescription=self.tool_description,
\nparameters={
\n“type”: “object”,
\n“properties”: {},
\n“required”: [],
\n},
\n)<\/p>\n

for name, parameter in self.tool_parameters.items():
\ntool.parameters[name] = {
\n“type”: parameter.type.value,
\n“description”: parameter.description,
\n}<\/p>\n

if parameter.required:
\ntool.parameters[“required”].append(name)<\/p>\n

if parameter.options:
\ntool.parameters[name][“enum”] = [option.value for option in parameter.options]<\/p>\n

return tool
\nFile Purpose
\nThe tool YAML file (your_plugin.yaml) defines:
\nBasic identity information about your tool
\nDescriptions for both humans and the AI agent
\nParameters that your tool accepts
\nHow these parameters are presented and collected
\nExample Implementation
\nHere’s how the tool YAML files for Dropbox looks:
\nceate_folder.yaml:
\nidentity:
\nname: create_folder
\nauthor: lcandy
\nlabel:
\nen_US: Create Folder
\nzh_Hans: \u521b\u5efa\u6587\u4ef6\u5939
\npt_BR: Criar Pasta
\nja_JP: \u30d5\u30a9\u30eb\u30c0\u4f5c\u6210
\nzh_Hant: \u5efa\u7acb\u8cc7\u6599\u593e
\ndescription:
\nhuman:
\nen_US: Create a new folder in Dropbox
\nzh_Hans: \u5728 Dropbox \u4e2d\u521b\u5efa\u65b0\u6587\u4ef6\u5939
\npt_BR: Criar uma nova pasta no Dropbox
\nja_JP: Dropbox \u306b\u65b0\u3057\u3044\u30d5\u30a9\u30eb\u30c0\u3092\u4f5c\u6210\u3057\u307e\u3059
\nzh_Hant: \u5728 Dropbox \u4e2d\u5efa\u7acb\u65b0\u8cc7\u6599\u593e
\nllm: Creates a new folder at the specified path in Dropbox. Returns information about the created folder including path and ID.
\nparameters:
\n– name: folder_path
\ntype: string
\nrequired: true
\nlabel:
\nen_US: Folder Path
\nzh_Hans: \u6587\u4ef6\u5939\u8def\u5f84
\npt_BR: Caminho da Pasta
\nja_JP: \u30d5\u30a9\u30eb\u30c0\u30d1\u30b9
\nzh_Hant: \u8cc7\u6599\u593e\u8def\u5f91
\nhuman_description:
\nen_US: The path where the folder will be created in Dropbox
\nzh_Hans: \u6587\u4ef6\u5939\u5728 Dropbox \u4e2d\u7684\u521b\u5efa\u8def\u5f84
\npt_BR: O caminho onde a pasta ser\u00e1 criada no Dropbox
\nja_JP: Dropbox \u3067\u30d5\u30a9\u30eb\u30c0\u3092\u4f5c\u6210\u3059\u308b\u30d1\u30b9
\nzh_Hant: \u6b32\u5728 Dropbox \u4e2d\u5efa\u7acb\u8cc7\u6599\u593e\u7684\u8def\u5f91
\nllm_description: The path where the folder will be created in Dropbox. Should be specified as a complete path, like ‘\/Documents\/Projects’ or ‘\/Photos\/Vacation2023’. Paths are case-sensitive and must start with a forward slash.
\nform: llm
\nextra:
\npython:
\nsource: tools\/create_folder.py
\ndelete_file.yaml:
\nidentity:
\nname: delete_file
\nauthor: lcandy
\nlabel:
\nen_US: Delete File\/Folder
\nzh_Hans: \u5220\u9664\u6587\u4ef6\/\u6587\u4ef6\u5939
\npt_BR: Excluir Arquivo\/Pasta
\nja_JP: \u30d5\u30a1\u30a4\u30eb\/\u30d5\u30a9\u30eb\u30c0\u524a\u9664
\nzh_Hant: \u522a\u9664\u6a94\u6848\/\u8cc7\u6599\u593e
\ndescription:
\nhuman:
\nen_US: Delete a file or folder from Dropbox
\nzh_Hans: \u4ece Dropbox \u5220\u9664\u6587\u4ef6\u6216\u6587\u4ef6\u5939
\npt_BR: Excluir um arquivo ou pasta do Dropbox
\nja_JP: Dropbox \u304b\u3089\u30d5\u30a1\u30a4\u30eb\u3084\u30d5\u30a9\u30eb\u30c0\u3092\u524a\u9664\u3057\u307e\u3059
\nzh_Hant: \u5f9e Dropbox \u522a\u9664\u6a94\u6848\u6216\u8cc7\u6599\u593e
\nllm: Permanently deletes a file or folder from Dropbox at the specified path. Returns confirmation information about the deleted item.
\nparameters:
\n– name: file_path
\ntype: string
\nrequired: true
\nlabel:
\nen_US: File\/Folder Path
\nzh_Hans: \u6587\u4ef6\/\u6587\u4ef6\u5939\u8def\u5f84
\npt_BR: Caminho do Arquivo\/Pasta
\nja_JP: \u30d5\u30a1\u30a4\u30eb\/\u30d5\u30a9\u30eb\u30c0\u30d1\u30b9
\nzh_Hant: \u6a94\u6848\/\u8cc7\u6599\u593e\u8def\u5f91
\nhuman_description:
\nen_US: The path of the file or folder to delete from Dropbox
\nzh_Hans: \u8981\u4ece Dropbox \u5220\u9664\u7684\u6587\u4ef6\u6216\u6587\u4ef6\u5939\u7684\u8def\u5f84
\npt_BR: O caminho do arquivo ou pasta para excluir do Dropbox
\nja_JP: Dropbox \u304b\u3089\u524a\u9664\u3059\u308b\u30d5\u30a1\u30a4\u30eb\u3084\u30d5\u30a9\u30eb\u30c0\u306e\u30d1\u30b9
\nzh_Hant: \u6b32\u5f9e Dropbox \u522a\u9664\u7684\u6a94\u6848\u6216\u8cc7\u6599\u593e\u8def\u5f91
\nllm_description: The path of the file or folder to delete from Dropbox. Should be specified as a complete path, like ‘\/Documents\/report.txt’ or ‘\/Photos\/Vacation2023’. Paths are case-sensitive and must start with a forward slash. WARNING – This is a permanent deletion.
\nform: llm
\nextra:
\npython:
\nsource: tools\/delete_file.py
\ndownload_file.py:
\nidentity:
\nname: download_file
\nauthor: lcandy
\nlabel:
\nen_US: Download File
\nzh_Hans: \u4e0b\u8f7d\u6587\u4ef6
\npt_BR: Baixar Arquivo
\nja_JP: \u30d5\u30a1\u30a4\u30eb\u30c0\u30a6\u30f3\u30ed\u30fc\u30c9
\nzh_Hant: \u4e0b\u8f09\u6a94\u6848
\ndescription:
\nhuman:
\nen_US: Download a file from Dropbox
\nzh_Hans: \u4ece Dropbox \u4e0b\u8f7d\u6587\u4ef6
\npt_BR: Baixar um arquivo do Dropbox
\nja_JP: Dropbox \u304b\u3089\u30d5\u30a1\u30a4\u30eb\u3092\u30c0\u30a6\u30f3\u30ed\u30fc\u30c9\u3057\u307e\u3059
\nzh_Hant: \u5f9e Dropbox \u4e0b\u8f09\u6a94\u6848
\nllm: Downloads a file from Dropbox at the specified path. Returns file metadata and optionally the file content (as base64 for binary files or text for text files).
\nparameters:
\n– name: file_path
\ntype: string
\nrequired: true
\nlabel:
\nen_US: File Path
\nzh_Hans: \u6587\u4ef6\u8def\u5f84
\npt_BR: Caminho do Arquivo
\nja_JP: \u30d5\u30a1\u30a4\u30eb\u30d1\u30b9
\nzh_Hant: \u6a94\u6848\u8def\u5f91
\nhuman_description:
\nen_US: The path of the file to download from Dropbox
\nzh_Hans: \u8981\u4ece Dropbox \u4e0b\u8f7d\u7684\u6587\u4ef6\u8def\u5f84
\npt_BR: O caminho do arquivo para baixar do Dropbox
\nja_JP: Dropbox \u304b\u3089\u30c0\u30a6\u30f3\u30ed\u30fc\u30c9\u3059\u308b\u30d5\u30a1\u30a4\u30eb\u306e\u30d1\u30b9
\nzh_Hant: \u6b32\u5f9e Dropbox \u4e0b\u8f09\u7684\u6a94\u6848\u8def\u5f91
\nllm_description: The path of the file to download from Dropbox. Should include the complete path with filename and extension, like ‘\/Documents\/report.txt’. Paths are case-sensitive and must start with a forward slash.
\nform: llm
\n– name: include_content
\ntype: boolean
\nrequired: false
\ndefault: false
\nlabel:
\nen_US: Include Content
\nzh_Hans: \u5305\u542b\u5185\u5bb9
\npt_BR: Incluir Conte\u00fado
\nja_JP: \u5185\u5bb9\u3092\u542b\u3081\u308b
\nzh_Hant: \u5305\u542b\u5167\u5bb9
\nhuman_description:
\nen_US: Whether to include the file content in the response
\nzh_Hans: \u662f\u5426\u5728\u54cd\u5e94\u4e2d\u5305\u542b\u6587\u4ef6\u5185\u5bb9
\npt_BR: Se deve incluir o conte\u00fado do arquivo na resposta
\nja_JP: \u30ec\u30b9\u30dd\u30f3\u30b9\u306b\u30d5\u30a1\u30a4\u30eb\u306e\u5185\u5bb9\u3092\u542b\u3081\u308b\u304b\u3069\u3046\u304b
\nzh_Hant: \u662f\u5426\u5728\u56de\u61c9\u4e2d\u5305\u542b\u6a94\u6848\u5167\u5bb9
\nllm_description: Set to true to include the file content in the response. For small text files, the content will be provided as text. For binary files, the content will be provided as base64-encoded string. Default is false.
\nform: llm
\nextra:
\npython:
\nsource: tools\/download_file.py<\/p>\n

dropbox.yaml:
\nidentity:
\nname: dropbox
\nauthor: lcandy
\nlabel:
\nen_US: Dropbox
\nzh_Hans: Dropbox
\npt_BR: Dropbox
\nja_JP: Dropbox
\nzh_Hant: Dropbox
\ndescription:
\nhuman:
\nen_US: Interact with Dropbox
\nzh_Hans: \u4e0e Dropbox \u4ea4\u4e92
\npt_BR: Interagir com o Dropbox
\nja_JP: Dropbox \u3068\u9023\u643a\u3059\u308b
\nzh_Hant: \u8207 Dropbox \u4e92\u52d5
\nllm: Provides access to Dropbox services, allowing you to interact with files and folders in a Dropbox account.
\nparameters:
\n– name: query
\ntype: string
\nrequired: true
\nlabel:
\nen_US: Query string
\nzh_Hans: \u67e5\u8be2\u8bed\u53e5
\npt_BR: Termo de consulta
\nja_JP: \u30af\u30a8\u30ea\u6587\u5b57\u5217
\nzh_Hant: \u67e5\u8a62\u8a9e\u53e5
\nhuman_description:
\nen_US: Enter your Dropbox operation query
\nzh_Hans: \u8f93\u5165\u60a8\u7684 Dropbox \u64cd\u4f5c\u67e5\u8be2
\npt_BR: Digite sua consulta de opera\u00e7\u00e3o do Dropbox
\nja_JP: Dropbox \u64cd\u4f5c\u30af\u30a8\u30ea\u3092\u5165\u529b\u3057\u3066\u304f\u3060\u3055\u3044
\nzh_Hant: \u8acb\u8f38\u5165\u60a8\u8981\u57f7\u884c\u7684 Dropbox \u64cd\u4f5c\u6307\u4ee4
\nllm_description: The query describing the Dropbox operation you want to perform.
\nform: llm
\nextra:
\npython:
\nsource: tools\/dropbox.py
\nKey Components
\nIdentity Section:
\nname: Internal name for your tool (should match your file naming)
\nauthor: Who created the tool
\nlabel: Display name in different languages
\nDescription Section:
\nhuman: Description shown to human users in different languages
\nllm: Description provided to the AI agent to understand what your tool does and how to use it
\nParameters Section:
\nList of parameters your tool accepts, each with:
\nname: Parameter identifier (used in your Python code)
\ntype: Data type (string, number, boolean, etc.)
\nrequired: Whether this parameter is mandatory
\nlabel: User-friendly name in different languages
\nhuman_description: Explanation for human users in different languages
\nllm_description: Explanation for the AI agent to understand this parameter
\nform: How the parameter is collected
\nllm: AI agent extracts from user queries
\nworkflow: User must provide as a variable in the UI
\nOptional: default: Default value for this parameter
\nExtra Section:
\npython.source: Path to your tool’s Python implementation file
\nImportant Notes
\nFile Seperation:
\nImportant!!!!: If your tool has different functionality, like read and write a email, or read or update a database, you should seperate the yaml file into more than one. The principle is each yaml and code file are exclusively for each type of tool execution. The file itself should only extract parameter that the tool\u2019s functionality will use. For example, for to read and update a database, you should use two yaml file: read_database.yaml and update_database.yaml seperately.
\nLLM Descriptions:
\nThe llm description for both the tool and parameters is crucial – it tells the AI agent how to use your tool
\nBe clear about what parameters are needed and what information your tool will return
\nThis helps the AI agent decide when to use your tool and how to extract parameters from user queries
\nParameter Configuration:
\nFor each parameter, specify whether it’s required
\nChoose the appropriate data type
\nSet the form to llm if you want the AI to extract it from user queries
\nSet the form to workflow if you want users to provide it directly
\nLocalization:
\nProvide translations for labels and descriptions in multiple languages as needed
\nAt minimum, include English (en_US)
\nTo create your own tool YAML file, adapt this structure for your specific tool, clearly defining what parameters it needs and how they should be presented to both humans and the AI agent.
\n5. How to edit tools\/your_plugin.py
\nYou’re tasked with creating the tool implementation file for a Dify plugin. This file contains the actual logic for your tool that makes API requests and processes the results. I’ll guide you through creating this file, using Google Search as an example.
\nFile Purpose
\nThe tool Python file (your_plugin.py) is responsible for:
\nMaking API requests to your service
\nProcessing the responses
\nReturning the results in a format usable by Dify
\nRequired Components
\nYour tool class must inherit from dify_plugin.Tool
\nYou must implement the _invoke method that returns a generator
\nYou must include these essential imports:
\nfrom collections.abc import Generator
\nfrom typing import Any
\nfrom dify_plugin import Tool
\nfrom dify_plugin.entities.tool import ToolInvokeMessage
\nExample Implementation
\nHere’s how the tool implementation for Dropbox tool looks:
\nceate_folder.yaml:
\nfrom collections.abc import Generator
\nfrom typing import Any<\/p>\n

from dify_plugin import Tool
\nfrom dify_plugin.entities.tool import ToolInvokeMessage
\nfrom dropbox.exceptions import ApiError, AuthError<\/p>\n

from dropbox_utils import DropboxUtils<\/p>\n

class CreateFolderTool(Tool):
\ndef _invoke(self, tool_parameters: dict[str, Any]) -> Generator[ToolInvokeMessage, None, None]:
\n“””
\nCreate a folder in Dropbox
\n“””
\n# Get parameters
\nfolder_path = tool_parameters.get(“folder_path”, “”)<\/p>\n

# Validate parameters
\nif not folder_path:
\nyield self.create_text_message(“Folder path in Dropbox is required.”)
\nreturn<\/p>\n

# Make sure folder path starts with \/
\nif not folder_path.startswith(“\/”):
\nfolder_path = “\/” + folder_path<\/p>\n

try:
\n# Get access token from credentials
\naccess_token = self.runtime.credentials.get(“access_token”)
\nif not access_token:
\nyield self.create_text_message(“Dropbox access token is required.”)
\nreturn<\/p>\n

# Get Dropbox client
\ntry:
\ndbx = DropboxUtils.get_client(access_token)
\nexcept AuthError as e:
\nyield self.create_text_message(f”Authentication failed: {str(e)}”)
\nreturn
\nexcept Exception as e:
\nyield self.create_text_message(f”Failed to connect to Dropbox: {str(e)}”)
\nreturn<\/p>\n

# Create the folder
\ntry:
\nresult = DropboxUtils.create_folder(dbx, folder_path)<\/p>\n

# Create response
\nsummary = f”Folder ‘{result[‘name’]}’ created successfully at ‘{result[‘path’]}'”
\nyield self.create_text_message(summary)
\nyield self.create_json_message(result)<\/p>\n

except ApiError as e:
\nif “path\/conflict” in str(e):
\nyield self.create_text_message(f”A folder already exists at ‘{folder_path}'”)
\nelse:
\nyield self.create_text_message(f”Error creating folder: {str(e)}”)
\nreturn<\/p>\n

except Exception as e:
\nyield self.create_text_message(f”Error: {str(e)}”)
\nreturn
\ndelete_file.py
\nfrom collections.abc import Generator
\nfrom typing import Any<\/p>\n

from dify_plugin import Tool
\nfrom dify_plugin.entities.tool import ToolInvokeMessage
\nfrom dropbox.exceptions import ApiError, AuthError<\/p>\n

from dropbox_utils import DropboxUtils<\/p>\n

class DeleteFileTool(Tool):
\ndef _invoke(self, tool_parameters: dict[str, Any]) -> Generator[ToolInvokeMessage, None, None]:
\n“””
\nDelete a file or folder from Dropbox
\n“””
\n# Get parameters
\nfile_path = tool_parameters.get(“file_path”, “”)<\/p>\n

# Validate parameters
\nif not file_path:
\nyield self.create_text_message(“File or folder path in Dropbox is required.”)
\nreturn<\/p>\n

# Make sure path starts with \/
\nif not file_path.startswith(“\/”):
\nfile_path = “\/” + file_path<\/p>\n

try:
\n# Get access token from credentials
\naccess_token = self.runtime.credentials.get(“access_token”)
\nif not access_token:
\nyield self.create_text_message(“Dropbox access token is required.”)
\nreturn<\/p>\n

# Get Dropbox client
\ntry:
\ndbx = DropboxUtils.get_client(access_token)
\nexcept AuthError as e:
\nyield self.create_text_message(f”Authentication failed: {str(e)}”)
\nreturn
\nexcept Exception as e:
\nyield self.create_text_message(f”Failed to connect to Dropbox: {str(e)}”)
\nreturn<\/p>\n

# Delete the file or folder
\ntry:
\nresult = DropboxUtils.delete_file(dbx, file_path)<\/p>\n

# Create response
\nsummary = f”‘{result[‘name’]}’ deleted successfully”
\nyield self.create_text_message(summary)
\nyield self.create_json_message(result)<\/p>\n

except ApiError as e:
\nif “path\/not_found” in str(e):
\nyield self.create_text_message(f”File or folder not found at ‘{file_path}'”)
\nelse:
\nyield self.create_text_message(f”Error deleting file\/folder: {str(e)}”)
\nreturn<\/p>\n

except Exception as e:
\nyield self.create_text_message(f”Error: {str(e)}”)
\nreturn
\ndownload_file.yaml:
\nfrom collections.abc import Generator
\nimport base64
\nfrom typing import Any<\/p>\n

from dify_plugin import Tool
\nfrom dify_plugin.entities.tool import ToolInvokeMessage
\nfrom dropbox.exceptions import ApiError, AuthError<\/p>\n

from dropbox_utils import DropboxUtils<\/p>\n

class DownloadFileTool(Tool):
\ndef _invoke(self, tool_parameters: dict[str, Any]) -> Generator[ToolInvokeMessage, None, None]:
\n“””
\nDownload a file from Dropbox
\n“””
\n# Get parameters
\nfile_path = tool_parameters.get(“file_path”, “”)
\ninclude_content = tool_parameters.get(“include_content”, False)<\/p>\n

# Validate parameters
\nif not file_path:
\nyield self.create_text_message(“File path in Dropbox is required.”)
\nreturn<\/p>\n

# Make sure file path starts with \/
\nif not file_path.startswith(“\/”):
\nfile_path = “\/” + file_path<\/p>\n

try:
\n# Get access token from credentials
\naccess_token = self.runtime.credentials.get(“access_token”)
\nif not access_token:
\nyield self.create_text_message(“Dropbox access token is required.”)
\nreturn<\/p>\n

# Get Dropbox client
\ntry:
\ndbx = DropboxUtils.get_client(access_token)
\nexcept AuthError as e:
\nyield self.create_text_message(f”Authentication failed: {str(e)}”)
\nreturn
\nexcept Exception as e:
\nyield self.create_text_message(f”Failed to connect to Dropbox: {str(e)}”)
\nreturn<\/p>\n

# Download the file
\ntry:
\nresult = DropboxUtils.download_file(dbx, file_path)<\/p>\n

# Create response
\nresponse = {
\n“name”: result[“name”],
\n“path”: result[“path”],
\n“id”: result[“id”],
\n“size”: result[“size”],
\n“modified”: result[“modified”]
\n}<\/p>\n

# Include content if requested
\nif include_content:
\n# Encode binary content as base64
\nresponse[“content_base64”] = base64.b64encode(result[“content”]).decode(‘utf-8’)<\/p>\n

# Try to decode as text if small enough
\nif result[“size”] < 1024 * 1024: # Less than 1MB
\ntry:
\ntext_content = result[“content”].decode(‘utf-8’)
\nresponse[“content_text”] = text_content
\nexcept UnicodeDecodeError:
\n# Not a text file, just include base64
\npass<\/p>\n

summary = f”File ‘{result[‘name’]}’ downloaded successfully”
\nyield self.create_text_message(summary)
\nyield self.create_json_message(response)<\/p>\n

except ApiError as e:
\nyield self.create_text_message(f”Error downloading file: {str(e)}”)
\nreturn<\/p>\n

except Exception as e:
\nyield self.create_text_message(f”Error: {str(e)}”)
\nreturn
\nKey Points to Remember
\nFile Seperation:
\nImportant: If your tool has different functionality, like read and write a email, or read or update a database, you should seperate the yaml file into more than one. The principle is each yaml and code file are exclusively for each type of tool execution. The file itself should only extract parameter that the tool\u2019s functionality will use. For example, for to read and update a database, you should use two yaml file: read_database.py and update_database.py seperately.
\nRequired Imports: Always include the essential imports at the top of your file.
\nClass Inheritance: Your tool class must inherit from dify_plugin.Tool
\nExtracting Parameters:
\nThe tool_parameters dictionary contains all parameters defined in your tool’s YAML file
\nAccess these parameters directly using dictionary keys, e.g., tool_parameters[“query”]
\nThese parameters are automatically extracted from user queries by the AI agent
\nEnsure you handle any required parameters and provide appropriate error handling if they’re missing
\nExample:
\nquery = tool_parameters[“query”] # Extract the query parameterlimit = tool_parameters.get(“limit”, 10) # Extract with a default value# Optional validationif not query: raise ValueError(“Query parameter cannot be empty”)
\nAccessing Credentials:
\nAccess your authentication credentials using self.runtime.credentials
\nThe keys match those defined in your provider YAML file
\nExample: self.runtime.credentials[“serpapi_api_key”]
\nResponse Processing: Create a helper method to extract only the relevant information from API responses.
\nYielding Results: You must use yield with one of the message creation methods to return data.
\nWhen implementing your own tool, make sure you correctly extract all the parameters you need from the tool_parameters dictionary, and validate them if necessary. The available parameters are defined in your tool’s YAML file and will be automatically extracted from user queries by the AI agent.
\n6. How to Create PRIVACY.md and README.md
\nYou’re tasked with creating the privacy policy and readme files for your Dify plugin. These files are written in Markdown format and serve important purposes for users and developers of your plugin. Let me guide you through creating both files.
\nPRIVACY.md
\nThe PRIVACY.md file outlines<\/a> your plugin’s privacy practices, including what data it collects and how that data is used. This is critical information for users concerned about their data privacy.
\nWhat to Include
\nBased on the placeholder text you shared (“!!! Please fill in the privacy policy of the plugin.”), you should include:
\nWhat data your plugin collects
\nHow this data is stored and processed
\nWhat third-party services are used (if any)
\nUser rights regarding their data
\nHow long data is retained
\nContact information for privacy concerns
\nExample Structure
\n# Privacy Policy<\/p>\n

## Data Collection
\n[Describe what user data your plugin collects and why]<\/p>\n

## Data Processing
\n[Explain how the collected data is processed]<\/p>\n

## Third-party Services
\n[List any third-party services used by your plugin and link to their privacy policies]<\/p>\n

## Data Retention
\n[Explain how long user data is stored]<\/p>\n

## User Rights
\n[Outline what rights users have regarding their data]<\/p>\n

## Contact Information
\n[Provide contact information for privacy-related inquiries]<\/p>\n

Last updated: [Date]
\nREADME.md
\nThe README.md file provides essential information about your plugin, including what it does, how to install it, and how to use it. This is the first document most users and developers will refer to.
\nWhat to Include
\nBased on the example you shared (Jira plugin readme), you should include:
\nPlugin name as the main heading
\nAuthor information
\nVersion information
\nType of plugin
\nDetailed description of what the plugin does
\nInstallation instructions
\nUsage examples
\nConfiguration options
\nTroubleshooting information
\nExample Structure
\n# Your Plugin Name<\/p>\n

**Author:** [Your name or organization]
\n**Version:** [Current version number]
\n**Type:** [Plugin type]<\/p>\n

## Description
\n[Provide a detailed description of what your plugin does]<\/p>\n

## Features
\n– [Feature 1]
\n– [Feature 2]
\n– [Feature 3]<\/p>\n

## Installation
\n[Provide step-by-step installation instructions]<\/p>\n

## Configuration
\n[Explain how to configure your plugin]<\/p>\n

## Usage Examples
\n[Provide examples of how to use your plugin]<\/p>\n

## Troubleshooting
\n[List common issues and their solutions]<\/p>\n

## Contributing
\n[Explain how others can contribute to your plugin]<\/p>\n

## License
\n[Specify the license under which your plugin is released]
\nUsing Images
\nAs you mentioned, if you want to include images in either document:
\nStore the images in the _assets folder
\nReference them in your Markdown using relative paths:
\n![Description of image](_assets\/image_name.png)
\nBoth of these files should be written in Markdown format (.md extension) and placed in the root directory of your plugin project. Make sure to keep them up-to-date as your plugin evolves.
\nRequirements.txt
\nYou should always use the latest dependencies by using ~= in your txt file, and the dify_plugin~=0.0.1b72 is a must be.<\/p>\n","protected":false},"excerpt":{"rendered":"

You are a senior developer that can help me with developing Dify Plugin Tool, which is an AI Agent Tool that can be used…<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[18],"tags":[],"class_list":["post-30712","post","type-post","status-publish","format-standard","hentry","category-prompts"],"_links":{"self":[{"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/posts\/30712","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/comments?post=30712"}],"version-history":[{"count":0,"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/posts\/30712\/revisions"}],"wp:attachment":[{"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/media?parent=30712"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/categories?post=30712"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.kdjingpai.com\/ja\/wp-json\/wp\/v2\/tags?post=30712"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}