Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

25.7 KB
Raw Blame
import asyncio
import json
from typing import Any, cast

import httpx
import pytest
from dify_agent.adapters.llm.model import _get_stop_sequences, _map_model_settings_to_parameters
from dify_agent.layers.dify_core_tools import DifyCoreToolConfig, DifyCoreToolsLayerConfig
from dify_agent.layers.dify_plugin import DifyPluginLLMLayerConfig, DifyPluginToolConfig, DifyPluginToolsLayerConfig
from dify_agent.layers.execution_context import ApplicationTracingContext, DifyExecutionContextLayerConfig
from dify_agent.layers.knowledge import DifyKnowledgeBaseLayerConfig
from dify_agent.layers.knowledge_fs import DifyKnowledgeFsLayerConfig
from dify_agent.layers.prompt import Config as PromptConfig
from dify_agent.layers.shell import DifyShellEnvVarConfig, DifyShellLayerConfig
from dify_agent.layers.user_prompt import DifyUserPromptDownloadConfig, DifyUserPromptImageConfig
from dify_agent.protocol import (
    DIFY_AGENT_HISTORY_LAYER_ID,
    DIFY_AGENT_MODEL_LAYER_ID,
    DIFY_AGENT_OUTPUT_LAYER_ID,
    CreateRunRequest,
)
from dify_agent.runtime.context import Services
from dify_agent.runtime.modules import create_modules, load_modules
from pydantic import JsonValue, ValidationError

from clients.agent_backend import (
    AGENT_SOUL_PROMPT_LAYER_ID,
    DIFY_CORE_TOOLS_LAYER_ID,
    DIFY_EXECUTION_CONTEXT_LAYER_ID,
    DIFY_KNOWLEDGE_BASE_LAYER_ID,
    DIFY_PLUGIN_TOOLS_LAYER_ID,
    WORKFLOW_NODE_JOB_PROMPT_LAYER_ID,
    WORKFLOW_USER_PROMPT_LAYER_ID,
    AgentBackendAgentAppRunInput,
    AgentBackendModelConfig,
    AgentBackendOutputConfig,
    AgentBackendRunRequestBuilder,
    AgentBackendWorkflowNodeRunInput,
    redact_for_agent_backend_log,
)
from clients.agent_backend.request_builder import DIFY_SHELL_LAYER_ID
from models.agent_config_entities import AgentSoulModelSettings


def _run_input() -> AgentBackendWorkflowNodeRunInput:
    return AgentBackendWorkflowNodeRunInput(
        model=AgentBackendModelConfig(
            plugin_id="langgenius/openai",
            model_provider="openai",
            model="gpt-test",
        ),
        execution_context=DifyExecutionContextLayerConfig(
            tenant_id="tenant-1",
            user_id="user-1",
            user_from="account",
            workflow_id="workflow-1",
            workflow_run_id="workflow-run-1",
            node_id="node-1",
            node_execution_id="node-execution-1",
            agent_mode="workflow_run",
            invoke_from="debugger",
        ),
        backend_binding_ref="binding-ref-1",
        idempotency_key="workflow-run-1:node-execution-1",
        agent_soul_prompt="You are a careful reviewer.",
        workflow_node_job_prompt="Review the previous node output.",
        user_prompt="Summarize the report.",
        output=AgentBackendOutputConfig(
            json_schema={
                "type": "object",
                "properties": {"summary": {"type": "string"}},
                "required": ["summary"],
            }
        ),
        metadata={"workflow_id": "workflow-1", "node_id": "node-1"},
    )


def test_request_builder_outputs_dify_agent_create_run_request() -> None:
    request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
    dumped = request.model_dump(mode="json")

    assert isinstance(request, CreateRunRequest)
    assert [layer.name for layer in request.composition.layers] == [
        AGENT_SOUL_PROMPT_LAYER_ID,
        WORKFLOW_NODE_JOB_PROMPT_LAYER_ID,
        WORKFLOW_USER_PROMPT_LAYER_ID,
        DIFY_EXECUTION_CONTEXT_LAYER_ID,
        DIFY_AGENT_HISTORY_LAYER_ID,
        DIFY_AGENT_MODEL_LAYER_ID,
        DIFY_AGENT_OUTPUT_LAYER_ID,
    ]
    assert request.idempotency_key == "workflow-run-1:node-execution-1"
    assert request.metadata == {"workflow_id": "workflow-1", "node_id": "node-1"}
    assert "purpose" not in dumped


def test_request_builder_separates_agent_soul_and_workflow_job_prompt() -> None:
    request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
    {layer.name: layer for layer in request.composition.layers}

    dumped = request.model_dump(mode="json")
    assert dumped["composition"]["layers"][0]["config"]["prefix"] == "You are a careful reviewer."
    workflow_job_config = dumped["composition"]["layers"][1]["config"]
    assert workflow_job_config["user"] == "Review the previous node output."
    assert not workflow_job_config.get("prefix")
    assert dumped["composition"]["layers"][2]["config"]["user"] == "Summarize the report."


def test_request_builder_forwards_plugin_specific_model_settings_via_extra_body() -> None:
    run_input = _run_input().model_copy(
        update={
            "model": AgentBackendModelConfig(
                plugin_id="langgenius/tongyi",
                model_provider="tongyi",
                model="qwen-plus-latest",
                model_settings={"temperature": 0.7, "enable_thinking": True, "thinking_budget": 4096},
            )
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}
    model_config = DifyPluginLLMLayerConfig.model_validate(layers[DIFY_AGENT_MODEL_LAYER_ID].config)

    assert model_config.model_settings == {
        "temperature": 0.7,
        "extra_body": {"enable_thinking": True, "thinking_budget": 4096},
    }


@pytest.mark.parametrize("builder_kind", ["agent_app", "workflow_node"])
@pytest.mark.parametrize(
    "settings",
    [
        pytest.param({}, id="default"),
        pytest.param({"response_format": None}, id="none"),
        pytest.param({"response_format": "text"}, id="plugin-text"),
        pytest.param(
            {
                "response_format": "json_schema",
                "json_schema": json.dumps(
                    {"type": "object", "properties": {"answer": {"type": "string"}}, "required": ["answer"]}
                ),
            },
            id="plugin-json-schema",
        ),
        pytest.param({"response_format": {"type": "text"}}, id="legacy-text"),
        pytest.param(
            {
                "response_format": {
                    "type": "json_schema",
                    "json_schema": {"name": "response", "schema": {"type": "object"}},
                }
            },
            id="legacy-json-schema",
        ),
    ],
)
def test_response_format_reaches_plugin_parameters_through_real_request_serialization(
    builder_kind: str, settings: dict[str, JsonValue]
) -> None:
    soul_settings = AgentSoulModelSettings.model_validate(
        {**settings, "temperature": 0.2, "stop": ["END"], "enable_thinking": True}
    )
    model = AgentBackendModelConfig(
        plugin_id="langgenius/openai",
        model_provider="openai",
        model="gpt-test",
        model_settings=soul_settings.model_dump(mode="json", exclude_none=True),
    )
    builder = AgentBackendRunRequestBuilder()
    if builder_kind == "agent_app":
        request = builder.build_for_agent_app(_agent_app_input().model_copy(update={"model": model}))
    else:
        request = builder.build_for_workflow_node(_run_input().model_copy(update={"model": model}))

    request = CreateRunRequest.model_validate_json(request.model_dump_json())
    model_layer = next(layer for layer in request.composition.layers if layer.name == DIFY_AGENT_MODEL_LAYER_ID)
    model_config = DifyPluginLLMLayerConfig.model_validate(model_layer.config)
    plugin_settings = {key: value for key, value in settings.items() if value is not None}

    assert model_config.model_settings == {
        "temperature": 0.2,
        "stop_sequences": ["END"],
        "extra_body": {"enable_thinking": True, **plugin_settings},
    }
    assert _map_model_settings_to_parameters(model_config.model_settings) == {
        "temperature": 0.2,
        "enable_thinking": True,
        **plugin_settings,
    }
    assert _get_stop_sequences(model_config.model_settings) == ["END"]


@pytest.mark.parametrize("agent_config_version_kind", ["snapshot", "draft"])
def test_agent_app_request_builder_keeps_agent_soul_prompt_for_snapshot_and_draft(
    agent_config_version_kind: str,
) -> None:
    original_prompt = "  You are Iris.  \n"
    run_input = _agent_app_input().model_copy(
        update={
            "agent_config_version_kind": agent_config_version_kind,
            "agent_soul_prompt": original_prompt,
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
    assert prompt_config.prefix == original_prompt


def test_agent_app_request_builder_wraps_agent_soul_prompt_for_build_draft() -> None:
    original_prompt = "  You are Iris.  \n"
    run_input = _agent_app_input().model_copy(
        update={
            "agent_config_version_kind": "build_draft",
            "agent_soul_prompt": original_prompt,
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
    assert prompt_config.prefix != original_prompt
    assert isinstance(prompt_config.prefix, str)
    assert prompt_config.prefix.startswith("You are running in build mode.")
    assert "```text\nYou are Iris.\n```" in prompt_config.prefix


def test_agent_app_request_builder_uses_longer_fence_for_build_draft_prompt_body() -> None:
    run_input = _agent_app_input().model_copy(
        update={
            "agent_config_version_kind": "build_draft",
            "agent_soul_prompt": "Keep this snippet:\n```python\nprint('hi')\n```",
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
    assert "````text" in prompt_config.prefix
    assert "```python" in prompt_config.prefix


def test_request_builder_sets_model_and_output_layer_contract_ids() -> None:
    request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
    layers = {layer.name: layer for layer in request.composition.layers}

    execution_context_config = DifyExecutionContextLayerConfig.model_validate(
        layers[DIFY_EXECUTION_CONTEXT_LAYER_ID].config
    )
    assert execution_context_config.user_id == "user-1"
    assert execution_context_config.user_from == "account"
    assert execution_context_config.agent_mode == "workflow_run"
    assert execution_context_config.invoke_from == "debugger"
    model_config = DifyPluginLLMLayerConfig.model_validate(layers[DIFY_AGENT_MODEL_LAYER_ID].config)
    assert model_config.plugin_id == "langgenius/openai"
    assert "credentials" not in model_config.model_dump(mode="json")
    assert layers[DIFY_AGENT_MODEL_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID


@pytest.mark.parametrize("mode", ["agent_app", "workflow_node"])
@pytest.mark.parametrize("traced", [False, True])
def test_context_wire_contract_omits_tracing_for_legacy_runtime(mode: str, traced: bool) -> None:
    run_input = _agent_app_input() if mode == "agent_app" else _run_input()
    tracing = ApplicationTracingContext(
        run_id="00000000-0000-0000-0000-000000000001",
        invocation_id="00000000-0000-0000-0000-000000000002",
        trace_id="a" * 32,
        parent_span_id="b" * 16,
        session_id="session",
        capture_content=False,
    )
    if traced:
        run_input = run_input.model_copy(
            update={"execution_context": run_input.execution_context.model_copy(update={"tracing": tracing})}
        )
    builder = AgentBackendRunRequestBuilder()
    request = (
        builder.build_for_agent_app(run_input)
        if isinstance(run_input, AgentBackendAgentAppRunInput)
        else builder.build_for_workflow_node(run_input)
    )
    payload = next(
        layer.config for layer in request.composition.layers if layer.name == DIFY_EXECUTION_CONTEXT_LAYER_ID
    )
    if traced:
        assert payload["tracing"] == tracing.model_dump(mode="json")
    else:
        # Pre-tracing runtimes reject even a null unknown field (extra=forbid).
        assert "tracing" not in payload


def test_request_builder_adds_dify_plugin_tools_layer_when_configured() -> None:
    run_input = _run_input()
    run_input.tools = DifyPluginToolsLayerConfig(
        tools=[
            DifyPluginToolConfig(
                plugin_id="langgenius/time",
                provider="time",
                tool_name="current_time",
                credential_type="unauthorized",
                name="current_time",
                description="Get current time.",
                credentials={},
                runtime_parameters={},
                parameters=[],
                parameters_json_schema={"type": "object", "properties": {}, "required": []},
                plugin_unique_identifier="langgenius/time:1.0.0@aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
            )
        ]
    )

    request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert layers[DIFY_PLUGIN_TOOLS_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
    tools_config = DifyPluginToolsLayerConfig.model_validate(layers[DIFY_PLUGIN_TOOLS_LAYER_ID].config)
    assert tools_config.tools[0].tool_name == "current_time"


def test_request_builder_adds_dify_core_tools_layer_when_configured() -> None:
    run_input = _run_input()
    run_input.core_tools = DifyCoreToolsLayerConfig(
        tools=[
            DifyCoreToolConfig(
                provider_type="builtin",
                provider_id="audio",
                tool_name="transcribe",
                name="transcribe",
                description="Transcribe audio.",
                runtime_parameters={"language": "en"},
                parameters=[],
                parameters_json_schema={"type": "object", "properties": {}, "required": []},
            )
        ]
    )

    request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert layers[DIFY_CORE_TOOLS_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID


def test_request_builder_adds_knowledge_layer_when_configured() -> None:
    run_input = _run_input()
    run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
        {
            "sets": [
                {
                    "id": "support",
                    "name": "Support KB",
                    "datasets": [{"id": "dataset-1"}],
                    "query": {"mode": "generated_query"},
                    "retrieval": {"mode": "multiple", "top_k": 4},
                }
            ],
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert DIFY_KNOWLEDGE_BASE_LAYER_ID in layers
    assert layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
    knowledge_config = DifyKnowledgeBaseLayerConfig.model_validate(layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
    assert knowledge_config.sets[0].dataset_ids == ["dataset-1"]


def test_request_builder_rejects_blank_prompts() -> None:
    with pytest.raises(ValidationError, match="prompt must not be blank"):
        AgentBackendWorkflowNodeRunInput(
            model=AgentBackendModelConfig(
                plugin_id="langgenius/openai",
                model_provider="openai",
                model="gpt-test",
            ),
            execution_context=DifyExecutionContextLayerConfig(
                tenant_id="tenant-1",
                user_from="account",
                agent_mode="workflow_run",
                invoke_from="debugger",
            ),
            backend_binding_ref="binding-ref-1",
            workflow_node_job_prompt=" ",
            user_prompt="hello",
        )


def test_agent_backend_request_does_not_contain_llm_credentials() -> None:
    request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())

    redacted = cast(dict[str, Any], redact_for_agent_backend_log(request))

    assert "credentials" not in redacted["composition"]["layers"][5]["config"]


def _agent_app_input(*, include_shell: bool = False) -> AgentBackendAgentAppRunInput:
    return AgentBackendAgentAppRunInput(
        model=AgentBackendModelConfig(
            plugin_id="langgenius/openai",
            model_provider="openai",
            model="gpt-test",
        ),
        execution_context=DifyExecutionContextLayerConfig(
            tenant_id="tenant-1",
            user_id="user-1",
            user_from="end-user",
            conversation_id="conv-1",
            agent_mode="agent_app",
            invoke_from="web-app",
        ),
        backend_binding_ref="binding-ref-1",
        agent_soul_prompt="You are Iris.",
        user_prompt="List files.",
        include_shell=include_shell,
        metadata={"conversation_id": "conv-1"},
    )


def test_workflow_request_builder_omits_shell_layer_by_default() -> None:
    request = AgentBackendRunRequestBuilder().build_for_workflow_node(_run_input())
    assert DIFY_SHELL_LAYER_ID not in {layer.name for layer in request.composition.layers}


def test_workflow_request_builder_adds_shell_layer_when_include_shell() -> None:
    run_input = _run_input()
    run_input.include_shell = True
    run_input.shell_config = DifyShellLayerConfig(env=[DifyShellEnvVarConfig(name="PROJECT_NAME", value="demo")])

    request = AgentBackendRunRequestBuilder().build_for_workflow_node(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert DIFY_SHELL_LAYER_ID in layers
    shell = layers[DIFY_SHELL_LAYER_ID]
    # The shell layer depends on execution_context so the agent server can mint
    # per-command Agent Stub env for sandbox CLI forwarding.
    assert shell.config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
    assert shell.config["runtime"] == "runtime"
    shell_config = DifyShellLayerConfig.model_validate(shell.config)
    assert shell_config.env[0].name == "PROJECT_NAME"


def test_agent_app_request_builder_omits_shell_layer_by_default() -> None:
    request = AgentBackendRunRequestBuilder().build_for_agent_app(_agent_app_input())
    assert DIFY_SHELL_LAYER_ID not in {layer.name for layer in request.composition.layers}


def test_agent_app_request_builder_emits_multimodal_user_prompt_layer() -> None:
    run_input = _agent_app_input()
    run_input.user_files = [
        DifyUserPromptDownloadConfig(
            type="document", transfer_method="remote_url", url="https://example.com/brief.pdf"
        ),
        DifyUserPromptImageConfig(
            filename="earth.png",
            mime_type="image/png",
            format="png",
            url="https://files.example.com/earth.png?sign=secret",
            detail="high",
        ),
    ]

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layer = next(layer for layer in request.composition.layers if layer.name == "agent_app_user_prompt")

    assert layer.config["text"] == "List files."
    assert layer.config["files"] == [f.model_dump(mode="json") for f in run_input.user_files]
    restored_request = CreateRunRequest.model_validate_json(request.model_dump_json())
    restored_layer = next(
        layer for layer in restored_request.composition.layers if layer.name == "agent_app_user_prompt"
    )
    assert restored_layer.config == layer.config
    assert "locators" not in restored_layer.config


def test_agent_backend_log_redacts_multimodal_file_transport() -> None:
    run_input = _agent_app_input()
    run_input.metadata = {"source_url": "https://example.com/docs"}
    run_input.user_files = [
        DifyUserPromptImageConfig(
            filename="earth.png",
            mime_type="image/png",
            format="png",
            url="https://files.example.com/earth.png?sign=secret",
        ),
        DifyUserPromptImageConfig(
            filename="inline.png",
            mime_type="image/png",
            format="png",
            base64_data="aW1hZ2UtYnl0ZXM=",
        ),
    ]

    redacted = cast(
        dict[str, Any],
        redact_for_agent_backend_log(AgentBackendRunRequestBuilder().build_for_agent_app(run_input)),
    )
    layer = next(item for item in redacted["composition"]["layers"] if item["name"] == "agent_app_user_prompt")

    assert layer["config"]["files"][0]["url"] == "[REDACTED]"
    assert layer["config"]["files"][1]["base64_data"] == "[REDACTED]"
    assert redacted["metadata"]["source_url"] == "https://example.com/docs"


def test_agent_app_request_builder_keeps_build_draft_prompt_when_agent_soul_prompt_is_blank() -> None:
    run_input = _agent_app_input().model_copy(
        update={"agent_soul_prompt": "   ", "agent_config_version_kind": "build_draft"}
    )

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    prompt_config = PromptConfig.model_validate(layers[AGENT_SOUL_PROMPT_LAYER_ID].config)
    assert "You are running in build mode." in prompt_config.prefix
    assert "No task prompt was provided." in prompt_config.prefix


def test_agent_app_request_builder_adds_shell_layer_when_include_shell() -> None:
    run_input = _agent_app_input(include_shell=True)
    run_input.shell_config = DifyShellLayerConfig(env=[DifyShellEnvVarConfig(name="APP_ENV", value="enabled")])

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert DIFY_SHELL_LAYER_ID in layers
    assert layers[DIFY_SHELL_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
    assert layers[DIFY_SHELL_LAYER_ID].config["runtime"] == "runtime"
    shell_config = DifyShellLayerConfig.model_validate(layers[DIFY_SHELL_LAYER_ID].config)
    assert shell_config.env[0].name == "APP_ENV"


def test_agent_app_request_builder_adds_knowledge_layer_when_configured() -> None:
    run_input = _agent_app_input()
    run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
        {
            "sets": [
                {
                    "id": "support",
                    "name": "Support KB",
                    "datasets": [{"id": "dataset-1"}, {"id": "dataset-2"}],
                    "query": {"mode": "generated_query"},
                    "retrieval": {"mode": "multiple", "top_k": 2},
                }
            ],
        }
    )

    request = AgentBackendRunRequestBuilder().build_for_agent_app(run_input)
    layers = {layer.name: layer for layer in request.composition.layers}

    assert DIFY_KNOWLEDGE_BASE_LAYER_ID in layers
    assert layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config["execution_context"] == DIFY_EXECUTION_CONTEXT_LAYER_ID
    knowledge_config = DifyKnowledgeBaseLayerConfig.model_validate(layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
    assert knowledge_config.sets[0].dataset_ids == ["dataset-1", "dataset-2"]


@pytest.mark.parametrize("mode", ["agent_app", "workflow"])
def test_knowledge_fs_requires_shell_and_can_coexist_with_classic_knowledge(mode: str) -> None:
    config = DifyKnowledgeFsLayerConfig.model_validate(
        {"spaces": [{"id": "docs", "name": "Docs", "control_space_id": "00000000-0000-4000-8000-000000000001"}]}
    )
    run_input = _agent_app_input() if mode == "agent_app" else _run_input()
    run_input.knowledge_fs = config
    builder = AgentBackendRunRequestBuilder()

    def build() -> CreateRunRequest:
        if isinstance(run_input, AgentBackendAgentAppRunInput):
            return builder.build_for_agent_app(run_input)
        return builder.build_for_workflow_node(run_input)

    with pytest.raises(ValueError, match="requires shell"):
        build()
    run_input.include_shell = True
    layers = {layer.name: layer for layer in build().composition.layers}
    knowledge_fs = DifyKnowledgeFsLayerConfig.model_validate(layers["knowledge_fs"].config)
    assert knowledge_fs == config
    assert knowledge_fs.execution_context == DIFY_EXECUTION_CONTEXT_LAYER_ID
    assert knowledge_fs.shell == DIFY_SHELL_LAYER_ID
    assert DIFY_KNOWLEDGE_BASE_LAYER_ID not in layers
    assert not any("search" in layer.name or "retriev" in layer.name for layer in layers.values())
    run_input.knowledge = DifyKnowledgeBaseLayerConfig.model_validate(
        {
            "sets": [
                {
                    "id": "legacy",
                    "name": "Legacy",
                    "datasets": [{"id": "dataset-1"}],
                    "query": {"mode": "generated_query"},
                    "retrieval": {"mode": "multiple", "top_k": 2},
                }
            ]
        }
    )
    mixed_layers = {layer.name: layer for layer in build().composition.layers}
    assert DIFY_KNOWLEDGE_BASE_LAYER_ID in mixed_layers
    assert "knowledge_fs" in mixed_layers
    classic_config = DifyKnowledgeBaseLayerConfig.model_validate(mixed_layers[DIFY_KNOWLEDGE_BASE_LAYER_ID].config)
    knowledge_fs_config = DifyKnowledgeFsLayerConfig.model_validate(mixed_layers["knowledge_fs"].config)
    assert classic_config.sets[0].id == "legacy"
    assert knowledge_fs_config.spaces[0].id == "docs"
    run_input.execution_context.app_id = "app-1"
    client = httpx.AsyncClient()
    try:
        services = Services(
            plugin_daemon_http_client=client,
            dify_api_http_client=client,
            runtime_backend_profile=cast(Any, object()),
            knowledge_session_store=cast(Any, object()),
        )
        modules = create_modules(load_modules(build(), services, "mixed-knowledge-run"))
        assert DIFY_KNOWLEDGE_BASE_LAYER_ID in modules
        assert "knowledge_fs" in modules
    finally:
        asyncio.run(client.aclose())