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.
Python agentagentic-aiagentic-frameworkagentic-workflowaiautomationclaudedeepseekgenaigptllmlow-codemcpnextjsno-codeopenaipythonskillsworkflow
test: replace 50 workflow, catalogue and token lock doubles (#43575)
Asuka Minato2a598012d199
diff --git a/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py b/api/tests/unit_tests/core/app/apps/completion/test_app_runner.pyindex c0f25df1dee..1203f2c69d2 100644--- a/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py+++ b/api/tests/unit_tests/core/app/apps/completion/test_app_runner.py@@ -1,13 +1,14 @@-from collections.abc import Callable, Iterator+from collections.abc import Callable, Generator, Iteratorfrom dataclasses import dataclass, fieldfrom decimal import Decimalimport pytest+from flask import Flaskfrom redis import Redisfrom sqlalchemy import event+from sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session-import core.app.apps.completion.app_runner as modulefrom core.app.app_config.entities import (AppAdditionalFeatures,DatasetEntity,@@ -22,20 +23,34 @@ from core.app.apps.completion.app_runner import CompletionAppRunnerfrom core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManagerfrom core.app.entities.app_invoke_entities import CompletionAppGenerateEntity, InvokeFromfrom core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy-from core.model_manager import ModelInstance, ModelManager+from core.entities.provider_configuration import ProviderModelBundle+from core.entities.provider_entities import CustomProviderConfigurationfrom core.moderation.base import ModerationError-from core.rag.retrieval.dataset_retrieval import DatasetRetrieval+from core.plugin.impl.model import PluginModelClient+from core.plugin.impl.model_runtime import PluginModelRuntime+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime+from core.provider_manager import ProviderManager+from extensions.ext_database import dbfrom extensions.ext_redis import RedisClientWrapperfrom graphon.file import FileUploadConfigfrom graphon.file.models import ImageConfig-from graphon.model_runtime.entities.message_entities import ImagePromptMessageContent+from graphon.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta+from graphon.model_runtime.entities.message_entities import (+ AssistantPromptMessage,+ ImagePromptMessageContent,+ UserPromptMessage,+)from graphon.model_runtime.entities.model_entities import ModelType+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel+from models.dataset import Datasetfrom models.enums import ConversationFromSourcefrom models.model import App, AppMode, Conversation, IconType, Message+from services.knowledge.external.service import ExternalDatasetServicefrom tests.unit_tests.core.model_fixtures import make_model_configAPP_ID = "00000000-0000-0000-0000-000000000001"TENANT_ID = "00000000-0000-0000-0000-000000000002"+PROVIDER = "langgenius/openai/openai"@dataclass(frozen=True)@@ -44,6 +59,16 @@ class RecordedCall:kwargs: dict[str, object]+def record_delegated_calls[**P, R](function: Callable[P, R], calls: list[RecordedCall]) -> Callable[P, R]:+ """Record arguments without replacing the production method's behavior."""++ def recorded(*args: P.args, **kwargs: P.kwargs) -> R:+ calls.append(RecordedCall(args=args, kwargs=kwargs))+ return function(*args, **kwargs)++ return recorded++@dataclassclass CallRecorder:result: object = None@@ -70,6 +95,7 @@ def queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQuredis = RedisClientWrapper()redis.initialize(client)monkeypatch.setattr("core.app.apps.base_app_queue_manager.redis_client", redis)+ monkeypatch.setattr("core.plugin.impl.model_runtime.redis_client", redis)yield MessageBasedAppQueueManager(task_id="task",user_id="user",@@ -80,52 +106,73 @@ def queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQu)-class RecordingDatasetRetrieval(DatasetRetrieval):- def __init__(self, result: tuple[object, list[object]]) -> None:- self.result = result- self.calls: list[RecordedCall] = []-- def retrieve(self, *args: object, **kwargs: object) -> tuple[object, list[object]]:- self.calls.append(RecordedCall(args=args, kwargs=kwargs))- return self.result---class RecordingModelInstance(ModelInstance):- def __init__(self, result: object = "invoke_result", implementation: Callable[..., object] | None = None) -> None:- self.result = result- self.implementation = implementation- self.calls: list[RecordedCall] = []-- def invoke_llm(self, *args: object, **kwargs: object) -> object:- self.calls.append(RecordedCall(args=args, kwargs=kwargs))- if self.implementation is not None:- return self.implementation(*args, **kwargs)- return self.result+def model_runtime(monkeypatch: pytest.MonkeyPatch) -> tuple[ProviderModelBundle, list[RecordedCall], list[str]]:+ """Run the real manager, model, runtime and client; isolate configuration lookup and daemon I/O."""+ config = make_model_config(provider=PROVIDER, model="model", mode="completion")+ bundle = config.provider_model_bundle+ bundle.configuration.tenant_id = TENANT_ID+ bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={"api_key": "token"})+ bundle.model_type_instance = LargeLanguageModel(+ provider_schema=bundle.configuration.provider,+ model_runtime=create_plugin_model_runtime(tenant_id=TENANT_ID),+ )+ calls: list[RecordedCall] = []+ events: list[str] = []++ def provider_bundle(+ _manager: ProviderManager, *, tenant_id: str, provider: str, model_type: ModelType+ ) -> ProviderModelBundle:+ assert (tenant_id, provider, model_type) == (TENANT_ID, PROVIDER, ModelType.LLM)+ return bundle++ def dispatch(_client: PluginModelClient, **kwargs: object) -> Generator[LLMResultChunk]:+ calls.append(RecordedCall(args=(), kwargs=kwargs))+ events.append("invoke")+ events.append("first-chunk")+ yield LLMResultChunk(+ model="model",+ delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content="answer")),+ )+ monkeypatch.setattr(ProviderManager, "get_provider_model_bundle", provider_bundle)+ monkeypatch.setattr(PluginModelRuntime, "invoke_llm", record_delegated_calls(PluginModelRuntime.invoke_llm, calls))+ monkeypatch.setattr(PluginModelClient, "_request_with_plugin_daemon_response_stream", dispatch)+ monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: config.model_schema)+ return bundle, calls, events-class RecordingModelManager(ModelManager):- def __init__(self, model_instance: RecordingModelInstance) -> None:- self.model_instance = model_instance- self.calls: list[RecordedCall] = []- def get_model_instance(self, *args: object, **kwargs: object) -> RecordingModelInstance:- self.calls.append(RecordedCall(args=args, kwargs=kwargs))- return self.model_instance+def retrieval_app(sqlite_engine: Engine) -> Iterator[Flask]:+ """Bind the real Flask database extension for independent retrieval audit writes."""+ app = Flask(__name__)+ app.config["SQLALCHEMY_DATABASE_URI"] = sqlite_engine.url+ db.init_app(app)+ with app.app_context():+ try:+ yield app+ finally:+ db.engine.dispose()@pytest.fixture-def runner():+def runner() -> CompletionAppRunner:return CompletionAppRunner()-def _build_app_config(dataset=None, external_tools=None, additional_features=None):+def _build_app_config(+ dataset: DatasetEntity | None = None,+ external_tools: list[ExternalDataVariableEntity] | None = None,+ additional_features: AppAdditionalFeatures | None = None,+) -> CompletionAppConfig:+ """None disables the corresponding optional retrieval, external-tool or feature configuration."""return CompletionAppConfig(app_id=APP_ID,tenant_id=TENANT_ID,app_mode=AppMode.COMPLETION,app_model_config_from=EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG,app_model_config_id="model-config",- model=ModelConfigEntity(provider="provider", model="model", mode="completion"),+ model=ModelConfigEntity(provider=PROVIDER, model="model", mode="completion"),prompt_template=PromptTemplateEntity(prompt_type=PromptTemplateEntity.PromptType.SIMPLE,simple_prompt_template="Answer the query.",@@ -137,8 +184,11 @@ def _build_app_config(dataset=None, external_tools=None, additional_features=Non)-def _build_generate_entity(app_config, file_upload_config=None):- model_conf = make_model_config(provider="provider", model="model", mode="completion")+def _build_generate_entity(+ app_config: CompletionAppConfig, file_upload_config: FileUploadConfig | None = None+) -> CompletionAppGenerateEntity:+ """None leaves uploads unconfigured so the runner uses its default image detail."""+ model_conf = make_model_config(provider=PROVIDER, model="model", mode="completion")model_conf.parameters = {"max_tokens": 10}model_conf.stop = ["stop"]return CompletionAppGenerateEntity(@@ -204,7 +254,9 @@ def _persist_records(session: Session) -> tuple[App, Message]:class TestCompletionAppRunner:- def test_run_app_not_found(self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager):+ def test_run_app_not_found(+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager+ ) -> None:app_config = _build_app_config()app_generate_entity = _build_generate_entity(app_config)@@ -212,8 +264,8 @@ class TestCompletionAppRunner:runner.run(app_generate_entity, queue_manager, _message(), sqlite_session)def test_run_moderation_error_outputs_direct(- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager- ):+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager+ ) -> None:_, message = _persist_records(sqlite_session)app_config = _build_app_config()@@ -232,8 +284,8 @@ class TestCompletionAppRunner:assert handle_invoke_result.calls == []def test_run_hosting_moderation_stops(- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager- ):+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager+ ) -> None:_, message = _persist_records(sqlite_session)app_config = _build_app_config()@@ -253,12 +305,19 @@ class TestCompletionAppRunner:def test_run_dataset_and_external_tools_flow(self,- runner,+ runner: CompletionAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,queue_manager: MessageBasedAppQueueManager,- ):+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],+ retrieval_app: Flask,+ ) -> None:_, message = _persist_records(sqlite_session)+ dataset = Dataset(+ id="ds", tenant_id=TENANT_ID, name="External knowledge", provider="external", created_by="user"+ )+ sqlite_session.add(dataset)+ sqlite_session.commit()retrieve_config = DatasetRetrieveConfigEntity(query_variable="qvar",@@ -276,9 +335,10 @@ class TestCompletionAppRunner:app_generate_entity = _build_generate_entity(app_config, file_upload_config=file_upload_config)- runner.organize_prompt_messages = CallRecorder( # type: ignore[method-assign]- results=[(["pm1"], ["stop"]), (["pm2"], ["stop"])]+ organize_prompt_messages = CallRecorder(+ results=[([UserPromptMessage(content="pm1")], ["stop"]), ([UserPromptMessage(content="pm2")], ["stop"])])+ runner.organize_prompt_messages = organize_prompt_messages # type: ignore[method-assign]runner.moderation_for_inputs = CallRecorder( # type: ignore[method-assign]result=(None, app_generate_entity.inputs, "query"))@@ -290,31 +350,37 @@ class TestCompletionAppRunner:handle_invoke_result = CallRecorder()runner._handle_invoke_result = handle_invoke_result # type: ignore[method-assign]- dataset_retrieval = RecordingDatasetRetrieval(("ctx", ["file1"]))- monkeypatch.setattr(module, "DatasetRetrieval", lambda _: dataset_retrieval)+ retrieval_calls: list[dict[str, object]] = []- model_instance = RecordingModelInstance()- model_manager = RecordingModelManager(model_instance)- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(lambda tenant_id: model_manager))+ def retrieve_external(**kwargs: object) -> list[dict[str, object]]:+ retrieval_calls.append(kwargs)+ return [{"content": "ctx", "metadata": {}, "score": 1.0, "title": "Document"}]++ monkeypatch.setattr(ExternalDatasetService, "fetch_external_knowledge_retrieval", retrieve_external)runner.run(app_generate_entity, queue_manager, message, sqlite_session)- assert len(dataset_retrieval.calls) == 1- assert dataset_retrieval.calls[0].kwargs["query"] == "query_from_input"+ assert len(retrieval_calls) == 1+ assert retrieval_calls[0]["query"] == "query_from_input"+ assert retrieval_calls[0]["tenant_id"] == TENANT_ID+ assert retrieval_calls[0]["dataset_id"] == dataset.id+ assert organize_prompt_messages.calls[-1].kwargs["context"] == "ctx"+ assert organize_prompt_messages.calls[-1].kwargs["context_files"] == []assert len(handle_invoke_result.calls) == 1def test_run_closes_explicit_session_before_stream_consumption(self,- runner,+ runner: CompletionAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,queue_manager: MessageBasedAppQueueManager,- ):+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],+ ) -> None:_, message = _persist_records(sqlite_session)app_config = _build_app_config()app_generate_entity = _build_generate_entity(app_config)- events = []+ _, _, events = model_runtimesession = sqlite_sessionoriginal_close = session.close@@ -334,17 +400,6 @@ class TestCompletionAppRunner:handle_invoke_result = CallRecorder(implementation=lambda invoke_result, **kwargs: list(invoke_result))runner._handle_invoke_result = handle_invoke_result # type: ignore[method-assign]- def invoke_stream():- events.append("first-chunk")- yield "chunk"-- def invoke_llm(**kwargs):- events.append("invoke")- return invoke_stream()-- model_instance = RecordingModelInstance(implementation=invoke_llm)- model_manager = RecordingModelManager(model_instance)- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(lambda tenant_id: model_manager))monkeypatch.setattr(session, "close", record_close)event.listen(session, "after_commit", record_commit)@@ -370,64 +425,80 @@ class TestCompletionAppRunner:@pytest.mark.parametrize("stream", [False, True])def test_run_invokes_model_resolved_by_model_manager(self,- runner,- monkeypatch: pytest.MonkeyPatch,+ runner: CompletionAppRunner,sqlite_session: Session,stream: bool,queue_manager: MessageBasedAppQueueManager,- ):+ model_runtime: tuple[ProviderModelBundle, list[RecordedCall], list[str]],+ ) -> None:_, message = _persist_records(sqlite_session)app_config = _build_app_config()app_generate_entity = _build_generate_entity(app_config)app_generate_entity.stream = stream- runner.organize_prompt_messages = CallRecorder(result=(["prompt"], ["stop"])) # type: ignore[method-assign]+ runner.organize_prompt_messages = CallRecorder( # type: ignore[method-assign]+ result=([UserPromptMessage(content="prompt")], ["stop"])+ )runner.moderation_for_inputs = CallRecorder( # type: ignore[method-assign]result=(None, app_generate_entity.inputs, "query"))runner.check_hosting_moderation = CallRecorder(result=False) # type: ignore[method-assign]runner.recalc_llm_max_tokens = CallRecorder() # type: ignore[method-assign]- runner._handle_invoke_result = CallRecorder() # type: ignore[method-assign]+ results: list[LLMResult | list[LLMResultChunk]] = []++ def handle_result(invoke_result: LLMResult | Generator[LLMResultChunk], **_kwargs: object) -> None:+ results.append(invoke_result if isinstance(invoke_result, LLMResult) else list(invoke_result))- model_instance = RecordingModelInstance()- model_manager = RecordingModelManager(model_instance)- model_manager_factory = CallRecorder(result=model_manager)- monkeypatch.setattr(module.ModelManager, "for_tenant", staticmethod(model_manager_factory))+ runner._handle_invoke_result = handle_result # type: ignore[method-assign]runner.run(app_generate_entity, queue_manager, message, sqlite_session)- assert model_manager_factory.calls == [RecordedCall(args=(), kwargs={"tenant_id": TENANT_ID})]- assert model_manager.calls == [- RecordedCall(- args=(),- kwargs={- "tenant_id": TENANT_ID,- "provider": "provider",- "model_type": ModelType.LLM,- "model": "model",- },- )- ]- assert model_instance.calls == [+ bundle, calls, _ = model_runtime+ assert bundle.configuration.tenant_id == TENANT_ID+ assert len(calls) == 2+ assert isinstance(calls[0].args[0], PluginModelRuntime)+ assert calls[0].kwargs["request_metadata"] == {+ "app_id": APP_ID,+ "app_type": CreditUsageAppType.COMPLETION,+ "created_by": CreditUsageCreatedBy.APP,+ }+ assert calls[1:] == [RecordedCall(args=(),kwargs={- "prompt_messages": ["prompt"],- "model_parameters": {"max_tokens": 10},- "stop": ["stop"],- "stream": stream,- "request_metadata": {+ "method": "POST",+ "path": f"plugin/{TENANT_ID}/dispatch/llm/invoke",+ "type_": LLMResultChunk,+ "headers": {"X-Plugin-ID": "langgenius/openai", "Content-Type": "application/json"},+ "data": {"app_id": APP_ID,- "app_type": CreditUsageAppType.COMPLETION,- "created_by": CreditUsageCreatedBy.APP,+ "data": {+ "provider": "openai",+ "model_type": "llm",+ "model": "model",+ "credentials": {"api_key": "token"},+ "prompt_messages": [{"role": "user", "content": "prompt", "name": None}],+ "model_parameters": {"max_tokens": 10},+ "tools": None,+ "stop": ["stop"],+ "stream": stream,+ },},},)]+ assert len(results) == 1+ result = results[0]+ if stream:+ assert isinstance(result, list)+ assert result[0].delta.message.content == "answer"+ else:+ assert isinstance(result, LLMResult)+ assert result.message.content == "answer"def test_run_uses_low_image_detail_default(- self, runner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager- ):+ self, runner: CompletionAppRunner, sqlite_session: Session, queue_manager: MessageBasedAppQueueManager+ ) -> None:_, message = _persist_records(sqlite_session)app_config = _build_app_config()diff --git a/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py b/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.pyindex 74043747f5c..bc0a02aa596 100644--- a/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py+++ b/api/tests/unit_tests/core/workflow/generator/test_tool_catalogue.py@@ -1,10 +1,24 @@"""Unit tests for the tool catalogue helpers."""-from types import SimpleNamespace-from unittest.mock import patch-+import pytest++from core.tools.__base.tool_runtime import ToolRuntime+from core.tools.builtin_tool.provider import BuiltinToolProviderController+from core.tools.builtin_tool.providers.time.time import WikiPediaProvider+from core.tools.builtin_tool.providers.time.tools.current_time import CurrentTimeTool+from core.tools.builtin_tool.tool import BuiltinTool+from core.tools.custom_tool.provider import ApiToolProviderControllerfrom core.tools.entities.common_entities import I18nObject-from core.tools.entities.tool_entities import ToolDescription+from core.tools.entities.tool_entities import (+ ToolDescription,+ ToolEntity,+ ToolIdentity,+ ToolProviderEntity,+ ToolProviderEntityWithPlugin,+ ToolProviderIdentity,+)+from core.tools.plugin_tool.provider import PluginToolProviderController+from core.tools.tool_manager import ToolManagerfrom core.workflow.generator.tool_catalogue import (MAX_ROUTED_TOOL_CANDIDATES,MAX_ROUTED_TOOLS_PER_PROVIDER,@@ -44,10 +58,10 @@ class TestInstalledToolKeys:``plugin_id`` or any other identifier."""- def test_empty_input_returns_empty_set(self):+ def test_empty_input_returns_empty_set(self) -> None:assert installed_tool_keys([]) == set()- def test_returns_provider_tool_tuples(self):+ def test_returns_provider_tool_tuples(self) -> None:keys = installed_tool_keys([_entry("google", "search"),@@ -56,7 +70,7 @@ class TestInstalledToolKeys:)assert keys == {("google", "search"), ("github", "list_issues")}- def test_dedupes_duplicate_entries(self):+ def test_dedupes_duplicate_entries(self) -> None:# Defensive — the catalogue builder dedupes on read, but a duplicate# entry slipping through should collapse rather than break the set# type contract.@@ -65,10 +79,10 @@ class TestInstalledToolKeys:class TestFormatToolCatalogue:- def test_empty_input_returns_empty_string(self):+ def test_empty_input_returns_empty_string(self) -> None:assert format_tool_catalogue([]) == ""- def test_renders_provider_slash_tool_per_line(self):+ def test_renders_provider_slash_tool_per_line(self) -> None:out = format_tool_catalogue([_entry("google", "search", description="Search the web with Google."),@@ -81,7 +95,7 @@ class TestFormatToolCatalogue:'- time/current_time [provider_id="time"; tool_name="current_time"] — Return the current time.',]- def test_includes_label_when_different_from_tool_name(self):+ def test_includes_label_when_different_from_tool_name(self) -> None:out = format_tool_catalogue([_entry("google", "search", label="Google Search", description="Search."),@@ -89,7 +103,7 @@ class TestFormatToolCatalogue:)assert out == '- google/search (Google Search) [provider_id="google"; tool_name="search"] — Search.'- def test_omits_label_when_identical_to_tool_name(self):+ def test_omits_label_when_identical_to_tool_name(self) -> None:out = format_tool_catalogue([_entry("time", "current_time", label="current_time", description="Now."),@@ -97,7 +111,7 @@ class TestFormatToolCatalogue:)assert out == '- time/current_time [provider_id="time"; tool_name="current_time"] — Now.'- def test_caps_only_prompt_text_while_full_inventory_remains_available(self):+ def test_caps_only_prompt_text_while_full_inventory_remains_available(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]out = format_tool_catalogue(entries)@@ -107,7 +121,7 @@ class TestFormatToolCatalogue:assert "tool_080" not in outassert ("provider", "tool_099") in installed_tool_keys(entries)- def test_can_disable_prompt_cap_for_an_already_selected_catalogue(self):+ def test_can_disable_prompt_cap_for_an_already_selected_catalogue(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]out = format_tool_catalogue(entries, max_tools=None)@@ -115,21 +129,21 @@ class TestFormatToolCatalogue:assert len(out.splitlines()) == 100assert "tool_099" in out- def test_truncates_long_descriptions(self):+ def test_truncates_long_descriptions(self) -> None:long_desc = "x" * 200out = format_tool_catalogue([_entry("p", "t", description=long_desc)])# Truncated to 117 chars + "..."assert out.endswith("...")assert len(out.split(" — ", 1)[1]) == 120- def test_strips_newlines_from_descriptions(self):+ def test_strips_newlines_from_descriptions(self) -> None:out = format_tool_catalogue([_entry("p", "t", description="line1\nline2\nline3")])assert "\n" not in out.split(" — ", 1)[1]assert "line1 line2 line3" in outclass TestSelectToolCandidates:- def test_routes_english_capability_query_to_relevant_tool_description(self):+ def test_routes_english_capability_query_to_relevant_tool_description(self) -> None:entries = [*[_entry(f"provider_{index}", "generic", description="Manage generic records.") for index in range(30)],_entry(@@ -150,7 +164,7 @@ class TestSelectToolCandidates:]assert selection.unmatched_queries == []- def test_pins_explicit_identifier_and_existing_refine_tool_without_queries(self):+ def test_pins_explicit_identifier_and_existing_refine_tool_without_queries(self) -> None:entries = [_entry("langgenius/google/google", "search"),_entry("langgenius/time/time", "current_time"),@@ -182,7 +196,7 @@ class TestSelectToolCandidates:]assert selection.pinned_count == 2- def test_explicit_identifier_does_not_also_pin_a_hyphenated_prefix(self):+ def test_explicit_identifier_does_not_also_pin_a_hyphenated_prefix(self) -> None:entries = [_entry("provider", "search"),_entry("provider", "search-web"),@@ -197,7 +211,7 @@ class TestSelectToolCandidates:assert selection.entries == [entries[1]]assert selection.pinned_count == 1- def test_reports_unmatched_capability_for_legacy_fallback(self):+ def test_reports_unmatched_capability_for_legacy_fallback(self) -> None:selection = select_tool_candidates([_entry("records", "list", description="List stored database records.")],[ToolCapabilityQuery(capability="synthesize quantum music", keywords=["qubits", "melody"])],@@ -206,7 +220,7 @@ class TestSelectToolCandidates:assert selection.entries == []assert selection.unmatched_queries == ["synthesize quantum music"]- def test_deduplicates_one_tool_selected_by_multiple_queries(self):+ def test_deduplicates_one_tool_selected_by_multiple_queries(self) -> None:entries = [_entry("langgenius/google/google",@@ -224,7 +238,7 @@ class TestSelectToolCandidates:assert selection.entries == entries- def test_enforces_provider_diversity(self):+ def test_enforces_provider_diversity(self) -> None:words = ["alpha", "bravo", "charlie", "delta", "echo"]entries = [_entry("large_provider", f"{word}_action", description=f"Perform the {word} capability.") for word in words@@ -238,7 +252,7 @@ class TestSelectToolCandidates:)assert selection.entries == select_tool_candidates(entries, queries).entries- def test_500_tool_catalogue_never_exceeds_global_candidate_limit(self):+ def test_500_tool_catalogue_never_exceeds_global_candidate_limit(self) -> None:words = ["alpha", "bravo", "charlie", "delta", "echo"]entries = [_entry(@@ -255,7 +269,7 @@ class TestSelectToolCandidates:assert len(selection.entries) == 15assert len(selection.entries) <= MAX_ROUTED_TOOL_CANDIDATES- def test_legacy_fallback_keeps_explicit_tool_beyond_first_80(self):+ def test_legacy_fallback_keeps_explicit_tool_beyond_first_80(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]selected = select_legacy_fallback_tools(@@ -270,7 +284,7 @@ class TestSelectToolCandidates:class TestLegacyFallbackSelection:- def test_returns_selected_and_omitted_tools(self):+ def test_returns_selected_and_omitted_tools(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]selection = select_legacy_fallback_selection(entries)@@ -281,12 +295,12 @@ class TestLegacyFallbackSelection:assert selection.limit == 80assert selection.overflow_count == 0- def test_keeps_legacy_fallback_tools_compatible(self):+ def test_keeps_legacy_fallback_tools_compatible(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(100)]assert select_legacy_fallback_tools(entries) == select_legacy_fallback_selection(entries).entries- def test_reports_pinned_overflow_without_fabricated_omissions(self):+ def test_reports_pinned_overflow_without_fabricated_omissions(self) -> None:entries = [_entry("provider", f"tool_{index:03d}") for index in range(85)]explicit_text = "Use " + ", ".join(f"provider/{entry['tool_name']}" for entry in entries) + " exactly."@@ -298,7 +312,7 @@ class TestLegacyFallbackSelection:assert selection.limit == 80assert selection.overflow_count == 5- def test_empty_catalogue_has_no_omissions_or_overflow(self):+ def test_empty_catalogue_has_no_omissions_or_overflow(self) -> None:selection = select_legacy_fallback_selection([])assert selection.entries == []@@ -309,13 +323,13 @@ class TestLegacyFallbackSelection:class TestToolBuilderContext:- def test_finds_exact_provider_and_tool_pair(self):+ def test_finds_exact_provider_and_tool_pair(self) -> None:entries = [_entry("google", "search"), _entry("google", "maps")]assert find_tool_entry(entries, "google", "search") == entries[0]assert find_tool_entry(entries, "google", "missing") is None- def test_renders_trusted_identity_and_parameter_contract(self):+ def test_renders_trusted_identity_and_parameter_contract(self) -> None:entry = _entry("langgenius/google/google", "search", label="Google Search", description="Search the web.")entry["plugin_id"] = "langgenius/google"entry["plugin_unique_identifier"] = "langgenius/google:1.0@checksum"@@ -358,130 +372,71 @@ class TestToolBuilderContext:# ── Helpers ──────────────────────────────────────────────────────────────────-class _FakeToolEntity(SimpleNamespace):- """Tool entity exposing ``identity`` + ``description`` like the real thing."""---class _FakeToolIdentity(SimpleNamespace):- """Identity holding ``name`` + ``label`` like ``ToolIdentity``."""---class _FakeTool:- """Tool stand-in: ``.entity`` is the only attribute the catalogue reads."""-- def __init__(self, entity):- self.entity = entity---def _make_tool(name: str, label_en: str = "", description_llm: str = "") -> _FakeTool:- return _FakeTool(- entity=_FakeToolEntity(- identity=_FakeToolIdentity(- name=name,- label=I18nObject(en_US=label_en),- ),+def _make_tool(name: str, label_en: str = "", description_llm: str = "") -> BuiltinTool:+ """Use a real builtin tool with optional empty display metadata."""+ return CurrentTimeTool(+ provider="time",+ runtime=ToolRuntime(tenant_id="tenant-1"),+ entity=ToolEntity(+ identity=ToolIdentity(author="test", provider="time", name=name, label=I18nObject(en_US=label_en)),description=ToolDescription(human=I18nObject(en_US=""), llm=description_llm),- parameters=[],- output_schema={},- )+ ),)-class _FakeProviderType(SimpleNamespace):- """Stand-in for ``ToolProviderType`` — only ``.value`` is read."""+def _make_builtin_provider(name: str, tools: list[BuiltinTool]) -> BuiltinToolProviderController:+ """Load the shipped time provider, then configure its real tool inventory."""+ provider = WikiPediaProvider()+ provider.entity.identity.name = name+ provider.tools = tools+ return provider-def _make_builtin_provider(name: str, tools: list, raises_on_get_tools: bool = False):- """- Build something ``isinstance(..., BuiltinToolProviderController)`` will- answer True to without actually constructing one (those require real- on-disk plugin metadata). We patch the isinstance call sites instead.- """- provider = SimpleNamespace(- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),- provider_type=_FakeProviderType(value="builtin"),- get_tools=((lambda: (_ for _ in ()).throw(RuntimeError("boom"))) if raises_on_get_tools else (lambda: tools)),+def _provider_identity(name: str) -> ToolProviderIdentity:+ return ToolProviderIdentity(+ author="test", name=name, description=I18nObject(en_US=name), icon="", label=I18nObject(en_US=name))- provider._is_builtin = True- return provider-def _make_plugin_provider(name: str, plugin_id: str | None, tools: list):- provider = SimpleNamespace(- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),- provider_type=_FakeProviderType(value="plugin"),+def _make_plugin_provider(name: str, plugin_id: str, tools: list[BuiltinTool]) -> PluginToolProviderController:+ return PluginToolProviderController(+ entity=ToolProviderEntityWithPlugin(identity=_provider_identity(name), tools=[tool.entity for tool in tools]),plugin_id=plugin_id,plugin_unique_identifier=f"{plugin_id}:1.0@checksum" if plugin_id else "",- get_tools=lambda: tools,+ tenant_id="tenant-1",)- provider._is_plugin = True- return provider---def _make_unknown_provider(name: str):- """A provider matching neither class — must be skipped."""- return SimpleNamespace(- entity=SimpleNamespace(identity=SimpleNamespace(name=name)),- provider_type=_FakeProviderType(value="weird"),- get_tools=lambda: [_make_tool("ghost")],- )---def _patched_isinstance(obj, cls):- """- Reroute the isinstance checks ``build_tool_catalogue`` makes onto the fake- providers built above.-- Match the provider classes by ``__name__`` rather than by identity (``is``).- In the full test suite a sibling test that reloads or stubs- ``core.tools.*.provider`` (e.g. via ``sys.modules``) gives the catalogue a- DIFFERENT class object than a fresh ``import`` here would; an ``is`` check- would then miss, every fake provider would fall through to the real- ``isinstance`` and fail it, and the catalogue would come back empty — which- is exactly how this test flaked in CI under parallel execution. A name match- is immune to those reloads. Anything we don't recognise (including tuple- ``cls`` args) defers to the real ``isinstance``.- """- cls_name = getattr(cls, "__name__", "")- if cls_name == "BuiltinToolProviderController":- return bool(getattr(obj, "_is_builtin", False))- if cls_name == "PluginToolProviderController":- return bool(getattr(obj, "_is_plugin", False))- import builtins as _b-- return _b.isinstance(obj, cls)# ── _i18n_text / _tool_description ───────────────────────────────────────────class TestI18nText:- def test_returns_empty_string_when_label_is_none(self):+ def test_returns_empty_string_when_label_is_none(self) -> None:assert _i18n_text(None) == ""- def test_returns_en_us_when_present(self):+ def test_returns_en_us_when_present(self) -> None:assert _i18n_text(I18nObject(en_US="Search", zh_Hans="搜索")) == "Search"- def test_falls_back_to_zh_hans_when_en_us_blank(self):+ def test_falls_back_to_zh_hans_when_en_us_blank(self) -> None:# Some plugins ship only Chinese metadata; falling back keeps the# planner aware of those tools instead of dropping them silently.assert _i18n_text(I18nObject(en_US="", zh_Hans="搜索")) == "搜索"- def test_returns_empty_when_both_locales_are_blank(self):+ def test_returns_empty_when_both_locales_are_blank(self) -> None:assert _i18n_text(I18nObject(en_US="", zh_Hans="")) == ""class TestToolDescription:- def test_returns_empty_string_for_none_description(self):+ def test_returns_empty_string_for_none_description(self) -> None:# ToolEntity.description is Optional — must not raise on absent.assert _tool_description(None) == ""- def test_returns_llm_attribute(self):+ def test_returns_llm_attribute(self) -> None:description = ToolDescription(human=I18nObject(en_US=""), llm="Web search")assert _tool_description(description) == "Web search"- def test_returns_empty_when_llm_is_blank(self):+ def test_returns_empty_when_llm_is_blank(self) -> None:description = ToolDescription(human=I18nObject(en_US=""), llm="")assert _tool_description(description) == ""@@ -494,20 +449,16 @@ class TestBuildToolCatalogue:"""The builder iterates the ``ToolManager.list_builtin_providers`` generator(which already covers both hardcoded and plugin providers in production).- We patch the generator + isinstance so the tests can exercise every branch- without standing up real plugin daemon state.+ Real builtin and plugin controllers retain their constructors and type checks.+ Only provider discovery and intentional failure injection are isolated."""- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_returns_empty_list_for_tenant_with_no_tools(self, mock_list, mock_isinstance):- mock_list.return_value = iter([])+ def test_returns_empty_list_for_tenant_with_no_tools(self, monkeypatch: pytest.MonkeyPatch) -> None:+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([]))assert build_tool_catalogue("tenant-1") == []- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_collects_hardcoded_and_plugin_tools(self, mock_list, mock_isinstance):+ def test_collects_hardcoded_and_plugin_tools(self, monkeypatch: pytest.MonkeyPatch) -> None:# Mixed-tenant scenario: hardcoded provider plus a plugin provider,# each carrying one tool. The catalogue must include all four fields# the workflow tool node will need (provider_name / provider_type /@@ -521,7 +472,7 @@ class TestBuildToolCatalogue:plugin_id="langgenius/google",tools=[_make_tool("search", label_en="Google Search", description_llm="Search the web.")],)- mock_list.return_value = iter([hardcoded, plugin])+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([hardcoded, plugin]))entries = build_tool_catalogue("tenant-1")@@ -542,52 +493,54 @@ class TestBuildToolCatalogue:assert time_entry["provider_type"] == "builtin"assert time_entry["plugin_id"] == ""- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_skips_unknown_provider_classes(self, mock_list, mock_isinstance):+ def test_skips_unknown_provider_classes(self, monkeypatch: pytest.MonkeyPatch) -> None:# If ToolManager ever yields a provider the catalogue doesn't know how# to label, we must continue (not raise) and leave it out of the# output rather than guessing at provider_type.- unknown = _make_unknown_provider("mystery")+ unknown = ApiToolProviderController(+ entity=ToolProviderEntity(identity=_provider_identity("mystery")),+ provider_id="provider-id",+ tenant_id="tenant-1",+ )hardcoded = _make_builtin_provider("time", [_make_tool("now")])- mock_list.return_value = iter([unknown, hardcoded])+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([unknown, hardcoded]))entries = build_tool_catalogue("tenant-1")assert [e["provider_name"] for e in entries] == ["time"]- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_continues_when_a_provider_get_tools_raises(self, mock_list, mock_isinstance):+ def test_continues_when_a_provider_get_tools_raises(self, monkeypatch: pytest.MonkeyPatch) -> None:# A buggy plugin must not break the whole catalogue. Resilient# per-provider try/except is what keeps generation usable in tenants# with broken installs.- bad = _make_builtin_provider("broken", [], raises_on_get_tools=True)+ bad = _make_builtin_provider("broken", [])++ def unavailable() -> list[BuiltinTool]:+ raise RuntimeError("boom")++ monkeypatch.setattr(bad, "get_tools", unavailable)good = _make_builtin_provider("time", [_make_tool("now")])- mock_list.return_value = iter([bad, good])+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([bad, good]))entries = build_tool_catalogue("tenant-1")assert [e["provider_name"] for e in entries] == ["time"]- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_skips_individual_tools_when_their_metadata_is_broken(self, mock_list, mock_isinstance):+ def test_skips_individual_tools_when_their_metadata_is_broken(self, monkeypatch: pytest.MonkeyPatch) -> None:# Per-tool try/except — a single mis-declared tool inside an otherwise# healthy provider gets dropped, the rest still surface.good_tool = _make_tool("ok", label_en="Ok", description_llm="Healthy tool.")- # Bad tool: accessing .entity.identity raises because entity is None.- bad_tool = SimpleNamespace(entity=None)+ # Inject corrupt metadata after normal construction to exercise defensive handling.+ bad_tool = _make_tool("bad")+ monkeypatch.setattr(bad_tool, "entity", None)hardcoded = _make_builtin_provider("p", [bad_tool, good_tool])- mock_list.return_value = iter([hardcoded])+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([hardcoded]))entries = build_tool_catalogue("tenant-1")assert [e["tool_name"] for e in entries] == ["ok"]- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_keeps_complete_inventory_for_validation_beyond_prompt_cap(self, mock_list, mock_isinstance):+ def test_keeps_complete_inventory_for_validation_beyond_prompt_cap(self, monkeypatch: pytest.MonkeyPatch) -> None:# Prompt formatting is capped separately. Dropping entries here would# make the validator falsely report installed tools after the cap as# missing from the workspace.@@ -595,21 +548,20 @@ class TestBuildToolCatalogue:"p",[_make_tool(f"t{i:03d}") for i in range(200)],)- mock_list.return_value = iter([big_provider])+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([big_provider]))entries = build_tool_catalogue("tenant-1")assert len(entries) == 200assert ("p", "t199") in installed_tool_keys(entries)- @patch("core.workflow.generator.tool_catalogue.isinstance", side_effect=_patched_isinstance)- @patch("core.workflow.generator.tool_catalogue.ToolManager.list_builtin_providers")- def test_defaults_plugin_id_to_empty_string_when_missing(self, mock_list, mock_isinstance):+ def test_defaults_plugin_id_to_empty_string_when_missing(self, monkeypatch: pytest.MonkeyPatch) -> None:# Plugin provider whose plugin_id is None should serialise to "" so# the consumer can safely index ``e["plugin_id"]`` without a None# check at every callsite.- plugin = _make_plugin_provider("p", plugin_id=None, tools=[_make_tool("t")])- mock_list.return_value = iter([plugin])+ plugin = _make_plugin_provider("p", plugin_id="", tools=[_make_tool("t")])+ monkeypatch.setattr(plugin, "plugin_id", None)+ monkeypatch.setattr(ToolManager, "list_builtin_providers", lambda _tenant: iter([plugin]))entries = build_tool_catalogue("tenant-1")diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.tomlindex dc569b5be7f..328f893c1ac 100644--- a/api/tests/unit_tests/pyrefly.toml+++ b/api/tests/unit_tests/pyrefly.toml@@ -197,7 +197,6 @@ project-excludes = ["core/app/apps/common/test_workflow_response_converter_human_input.py","core/app/apps/common/test_workflow_response_converter_resumption.py","core/app/apps/common/test_workflow_response_converter_truncation.py",- "core/app/apps/completion/test_app_runner.py","core/app/apps/completion/test_completion_app_config_manager.py","core/app/apps/completion/test_completion_completion_app_generator.py","core/app/apps/completion/test_completion_generate_response_converter.py",@@ -412,7 +411,6 @@ project-excludes = ["core/workflow/generator/test_prompts.py","core/workflow/generator/test_runner.py","core/workflow/generator/test_runner_missing.py",- "core/workflow/generator/test_tool_catalogue.py","core/workflow/graph_engine/layers/conftest.py","core/workflow/graph_engine/layers/test_observability.py","core/workflow/graph_engine/test_mock_config.py",@@ -634,7 +632,6 @@ project-excludes = ["services/test_webhook_service_additional.py","services/test_website_service.py","services/test_workflow_collaboration_service.py",- "services/test_workflow_generator_service.py","services/test_workflow_node_execution_trace_service.py","services/test_workflow_run_service.py","services/test_workflow_run_service_pause.py",diff --git a/api/tests/unit_tests/services/test_api_token_service.py b/api/tests/unit_tests/services/test_api_token_service.pyindex fd07797c0e0..5670552deb9 100644--- a/api/tests/unit_tests/services/test_api_token_service.py+++ b/api/tests/unit_tests/services/test_api_token_service.py@@ -4,15 +4,17 @@ from __future__ import annotationsfrom collections.abc import Iteratorfrom datetime import datetime-from unittest.mock import MagicMock, patch+from unittest.mock import patchfrom uuid import uuid4import pytestfrom flask import Flask+from redis import Redisfrom sqlalchemy.orm import Sessionfrom werkzeug.exceptions import Unauthorizedimport services.api_token_service as api_token_service_module+from extensions.ext_redis import RedisClientWrapperfrom models.engine import dbfrom models.enums import ApiTokenTypefrom models.model import ApiToken@@ -111,8 +113,37 @@ class TestRecordTokenUsage:api_token_service_module.record_token_usage("token-123", "app")+def single_flight_redis(monkeypatch: pytest.MonkeyPatch) -> Iterator[tuple[Redis, list[tuple[object, ...]]]]:+ """Use the real Redis client, wrapper and lock; isolate only wire commands."""+ commands: list[tuple[object, ...]] = []++ def execute(*args: object, **_kwargs: object) -> object:+ commands.append(args)+ assert args[0] in {"SET", "EVALSHA"}+ return True++ with Redis() as client:+ monkeypatch.setattr(client, "execute_command", execute)+ wrapper = RedisClientWrapper()+ wrapper.initialize(client)+ monkeypatch.setattr(api_token_service_module, "redis_client", wrapper)+ yield client, commands+++def _assert_lock_released(commands: list[tuple[object, ...]]) -> None:+ assert len(commands) == 2+ acquire, release = commands+ assert acquire[:2] == ("SET", "api_token_query_lock:app:token-123")+ assert acquire[3:] == ("NX", "PX", 10000)+ assert release[0] == "EVALSHA"+ assert release[2:] == (1, acquire[1], acquire[2]) # Release uses the acquired ownership token.++class TestFetchTokenWithSingleFlight:- def test_should_return_cached_token_when_lock_acquired_and_cache_filled(self):+ def test_should_return_cached_token_when_lock_acquired_and_cache_filled(+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]+ ) -> None:auth_token = "token-123"scope = "app"cached_token = CachedApiToken(@@ -124,69 +155,71 @@ class TestFetchTokenWithSingleFlight:last_used_at=None,created_at=None,)- lock = MagicMock()- lock.acquire.return_value = True+ _client, commands = single_flight_rediswith (- patch.object(api_token_service_module, "redis_client") as mock_redis,patch.object(api_token_service_module.ApiTokenCache, "get", return_value=cached_token),patch.object(api_token_service_module, "query_token_from_db") as mock_query_db,):- mock_redis.lock.return_value = lockresult = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)assert result == cached_token- lock.acquire.assert_called_once_with(blocking=True)- lock.release.assert_called_once()+ _assert_lock_released(commands)mock_query_db.assert_not_called()- def test_should_query_db_when_lock_acquired_and_cache_missed(self):+ def test_should_query_db_when_lock_acquired_and_cache_missed(+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]+ ) -> None:auth_token = "token-123"scope = "app"db_token = _api_token()- lock = MagicMock()- lock.acquire.return_value = True+ _client, commands = single_flight_rediswith (- patch.object(api_token_service_module, "redis_client") as mock_redis,patch.object(api_token_service_module.ApiTokenCache, "get", return_value=None),patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,):- mock_redis.lock.return_value = lockresult = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)assert result == db_tokenmock_query_db.assert_called_once_with(auth_token, scope)- lock.release.assert_called_once()+ _assert_lock_released(commands)- def test_should_query_db_directly_when_lock_not_acquired(self):+ def test_should_query_db_directly_when_lock_not_acquired(+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]], monkeypatch: pytest.MonkeyPatch+ ) -> None:auth_token = "token-123"scope = "app"db_token = _api_token()- lock = MagicMock()- lock.acquire.return_value = False+ client, commands = single_flight_redis++ def contended(*args: object, **_kwargs: object) -> bool:+ commands.append(args)+ assert args[0] == "SET"+ return False++ monkeypatch.setattr(client, "execute_command", contended)with (- patch.object(api_token_service_module, "redis_client") as mock_redis,patch.object(api_token_service_module.ApiTokenCache, "get") as mock_cache_get,patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,):- mock_redis.lock.return_value = lockresult = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)assert result == db_tokenmock_cache_get.assert_not_called()mock_query_db.assert_called_once_with(auth_token, scope)- lock.release.assert_not_called()+ assert commands+ assert all(command[0] == "SET" for command in commands)- def test_should_reraise_unauthorized_from_db_query(self):+ def test_should_reraise_unauthorized_from_db_query(+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]]+ ) -> None:auth_token = "token-123"scope = "app"- lock = MagicMock()- lock.acquire.return_value = True+ _client, commands = single_flight_rediswith (- patch.object(api_token_service_module, "redis_client") as mock_redis,patch.object(api_token_service_module.ApiTokenCache, "get", return_value=None),patch.object(api_token_service_module,@@ -194,28 +227,34 @@ class TestFetchTokenWithSingleFlight:side_effect=Unauthorized("Access token is invalid"),),):- mock_redis.lock.return_value = lockwith pytest.raises(Unauthorized, match="Access token is invalid"):api_token_service_module.fetch_token_with_single_flight(auth_token, scope)- lock.release.assert_called_once()+ _assert_lock_released(commands)- def test_should_fallback_to_db_query_when_lock_raises_exception(self):+ def test_should_fallback_to_db_query_when_lock_raises_exception(+ self, single_flight_redis: tuple[Redis, list[tuple[object, ...]]], monkeypatch: pytest.MonkeyPatch+ ) -> None:auth_token = "token-123"scope = "app"db_token = _api_token()- lock = MagicMock()- lock.acquire.side_effect = RuntimeError("redis lock error")+ client, commands = single_flight_redis++ def unavailable(*args: object, **_kwargs: object) -> bool:+ commands.append(args)+ raise RuntimeError("redis lock error")++ monkeypatch.setattr(client, "execute_command", unavailable)with (- patch.object(api_token_service_module, "redis_client") as mock_redis,patch.object(api_token_service_module, "query_token_from_db", return_value=db_token) as mock_query_db,):- mock_redis.lock.return_value = lockresult = api_token_service_module.fetch_token_with_single_flight(auth_token, scope)assert result == db_tokenmock_query_db.assert_called_once_with(auth_token, scope)+ assert len(commands) == 1+ assert commands[0][:2] == ("SET", "api_token_query_lock:app:token-123")class TestApiTokenCacheTenantBranches:diff --git a/api/tests/unit_tests/services/test_workflow_generator_service.py b/api/tests/unit_tests/services/test_workflow_generator_service.pyindex 86f4010bfa2..b0dc2620e7e 100644--- a/api/tests/unit_tests/services/test_workflow_generator_service.py+++ b/api/tests/unit_tests/services/test_workflow_generator_service.py@@ -1,297 +1,307 @@-"""-Unit tests for ``WorkflowGeneratorService``.+"""Exercise service wiring through the real model, tool catalogue and graph generator.-The service is a thin facade — its job is (1) hand the tenant model_config to-``ModelManager`` to get a model_instance, (2) build the tool catalogue, and-(3) delegate to ``WorkflowGenerator``. We mock both dependencies so the tests-stay fast and focus on the wiring itself.+Only provider discovery, schema lookup, Redis commands and plugin-daemon I/O are+isolated. Delegating spies preserve the production generator and runtime behavior."""-from unittest.mock import MagicMock, patch+import json+from collections.abc import Callable, Generator, Iterator+from dataclasses import dataclass, field++import pytest+from redis import Redisfrom core.app.app_config.entities import ModelConfigfrom core.credit_usage import CreditUsageAppType, CreditUsageCreatedBy-from graphon.model_runtime.entities.llm_entities import LLMMode+from core.entities.provider_configuration import ProviderModelBundle+from core.entities.provider_entities import CustomProviderConfiguration+from core.model_manager import ModelInstance+from core.plugin.impl.model import PluginModelClient+from core.plugin.impl.model_runtime import PluginModelRuntime+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime+from core.provider_manager import ProviderManager+from core.tools.entities.common_entities import I18nObject+from core.tools.entities.tool_entities import (+ ToolDescription,+ ToolEntity,+ ToolIdentity,+ ToolProviderEntityWithPlugin,+ ToolProviderIdentity,+)+from core.tools.plugin_tool.provider import PluginToolProviderController+from core.tools.tool_manager import ToolManager+from core.workflow.generator import WorkflowGenerator+from extensions.ext_redis import RedisClientWrapper+from graphon.model_runtime.entities.llm_entities import LLMMode, LLMResultChunk, LLMResultChunkDelta+from graphon.model_runtime.entities.message_entities import AssistantPromptMessage+from graphon.model_runtime.entities.model_entities import ModelType+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModelfrom services.workflow_generator_service import WorkflowGeneratorService+from tests.unit_tests.core.model_fixtures import make_model_config++TENANT_ID = "t-1"+PROVIDER = "langgenius/openai/openai"def _model_config() -> ModelConfig:- return ModelConfig(- provider="openai",- name="gpt-4o",- mode=LLMMode.CHAT,- completion_params={"temperature": 0.4},- )+ return ModelConfig(provider=PROVIDER, name="gpt-4o", mode=LLMMode.CHAT, completion_params={"temperature": 0.4})-class TestWorkflowGeneratorService:- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_forwards_model_instance_and_complete_catalogue_to_generator(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """Happy path: the runner receives the complete catalogue for dynamic routing."""- # Arrange- instance = MagicMock(name="model_instance")- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = instance- mock_build_catalogue.return_value = [- {- "provider_name": "google",- "provider_type": "builtin",- "plugin_id": "",- "tool_name": "search",- "tool_label": "Search",- "description": "Search.",- }- ]- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "ok",- "error": "",- }+def _record[**P, R](function: Callable[P, R], calls: list[dict[str, object]]) -> Callable[P, R]:+ """Observe keyword arguments and execute the original method unchanged."""- # Act- result = WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="workflow",- instruction="Summarize a URL",- model_config=_model_config(),- ideal_output="A 3-sentence summary",- )+ def delegated(*args: P.args, **kwargs: P.kwargs) -> R:+ calls.append(dict(kwargs))+ return function(*args, **kwargs)- # Assert- mock_model_manager.for_tenant.assert_called_once_with(- tenant_id="t-1",- request_metadata={- "app_type": CreditUsageAppType.WORKFLOW,- "created_by": CreditUsageCreatedBy.WORKFLOW_GENERATION,- },- )- mock_workflow_generator.generate_workflow_graph.assert_called_once()- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs- assert call_kwargs["model_instance"] is instance- assert call_kwargs["provider"] == "openai"- assert call_kwargs["model_name"] == "gpt-4o"- assert call_kwargs["mode"] == "workflow"- assert call_kwargs["instruction"] == "Summarize a URL"- assert call_kwargs["ideal_output"] == "A 3-sentence summary"- assert call_kwargs["tool_catalogue_text"] == ""- assert call_kwargs["tool_catalogue_entries"] == mock_build_catalogue.return_value- assert call_kwargs["model_parameters"] == {"temperature": 0.4}- assert result["error"] == ""-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_catalogue_build_failure_falls_back_to_empty_text(- self,- mock_build_catalogue,- mock_model_manager,- mock_workflow_generator,- ):- """- A plugin-daemon outage must not block generation — the catalogue helper- is wrapped in try/except so a failure downgrades to an empty catalogue.- """- # Arrange- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.side_effect = RuntimeError("plugin daemon unreachable")- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",- }+ return delegated- # Act- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="workflow",- instruction="Summarize a URL",- model_config=_model_config(),- )- # Assert: generation still ran, catalogue text was empty.- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs- assert call_kwargs["tool_catalogue_text"] == ""-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_defaults_ideal_output_to_empty_string(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """Callers can omit ideal_output; the runner should still receive ""."""- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.return_value = []- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",- }+@dataclass+class GenerationObservations:+ """Fixture data and captured calls, not a substitute for a production dependency."""- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="advanced-chat",- instruction="A chat bot",- model_config=_model_config(),- )+ bundle: ProviderModelBundle+ providers: list[PluginToolProviderController] = field(default_factory=list)+ generator_calls: list[dict[str, object]] = field(default_factory=list)+ runtime_calls: list[dict[str, object]] = field(default_factory=list)+ daemon_calls: list[dict[str, object]] = field(default_factory=list)+ resolutions: list[tuple[str, str, ModelType]] = field(default_factory=list)- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs- assert call_kwargs["ideal_output"] == ""- assert call_kwargs["mode"] == "advanced-chat"-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_forwards_current_graph_for_refine(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """The cmd+k `/refine` path passes the existing draft graph through to the runner."""- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.return_value = []- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",- }- current_graph = {"nodes": [{"id": "node1"}], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}}-- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="workflow",- instruction="Add a translation step",- model_config=_model_config(),- current_graph=current_graph,++def generation(monkeypatch: pytest.MonkeyPatch) -> Iterator[GenerationObservations]:+ config = make_model_config(provider=PROVIDER, model="gpt-4o", mode="chat")+ bundle = config.provider_model_bundle+ bundle.configuration.tenant_id = TENANT_ID+ bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(credentials={"api_key": "token"})+ bundle.model_type_instance = LargeLanguageModel(+ provider_schema=bundle.configuration.provider,+ model_runtime=create_plugin_model_runtime(tenant_id=TENANT_ID),+ )+ observed = GenerationObservations(bundle=bundle)++ def provider_bundle(+ _manager: ProviderManager, *, tenant_id: str, provider: str, model_type: ModelType+ ) -> ProviderModelBundle:+ observed.resolutions.append((tenant_id, provider, model_type))+ return bundle++ def providers(tenant_id: str) -> list[PluginToolProviderController]:+ assert tenant_id == TENANT_ID+ return observed.providers++ def dispatch(_client: PluginModelClient, **kwargs: object) -> Generator[LLMResultChunk]:+ observed.daemon_calls.append(kwargs)+ data = kwargs["data"]+ assert isinstance(data, dict)+ messages = data["data"]["prompt_messages"]+ system_prompt = messages[0]["content"]+ user_prompt = messages[-1]["content"]+ if "workflow planner" in system_prompt.lower():+ terminal = "answer" if "# Mode\n\nadvanced-chat" in user_prompt else "end"+ response: dict[str, object] = {+ "title": "Generated graph",+ "description": "ok",+ "nodes": [+ {"id": "start", "node_type": "start", "label": "Start", "purpose": "Input"},+ {"id": "finish", "node_type": terminal, "label": "Finish", "purpose": "Output"},+ ],+ "edges": [{"source": "start", "target": "finish"}],+ }+ else:+ response = {"config": {"variables": [], "outputs": [], "answer": "Done"}}+ yield LLMResultChunk(+ model="gpt-4o",+ delta=LLMResultChunkDelta(index=0, message=AssistantPromptMessage(content=json.dumps(response))),)- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs- assert call_kwargs["current_graph"] is current_graph-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_defaults_current_graph_to_none_for_create(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """Omitting current_graph (the `/create` path) forwards None to the runner."""- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.return_value = []- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",+ monkeypatch.setattr(ProviderManager, "get_provider_model_bundle", provider_bundle)+ monkeypatch.setattr(ToolManager, "list_builtin_providers", providers)+ monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: config.model_schema)+ monkeypatch.setattr(PluginModelClient, "_request_with_plugin_daemon_response_stream", dispatch)+ monkeypatch.setattr(+ PluginModelRuntime, "invoke_llm", _record(PluginModelRuntime.invoke_llm, observed.runtime_calls)+ )+ monkeypatch.setattr(+ WorkflowGenerator,+ "_iter_generation_events",+ _record(WorkflowGenerator._iter_generation_events, observed.generator_calls),+ )+ with Redis() as client:+ monkeypatch.setattr(client, "execute_command", lambda *_args, **_kwargs: None)+ redis = RedisClientWrapper()+ redis.initialize(client)+ monkeypatch.setattr("core.plugin.impl.model_runtime.redis_client", redis)+ yield observed+++def _planner_prompt(generation: GenerationObservations) -> str:+ data = generation.daemon_calls[0]["data"]+ assert isinstance(data, dict)+ return data["data"]["prompt_messages"][-1]["content"]+++def _assert_model_resolution(generation: GenerationObservations, app_type: CreditUsageAppType) -> None:+ assert generation.resolutions == [(TENANT_ID, PROVIDER, ModelType.LLM)]+ assert len(generation.generator_calls) == 1+ call = generation.generator_calls[0]+ instance = call["model_instance"]+ assert type(instance) is ModelInstance+ assert instance.provider_model_bundle is generation.bundle+ assert instance.credentials == {"api_key": "token"}+ assert call["provider"] == PROVIDER+ assert call["model_name"] == "gpt-4o"+ assert call["model_mode"] == "chat"+ assert call["model_parameters"] == {"temperature": 0.4}+ assert len(generation.runtime_calls) == len(generation.daemon_calls) == 3+ for runtime_call in generation.runtime_calls:+ assert runtime_call["request_metadata"] == {+ "app_type": app_type,+ "created_by": CreditUsageCreatedBy.WORKFLOW_GENERATION,}- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="workflow",- instruction="Summarize a URL",- model_config=_model_config(),++def test_forwards_model_instance_and_complete_catalogue_to_generator(generation: GenerationObservations) -> None:+ label = I18nObject(en_US="Search")+ generation.providers.append(+ PluginToolProviderController(+ entity=ToolProviderEntityWithPlugin(+ identity=ToolProviderIdentity(author="test", name="google", description=label, icon="", label=label),+ tools=[+ ToolEntity(+ identity=ToolIdentity(author="test", name="search", label=label, provider="google"),+ description=ToolDescription(human=label, llm="Search."),+ )+ ],+ ),+ plugin_id="langgenius/google",+ plugin_unique_identifier="langgenius/google:1.0.0",+ tenant_id=TENANT_ID,)+ )+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID,+ mode="workflow",+ instruction="Summarize a URL",+ model_config=_model_config(),+ ideal_output="A 3-sentence summary",+ )- call_kwargs = mock_workflow_generator.generate_workflow_graph.call_args.kwargs- assert call_kwargs["current_graph"] is None-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_auto_mode_forwards_sentinel_to_runner(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """``mode="auto"`` passes straight through — the planner resolves it, no extra LLM call."""- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.return_value = []- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)+ call = generation.generator_calls[0]+ assert call["instruction"] == "Summarize a URL"+ assert call["ideal_output"] == "A 3-sentence summary"+ assert call["tool_catalogue_text"] == ""+ assert call["installed_tools"] == {("google", "search")}+ assert call["tool_catalogue_entries"] == [+ {+ "provider_name": "google",+ "provider_type": "builtin",+ "plugin_id": "langgenius/google",+ "plugin_unique_identifier": "langgenius/google:1.0.0",+ "tool_name": "search",+ "tool_label": "Search",+ "description": "Search.",+ "parameters": [],+ "output_schema": {},}+ ]+ assert "google/search" in _planner_prompt(generation)+ assert "A 3-sentence summary" in _planner_prompt(generation)+ assert result["error"] == ""+ assert [node["data"]["type"] for node in result["graph"]["nodes"]] == ["start", "end"]- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="auto",- instruction="Summarize a URL",- model_config=_model_config(),- )- assert mock_workflow_generator.generate_workflow_graph.call_args.kwargs["mode"] == "auto"- # the model registry is consulted exactly once — no classifier resolution- mock_model_manager.for_tenant.return_value.get_model_instance.assert_called_once()-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_explicit_mode_passes_through_unchanged(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """A concrete mode reaches the runner verbatim."""- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = MagicMock()- mock_build_catalogue.return_value = []- mock_workflow_generator.generate_workflow_graph.return_value = {- "graph": {"nodes": [], "edges": [], "viewport": {"x": 0, "y": 0, "zoom": 0.7}},- "message": "",- "error": "",- }+def test_catalogue_build_failure_falls_back_to_empty_text(+ generation: GenerationObservations, monkeypatch: pytest.MonkeyPatch+) -> None:+ """A discovery outage must still run the real planner and builders without tool validation."""- WorkflowGeneratorService.generate_workflow_graph(- tenant_id="t-1",- mode="advanced-chat",- instruction="A chat bot",- model_config=_model_config(),- )+ def unavailable(tenant_id: str) -> list[PluginToolProviderController]:+ assert tenant_id == TENANT_ID+ raise RuntimeError("plugin daemon unreachable")++ monkeypatch.setattr(ToolManager, "list_builtin_providers", unavailable)+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()+ )+ assert result["error"] == ""+ call = generation.generator_calls[0]+ assert call["tool_catalogue_text"] == ""+ assert call["tool_catalogue_entries"] == []+ assert call["installed_tools"] is None+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)+++def test_defaults_ideal_output_to_empty_string(generation: GenerationObservations) -> None:+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID, mode="advanced-chat", instruction="A chat bot", model_config=_model_config()+ )+ assert result["error"] == ""+ assert generation.generator_calls[0]["ideal_output"] == ""+ assert generation.generator_calls[0]["mode"] == "advanced-chat"+ assert "# Ideal output" not in _planner_prompt(generation)+ _assert_model_resolution(generation, CreditUsageAppType.CHATFLOW)+++def test_forwards_current_graph_for_refine(generation: GenerationObservations) -> None:+ graph: dict[str, object] = {"nodes": [{"id": "node1", "data": {"type": "start", "title": "Original"}}], "edges": []}+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID,+ mode="workflow",+ instruction="Add a translation step",+ model_config=_model_config(),+ current_graph=graph,+ )+ assert result["error"] == ""+ assert generation.generator_calls[0]["current_graph"] is graph+ assert "# Existing graph to refine" in _planner_prompt(generation)+ assert "id='node1' type='start' title='Original'" in _planner_prompt(generation)- assert mock_workflow_generator.generate_workflow_graph.call_args.kwargs["mode"] == "advanced-chat"-- @patch("services.workflow_generator_service.WorkflowGenerator")- @patch("services.workflow_generator_service.ModelManager")- @patch("services.workflow_generator_service.build_tool_catalogue")- def test_stream_delegates_to_runner_stream(- self,- mock_build_catalogue: MagicMock,- mock_model_manager: MagicMock,- mock_workflow_generator: MagicMock,- ):- """Task 2b: the streaming facade resolves context and yields the runner's events through."""- instance = MagicMock(name="model_instance")- mock_model_manager.for_tenant.return_value.get_model_instance.return_value = instance- mock_build_catalogue.return_value = []-- def _runner_stream(**_kwargs):- yield ("plan", {"mode": "workflow"})- yield ("result", {"error": "", "mode": "workflow"})-- mock_workflow_generator.generate_workflow_graph_stream.side_effect = _runner_stream-- events = list(- WorkflowGeneratorService.generate_workflow_graph_stream(- tenant_id="t-1",- mode="workflow",- instruction="Summarize a URL",- model_config=_model_config(),- )- )- assert [name for name, _ in events] == ["plan", "result"]- call_kwargs = mock_workflow_generator.generate_workflow_graph_stream.call_args.kwargs- assert call_kwargs["model_instance"] is instance- assert call_kwargs["mode"] == "workflow"- assert call_kwargs["provider"] == "openai"+def test_defaults_current_graph_to_none_for_create(generation: GenerationObservations) -> None:+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()+ )+ assert result["error"] == ""+ assert generation.generator_calls[0]["current_graph"] is None+ assert generation.generator_calls[0]["installed_tools"] == set()+ assert "# Existing graph to refine" not in _planner_prompt(generation)+++def test_auto_mode_forwards_sentinel_to_runner(generation: GenerationObservations) -> None:+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID, mode="auto", instruction="Summarize a URL", model_config=_model_config()+ )+ assert result["error"] == ""+ assert result["mode"] == "workflow"+ assert generation.generator_calls[0]["mode"] == "auto"+ _assert_model_resolution(generation, CreditUsageAppType.UNKNOWN)+++def test_explicit_mode_passes_through_unchanged(generation: GenerationObservations) -> None:+ result = WorkflowGeneratorService.generate_workflow_graph(+ tenant_id=TENANT_ID, mode="advanced-chat", instruction="A chat bot", model_config=_model_config()+ )+ assert result["error"] == ""+ assert result["mode"] == "advanced-chat"+ assert generation.generator_calls[0]["mode"] == "advanced-chat"+ assert result["graph"]["nodes"][-1]["data"]["type"] == "answer"+++def test_stream_delegates_to_runner_stream(generation: GenerationObservations) -> None:+ stream = WorkflowGeneratorService.generate_workflow_graph_stream(+ tenant_id=TENANT_ID, mode="workflow", instruction="Summarize a URL", model_config=_model_config()+ )+ name, plan = next(stream)+ assert name == "plan"+ assert plan["mode"] == "workflow"+ assert len(generation.daemon_calls) == 1 # Builders start only after the caller receives the plan.+ name, result = next(stream)+ assert name == "result"+ assert result["error"] == ""+ assert result["mode"] == "workflow"+ assert list(stream) == []+ assert generation.generator_calls[0]["mode"] == "workflow"+ _assert_model_resolution(generation, CreditUsageAppType.WORKFLOW)