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.

32.8 KB
Raw Blame
from __future__ import annotations

import json
from inspect import unwrap as _generator_api_unwrap
from unittest.mock import MagicMock

import pytest
from flask import Flask, request
from sqlalchemy.orm import Session

from controllers.console.app import generator as generator_module
from controllers.console.app.error import ProviderNotInitializeError
from controllers.console.app.generator import (
    InstructionGeneratePayload,
    InstructionTemplatePayload,
    RuleCodeGeneratePayload,
    RuleGeneratePayload,
    RuleStructuredOutputPayload,
    WorkflowGeneratePayload,
    WorkflowInstructionSuggestionsPayload,
)
from core.errors.error import ModelCurrentlyNotSupportError, ProviderTokenNotInitError, QuotaExceededError
from graphon.model_runtime.errors.invoke import InvokeError
from models.model import App, AppMode
from models.workflow import Workflow
from tests.helpers.unit.model_factories import make_workflow


def _persist_app(session: Session, *, tenant_id: str = "t1") -> App:
    app_model = App(
        id="app-1",
        tenant_id=tenant_id,
        name="Workflow App",
        description="",
        mode=AppMode.WORKFLOW,
        enable_site=False,
        enable_api=False,
        max_active_requests=None,
    )
    session.add(app_model)
    session.commit()
    return app_model


def _generator_api_model_config_payload():
    return {"provider": "openai", "name": "gpt-4o", "mode": "chat", "completion_params": {}}


def _workflow(graph_dict: dict[str, object]) -> Workflow:
    return make_workflow(workflow_id="workflow-1", tenant_id="t1", graph=graph_dict)


def _install_workflow_service(monkeypatch: pytest.MonkeyPatch, workflow):
    class _Service:
        app_model = None
        session = None

        def get_draft_workflow(self, app_model, session=None):
            self.app_model = app_model
            self.session = session
            return workflow

    service = _Service()
    monkeypatch.setattr(generator_module, "WorkflowService", lambda: service)
    return service


def test_rule_generate_success(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.RuleGenerateApi()
    method = _generator_api_unwrap(api.post)

    rule_config = {
        "prompt": "You are a helpful assistant.",
        "variables": ["topic"],
        "opening_statement": "Hi",
        "error": "",
    }
    monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", lambda **_kwargs: rule_config)

    with app.test_request_context(
        "/console/api/rule-generate",
        method="POST",
        json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
    ):
        response = method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")

    assert response == rule_config


def test_rule_code_generate_maps_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.RuleCodeGenerateApi()
    method = _generator_api_unwrap(api.post)

    def _raise(*_args, **_kwargs):
        raise ProviderTokenNotInitError("missing token")

    monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)

    with app.test_request_context(
        "/console/api/rule-code-generate",
        method="POST",
        json={"instruction": "do it", "model_config": _generator_api_model_config_payload()},
    ):
        with pytest.raises(ProviderNotInitializeError):
            method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_app_not_found(app: Flask, sqlite_session: Session) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)
    _persist_app(sqlite_session, tenant_id="other-tenant")

    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "node-1",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response, status = method(
            api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
        )

    assert status == 400
    assert response["error"] == "app app-1 not found"
    assert sqlite_session.get(App, "app-1") is not None


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_workflow_not_found(
    app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)

    _persist_app(sqlite_session)
    _install_workflow_service(monkeypatch, workflow=None)

    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "node-1",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response, status = method(
            api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
        )

    assert status == 400
    assert response["error"] == "workflow app-1 not found"


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_node_missing(
    app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)

    _persist_app(sqlite_session)

    workflow = _workflow({"nodes": []})
    _install_workflow_service(monkeypatch, workflow=workflow)

    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "node-1",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response, status = method(
            api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
        )

    assert status == 400
    assert response["error"] == "node node-1 not found"


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_code_node(app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)

    app_model = _persist_app(sqlite_session)

    workflow = _workflow(
        {
            "nodes": [
                {"id": "node-1", "data": {"type": "code"}},
            ]
        }
    )
    workflow_service = _install_workflow_service(monkeypatch, workflow=workflow)
    monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", lambda **_kwargs: {"code": "x"})

    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "node-1",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")

    assert response == {"code": "x"}
    assert workflow_service.app_model is app_model
    assert workflow_service.session is sqlite_session


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_legacy_modify(
    app: Flask, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session
) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)
    captured: dict = {}

    def _capture(**kwargs):
        captured.update(kwargs)
        return {"instruction": "ok"}

    monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _capture)

    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "",
            "current": "old",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response = method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")

    assert response == {"instruction": "ok"}
    assert captured["session"] is sqlite_session


@pytest.mark.parametrize("sqlite_session", [(App,)], indirect=True)
def test_instruction_generate_incompatible_params(app: Flask, sqlite_session: Session) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_unwrap(api.post)
    with app.test_request_context(
        "/console/api/instruction-generate",
        method="POST",
        json={
            "flow_id": "app-1",
            "node_id": "",
            "current": "",
            "instruction": "do",
            "model_config": _generator_api_model_config_payload(),
        },
    ):
        response, status = method(
            api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1"
        )

    assert status == 400
    assert response["error"] == "incompatible parameters"


def test_instruction_template_prompt(app: Flask) -> None:
    api = generator_module.InstructionGenerationTemplateApi()
    method = _generator_api_unwrap(api.post)

    with app.test_request_context(
        "/console/api/instruction-generate/template",
        method="POST",
        json={"type": "prompt"},
    ):
        response = method(api, InstructionTemplatePayload.model_validate(request.get_json()))

    assert "data" in response


def test_instruction_template_invalid_type(app: Flask) -> None:
    api = generator_module.InstructionGenerationTemplateApi()
    method = _generator_api_unwrap(api.post)

    with app.test_request_context(
        "/console/api/instruction-generate/template",
        method="POST",
        json={"type": "unknown"},
    ):
        with pytest.raises(ValueError, match="Invalid type: unknown"):
            method(api, InstructionTemplatePayload.model_validate(request.get_json()))


# ─ /workflow-generate ─────────────────────────────────────────────────────────


def _workflow_generate_payload() -> dict:
    return {
        "mode": "workflow",
        "instruction": "Summarize a URL",
        "ideal_output": "A 3-sentence summary.",
        "model_config": _generator_api_model_config_payload(),
    }


def _workflow_graph(*, node_id: str | None = None) -> dict:
    nodes = []
    if node_id:
        nodes.append(
            {
                "id": node_id,
                "type": "custom",
                "position": {"x": 0, "y": 0},
                "data": {"type": "start", "title": "Start"},
            }
        )
    return {"nodes": nodes, "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}}


def _stub_workflow_service(monkeypatch: pytest.MonkeyPatch, returns=None, raises: Exception | None = None):
    def _call(**_kwargs):
        if raises is not None:
            raise raises
        return returns or {
            "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
            "message": "",
            "error": "",
        }

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _call)


def test_workflow_generate_returns_service_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    expected = {
        "graph": _workflow_graph(node_id="node-1"),
        "message": "Summarize",
        "app_name": "",
        "icon": "",
        "error": "",
        "errors": [],
        "mode": None,
    }
    expected["graph"]["nodes"][0]["parentId"] = "container-1"
    _stub_workflow_service(monkeypatch, returns=expected)

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert response == expected


def test_workflow_generate_response_schema_is_concrete() -> None:
    schema = generator_module.WorkflowGenerateResponse.model_json_schema()

    assert schema["properties"]["graph"]["$ref"].endswith("/$defs/WorkflowGraph")
    error_items = schema["properties"]["errors"]["items"]
    assert error_items["$ref"].endswith("/$defs/WorkflowGenerateErrorResponse")
    assert set(schema["$defs"]["WorkflowGenerateErrorCode"]["enum"]) == {
        code.value for code in generator_module.WorkflowGenerateErrorCode
    }


def test_workflow_generate_maps_provider_token_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """ProviderTokenNotInitError → ProviderNotInitializeError so the frontend
    can render the same "provider missing" UX as /rule-generate."""
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    _stub_workflow_service(monkeypatch, raises=ProviderTokenNotInitError("missing token"))

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        with pytest.raises(ProviderNotInitializeError):
            method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")


def test_workflow_generate_maps_quota_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    from controllers.console.app.error import ProviderQuotaExceededError
    from core.errors.error import QuotaExceededError

    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    _stub_workflow_service(monkeypatch, raises=QuotaExceededError())

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        with pytest.raises(ProviderQuotaExceededError):
            method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")


def test_workflow_generate_maps_model_not_support_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    from controllers.console.app.error import ProviderModelCurrentlyNotSupportError
    from core.errors.error import ModelCurrentlyNotSupportError

    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    _stub_workflow_service(monkeypatch, raises=ModelCurrentlyNotSupportError("not supported"))

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        with pytest.raises(ProviderModelCurrentlyNotSupportError):
            method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")


def test_workflow_generate_maps_invoke_error(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    from controllers.console.app.error import CompletionRequestError
    from graphon.model_runtime.errors.invoke import InvokeError

    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    _stub_workflow_service(monkeypatch, raises=InvokeError("LLM unreachable"))

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        with pytest.raises(CompletionRequestError):
            method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")


def test_workflow_generate_accepts_advanced_chat_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """The payload Literal must accept advanced-chat as well as workflow."""
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    captured: dict = {}

    def _capture(**kwargs):
        captured.update(kwargs)
        return {
            "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
            "message": "",
            "error": "",
        }

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)

    payload = _workflow_generate_payload()
    payload["mode"] = "advanced-chat"
    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=payload,
    ):
        method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert captured["mode"] == "advanced-chat"
    assert captured["instruction"] == "Summarize a URL"
    assert captured["ideal_output"] == "A 3-sentence summary."


def test_workflow_generate_forwards_current_graph_for_refine(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """cmd+k `/refine`: the optional current_graph field reaches the service."""
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    captured: dict = {}

    def _capture(**kwargs):
        captured.update(kwargs)
        return {
            "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
            "message": "",
            "error": "",
        }

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)

    graph = _workflow_graph(node_id="node1")
    payload = _workflow_generate_payload()
    payload["current_graph"] = graph
    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=payload,
    ):
        method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert captured["current_graph"] == graph


def test_workflow_generate_current_graph_defaults_to_none(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Omitting current_graph (the `/create` path) forwards None to the service."""
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    captured: dict = {}

    def _capture(**kwargs):
        captured.update(kwargs)
        return {
            "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
            "message": "",
            "error": "",
        }

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)

    with app.test_request_context(
        "/console/api/workflow-generate",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert captured["current_graph"] is None


def test_workflow_generate_accepts_auto_mode(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 3: the payload Literal must accept ``auto``; the controller forwards
    it unchanged (the service resolves it) and returns the resolved ``mode``."""
    api = generator_module.WorkflowGenerateApi()
    method = _generator_api_unwrap(api.post)

    captured: dict = {}

    def _capture(**kwargs):
        captured.update(kwargs)
        return {
            "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},
            "message": "",
            "error": "",
            "mode": "advanced-chat",
        }

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph", _capture)

    payload = _workflow_generate_payload()
    payload["mode"] = "auto"
    with app.test_request_context("/console/api/workflow-generate", method="POST", json=payload):
        response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert captured["mode"] == "auto"
    assert response["mode"] == "advanced-chat"


# ─ /workflow-generate/suggestions ─────────────────────────────────────────────


def test_generate_instruction_suggestions_parses_and_cleans(monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 1c (i): a mocked default model returning a JSON array is parsed + cleaned."""
    from core.llm_generator import llm_generator as llm_gen_module

    instance = MagicMock()
    instance.invoke_llm.return_value.message.get_text_content.return_value = '["Summarize a URL", "Translate text"]'
    mock_manager = MagicMock()
    mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
    monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
    monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))

    result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
        tenant_id="t1", mode="workflow", count=4
    )

    assert result == ["Summarize a URL", "Translate text"]


def test_generate_instruction_suggestions_dedupes_and_caps(monkeypatch: pytest.MonkeyPatch) -> None:
    """Whitespace / surrounding quotes are stripped, case-insensitive dupes dropped, capped to count."""
    from core.llm_generator import llm_generator as llm_gen_module

    instance = MagicMock()
    instance.invoke_llm.return_value.message.get_text_content.return_value = (
        '["  Summarize a URL  ", "summarize a URL", "\'Translate text\'", "Draft an email", "Extra idea"]'
    )
    mock_manager = MagicMock()
    mock_manager.for_tenant.return_value.get_default_model_instance.return_value = instance
    monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)
    monkeypatch.setattr(llm_gen_module.LLMGenerator, "_build_suggestion_context", staticmethod(lambda _tenant: ""))

    result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(
        tenant_id="t1", mode="advanced-chat", count=3
    )

    assert result == ["Summarize a URL", "Translate text", "Draft an email"]


def test_generate_instruction_suggestions_no_default_model_returns_empty(monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 1c (ii): a missing default model degrades to an empty list, never raising."""
    from core.llm_generator import llm_generator as llm_gen_module

    mock_manager = MagicMock()
    mock_manager.for_tenant.return_value.get_default_model_instance.side_effect = ProviderTokenNotInitError(
        "no default model"
    )
    monkeypatch.setattr(llm_gen_module, "ModelManager", mock_manager)

    result = llm_gen_module.LLMGenerator.generate_workflow_instruction_suggestions(tenant_id="t1", mode="workflow")

    assert result == []


def test_workflow_instruction_suggestions_route_returns_list(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 1c (iii): the route wraps the generator output in {"suggestions": [...]}."""
    api = generator_module.WorkflowInstructionSuggestionsApi()
    method = _generator_api_unwrap(api.post)

    captured: dict = {}

    def _suggest(**kwargs):
        captured.update(kwargs)
        return ["Summarize a URL", "Translate text"]

    monkeypatch.setattr(generator_module.LLMGenerator, "generate_workflow_instruction_suggestions", _suggest)

    with app.test_request_context(
        "/console/api/workflow-generate/suggestions",
        method="POST",
        json={"mode": "workflow", "language": "French", "count": 3},
    ):
        response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")

    assert response == {"suggestions": ["Summarize a URL", "Translate text"]}
    assert captured["mode"] == "workflow"
    assert captured["language"] == "French"
    assert captured["count"] == 3


def test_workflow_instruction_suggestions_route_empty_is_valid_200(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 1c (iii): an empty list is a valid soft-fail response."""
    api = generator_module.WorkflowInstructionSuggestionsApi()
    method = _generator_api_unwrap(api.post)

    monkeypatch.setattr(
        generator_module.LLMGenerator,
        "generate_workflow_instruction_suggestions",
        lambda **_kwargs: [],
    )

    with app.test_request_context(
        "/console/api/workflow-generate/suggestions",
        method="POST",
        json={"mode": "advanced-chat"},
    ):
        response = method(api, WorkflowInstructionSuggestionsPayload.model_validate(request.get_json()), "t1")

    assert response == {"suggestions": []}


# ─ /workflow-generate/stream ──────────────────────────────────────────────────


def _read_sse_frames(response) -> list[dict]:
    """Decode an SSE Response body into its parsed ``data:`` JSON frames."""
    body = response.get_data(as_text=True)
    frames = []
    for chunk in body.strip().split("\n\n"):
        chunk = chunk.strip()
        if chunk.startswith("data: "):
            frames.append(json.loads(chunk[len("data: ") :]))
    return frames


def test_workflow_generate_stream_emits_plan_then_result(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 2c: the stream endpoint writes one SSE frame per service event."""
    api = generator_module.WorkflowGenerateStreamApi()
    method = _generator_api_unwrap(api.post)

    def _stream(**_kwargs):
        yield ("plan", {"title": "Summarizer", "mode": "workflow", "nodes": []})
        yield ("result", {"graph": _workflow_graph(), "error": "", "mode": "workflow"})

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)

    with app.test_request_context(
        "/console/api/workflow-generate/stream",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
        assert response.mimetype == "text/event-stream"
        frames = _read_sse_frames(response)

    assert [f["event"] for f in frames] == ["plan", "result"]
    assert frames[0]["title"] == "Summarizer"
    assert frames[1]["mode"] == "workflow"


def test_workflow_generate_stream_provider_error_emits_result_event(
    app: Flask, monkeypatch: pytest.MonkeyPatch
) -> None:
    """Task 2c: a provider-init error becomes a single MODEL_ERROR result frame, not a non-SSE error."""
    api = generator_module.WorkflowGenerateStreamApi()
    method = _generator_api_unwrap(api.post)

    def _stream(**_kwargs):
        raise ProviderTokenNotInitError("missing token")
        yield  # pragma: no cover - marks this a generator

    monkeypatch.setattr(generator_module.WorkflowGeneratorService, "generate_workflow_graph_stream", _stream)

    with app.test_request_context(
        "/console/api/workflow-generate/stream",
        method="POST",
        json=_workflow_generate_payload(),
    ):
        response = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")
        frames = _read_sse_frames(response)

    assert len(frames) == 1
    assert frames[0]["event"] == "result"
    assert frames[0]["errors"][0]["code"] == "MODEL_ERROR"
    assert frames[0]["graph"]["nodes"] == []


def test_workflow_generate_stream_rejects_empty_instruction(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    """Task 2c: empty instructions get a normal 400 JSON BEFORE the stream opens."""
    api = generator_module.WorkflowGenerateStreamApi()
    method = _generator_api_unwrap(api.post)

    payload = _workflow_generate_payload()
    payload["instruction"] = "   "
    with app.test_request_context("/console/api/workflow-generate/stream", method="POST", json=payload):
        response, status = method(api, WorkflowGeneratePayload.model_validate(request.get_json()), "t1")

    assert status == 400
    assert response["errors"][0]["code"] == "EMPTY_INSTRUCTION"


def _generator_api_missing_unwrap(func):
    """Unwrap a decorated function to test it directly."""
    while hasattr(func, "__wrapped__"):
        func = func.__wrapped__
    return func


def _generator_api_missing_model_config_payload():
    return {
        "provider": "test_provider",
        "name": "test_model",
        "mode": "chat",
        "completion_params": {},
    }


def test_rule_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.RuleGenerateApi()
    method = _generator_api_missing_unwrap(api.post)

    exceptions_to_test = [
        (ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
        (QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
        (ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
        (InvokeError("invoke error"), generator_module.CompletionRequestError),
    ]

    for err_to_raise, expected_exception in exceptions_to_test:

        def _raise(*_args, _err=err_to_raise, **_kwargs):
            raise _err

        monkeypatch.setattr(generator_module.LLMGenerator, "generate_rule_config", _raise)

        with app.test_request_context(
            "/console/api/rule-generate",
            method="POST",
            json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
        ):
            with pytest.raises(expected_exception):
                method(api, RuleGeneratePayload.model_validate(request.get_json()), "t1")


def test_rule_code_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.RuleCodeGenerateApi()
    method = _generator_api_missing_unwrap(api.post)

    exceptions_to_test = [
        (QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
        (ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
        (InvokeError("invoke error"), generator_module.CompletionRequestError),
    ]

    for err_to_raise, expected_exception in exceptions_to_test:

        def _raise(*_args, _err=err_to_raise, **_kwargs):
            raise _err

        monkeypatch.setattr(generator_module.LLMGenerator, "generate_code", _raise)

        with app.test_request_context(
            "/console/api/rule-code-generate",
            method="POST",
            json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
        ):
            with pytest.raises(expected_exception):
                method(api, RuleCodeGeneratePayload.model_validate(request.get_json()), "t1")


def test_structured_output_generate_exceptions(app: Flask, monkeypatch: pytest.MonkeyPatch) -> None:
    api = generator_module.RuleStructuredOutputGenerateApi()
    method = _generator_api_missing_unwrap(api.post)

    exceptions_to_test = [
        (ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
        (QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
        (ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
        (InvokeError("invoke error"), generator_module.CompletionRequestError),
    ]

    for err_to_raise, expected_exception in exceptions_to_test:

        def _raise(*_args, _err=err_to_raise, **_kwargs):
            raise _err

        monkeypatch.setattr(generator_module.LLMGenerator, "generate_structured_output", _raise)

        with app.test_request_context(
            "/console/api/structured-output-generate",
            method="POST",
            json={"instruction": "do it", "model_config": _generator_api_missing_model_config_payload()},
        ):
            with pytest.raises(expected_exception):
                method(api, RuleStructuredOutputPayload.model_validate(request.get_json()), "t1")


@pytest.mark.parametrize("sqlite_session", [()], indirect=True)
def test_instruction_generate_exceptions(
    app: Flask,
    monkeypatch: pytest.MonkeyPatch,
    sqlite_session: Session,
) -> None:
    api = generator_module.InstructionGenerateApi()
    method = _generator_api_missing_unwrap(api.post)

    exceptions_to_test = [
        (ProviderTokenNotInitError("token error"), generator_module.ProviderNotInitializeError),
        (QuotaExceededError("quota error"), generator_module.ProviderQuotaExceededError),
        (ModelCurrentlyNotSupportError("model error"), generator_module.ProviderModelCurrentlyNotSupportError),
        (InvokeError("invoke error"), generator_module.CompletionRequestError),
    ]

    for err_to_raise, expected_exception in exceptions_to_test:

        def _raise(*_args, _err=err_to_raise, **_kwargs):
            raise _err

        monkeypatch.setattr(generator_module.LLMGenerator, "instruction_modify_legacy", _raise)

        with app.test_request_context(
            "/console/api/instruction-generate",
            method="POST",
            json={
                "flow_id": "app-1",
                "node_id": "",
                "current": "old",
                "instruction": "do it",
                "model_config": _generator_api_missing_model_config_payload(),
            },
        ):
            with pytest.raises(expected_exception):
                method(api, InstructionGeneratePayload.model_validate(request.get_json()), sqlite_session, "t1")