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.

40.0 KB
Raw Blame
import json
from unittest.mock import Mock
from uuid import uuid4

import pytest
from pydantic import ValidationError
from sqlalchemy import select
from sqlalchemy.orm import Session

from graphon.enums import BuiltinNodeTypes
from models.account import Account
from models.agent import (
    Agent,
    AgentConfigDraft,
    AgentConfigDraftType,
    AgentConfigRevision,
    AgentConfigRevisionOperation,
    AgentConfigSnapshot,
    AgentIconType,
    AgentScope,
    AgentSource,
    AgentStatus,
    WorkflowAgentBindingType,
    WorkflowAgentNodeBinding,
)
from models.agent_config_entities import AgentConfigFileRefConfig, AgentConfigSkillRefConfig, AgentSoulConfig
from models.dataset import Dataset
from models.enums import AppStatus
from models.model import App, AppMode, IconType
from models.tools import ToolFile
from models.workflow import Workflow, WorkflowType
from services.agent.dsl_entities import (
    AGENT_NODE_JOB_DSL_KEY,
    AGENT_PACKAGE_REF_KEY,
    AgentPackage,
    AgentPackageMetadata,
    make_portable_agent_package,
)
from services.agent.dsl_service import AgentDslService, AgentPackageImportResult, is_agent_v2_graph
from services.entities.dsl_entities import DslImportWarning
from tests.helpers.unit.model_factories import make_upload_file


def _agent(
    *,
    agent_id: str = "agent-1",
    app_id: str | None = None,
    name: str = "Portable Agent",
    scope: AgentScope = AgentScope.ROSTER,
    source: AgentSource = AgentSource.AGENT_APP,
) -> Agent:
    agent = Agent(
        tenant_id="tenant-1",
        name=name,
        description="description",
        role="researcher",
        scope=scope,
        source=source,
        status=AgentStatus.ACTIVE,
        app_id=app_id,
        icon_type=AgentIconType.EMOJI,
        icon="R",
    )
    agent.id = agent_id
    return agent


def _snapshot(
    *,
    snapshot_id: str = "snapshot-1",
    agent_id: str = "agent-1",
    version: int = 1,
    soul: AgentSoulConfig | None = None,
) -> AgentConfigSnapshot:
    snapshot = AgentConfigSnapshot(
        tenant_id="tenant-1",
        agent_id=agent_id,
        version=version,
        home_snapshot_id="home-1",
        config_snapshot=soul or AgentSoulConfig(),
        created_by="account-1",
    )
    snapshot.id = snapshot_id
    return snapshot


def _app(*, name: str = "", description: str = "", mode: AppMode = AppMode.AGENT_CHAT) -> App:
    return App(
        id="app-1",
        tenant_id="tenant-1",
        name=name,
        description=description,
        mode=mode,
        status=AppStatus.NORMAL,
        enable_site=False,
        enable_api=False,
        api_rpm=0,
        api_rph=0,
    )


def _account() -> Account:
    account = Account(name="Owner", email="[email protected]")
    account.id = "account-1"
    return account


def _workflow(*, workflow_id: str = "workflow-1") -> Workflow:
    return Workflow(
        id=workflow_id,
        tenant_id="tenant-1",
        app_id="app-1",
        type=WorkflowType.WORKFLOW,
        version=Workflow.VERSION_DRAFT,
        graph={"nodes": [], "edges": []},
        _features={},
        created_by="account-1",
        _environment_variables=[],
        _conversation_variables=[],
    )


def _agent_node(node_id: str, binding: object | None = None) -> dict:
    data = {"type": BuiltinNodeTypes.AGENT, "version": "2", "agent_node_kind": "dify_agent"}
    if binding is not None:
        data["agent_binding"] = binding
    return {"id": node_id, "data": data}


@pytest.mark.parametrize("include_assets", [False, True])
def test_make_portable_agent_package_strips_workspace_credentials_and_assets(include_assets: bool) -> None:
    soul = AgentSoulConfig.model_validate(
        {
            "model": {
                "plugin_id": "langgenius/openai",
                "model_provider": "langgenius/openai/openai",
                "model": "gpt-test",
                "credential_ref": {"type": "provider", "id": "model-secret"},
            },
            "tools": {
                "dify_tools": [
                    {
                        "provider_id": "langgenius/google/google",
                        "provider_type": "plugin",
                        "tool_name": "search",
                        "credential_type": "api-key",
                        "credential_ref": {"type": "tool", "id": "tool-secret"},
                        "runtime_parameters": {
                            "query": "hello",
                            "upload_file_id": "upload-1",
                            "api_key": "plain-secret",
                        },
                    }
                ],
                "cli_tools": [
                    {
                        "name": "cli",
                        "env": {
                            "secret_refs": [
                                {
                                    "name": "TOKEN",
                                    "value": "plain-secret",
                                    "credential_id": "credential-1",
                                }
                            ]
                        },
                    }
                ],
            },
            "env": {"secret_refs": [{"name": "GLOBAL_TOKEN", "value": "plain-secret", "id": "secret-1"}]},
            "config_skills": [{"name": "research", "file_id": "skill-file"}, {"name": "missing", "is_missing": True}],
            "config_files": [
                {"name": "guide.md", "file_kind": "upload_file", "file_id": "config-file", "mime_type": "text/markdown"}
            ],
            "human": {
                "contacts": [
                    {
                        "id": "human-1",
                        "tenant_id": "tenant-1",
                        "name": "Reviewer",
                        "email": "[email protected]",
                    }
                ]
            },
        }
    )

    original = soul.model_dump(mode="json")
    package = make_portable_agent_package(_agent(), soul, include_assets=include_assets)
    assert soul.model_dump(mode="json") == original
    serialized = package.model_dump(mode="json")

    assert package.soul.model is not None
    assert package.soul.model.credential_ref is None
    assert package.soul.tools.dify_tools[0].credential_type == "unauthorized"
    assert package.soul.tools.dify_tools[0].credential_ref is None
    assert package.soul.tools.dify_tools[0].runtime_parameters["upload_file_id"] is None
    assert package.soul.tools.dify_tools[0].runtime_parameters["api_key"] is None
    assert package.soul.config_skills[0].name == "research"
    assert package.soul.config_skills[0].file_id == ("skill-file" if include_assets else "")
    assert package.soul.config_skills[0].is_missing is (not include_assets)
    assert package.soul.config_files[0].name == "guide.md"
    assert package.soul.config_files[0].file_id == ("config-file" if include_assets else "")
    assert package.soul.config_files[0].is_missing is (not include_assets)
    assert package.soul.config_skills[1].is_missing
    assert package.soul.config_files[0].mime_type == "text/markdown"
    assert [asset.kind for asset in package.omitted_assets] == (
        ["skill"] if include_assets else ["skill", "skill", "file"]
    )
    assert [asset.name for asset in package.omitted_assets] == (
        ["missing"] if include_assets else ["research", "missing", "guide.md"]
    )
    assert "plain-secret" not in str(serialized)
    assert "model-secret" not in str(serialized)
    assert "tool-secret" not in str(serialized)
    assert ("skill-file" in str(serialized)) is include_assets
    assert ("config-file" in str(serialized)) is include_assets
    assert package.soul.human.contacts[0].id is None
    assert package.soul.human.contacts[0].name == "Reviewer"

    package.soul.config_skills[0].description = "Changed"
    package.soul.config_files[0].name = "changed.md"
    package.soul.tools.cli_tools[0].env.secret_refs[0].name = "CHANGED"
    assert soul.model_dump(mode="json") == original


def test_agent_package_round_trips_as_strict_dsl_dto() -> None:
    package = make_portable_agent_package(_agent(), AgentSoulConfig())

    restored = AgentPackage.model_validate(package.model_dump(mode="json"))

    assert restored == package


def test_agent_package_normalizes_legacy_null_missing_asset_file_ids() -> None:
    package = make_portable_agent_package(
        _agent(),
        AgentSoulConfig.model_validate(
            {
                "config_skills": [{"name": "research", "file_id": "skill-file"}],
                "config_files": [{"name": "guide.md", "file_kind": "tool_file", "file_id": "config-file"}],
            }
        ),
    ).model_dump(mode="json")
    package["soul"]["config_skills"][0]["file_id"] = None
    package["soul"]["config_files"][0]["file_id"] = None

    restored = AgentPackage.model_validate(package)

    assert restored.soul.config_skills[0].file_id == ""
    assert restored.soul.config_files[0].file_id == ""
    assert restored.model_dump(mode="json")["soul"]["config_skills"][0]["file_id"] == ""
    assert restored.model_dump(mode="json")["soul"]["config_files"][0]["file_id"] == ""


@pytest.mark.parametrize(
    "asset",
    [
        {"name": "research", "file_id": None, "is_missing": False},
        {"name": "guide.md", "file_kind": "tool_file", "file_id": None, "is_missing": False},
    ],
)
def test_agent_package_rejects_null_file_id_for_available_assets(asset: dict) -> None:
    package = make_portable_agent_package(_agent(), AgentSoulConfig()).model_dump(mode="json")
    target = "config_files" if "file_kind" in asset else "config_skills"
    package["soul"][target] = [asset]

    with pytest.raises(ValidationError):
        AgentPackage.model_validate(package)


def test_import_warnings_cover_runtime_setup_removed_from_package(
    monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
    soul = AgentSoulConfig.model_validate(
        {
            "tools": {
                "dify_tools": [
                    {
                        "provider_id": "langgenius/google/google",
                        "provider_type": "plugin",
                        "tool_name": "search",
                        "credential_type": "unauthorized",
                    }
                ],
                "cli_tools": [{"name": "cli", "env": {"secret_refs": [{"name": "CLI_TOKEN"}]}}],
            },
            "env": {"secret_refs": [{"name": "GLOBAL_TOKEN"}]},
            "human": {"contacts": [{"name": "Reviewer", "email": "[email protected]"}]},
        }
    )
    monkeypatch.setattr("services.agent.dsl_service.get_tenant_knowledge_dataset_rows", Mock(return_value={}))

    _, warnings = AgentDslService(unbound_session).resolve_package_soul(
        tenant_id="tenant-1",
        package=make_portable_agent_package(_agent(), soul),
        package_path="agent_packages.agent_1",
    )

    codes = [warning.code for warning in warnings]
    assert codes.count("agent_tool_authorization_required") == 1
    assert codes.count("agent_secret_required") == 2
    assert codes.count("agent_human_contact_unresolved") == 1


def test_agent_package_rejects_unknown_schema_version() -> None:
    package = make_portable_agent_package(_agent(), AgentSoulConfig()).model_dump(mode="json")
    package["schema_version"] = 2

    with pytest.raises(ValidationError):
        AgentPackage.model_validate(package)


def test_export_agent_app_requires_backing_agent(sqlite_session: Session) -> None:
    with pytest.raises(ValueError, match="no active backing Agent"):
        AgentDslService(sqlite_session).export_agent_app(app=_app(), version_id=None)


@pytest.mark.parametrize("use_draft", [True, False])
def test_export_agent_app_uses_draft_or_active_snapshot(sqlite_session: Session, use_draft: bool) -> None:
    agent = _agent(app_id="app-1")
    agent.active_config_snapshot_id = "snapshot-1"
    snapshot = _snapshot(soul=AgentSoulConfig(config_note="snapshot"))
    rows: list[object] = [agent, snapshot]
    if use_draft:
        rows.append(
            AgentConfigDraft(
                id="draft-1",
                tenant_id="tenant-1",
                agent_id=agent.id,
                draft_type=AgentConfigDraftType.DRAFT,
                account_id=None,
                draft_owner_key="",
                config_snapshot=AgentSoulConfig(config_note="draft"),
            )
        )
    sqlite_session.add_all(rows)
    sqlite_session.commit()

    package_ref, packages = AgentDslService(sqlite_session).export_agent_app(app=_app(), version_id=None)

    assert package_ref == "agent_1"
    assert packages[package_ref].soul.config_note == ("draft" if use_draft else "snapshot")


def test_export_workflow_packages_deduplicates_shared_agent(sqlite_session: Session) -> None:
    graph = {"nodes": [_agent_node("node-1"), _agent_node("node-2")], "edges": []}
    bindings = [
        WorkflowAgentNodeBinding(
            id=f"binding-{node_id}",
            tenant_id="tenant-1",
            app_id="app-1",
            workflow_id="workflow-1",
            workflow_version=Workflow.VERSION_DRAFT,
            node_id=node_id,
            agent_id="agent-1",
            current_snapshot_id="snapshot-1",
            binding_type=WorkflowAgentBindingType.ROSTER_AGENT,
            node_job_config={"workflow_prompt": node_id},
            created_by="account-1",
        )
        for node_id in ("node-1", "node-2")
    ]
    sqlite_session.add_all([_agent(), _snapshot(), *bindings])
    sqlite_session.commit()

    portable_graph, packages = AgentDslService(sqlite_session).export_workflow_packages(
        workflow=_workflow(),
        graph=graph,
    )

    assert list(packages) == ["agent_1"]
    for node in portable_graph["nodes"]:
        assert node["data"]["agent_binding"] == {
            "binding_type": WorkflowAgentBindingType.ROSTER_AGENT.value,
            AGENT_PACKAGE_REF_KEY: "agent_1",
        }
        assert node["data"][AGENT_NODE_JOB_DSL_KEY]["workflow_prompt"] == node["id"]


def test_export_workflow_packages_rejects_incomplete_binding(sqlite_session: Session) -> None:
    with pytest.raises(ValueError, match="no complete persisted binding"):
        AgentDslService(sqlite_session).export_workflow_packages(
            workflow=_workflow(),
            graph={"nodes": [_agent_node("node-1")], "edges": []},
        )


def test_graph_without_package_bindings_removes_portable_fields() -> None:
    graph = {
        "nodes": [
            _agent_node(
                "portable",
                {
                    "binding_type": WorkflowAgentBindingType.INLINE_AGENT.value,
                    AGENT_PACKAGE_REF_KEY: "agent_1",
                },
            ),
            _agent_node("persisted", {"binding_type": "inline_agent", "agent_id": "agent-1"}),
        ],
        "edges": [],
    }
    for node in graph["nodes"]:
        node["data"][AGENT_NODE_JOB_DSL_KEY] = {"workflow_prompt": "work"}

    result = AgentDslService.graph_without_package_bindings(graph)

    assert "agent_binding" not in result["nodes"][0]["data"]
    assert result["nodes"][1]["data"]["agent_binding"]["agent_id"] == "agent-1"
    assert all(AGENT_NODE_JOB_DSL_KEY not in node["data"] for node in result["nodes"])
    assert AGENT_NODE_JOB_DSL_KEY in graph["nodes"][0]["data"]


def test_import_agent_app_package_creates_config_and_unpublished_draft(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    service = AgentDslService(sqlite_session)
    soul = AgentSoulConfig(config_note="portable")
    warning = DslImportWarning(code="setup", path="agent.soul", message="setup required")
    service.resolve_package_soul = Mock(return_value=(soul, [warning]))
    service.unique_roster_name = Mock(return_value="Portable Agent import")
    agent = _agent()
    agent.active_config_snapshot_id = "snapshot-1"
    agent.active_config_is_published = True
    snapshot = _snapshot(soul=soul)
    roster_service = Mock()

    def create_backing_agent(**_kwargs: object) -> Agent:
        sqlite_session.add_all([agent, snapshot])
        sqlite_session.flush()
        return agent

    roster_service.create_backing_agent_for_app.side_effect = create_backing_agent
    monkeypatch.setattr("services.agent.dsl_service.AgentRosterService", Mock(return_value=roster_service))
    app = _app()
    app.icon_type = IconType.LINK
    app.icon = "https://example.com/override.png"
    app.icon_background = "#123456"
    sqlite_session.add(app)
    sqlite_session.commit()

    result = service.import_agent_app_package(
        app=app,
        account=_account(),
        package=make_portable_agent_package(_agent(), soul),
    )

    assert result.warnings == [warning]
    creation = roster_service.create_backing_agent_for_app.call_args.kwargs
    assert creation["icon_type"] == AgentIconType.LINK
    assert creation["icon"] == app.icon
    assert creation["icon_background"] == app.icon_background
    assert agent.active_config_is_published is False
    assert app.name == "Portable Agent"
    assert app.description == "description"
    assert app.app_model_config_id is not None
    draft = sqlite_session.scalar(
        select(AgentConfigDraft).where(
            AgentConfigDraft.agent_id == agent.id,
            AgentConfigDraft.draft_type == AgentConfigDraftType.DRAFT,
        )
    )
    assert draft is not None
    assert draft.config_snapshot.config_note == "portable"


def test_import_workflow_packages_materializes_every_package_binding_as_inline(sqlite_session: Session) -> None:
    package = make_portable_agent_package(_agent(), AgentSoulConfig())
    graph = {
        "nodes": [
            _agent_node(
                "roster-1",
                {"binding_type": WorkflowAgentBindingType.ROSTER_AGENT.value, AGENT_PACKAGE_REF_KEY: "agent_1"},
            ),
            _agent_node(
                "roster-2",
                {"binding_type": WorkflowAgentBindingType.ROSTER_AGENT.value, AGENT_PACKAGE_REF_KEY: "agent_1"},
            ),
            _agent_node(
                "inline",
                {"binding_type": WorkflowAgentBindingType.INLINE_AGENT.value, AGENT_PACKAGE_REF_KEY: "agent_1"},
            ),
            _agent_node("missing-binding"),
            _agent_node("invalid-ref", {AGENT_PACKAGE_REF_KEY: 1}),
        ],
        "edges": [],
    }
    for node in graph["nodes"][:3]:
        node["data"][AGENT_NODE_JOB_DSL_KEY] = {"workflow_prompt": node["id"]}
    old_binding = WorkflowAgentNodeBinding(
        id="old-binding",
        tenant_id="tenant-1",
        app_id="app-1",
        workflow_id="workflow-1",
        workflow_version=Workflow.VERSION_DRAFT,
        node_id="old-node",
        binding_type=WorkflowAgentBindingType.INLINE_AGENT,
        agent_id="old-inline-agent",
        current_snapshot_id="old-snapshot",
        node_job_config={},
        created_by="account-1",
    )
    sqlite_session.add(old_binding)
    sqlite_session.commit()
    service = AgentDslService(sqlite_session)
    imported_results = [
        AgentPackageImportResult(
            agent=_agent(
                agent_id=f"inline-agent-{index}",
                scope=AgentScope.WORKFLOW_ONLY,
                source=AgentSource.IMPORTED,
            ),
            snapshot=_snapshot(
                snapshot_id=f"inline-snapshot-{index}",
                agent_id=f"inline-agent-{index}",
            ),
            warnings=[DslImportWarning(code=f"inline-{index}", path="agent", message="inline warning")],
        )
        for index in range(1, 4)
    ]
    service._create_imported_inline_agent = Mock(side_effect=imported_results)
    workflow = _workflow()

    result, warnings, retirement_candidates = service.import_workflow_packages(
        workflow=workflow,
        portable_graph=graph,
        raw_packages={"agent_1": package.model_dump(mode="json")},
        account=_account(),
    )

    assert sqlite_session.get(WorkflowAgentNodeBinding, old_binding.id) is None
    assert retirement_candidates == {"old-inline-agent"}
    assert service._create_imported_inline_agent.call_count == 3
    assert [call.kwargs["node_id"] for call in service._create_imported_inline_agent.call_args_list] == [
        "roster-1",
        "roster-2",
        "inline",
    ]
    assert [warning.code for warning in warnings] == ["inline-1", "inline-2", "inline-3"]
    bindings = [result["nodes"][index]["data"]["agent_binding"] for index in range(3)]
    assert [binding["agent_id"] for binding in bindings] == [
        "inline-agent-1",
        "inline-agent-2",
        "inline-agent-3",
    ]
    assert all(binding["binding_type"] == WorkflowAgentBindingType.INLINE_AGENT.value for binding in bindings)
    assert AGENT_NODE_JOB_DSL_KEY not in result["nodes"][0]["data"]
    assert json.loads(workflow.graph) == result
    added_bindings = sqlite_session.scalars(
        select(WorkflowAgentNodeBinding).where(WorkflowAgentNodeBinding.workflow_id == workflow.id)
    ).all()
    assert len(added_bindings) == 3
    assert all(binding.binding_type == WorkflowAgentBindingType.INLINE_AGENT for binding in added_bindings)


@pytest.mark.parametrize(
    ("binding", "error"),
    [
        (
            {"binding_type": WorkflowAgentBindingType.INLINE_AGENT.value, AGENT_PACKAGE_REF_KEY: "missing"},
            "unknown package",
        ),
        ({"binding_type": "invalid", AGENT_PACKAGE_REF_KEY: "agent_1"}, "invalid binding type"),
    ],
)
def test_import_workflow_packages_rejects_invalid_package_binding(
    sqlite_session: Session, binding: dict, error: str
) -> None:
    package = make_portable_agent_package(_agent(), AgentSoulConfig())

    with pytest.raises(ValueError, match=error):
        AgentDslService(sqlite_session).import_workflow_packages(
            workflow=_workflow(),
            portable_graph={"nodes": [_agent_node("node-1", binding)], "edges": []},
            raw_packages={"agent_1": package.model_dump(mode="json")},
            account=_account(),
        )


def test_clone_inline_binding_copies_soul(unbound_session: Session) -> None:
    service = AgentDslService(unbound_session)
    target_agent = _agent(
        agent_id="target-agent",
        scope=AgentScope.WORKFLOW_ONLY,
        source=AgentSource.WORKFLOW,
    )
    target_snapshot = _snapshot(snapshot_id="target-snapshot", agent_id=target_agent.id)
    service._create_workflow_only_agent = Mock(return_value=(target_agent, target_snapshot))
    source_agent = _agent()
    source_soul = AgentSoulConfig(
        config_note="source",
        config_skills=[AgentConfigSkillRefConfig(name="summarizer", file_id="skill-file-1")],
        config_files=[AgentConfigFileRefConfig(name="brief.pdf", file_kind="upload_file", file_id="config-file-1")],
    )
    source_snapshot = _snapshot(soul=source_soul)
    workflow = _workflow()

    result = service.clone_inline_binding_for_node(
        workflow=workflow,
        node_id="target-node",
        source_agent=source_agent,
        source_snapshot=source_snapshot,
        account_id="account-1",
    )

    assert result == (target_agent, target_snapshot)
    create_kwargs = service._create_workflow_only_agent.call_args.kwargs
    assert create_kwargs["metadata"].name == source_agent.name
    cloned_soul = create_kwargs["soul"]
    assert cloned_soul.config_note == "source"
    assert [(item.name, item.file_kind, item.file_id) for item in cloned_soul.config_skills] == [
        ("summarizer", "tool_file", "skill-file-1")
    ]
    assert [(item.name, item.file_kind, item.file_id) for item in cloned_soul.config_files] == [
        ("brief.pdf", "upload_file", "config-file-1")
    ]
    assert create_kwargs["source"] == AgentSource.WORKFLOW


def test_extract_package_dependencies_covers_models_features_tools_and_knowledge(
    monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
    model_dependency = Mock(side_effect=lambda provider: f"model:{provider}")
    tool_dependency = Mock(side_effect=lambda provider: f"tool:{provider}")
    monkeypatch.setattr(
        "services.agent.dependency_service.DependenciesAnalysisService.analyze_model_provider_dependency",
        model_dependency,
    )
    monkeypatch.setattr(
        "services.agent.dependency_service.DependenciesAnalysisService.analyze_tool_dependency",
        tool_dependency,
    )
    soul = AgentSoulConfig.model_validate(
        {
            "model": {"plugin_id": "model-plugin", "model_provider": "provider/model", "model": "model"},
            "app_features": {
                "suggested_questions_after_answer": {
                    "enabled": True,
                    "model": {"provider": "provider/follow-up", "name": "follow-up-model"},
                }
            },
            "tools": {
                "dify_tools": [
                    {
                        "provider_id": "provider/tool",
                        "provider_type": "plugin",
                        "credential_type": "unauthorized",
                    },
                    {
                        "plugin_id": "plugin-id",
                        "provider": "fallback-provider",
                        "provider_type": "plugin",
                        "credential_type": "unauthorized",
                    },
                ]
            },
            "knowledge": {
                "sets": [
                    {
                        "id": "set-1",
                        "name": "Set",
                        "datasets": [{"id": "dataset-1", "name": "Docs"}],
                        "query": {"mode": "user_query", "value": "query"},
                        "retrieval": {
                            "mode": "single",
                            "model": {"provider": "provider/retrieval", "name": "embed", "mode": "embedding"},
                        },
                        "metadata_filtering": {
                            "mode": "automatic",
                            "model_config": {
                                "provider": "provider/metadata",
                                "name": "metadata-model",
                                "mode": "chat",
                            },
                        },
                    },
                    {
                        "id": "set-2",
                        "name": "Reranked Set",
                        "datasets": [{"id": "dataset-2", "name": "Reranked Docs"}],
                        "query": {"mode": "user_query", "value": "query"},
                        "retrieval": {
                            "mode": "multiple",
                            "top_k": 5,
                            "reranking_enable": True,
                            "reranking_mode": "reranking_model",
                            "reranking_model": {"provider": "provider/rerank", "model": "rerank"},
                        },
                    },
                    {
                        "id": "set-3",
                        "name": "Weighted Set",
                        "datasets": [{"id": "dataset-3", "name": "Weighted Docs"}],
                        "query": {"mode": "user_query", "value": "query"},
                        "retrieval": {
                            "mode": "multiple",
                            "top_k": 5,
                            "reranking_enable": True,
                            "reranking_mode": "weighted_score",
                            "weights": {
                                "vector_setting": {
                                    "embedding_provider_name": "provider/embedding",
                                    "embedding_model_name": "embedding-model",
                                    "vector_weight": 0.7,
                                },
                                "keyword_setting": {"keyword_weight": 0.3},
                            },
                        },
                    },
                ]
            },
        }
    )

    dependencies = AgentDslService(unbound_session).extract_package_dependencies(
        {"agent_1": make_portable_agent_package(_agent(), soul)}
    )

    assert dependencies == [
        "model:provider/model",
        "model:provider/follow-up",
        "tool:provider/tool",
        "tool:plugin-id/fallback-provider",
        "model:provider/retrieval",
        "model:provider/metadata",
        "model:provider/rerank",
        "model:provider/embedding",
    ]


def test_extract_package_dependencies_ignores_inactive_knowledge_models(
    monkeypatch: pytest.MonkeyPatch, unbound_session: Session
) -> None:
    model_dependency = Mock(side_effect=lambda provider: f"model:{provider}")
    monkeypatch.setattr(
        "services.agent.dependency_service.DependenciesAnalysisService.analyze_model_provider_dependency",
        model_dependency,
    )
    soul = AgentSoulConfig.model_validate(
        {
            "knowledge": {
                "sets": [
                    {
                        "id": "set-1",
                        "name": "Set",
                        "datasets": [{"id": "dataset-1", "name": "Docs"}],
                        "query": {"mode": "user_query", "value": "query"},
                        "retrieval": {
                            "mode": "multiple",
                            "top_k": 5,
                            "reranking_enable": False,
                            "reranking_mode": "weighted_score",
                            "reranking_model": {"provider": "provider/inactive-rerank", "model": "rerank"},
                            "weights": {
                                "vector_setting": {
                                    "embedding_provider_name": "provider/inactive-embedding",
                                }
                            },
                            "model": {
                                "provider": "provider/inactive-retrieval",
                                "name": "retrieval-model",
                                "mode": "chat",
                            },
                        },
                        "metadata_filtering": {
                            "mode": "disabled",
                            "model_config": {
                                "provider": "provider/inactive-metadata",
                                "name": "metadata-model",
                                "mode": "chat",
                            },
                        },
                    }
                ]
            }
        }
    )

    dependencies = AgentDslService(unbound_session).extract_package_dependencies(
        {"agent_1": make_portable_agent_package(_agent(), soul)}
    )

    assert dependencies == []
    model_dependency.assert_not_called()


def test_create_imported_inline_agent_uses_import_provenance(unbound_session: Session) -> None:
    service = AgentDslService(unbound_session)
    soul = AgentSoulConfig(config_note="inline")
    warning = DslImportWarning(code="setup", path="agent", message="setup")
    service.resolve_package_soul = Mock(return_value=(soul, [warning]))
    service._create_workflow_only_agent = Mock(return_value=(_agent(), _snapshot(soul=soul)))
    workflow = _workflow()

    result = service._create_imported_inline_agent(
        workflow=workflow,
        node_id="node-1",
        account=_account(),
        package=make_portable_agent_package(_agent(), soul),
        package_path="agent_packages.agent_1",
    )

    assert result.warnings == [warning]
    assert service._create_workflow_only_agent.call_args.kwargs["source"] == AgentSource.IMPORTED
    assert (
        service._create_workflow_only_agent.call_args.kwargs["operation"] == AgentConfigRevisionOperation.IMPORT_PACKAGE
    )


def test_create_workflow_only_agent_sets_backing_app_and_snapshot(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    service = AgentDslService(sqlite_session)
    roster_service = Mock()
    backing_app = _app()
    backing_app.id = "backing-app"
    roster_service.create_hidden_backing_app_for_workflow_agent.return_value = backing_app
    monkeypatch.setattr("services.agent.dsl_service.AgentRosterService", Mock(return_value=roster_service))
    monkeypatch.setattr("services.agent.dsl_service.agent_soul_has_model", Mock(return_value=True))
    workflow = _workflow()

    agent, snapshot = service._create_workflow_only_agent(
        workflow=workflow,
        node_id="node-1",
        account_id="account-1",
        metadata=AgentPackageMetadata(name="Inline", icon_type=AgentIconType.EMOJI.value),
        soul=AgentSoulConfig(),
        source=AgentSource.IMPORTED,
        operation=AgentConfigRevisionOperation.IMPORT_PACKAGE,
    )

    assert sqlite_session.get(Agent, agent.id) is agent
    assert sqlite_session.get(AgentConfigSnapshot, snapshot.id) is snapshot
    assert agent.scope == AgentScope.WORKFLOW_ONLY
    assert agent.backing_app_id == "backing-app"
    assert agent.active_config_snapshot_id == snapshot.id
    assert agent.active_config_has_model is True
    assert agent.active_config_is_published is True
    revision = sqlite_session.scalar(
        select(AgentConfigRevision).where(AgentConfigRevision.current_snapshot_id == snapshot.id)
    )
    assert revision is not None
    assert revision.operation == AgentConfigRevisionOperation.IMPORT_PACKAGE


def test_resolve_package_soul_preserves_existing_and_marks_missing_knowledge(
    monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    soul = AgentSoulConfig.model_validate(
        {
            "config_skills": [{"name": "skill", "file_kind": "tool_file", "file_id": "skill-file"}],
            "config_files": [{"name": "Guide", "file_kind": "upload_file", "file_id": "guide-file"}],
            "knowledge": {
                "sets": [
                    {
                        "id": "set-1",
                        "name": "Set",
                        "datasets": [
                            {"id": "existing", "name": "Existing"},
                            {"id": "missing", "name": "Missing"},
                        ],
                        "query": {"mode": "user_query", "value": "query"},
                        "retrieval": {"mode": "multiple", "top_k": 3},
                    }
                ]
            },
        }
    )
    existing_dataset = Dataset(
        id="existing",
        tenant_id="tenant-1",
        name="Existing",
        created_by="account-1",
    )
    get_dataset_rows = Mock(return_value={"existing": existing_dataset})
    monkeypatch.setattr("services.agent.dsl_service.get_tenant_knowledge_dataset_rows", get_dataset_rows)

    resolved, warnings = AgentDslService(sqlite_session).resolve_package_soul(
        tenant_id="tenant-1",
        package=make_portable_agent_package(_agent(), soul),
        package_path="agent_packages.agent_1",
    )

    get_dataset_rows.assert_called_once_with(
        session=sqlite_session,
        tenant_id="tenant-1",
        dataset_ids=["existing", "missing"],
    )
    datasets = resolved.knowledge.sets[0].datasets
    assert datasets[0].id == "existing"
    assert datasets[1].id is not None
    assert datasets[1].id.startswith("missing-dataset-")
    assert resolved.config_skills[0].model_dump(mode="json") == {
        "name": "skill",
        "description": "",
        "file_kind": "tool_file",
        "file_id": "",
        "is_missing": True,
        "size": None,
        "hash": None,
        "mime_type": "application/zip",
    }
    assert resolved.config_files[0].model_dump(mode="json") == {
        "name": "Guide",
        "file_kind": "upload_file",
        "file_id": "",
        "is_missing": True,
        "size": None,
        "hash": None,
        "mime_type": None,
    }
    assert {warning.code for warning in warnings} == {
        "agent_skill_omitted",
        "agent_file_omitted",
        "agent_knowledge_unresolved",
    }


@pytest.mark.parametrize(
    ("field", "file_kind"),
    [("config_skills", "tool_file"), ("config_files", "tool_file"), ("config_files", "upload_file")],
)
@pytest.mark.parametrize("availability", ["local", "foreign", "deleted", "invalid_id"])
def test_resolve_legacy_package_asset_references(
    sqlite_session: Session, field: str, file_kind: str, availability: str
) -> None:
    tenant_id = "tenant-2" if availability == "foreign" else "tenant-1"
    file_id = "legacy-file-id" if availability == "invalid_id" else str(uuid4())
    if availability in {"local", "foreign"}:
        if file_kind == "upload_file":
            row = make_upload_file(file_id=file_id, tenant_id=tenant_id)
        else:
            row = ToolFile(
                tenant_id=tenant_id,
                user_id="account-1",
                conversation_id=None,
                file_key="tools/asset.zip",
                mimetype="application/zip",
            )
            row.id = file_id
        sqlite_session.add(row)
        sqlite_session.flush()
    package = AgentPackage.model_validate(
        {
            "metadata": {"name": "Legacy Agent"},
            "soul": {field: [{"name": "asset", "file_kind": file_kind, "file_id": file_id, "size": 42}]},
        }
    )

    resolved, warnings = AgentDslService(sqlite_session).resolve_package_soul(
        tenant_id="tenant-1", package=package, package_path="agent_packages.agent_1"
    )

    ref = (resolved.config_skills if field == "config_skills" else resolved.config_files)[0]
    assert ref.is_missing is (availability != "local")
    assert ref.file_id == (file_id if availability == "local" else "")
    assert ref.name == "asset"
    assert ref.size == 42
    original_ref = (package.soul.config_skills if field == "config_skills" else package.soul.config_files)[0]
    assert original_ref.file_id == file_id
    if availability == "local":
        assert warnings == []
    else:
        kind = "skill" if field == "config_skills" else "file"
        assert [warning.code for warning in warnings] == [f"agent_{kind}_missing"]
        assert warnings[0].path == f"agent_packages.agent_1.soul.{field}.0"


def test_create_snapshot_increments_version_and_records_revision(sqlite_session: Session) -> None:
    agent = _agent()
    sqlite_session.add_all(
        [
            agent,
            _snapshot(snapshot_id="snapshot-1", version=1),
            _snapshot(snapshot_id="snapshot-2", version=2),
        ]
    )
    sqlite_session.commit()
    service = AgentDslService(sqlite_session)

    snapshot = service._create_snapshot(
        tenant_id="tenant-1",
        agent=agent,
        account_id="account-1",
        soul=AgentSoulConfig(config_note="version 3"),
        operation=AgentConfigRevisionOperation.IMPORT_PACKAGE,
    )

    assert snapshot.version == 3
    assert snapshot.home_snapshot_id is None
    assert sqlite_session.get(AgentConfigSnapshot, snapshot.id) is snapshot
    revision = sqlite_session.scalar(
        select(AgentConfigRevision).where(AgentConfigRevision.current_snapshot_id == snapshot.id)
    )
    assert revision is not None
    assert revision.operation == AgentConfigRevisionOperation.IMPORT_PACKAGE


def test_unique_roster_name_uses_first_available_suffix(sqlite_session: Session) -> None:
    sqlite_session.add_all(
        [
            _agent(agent_id="agent-1", name="Agent"),
            _agent(agent_id="agent-2", name="Agent import"),
            _agent(agent_id="decoy-agent", name="Agent import 2", scope=AgentScope.WORKFLOW_ONLY),
        ]
    )
    sqlite_session.commit()

    result = AgentDslService(sqlite_session).unique_roster_name(tenant_id="tenant-1", requested="Agent")

    assert result == "Agent import 2"


def test_require_helpers_and_graph_detection(sqlite_session: Session) -> None:
    agent = _agent()
    snapshot = _snapshot()
    sqlite_session.add_all([agent, snapshot])
    sqlite_session.commit()
    service = AgentDslService(sqlite_session)

    assert service._require_agent(tenant_id="tenant-1", agent_id="agent-1") is agent
    with pytest.raises(ValueError, match="source Agent"):
        service._require_agent(tenant_id="tenant-1", agent_id="missing")
    with pytest.raises(ValueError, match="source snapshot"):
        service._require_snapshot(tenant_id="tenant-1", agent_id="agent-1", snapshot_id=None)
    assert service._require_snapshot(tenant_id="tenant-1", agent_id="agent-1", snapshot_id="snapshot-1") is snapshot
    with pytest.raises(ValueError, match="source snapshot"):
        service._require_snapshot(tenant_id="tenant-1", agent_id="agent-1", snapshot_id="missing")

    assert AgentDslService._agent_icon_type(AgentIconType.EMOJI.value) == AgentIconType.EMOJI
    assert AgentDslService._agent_icon_type(None) is None
    assert is_agent_v2_graph({"nodes": [_agent_node("agent")]}) is True
    assert is_agent_v2_graph({"nodes": ["invalid", {"data": {"type": "start"}}]}) is False