dify/api/core/dify_builder/placeholder_agent.py

"""Legacy deterministic ``DifyBuilderAgent`` used by isolated domain tests.

Port of dify-enterprise/server/pkg/enterprise/biz/dify_builder/placeholder_agent.go.

It is not selectable by production configuration; runtime Builder cognition is
always provided by ``LlmBuilderAgent``. The deterministic implementation stays
as a compact fixture for state-machine tests that do not exercise model calls.
"""

from collections.abc import Callable
from typing import Any

from core.dify_builder.contract import ResourceOption
from core.dify_builder.models import (
    ChecklistError,
    ConversationItem,
    Diagnosis,
    DifyBuilderContext,
    Graph,
    Inputs,
    MutationIntent,
    NodeOutput,
    Risk,
    Run,
    StartSchema,
)
from core.dify_builder.state import PcState
from graphon.enums import BuiltinNodeTypes
from services.dify_builder import node_defaults

__all__ = [
    "BUILD_END_ID",
    "BUILD_KNOWLEDGE_ID",
    "BUILD_LLM_ID",
    "BUILD_START_ID",
    "FIXED_CODE",
    "PlaceholderAgent",
]

FIXED_CODE = 'def main() -> dict:\n    return {"result": "ok"}'

# Deterministic node ids for the canned Build graph, so connect intents can
# reference them and built_node_ids is known up front.
BUILD_START_ID = "start"
BUILD_KNOWLEDGE_ID = "knowledge_retrieval"
BUILD_LLM_ID = "llm"
BUILD_END_ID = "end"


class PlaceholderAgent:
    """Deterministic test cognition; see module docstring."""

    def diagnose(self, failed_run: Run, graph: Graph, node_outputs: list[NodeOutput]) -> Diagnosis:
        culprit = "output"
        for o in node_outputs:
            if o.status in ("failed", "exception"):
                culprit = o.node_id
                break
        return Diagnosis(culprit_node_id=culprit, root_cause="Code node raised at runtime", severity="high")

    def diagnose_checklist(self, errors: list[ChecklistError], graph: Graph) -> Diagnosis:
        culprit, cause = "", "Checklist error"
        for e in errors:
            if e.messages:
                culprit, cause = e.node_id, e.messages[0]
                break
        return Diagnosis(culprit_node_id=culprit, root_cause=cause, severity="medium")

    def propose_repair(self, diagnosis: Diagnosis, graph: Graph) -> tuple[list[MutationIntent], Risk]:
        intents = [
            MutationIntent(
                op="set_node_config",
                args={"node_id": diagnosis.culprit_node_id, "path": "code", "value": FIXED_CODE},
            )
        ]
        return intents, Risk(level="low", reason="config-only fix", has_external_side_effect=False)

    def generate_mock_inputs(self, schema: StartSchema, prior_failed: Inputs) -> Inputs:
        return {"query": "mock"}

    # -- Build cognition (Slice 2; fixed, deterministic canned output) --

    def analyze_goal(self, goal_text: str) -> dict[str, Any]:
        # Always proceeds -- no real missing-info branch. The challenge card
        # the handler shows is an informational "proceeding" note.
        return {
            "fields": [
                {"key": "report_types", "label": "Report types", "type": "text"},
                {"key": "audience", "label": "Audience", "type": "text"},
                {"key": "currency", "label": "Currency", "type": "text"},
                {"key": "metrics", "label": "Metrics", "type": "text"},
                {"key": "output", "label": "Output", "type": "textarea"},
                {"key": "prefer_audited", "label": "Prefer audited sources", "type": "bool"},
            ],
            "values": {
                "report_types": "quarterly",
                "audience": "executives",
                "currency": "USD",
                "metrics": "revenue, gross_margin",
                "output": "PDF summary",
                "prefer_audited": True,
            },
        }

    def propose_plan_v1(self, requirements: dict[str, Any]) -> list[str]:
        return [
            "Ingest source documents",
            "Retrieve relevant knowledge",
            "Summarize with an LLM",
            "Emit the final report",
        ]

    def discover_resources(self, plan_items: list[str]) -> list[ResourceOption]:
        return [
            ResourceOption(
                id="kb-company",
                label="Company Knowledge Base",
                meta="1,024 documents",
                kind="knowledge",
                readiness="ready",
            )
        ]

    def bind_resources(self, plan_items: list[str], resource_ids: list[str], conflict_policy: str) -> list[str]:
        return [
            "Ingest source documents",
            "Retrieve from Company Knowledge Base",
            "Summarize with the configured LLM",
            "Emit the final report",
        ]

    def build_nodes(self, plan_items: list[str]) -> list[MutationIntent]:
        # Start -> Knowledge-Retrieval -> LLM -> End. Creates and connects are
        # interleaved so each connect's endpoints already exist when
        # apply_connect validates them.
        return [
            MutationIntent(
                op="create_node",
                args={
                    "node_type": BuiltinNodeTypes.START,
                    "config": node_defaults.default_config(BuiltinNodeTypes.START),
                    "node_id": BUILD_START_ID,
                },
            ),
            MutationIntent(
                op="create_node",
                args={
                    "node_type": BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL,
                    "config": node_defaults.default_config(BuiltinNodeTypes.KNOWLEDGE_RETRIEVAL),
                    "node_id": BUILD_KNOWLEDGE_ID,
                },
            ),
            MutationIntent(op="connect", args={"from_node": BUILD_START_ID, "to_node": BUILD_KNOWLEDGE_ID}),
            MutationIntent(
                op="create_node",
                args={
                    "node_type": BuiltinNodeTypes.LLM,
                    "config": node_defaults.default_config(BuiltinNodeTypes.LLM),
                    "node_id": BUILD_LLM_ID,
                },
            ),
            MutationIntent(op="connect", args={"from_node": BUILD_KNOWLEDGE_ID, "to_node": BUILD_LLM_ID}),
            MutationIntent(
                op="create_node",
                args={
                    "node_type": BuiltinNodeTypes.END,
                    "config": node_defaults.default_config(BuiltinNodeTypes.END),
                    "node_id": BUILD_END_ID,
                },
            ),
            MutationIntent(op="connect", args={"from_node": BUILD_LLM_ID, "to_node": BUILD_END_ID}),
        ]

    def learn_from_build(
        self,
        goal_text: str,
        requirements: dict[str, Any],
        plan_items: list[str],
        built_node_ids: list[str],
    ) -> str:
        return "Reusable skill: a Start->Knowledge->LLM->End summary workflow"

    # -- Edit cognition (Slice 3; fixed, deterministic canned output) --

    def analyze_impact(self, goal_text: str, graph: Graph) -> dict[str, Any]:
        # Pick affected nodes from the existing graph (LLM + knowledge), with a
        # canned-id fallback so the flow works on any Build-shaped draft.
        node_ids = {n.get("id") for n in graph.get("nodes", [])}
        targets = [nid for nid in (BUILD_LLM_ID, BUILD_KNOWLEDGE_ID) if nid in node_ids] or [BUILD_LLM_ID]
        return {
            "fields": [
                {"key": "risk_threshold", "label": "Risk threshold", "type": "text"},
                {
                    "key": "review_team",
                    "label": "Review team",
                    "type": "select",
                    "options": ["compliance", "legal", "engineering"],
                },
                {
                    "key": "timeout_behavior",
                    "label": "Timeout behavior",
                    "type": "select",
                    "options": ["fail_open", "fail_closed"],
                },
                {"key": "preserve_summary", "label": "Preserve summary", "type": "bool"},
            ],
            "values": {
                "risk_threshold": "medium",
                "review_team": "compliance",
                "timeout_behavior": "fail_closed",
                "preserve_summary": True,
            },
            "target_node_ids": targets,
        }

    def propose_edit_plan(self, edit_rules: dict[str, Any], graph: Graph) -> list[str]:
        return [
            "Tighten the LLM risk threshold",
            "Route high-risk output to the review team",
            "Apply the timeout behavior",
            "Preserve the existing summary contract",
        ]

    def build_edit_intents(self, edit_rules: dict[str, Any], graph: Graph) -> list[MutationIntent]:
        # Canned config-level edits (set_node_config) on the existing LLM node,
        # matching the edit_rules semantics. Deterministic target selection:
        # prefer the canned LLM id, else the lexicographically-first node id.
        node_ids = {n.get("id") for n in graph.get("nodes", []) if n.get("id")}
        if BUILD_LLM_ID in node_ids:
            llm_id = BUILD_LLM_ID
        elif node_ids:
            llm_id = min(node_ids)
        else:
            llm_id = BUILD_LLM_ID
        return [
            MutationIntent(
                op="set_node_config",
                args={
                    "node_id": llm_id,
                    "path": "risk_threshold",
                    "value": edit_rules.get("risk_threshold", "medium"),
                },
            ),
            MutationIntent(
                op="set_node_config",
                args={
                    "node_id": llm_id,
                    "path": "timeout_behavior",
                    "value": edit_rules.get("timeout_behavior", "fail_closed"),
                },
            ),
        ]

    def respond_to_message(
        self,
        state: PcState,
        context: DifyBuilderContext,
        history: list[ConversationItem],
        graph: Graph,
        text: str,
        on_delta: Callable[[str], None] | None = None,
    ) -> str:
        """Return a deterministic reply for isolated state-machine tests."""
        del context, history, graph
        reply = (
            f'I understand your note: "{text}". The Builder is currently at {state}. '
            "I have not changed the workflow; use one of the available actions when you want to continue."
        )
        if on_delta is not None:
            on_delta(reply)
        return reply