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.

refactor(api): separate suggested question model preparation and invocation (#42966)

非法操作fb7b00365ced
diff --git a/api/core/llm_generator/llm_generator.py b/api/core/llm_generator/llm_generator.py
index 2ea9bf0af39..d4104e3c67f 100644
--- a/api/core/llm_generator/llm_generator.py
+++ b/api/core/llm_generator/llm_generator.py
@@ -2,6 +2,7 @@ import json
import logging
import re
from collections.abc import Sequence
+from dataclasses import dataclass
from typing import Any, Literal, NotRequired, Protocol, TypedDict, cast
import json_repair
@@ -55,6 +56,14 @@ class SuggestedQuestionsModelConfig(TypedDict):
completion_params: NotRequired[dict[str, object]]
+@dataclass(frozen=True)
+class PreparedSuggestedQuestionsModel:
+ """Resolved model credentials; ``None`` parameters select the default-model tuning."""
+
+ model_instance: ModelInstance
+ completion_params: dict[str, object] | None
+
+
def _normalize_completion_params(completion_params: dict[str, object]) -> tuple[dict[str, object], list[str]]:
"""
Normalize raw completion params into invocation parameters and stop sequences.
@@ -305,13 +314,26 @@ class LLMGenerator:
instruction_prompt: str | None = None,
model_config: object | None = None,
) -> Sequence[str]:
- output_parser = SuggestedQuestionsAfterAnswerOutputParser(instruction_prompt=instruction_prompt)
- format_instructions = output_parser.get_format_instructions()
-
- prompt_template = PromptTemplateParser(template="{{histories}}\n{{format_instructions}}\nquestions:\n")
+ prepared_model = cls.prepare_suggested_questions_model(tenant_id, model_config=model_config)
+ if prepared_model is None:
+ return []
+ return cls.invoke_suggested_questions_after_answer(
+ prepared_model, histories, instruction_prompt=instruction_prompt
+ )
- prompt = prompt_template.format({"histories": histories, "format_instructions": format_instructions})
+ @classmethod
+ @with_credit_usage_created_by(CreditUsageCreatedBy.SUGGESTED_QUESTIONS)
+ def prepare_suggested_questions_model(
+ cls,
+ tenant_id: str,
+ *,
+ model_config: object | None = None,
+ ) -> PreparedSuggestedQuestionsModel | None:
+ """Resolve the model before its caller releases database sessions.
+ ``None`` means no usable configured or default model was found. Schema
+ inspection and generation belong to invocation, after the read phase.
+ """
try:
model_manager = ModelManager.for_tenant(tenant_id=tenant_id)
configured_model = cast(dict[str, object], model_config) if isinstance(model_config, dict) else {}
@@ -346,7 +368,33 @@ class LLMGenerator:
)
except Exception:
logger.exception("Failed to resolve the suggested-questions model")
- return []
+ return None
+
+ completion_params: dict[str, object] | None = None
+ if use_configured_model:
+ configured_completion_params = configured_model.get("completion_params")
+ completion_params = (
+ dict(configured_completion_params) if isinstance(configured_completion_params, dict) else {}
+ )
+ return PreparedSuggestedQuestionsModel(
+ model_instance=model_instance,
+ completion_params=completion_params,
+ )
+
+ @classmethod
+ @with_credit_usage_created_by(CreditUsageCreatedBy.SUGGESTED_QUESTIONS)
+ def invoke_suggested_questions_after_answer(
+ cls,
+ prepared_model: PreparedSuggestedQuestionsModel,
+ histories: str,
+ *,
+ instruction_prompt: str | None = None,
+ ) -> Sequence[str]:
+ """Generate with an already resolved model without repeating model resolution."""
+ output_parser = SuggestedQuestionsAfterAnswerOutputParser(instruction_prompt=instruction_prompt)
+ format_instructions = output_parser.get_format_instructions()
+ prompt_template = PromptTemplateParser(template="{{histories}}\n{{format_instructions}}\nquestions:\n")
+ prompt = prompt_template.format({"histories": histories, "format_instructions": format_instructions})
prompt_messages: list[PromptMessage] = [UserPromptMessage(content=prompt)]
@@ -355,12 +403,9 @@ class LLMGenerator:
try:
model_parameters: dict[str, object]
stop: list[str]
- configured_completion_params = configured_model.get("completion_params")
- if use_configured_model and isinstance(configured_completion_params, dict):
- model_parameters, stop = _normalize_completion_params(configured_completion_params)
- elif use_configured_model:
- model_parameters = {}
- stop = []
+ model_instance = prepared_model.model_instance
+ if prepared_model.completion_params is not None:
+ model_parameters, stop = _normalize_completion_params(prepared_model.completion_params)
else:
# Default-model generation keeps the built-in suggested-questions tuning.
model_parameters = _default_suggested_questions_model_parameters(model_instance)
diff --git a/api/tests/unit_tests/core/llm_generator/test_llm_generator.py b/api/tests/unit_tests/core/llm_generator/test_llm_generator.py
index 511102eeba9..617c45b3e98 100644
--- a/api/tests/unit_tests/core/llm_generator/test_llm_generator.py
+++ b/api/tests/unit_tests/core/llm_generator/test_llm_generator.py
@@ -12,10 +12,13 @@ import pytest
from sqlalchemy.orm import Session, scoped_session, sessionmaker
from core.app.app_config.entities import ModelConfig
+from core.app.entities.app_invoke_entities import CreditUsageCreatedBy
from core.llm_generator import llm_generator as llm_generator_module
from core.llm_generator.entities import RuleCodeGeneratePayload, RuleGeneratePayload, RuleStructuredOutputPayload
from core.llm_generator.llm_generator import LLMGenerator
+from core.model_context import get_credit_usage_metadata
from core.model_manager import ModelInstance, ModelManager
+from core.plugin.impl.base import _get_plugin_daemon_request_timeout
from graphon.enums import WorkflowNodeExecutionStatus
from graphon.model_runtime.entities.llm_entities import LLMMode, LLMResult, LLMUsage
from graphon.model_runtime.entities.message_entities import AssistantPromptMessage
@@ -463,6 +466,62 @@ class TestLLMGenerator:
assert invoke_kwargs["model_parameters"] == {"temperature": 0.2}
assert invoke_kwargs["stop"] == ["END"]
+ @pytest.mark.parametrize("use_configured_model", [False, True])
+ def test_prepared_suggested_questions_defer_provider_calls_without_resolving_again(
+ self, monkeypatch: pytest.MonkeyPatch, use_configured_model: bool
+ ) -> None:
+ model_instance = Mock(spec=ModelInstance)
+ model_instance.get_model_schema.return_value.parameter_rules = []
+ manager = Mock(spec=ModelManager)
+ manager.get_model_instance.return_value = model_instance
+ manager.get_default_model_instance.return_value = model_instance
+ resolve_manager = Mock(return_value=manager)
+ monkeypatch.setattr(ModelManager, "for_tenant", resolve_manager)
+ original_metadata = get_credit_usage_metadata()
+ original_timeout = _get_plugin_daemon_request_timeout()
+
+ def invoke(**_kwargs: object) -> LLMResult:
+ metadata = get_credit_usage_metadata()
+ assert metadata is not None
+ assert metadata["created_by"] == CreditUsageCreatedBy.SUGGESTED_QUESTIONS
+ timeout = _get_plugin_daemon_request_timeout()
+ assert timeout is not None
+ assert timeout.read == 30.0
+ return _llm_result('["Next question?"]')
+
+ model_instance.invoke_llm.side_effect = invoke
+ model_config = (
+ {
+ "provider": "openai",
+ "name": "custom-model",
+ "completion_params": {"temperature": 0.2, "stop": ["END"], "max_tokens": 0},
+ }
+ if use_configured_model
+ else None
+ )
+ prepared_model = LLMGenerator.prepare_suggested_questions_model("tenant_id", model_config=model_config)
+
+ assert prepared_model is not None
+ model_instance.get_model_schema.assert_not_called()
+ model_instance.invoke_llm.assert_not_called()
+ resolve_manager.side_effect = AssertionError("Model lookup must finish in the preparation phase")
+
+ result = LLMGenerator.invoke_suggested_questions_after_answer(
+ prepared_model, "Human: hello\nAssistant: world", instruction_prompt="Ask a follow-up"
+ )
+
+ assert result == ["Next question?"]
+ parameters = model_instance.invoke_llm.call_args.kwargs
+ assert parameters["model_parameters"] == (
+ {"temperature": 0.2} if use_configured_model else {"max_tokens": 256, "temperature": 0.0}
+ )
+ assert parameters["stop"] == (["END"] if use_configured_model else [])
+ assert parameters["stream"] is False
+ assert "Human: hello\nAssistant: world" in parameters["prompt_messages"][0].content
+ assert "Ask a follow-up" in parameters["prompt_messages"][0].content
+ assert get_credit_usage_metadata() == original_metadata
+ assert _get_plugin_daemon_request_timeout() == original_timeout
+
def test_generate_rule_config_no_variable_success(self, mock_model_instance, model_config_entity):
payload = RuleGeneratePayload(
instruction="test instruction", model_config=model_config_entity, no_variable=True