dify

dify/api/core/plugin/backwards_invocation/app.py

@@ -0,0 +1,222 @@
+from collections.abc import Generator, Mapping
+from typing import Union
+
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from core.app.app_config.common.parameters_mapping import get_parameters_from_feature_dict
+from core.app.apps.advanced_chat.app_generator import AdvancedChatAppGenerator
+from core.app.apps.agent_chat.app_generator import AgentChatAppGenerator
+from core.app.apps.chat.app_generator import ChatAppGenerator
+from core.app.apps.completion.app_generator import CompletionAppGenerator
+from core.app.apps.workflow.app_generator import WorkflowAppGenerator
+from core.app.entities.app_invoke_entities import InvokeFrom
+from core.plugin.backwards_invocation.base import BaseBackwardsInvocation
+from extensions.ext_database import db
+from models import Account
+from models.model import App, AppMode, EndUser
+from services.end_user_service import EndUserService
+
+
+class PluginAppBackwardsInvocation(BaseBackwardsInvocation):
+    @classmethod
+    def fetch_app_info(cls, app_id: str, tenant_id: str) -> Mapping:
+        """
+        Fetch app info
+        """
+        app = cls._get_app(app_id, tenant_id)
+
+        """Retrieve app parameters."""
+        if app.mode in {AppMode.ADVANCED_CHAT, AppMode.WORKFLOW}:
+            workflow = app.workflow
+            if workflow is None:
+                raise ValueError("unexpected app type")
+
+            features_dict = workflow.features_dict
+            user_input_form = workflow.user_input_form(to_old_structure=True)
+        else:
+            app_model_config = app.app_model_config
+            if app_model_config is None:
+                raise ValueError("unexpected app type")
+
+            features_dict = app_model_config.to_dict()
+
+            user_input_form = features_dict.get("user_input_form", [])
+
+        return {
+            "data": get_parameters_from_feature_dict(features_dict=features_dict, user_input_form=user_input_form),
+        }
+
+    @classmethod
+    def invoke_app(
+        cls,
+        app_id: str,
+        user_id: str,
+        tenant_id: str,
+        conversation_id: str | None,
+        query: str | None,
+        stream: bool,
+        inputs: Mapping,
+        files: list[dict],
+    ) -> Generator[Mapping | str, None, None] | Mapping:
+        """
+        invoke app
+        """
+        app = cls._get_app(app_id, tenant_id)
+        if not user_id:
+            user = EndUserService.get_or_create_end_user(app)
+        else:
+            user = cls._get_user(user_id)
+
+        conversation_id = conversation_id or ""
+
+        if app.mode in {AppMode.ADVANCED_CHAT, AppMode.AGENT_CHAT, AppMode.CHAT}:
+            if not query:
+                raise ValueError("missing query")
+
+            return cls.invoke_chat_app(app, user, conversation_id, query, stream, inputs, files)
+        elif app.mode == AppMode.WORKFLOW:
+            return cls.invoke_workflow_app(app, user, stream, inputs, files)
+        elif app.mode == AppMode.COMPLETION:
+            return cls.invoke_completion_app(app, user, stream, inputs, files)
+
+        raise ValueError("unexpected app type")
+
+    @classmethod
+    def invoke_chat_app(
+        cls,
+        app: App,
+        user: Account | EndUser,
+        conversation_id: str,
+        query: str,
+        stream: bool,
+        inputs: Mapping,
+        files: list[dict],
+    ) -> Generator[Mapping | str, None, None] | Mapping:
+        """
+        invoke chat app
+        """
+        if app.mode == AppMode.ADVANCED_CHAT:
+            workflow = app.workflow
+            if not workflow:
+                raise ValueError("unexpected app type")
+
+            return AdvancedChatAppGenerator().generate(
+                app_model=app,
+                workflow=workflow,
+                user=user,
+                args={
+                    "inputs": inputs,
+                    "query": query,
+                    "files": files,
+                    "conversation_id": conversation_id,
+                },
+                invoke_from=InvokeFrom.SERVICE_API,
+                streaming=stream,
+            )
+        elif app.mode == AppMode.AGENT_CHAT:
+            return AgentChatAppGenerator().generate(
+                app_model=app,
+                user=user,
+                args={
+                    "inputs": inputs,
+                    "query": query,
+                    "files": files,
+                    "conversation_id": conversation_id,
+                },
+                invoke_from=InvokeFrom.SERVICE_API,
+                streaming=stream,
+            )
+        elif app.mode == AppMode.CHAT:
+            return ChatAppGenerator().generate(
+                app_model=app,
+                user=user,
+                args={
+                    "inputs": inputs,
+                    "query": query,
+                    "files": files,
+                    "conversation_id": conversation_id,
+                },
+                invoke_from=InvokeFrom.SERVICE_API,
+                streaming=stream,
+            )
+        else:
+            raise ValueError("unexpected app type")
+
+    @classmethod
+    def invoke_workflow_app(
+        cls,
+        app: App,
+        user: EndUser | Account,
+        stream: bool,
+        inputs: Mapping,
+        files: list[dict],
+    ) -> Generator[Mapping | str, None, None] | Mapping:
+        """
+        invoke workflow app
+        """
+        workflow = app.workflow
+        if not workflow:
+            raise ValueError("unexpected app type")
+
+        return WorkflowAppGenerator().generate(
+            app_model=app,
+            workflow=workflow,
+            user=user,
+            args={"inputs": inputs, "files": files},
+            invoke_from=InvokeFrom.SERVICE_API,
+            streaming=stream,
+            call_depth=1,
+        )
+
+    @classmethod
+    def invoke_completion_app(
+        cls,
+        app: App,
+        user: EndUser | Account,
+        stream: bool,
+        inputs: Mapping,
+        files: list[dict],
+    ) -> Generator[Mapping | str, None, None] | Mapping:
+        """
+        invoke completion app
+        """
+        return CompletionAppGenerator().generate(
+            app_model=app,
+            user=user,
+            args={"inputs": inputs, "files": files},
+            invoke_from=InvokeFrom.SERVICE_API,
+            streaming=stream,
+        )
+
+    @classmethod
+    def _get_user(cls, user_id: str) -> Union[EndUser, Account]:
+        """
+        get the user by user id
+        """
+        with Session(db.engine, expire_on_commit=False) as session:
+            stmt = select(EndUser).where(EndUser.id == user_id)
+            user = session.scalar(stmt)
+            if not user:
+                stmt = select(Account).where(Account.id == user_id)
+                user = session.scalar(stmt)
+
+        if not user:
+            raise ValueError("user not found")
+
+        return user
+
+    @classmethod
+    def _get_app(cls, app_id: str, tenant_id: str) -> App:
+        """
+        get app
+        """
+        try:
+            app = db.session.query(App).where(App.id == app_id).where(App.tenant_id == tenant_id).first()
+        except Exception:
+            raise ValueError("app not found")
+
+        if not app:
+            raise ValueError("app not found")
+
+        return app

dify/api/core/plugin/backwards_invocation/base.py

@@ -0,0 +1,27 @@
+from collections.abc import Generator, Mapping
+from typing import Generic, TypeVar
+
+from pydantic import BaseModel
+
+
+class BaseBackwardsInvocation:
+    @classmethod
+    def convert_to_event_stream(cls, response: Generator[BaseModel | Mapping | str, None, None] | BaseModel | Mapping):
+        if isinstance(response, Generator):
+            try:
+                for chunk in response:
+                    if isinstance(chunk, BaseModel | dict):
+                        yield BaseBackwardsInvocationResponse(data=chunk).model_dump_json().encode()
+            except Exception as e:
+                error_message = BaseBackwardsInvocationResponse(error=str(e)).model_dump_json()
+                yield error_message.encode()
+        else:
+            yield BaseBackwardsInvocationResponse(data=response).model_dump_json().encode()
+
+
+T = TypeVar("T", bound=dict | Mapping | str | bool | int | BaseModel)
+
+
+class BaseBackwardsInvocationResponse(BaseModel, Generic[T]):
+    data: T | None = None
+    error: str = ""

dify/api/core/plugin/backwards_invocation/encrypt.py

@@ -0,0 +1,34 @@
+from core.helper.provider_cache import SingletonProviderCredentialsCache
+from core.plugin.entities.request import RequestInvokeEncrypt
+from core.tools.utils.encryption import create_provider_encrypter
+from models.account import Tenant
+
+
+class PluginEncrypter:
+    @classmethod
+    def invoke_encrypt(cls, tenant: Tenant, payload: RequestInvokeEncrypt):
+        encrypter, cache = create_provider_encrypter(
+            tenant_id=tenant.id,
+            config=payload.config,
+            cache=SingletonProviderCredentialsCache(
+                tenant_id=tenant.id,
+                provider_type=payload.namespace,
+                provider_identity=payload.identity,
+            ),
+        )
+
+        if payload.opt == "encrypt":
+            return {
+                "data": encrypter.encrypt(payload.data),
+            }
+        elif payload.opt == "decrypt":
+            return {
+                "data": encrypter.decrypt(payload.data),
+            }
+        elif payload.opt == "clear":
+            cache.delete()
+            return {
+                "data": {},
+            }
+        else:
+            raise ValueError(f"Invalid opt: {payload.opt}")

dify/api/core/plugin/backwards_invocation/model.py

@@ -0,0 +1,410 @@
+import tempfile
+from binascii import hexlify, unhexlify
+from collections.abc import Generator
+
+from core.llm_generator.output_parser.structured_output import invoke_llm_with_structured_output
+from core.model_manager import ModelManager
+from core.model_runtime.entities.llm_entities import (
+    LLMResult,
+    LLMResultChunk,
+    LLMResultChunkDelta,
+    LLMResultChunkWithStructuredOutput,
+    LLMResultWithStructuredOutput,
+)
+from core.model_runtime.entities.message_entities import (
+    PromptMessage,
+    SystemPromptMessage,
+    UserPromptMessage,
+)
+from core.plugin.backwards_invocation.base import BaseBackwardsInvocation
+from core.plugin.entities.request import (
+    RequestInvokeLLM,
+    RequestInvokeLLMWithStructuredOutput,
+    RequestInvokeModeration,
+    RequestInvokeRerank,
+    RequestInvokeSpeech2Text,
+    RequestInvokeSummary,
+    RequestInvokeTextEmbedding,
+    RequestInvokeTTS,
+)
+from core.tools.entities.tool_entities import ToolProviderType
+from core.tools.utils.model_invocation_utils import ModelInvocationUtils
+from core.workflow.nodes.llm import llm_utils
+from models.account import Tenant
+
+
+class PluginModelBackwardsInvocation(BaseBackwardsInvocation):
+    @classmethod
+    def invoke_llm(
+        cls, user_id: str, tenant: Tenant, payload: RequestInvokeLLM
+    ) -> Generator[LLMResultChunk, None, None] | LLMResult:
+        """
+        invoke llm
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        response = model_instance.invoke_llm(
+            prompt_messages=payload.prompt_messages,
+            model_parameters=payload.completion_params,
+            tools=payload.tools,
+            stop=payload.stop,
+            stream=True if payload.stream is None else payload.stream,
+            user=user_id,
+        )
+
+        if isinstance(response, Generator):
+
+            def handle() -> Generator[LLMResultChunk, None, None]:
+                for chunk in response:
+                    if chunk.delta.usage:
+                        llm_utils.deduct_llm_quota(
+                            tenant_id=tenant.id, model_instance=model_instance, usage=chunk.delta.usage
+                        )
+                    chunk.prompt_messages = []
+                    yield chunk
+
+            return handle()
+        else:
+            if response.usage:
+                llm_utils.deduct_llm_quota(tenant_id=tenant.id, model_instance=model_instance, usage=response.usage)
+
+            def handle_non_streaming(response: LLMResult) -> Generator[LLMResultChunk, None, None]:
+                yield LLMResultChunk(
+                    model=response.model,
+                    prompt_messages=[],
+                    system_fingerprint=response.system_fingerprint,
+                    delta=LLMResultChunkDelta(
+                        index=0,
+                        message=response.message,
+                        usage=response.usage,
+                        finish_reason="",
+                    ),
+                )
+
+            return handle_non_streaming(response)
+
+    @classmethod
+    def invoke_llm_with_structured_output(
+        cls, user_id: str, tenant: Tenant, payload: RequestInvokeLLMWithStructuredOutput
+    ):
+        """
+        invoke llm with structured output
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        model_schema = model_instance.model_type_instance.get_model_schema(payload.model, model_instance.credentials)
+
+        if not model_schema:
+            raise ValueError(f"Model schema not found for {payload.model}")
+
+        response = invoke_llm_with_structured_output(
+            provider=payload.provider,
+            model_schema=model_schema,
+            model_instance=model_instance,
+            prompt_messages=payload.prompt_messages,
+            json_schema=payload.structured_output_schema,
+            tools=payload.tools,
+            stop=payload.stop,
+            stream=True if payload.stream is None else payload.stream,
+            user=user_id,
+            model_parameters=payload.completion_params,
+        )
+
+        if isinstance(response, Generator):
+
+            def handle() -> Generator[LLMResultChunkWithStructuredOutput, None, None]:
+                for chunk in response:
+                    if chunk.delta.usage:
+                        llm_utils.deduct_llm_quota(
+                            tenant_id=tenant.id, model_instance=model_instance, usage=chunk.delta.usage
+                        )
+                    chunk.prompt_messages = []
+                    yield chunk
+
+            return handle()
+        else:
+            if response.usage:
+                llm_utils.deduct_llm_quota(tenant_id=tenant.id, model_instance=model_instance, usage=response.usage)
+
+            def handle_non_streaming(
+                response: LLMResultWithStructuredOutput,
+            ) -> Generator[LLMResultChunkWithStructuredOutput, None, None]:
+                yield LLMResultChunkWithStructuredOutput(
+                    model=response.model,
+                    prompt_messages=[],
+                    system_fingerprint=response.system_fingerprint,
+                    structured_output=response.structured_output,
+                    delta=LLMResultChunkDelta(
+                        index=0,
+                        message=response.message,
+                        usage=response.usage,
+                        finish_reason="",
+                    ),
+                )
+
+            return handle_non_streaming(response)
+
+    @classmethod
+    def invoke_text_embedding(cls, user_id: str, tenant: Tenant, payload: RequestInvokeTextEmbedding):
+        """
+        invoke text embedding
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        response = model_instance.invoke_text_embedding(
+            texts=payload.texts,
+            user=user_id,
+        )
+
+        return response
+
+    @classmethod
+    def invoke_rerank(cls, user_id: str, tenant: Tenant, payload: RequestInvokeRerank):
+        """
+        invoke rerank
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        response = model_instance.invoke_rerank(
+            query=payload.query,
+            docs=payload.docs,
+            score_threshold=payload.score_threshold,
+            top_n=payload.top_n,
+            user=user_id,
+        )
+
+        return response
+
+    @classmethod
+    def invoke_tts(cls, user_id: str, tenant: Tenant, payload: RequestInvokeTTS):
+        """
+        invoke tts
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        response = model_instance.invoke_tts(
+            content_text=payload.content_text,
+            tenant_id=tenant.id,
+            voice=payload.voice,
+            user=user_id,
+        )
+
+        def handle() -> Generator[dict, None, None]:
+            for chunk in response:
+                yield {"result": hexlify(chunk).decode("utf-8")}
+
+        return handle()
+
+    @classmethod
+    def invoke_speech2text(cls, user_id: str, tenant: Tenant, payload: RequestInvokeSpeech2Text):
+        """
+        invoke speech2text
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        with tempfile.NamedTemporaryFile(suffix=".mp3", mode="wb", delete=True) as temp:
+            temp.write(unhexlify(payload.file))
+            temp.flush()
+            temp.seek(0)
+
+            response = model_instance.invoke_speech2text(
+                file=temp,
+                user=user_id,
+            )
+
+            return {
+                "result": response,
+            }
+
+    @classmethod
+    def invoke_moderation(cls, user_id: str, tenant: Tenant, payload: RequestInvokeModeration):
+        """
+        invoke moderation
+        """
+        model_instance = ModelManager().get_model_instance(
+            tenant_id=tenant.id,
+            provider=payload.provider,
+            model_type=payload.model_type,
+            model=payload.model,
+        )
+
+        # invoke model
+        response = model_instance.invoke_moderation(
+            text=payload.text,
+            user=user_id,
+        )
+
+        return {
+            "result": response,
+        }
+
+    @classmethod
+    def get_system_model_max_tokens(cls, tenant_id: str) -> int:
+        """
+        get system model max tokens
+        """
+        return ModelInvocationUtils.get_max_llm_context_tokens(tenant_id=tenant_id)
+
+    @classmethod
+    def get_prompt_tokens(cls, tenant_id: str, prompt_messages: list[PromptMessage]) -> int:
+        """
+        get prompt tokens
+        """
+        return ModelInvocationUtils.calculate_tokens(tenant_id=tenant_id, prompt_messages=prompt_messages)
+
+    @classmethod
+    def invoke_system_model(
+        cls,
+        user_id: str,
+        tenant: Tenant,
+        prompt_messages: list[PromptMessage],
+    ) -> LLMResult:
+        """
+        invoke system model
+        """
+        return ModelInvocationUtils.invoke(
+            user_id=user_id,
+            tenant_id=tenant.id,
+            tool_type=ToolProviderType.PLUGIN,
+            tool_name="plugin",
+            prompt_messages=prompt_messages,
+        )
+
+    @classmethod
+    def invoke_summary(cls, user_id: str, tenant: Tenant, payload: RequestInvokeSummary):
+        """
+        invoke summary
+        """
+        max_tokens = cls.get_system_model_max_tokens(tenant_id=tenant.id)
+        content = payload.text
+
+        SUMMARY_PROMPT = """You are a professional language researcher, you are interested in the language
+and you can quickly aimed at the main point of an webpage and reproduce it in your own words but
+retain the original meaning and keep the key points.
+however, the text you got is too long, what you got is possible a part of the text.
+Please summarize the text you got.
+
+Here is the extra instruction you need to follow:
+<extra_instruction>
+{payload.instruction}
+</extra_instruction>
+"""
+
+        if (
+            cls.get_prompt_tokens(
+                tenant_id=tenant.id,
+                prompt_messages=[UserPromptMessage(content=content)],
+            )
+            < max_tokens * 0.6
+        ):
+            return content
+
+        def get_prompt_tokens(content: str) -> int:
+            return cls.get_prompt_tokens(
+                tenant_id=tenant.id,
+                prompt_messages=[
+                    SystemPromptMessage(content=SUMMARY_PROMPT.replace("{payload.instruction}", payload.instruction)),
+                    UserPromptMessage(content=content),
+                ],
+            )
+
+        def summarize(content: str) -> str:
+            summary = cls.invoke_system_model(
+                user_id=user_id,
+                tenant=tenant,
+                prompt_messages=[
+                    SystemPromptMessage(content=SUMMARY_PROMPT.replace("{payload.instruction}", payload.instruction)),
+                    UserPromptMessage(content=content),
+                ],
+            )
+
+            assert isinstance(summary.message.content, str)
+            return summary.message.content
+
+        lines = content.split("\n")
+        new_lines: list[str] = []
+        # split long line into multiple lines
+        for i in range(len(lines)):
+            line = lines[i]
+            if not line.strip():
+                continue
+            if len(line) < max_tokens * 0.5:
+                new_lines.append(line)
+            elif get_prompt_tokens(line) > max_tokens * 0.7:
+                while get_prompt_tokens(line) > max_tokens * 0.7:
+                    new_lines.append(line[: int(max_tokens * 0.5)])
+                    line = line[int(max_tokens * 0.5) :]
+                new_lines.append(line)
+            else:
+                new_lines.append(line)
+
+        # merge lines into messages with max tokens
+        messages: list[str] = []
+        for line in new_lines:
+            if len(messages) == 0:
+                messages.append(line)
+            else:
+                if len(messages[-1]) + len(line) < max_tokens * 0.5:
+                    messages[-1] += line
+                if get_prompt_tokens(messages[-1] + line) > max_tokens * 0.7:
+                    messages.append(line)
+                else:
+                    messages[-1] += line
+
+        summaries = []
+        for i in range(len(messages)):
+            message = messages[i]
+            summary = summarize(message)
+            summaries.append(summary)
+
+        result = "\n".join(summaries)
+
+        if (
+            cls.get_prompt_tokens(
+                tenant_id=tenant.id,
+                prompt_messages=[UserPromptMessage(content=result)],
+            )
+            > max_tokens * 0.7
+        ):
+            return cls.invoke_summary(
+                user_id=user_id,
+                tenant=tenant,
+                payload=RequestInvokeSummary(text=result, instruction=payload.instruction),
+            )
+
+        return result

dify/api/core/plugin/backwards_invocation/node.py

@@ -0,0 +1,119 @@
+from core.plugin.backwards_invocation.base import BaseBackwardsInvocation
+from core.workflow.enums import NodeType
+from core.workflow.nodes.parameter_extractor.entities import (
+    ModelConfig as ParameterExtractorModelConfig,
+)
+from core.workflow.nodes.parameter_extractor.entities import (
+    ParameterConfig,
+    ParameterExtractorNodeData,
+)
+from core.workflow.nodes.question_classifier.entities import (
+    ClassConfig,
+    QuestionClassifierNodeData,
+)
+from core.workflow.nodes.question_classifier.entities import (
+    ModelConfig as QuestionClassifierModelConfig,
+)
+from services.workflow_service import WorkflowService
+
+
+class PluginNodeBackwardsInvocation(BaseBackwardsInvocation):
+    @classmethod
+    def invoke_parameter_extractor(
+        cls,
+        tenant_id: str,
+        user_id: str,
+        parameters: list[ParameterConfig],
+        model_config: ParameterExtractorModelConfig,
+        instruction: str,
+        query: str,
+    ):
+        """
+        Invoke parameter extractor node.
+
+        :param tenant_id: str
+        :param user_id: str
+        :param parameters: list[ParameterConfig]
+        :param model_config: ModelConfig
+        :param instruction: str
+        :param query: str
+        :return: dict
+        """
+        # FIXME(-LAN-): Avoid import service into core
+        workflow_service = WorkflowService()
+        node_id = "1919810"
+        node_data = ParameterExtractorNodeData(
+            title="parameter_extractor",
+            desc="parameter_extractor",
+            parameters=parameters,
+            reasoning_mode="function_call",
+            query=[node_id, "query"],
+            model=model_config,
+            instruction=instruction,  # instruct with variables are not supported
+        )
+        node_data_dict = node_data.model_dump()
+        node_data_dict["type"] = NodeType.PARAMETER_EXTRACTOR
+        execution = workflow_service.run_free_workflow_node(
+            node_data_dict,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            node_id=node_id,
+            user_inputs={
+                f"{node_id}.query": query,
+            },
+        )
+
+        return {
+            "inputs": execution.inputs,
+            "outputs": execution.outputs,
+            "process_data": execution.process_data,
+        }
+
+    @classmethod
+    def invoke_question_classifier(
+        cls,
+        tenant_id: str,
+        user_id: str,
+        model_config: QuestionClassifierModelConfig,
+        classes: list[ClassConfig],
+        instruction: str,
+        query: str,
+    ):
+        """
+        Invoke question classifier node.
+
+        :param tenant_id: str
+        :param user_id: str
+        :param model_config: ModelConfig
+        :param classes: list[ClassConfig]
+        :param instruction: str
+        :param query: str
+        :return: dict
+        """
+        # FIXME(-LAN-): Avoid import service into core
+        workflow_service = WorkflowService()
+        node_id = "1919810"
+        node_data = QuestionClassifierNodeData(
+            title="question_classifier",
+            desc="question_classifier",
+            query_variable_selector=[node_id, "query"],
+            model=model_config,
+            classes=classes,
+            instruction=instruction,  # instruct with variables are not supported
+        )
+        node_data_dict = node_data.model_dump()
+        execution = workflow_service.run_free_workflow_node(
+            node_data_dict,
+            tenant_id=tenant_id,
+            user_id=user_id,
+            node_id=node_id,
+            user_inputs={
+                f"{node_id}.query": query,
+            },
+        )
+
+        return {
+            "inputs": execution.inputs,
+            "outputs": execution.outputs,
+            "process_data": execution.process_data,
+        }

dify/api/core/plugin/backwards_invocation/tool.py

@@ -0,0 +1,46 @@
+from collections.abc import Generator
+from typing import Any
+
+from core.callback_handler.workflow_tool_callback_handler import DifyWorkflowCallbackHandler
+from core.plugin.backwards_invocation.base import BaseBackwardsInvocation
+from core.tools.entities.tool_entities import ToolInvokeMessage, ToolProviderType
+from core.tools.tool_engine import ToolEngine
+from core.tools.tool_manager import ToolManager
+from core.tools.utils.message_transformer import ToolFileMessageTransformer
+
+
+class PluginToolBackwardsInvocation(BaseBackwardsInvocation):
+    """
+    Backwards invocation for plugin tools.
+    """
+
+    @classmethod
+    def invoke_tool(
+        cls,
+        tenant_id: str,
+        user_id: str,
+        tool_type: ToolProviderType,
+        provider: str,
+        tool_name: str,
+        tool_parameters: dict[str, Any],
+        credential_id: str | None = None,
+    ) -> Generator[ToolInvokeMessage, None, None]:
+        """
+        invoke tool
+        """
+        # get tool runtime
+        try:
+            tool_runtime = ToolManager.get_tool_runtime_from_plugin(
+                tool_type, tenant_id, provider, tool_name, tool_parameters, credential_id
+            )
+            response = ToolEngine.generic_invoke(
+                tool_runtime, tool_parameters, user_id, DifyWorkflowCallbackHandler(), workflow_call_depth=1
+            )
+
+            response = ToolFileMessageTransformer.transform_tool_invoke_messages(
+                response, user_id=user_id, tenant_id=tenant_id
+            )
+
+            return response
+        except Exception as e:
+            raise e