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: use real agent config and tool call objects (#43582)
Asuka Minato2bb1b113343f
diff --git a/api/tests/unit_tests/agent_runtime_fixtures.py b/api/tests/unit_tests/agent_runtime_fixtures.pynew file mode 100644index 00000000000..be0eff6a99f--- /dev/null+++ b/api/tests/unit_tests/agent_runtime_fixtures.py@@ -0,0 +1,168 @@+"""Opt-in fixtures for production agent configuration, queues and SQLite records."""++from collections.abc import Iterator+from datetime import datetime++import pytest+from flask import Flask+from redis import Redis+from sqlalchemy.engine import Engine+from sqlalchemy.orm import Session++from core.agent.entities import AgentEntity, AgentPromptEntity+from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom, ModelConfigEntity, PromptTemplateEntity+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager+from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, InvokeFrom+from core.entities.provider_entities import CustomProviderConfiguration+from core.plugin.impl.model import PluginModelClient+from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime+from extensions.ext_database import db+from extensions.ext_redis import RedisClientWrapper+from graphon.model_runtime.entities.llm_entities import LLMMode+from graphon.model_runtime.entities.model_entities import ModelPropertyKey+from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel+from models.enums import ConversationFromSource+from models.model import App, AppMode, Conversation, Message+from tests.unit_tests.core.model_fixtures import make_model_config++PROVIDER = "langgenius/openai/openai"+++def agent_queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQueueManager]:+ """Use the production queue and Redis wrapper; isolate only Redis commands."""+ with Redis() as client:+ monkeypatch.setattr(client, "execute_command", lambda *_args, **_kwargs: None)+ redis = 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",+ invoke_from=InvokeFrom.SERVICE_API,+ conversation_id="conv",+ app_mode=AppMode.AGENT_CHAT,+ message_id="msg",+ )+++def agent_runtime_app(sqlite_engine: Engine) -> Iterator[Flask]:+ """Bind production agent-thought writes to the same SQLite database as setup reads."""+ 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()+++def agent_generate_entity(monkeypatch: pytest.MonkeyPatch) -> AgentChatAppGenerateEntity:+ model_config = make_model_config(provider=PROVIDER, model="m", mode=LLMMode.CHAT)+ model_config.credentials = {"api_key": "token"}+ model_config.model_schema.model_properties = {ModelPropertyKey.MODE: LLMMode.CHAT}+ bundle = model_config.provider_model_bundle+ bundle.configuration.tenant_id = "tenant"+ bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(+ credentials=model_config.credentials+ )+ bundle.model_type_instance = LargeLanguageModel(+ provider_schema=bundle.configuration.provider, model_runtime=create_plugin_model_runtime(tenant_id="tenant")+ )+ monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: model_config.model_schema)+ return AgentChatAppGenerateEntity(+ task_id="task",+ app_config=AgentChatAppConfig(+ app_id="app1",+ tenant_id="tenant",+ app_mode=AppMode.AGENT_CHAT,+ app_model_config_from=EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG,+ app_model_config_dict={},+ model=ModelConfigEntity(provider=PROVIDER, model="m", mode=LLMMode.CHAT),+ prompt_template=PromptTemplateEntity(+ prompt_type=PromptTemplateEntity.PromptType.SIMPLE, simple_prompt_template="Help the user."+ ),+ agent=AgentEntity(+ provider=PROVIDER,+ model="m",+ strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT,+ prompt=AgentPromptEntity(+ first_prompt=(+ "{{instruction}} {{tools}} {{tool_names}} {{historic_messages}} {{query}} {{agent_scratchpad}}"+ ),+ next_iteration="continue",+ ),+ ),+ ),+ model_conf=model_config,+ inputs={},+ query="q",+ files=[],+ stream=True,+ user_id="user",+ invoke_from=InvokeFrom.SERVICE_API,+ )+++def agent_records(sqlite_session: Session) -> tuple[Conversation, Message]:+ app = App(+ id="app1",+ tenant_id="tenant",+ name="Agent chat app",+ description="",+ mode=AppMode.AGENT_CHAT,+ enable_site=False,+ enable_api=False,+ )+ conversation = Conversation(+ id="conv",+ app_id=app.id,+ app_model_config_id=None,+ model_provider=None,+ override_model_configs=None,+ model_id=None,+ mode=AppMode.AGENT_CHAT,+ name="Conversation",+ inputs={},+ introduction="",+ system_instruction="",+ system_instruction_tokens=0,+ status="normal",+ invoke_from=InvokeFrom.SERVICE_API,+ from_source=ConversationFromSource.API,+ from_end_user_id=None,+ from_account_id="user",+ )+ message = Message(+ id="msg",+ app_id=app.id,+ conversation_id=conversation.id,+ inputs={},+ query="q",+ message={},+ message_tokens=0,+ message_unit_price=0,+ message_price_unit=0,+ answer="",+ answer_tokens=0,+ answer_unit_price=0,+ answer_price_unit=0,+ provider_response_latency=0,+ total_price=0,+ currency="USD",+ invoke_from=InvokeFrom.SERVICE_API,+ from_source=ConversationFromSource.API,+ from_end_user_id=None,+ from_account_id="user",+ app_mode=AppMode.AGENT_CHAT,+ created_at=datetime(2025, 1, 1),+ )+ sqlite_session.add_all([app, conversation, message])+ sqlite_session.commit()+ return conversation, messagediff --git a/api/tests/unit_tests/conftest.py b/api/tests/unit_tests/conftest.pyindex c1e7e9287b2..63b928ef29e 100644--- a/api/tests/unit_tests/conftest.py+++ b/api/tests/unit_tests/conftest.py@@ -27,7 +27,7 @@ PROJECT_DIR = os.path.abspath(os.path.join(ABS_PATH, os.pardir, os.pardir))CACHED_APP = Flask(__name__)-pytest_plugins = ("tests.unit_tests.audio_runtime_fixtures",)+pytest_plugins = ("tests.unit_tests.audio_runtime_fixtures", "tests.unit_tests.agent_runtime_fixtures")# set global mock for Redis clientredis_mock = MagicMock()diff --git a/api/tests/unit_tests/core/agent/test_fc_agent_runner.py b/api/tests/unit_tests/core/agent/test_fc_agent_runner.pyindex 052bb7665f1..c886bf084f9 100644--- a/api/tests/unit_tests/core/agent/test_fc_agent_runner.py+++ b/api/tests/unit_tests/core/agent/test_fc_agent_runner.py@@ -11,18 +11,24 @@ from sqlalchemy import eventfrom sqlalchemy.engine import Enginefrom sqlalchemy.orm import Session+from core.agent.entities import AgentEntityfrom core.agent.errors import AgentMaxIterationErrorfrom core.agent.fc_agent_runner import FunctionCallAgentRunnerfrom core.app.app_config.entities import DatasetRetrieveConfigEntity+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigfrom core.app.apps.base_app_queue_manager import PublishFrom-from core.app.entities.app_invoke_entities import CreditUsageCreatedBy+from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager+from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, CreditUsageCreatedByfrom core.app.entities.queue_entities import QueueMessageFileEventfrom core.credit_usage import CreditUsageAppType-from graphon.model_runtime.entities.llm_entities import LLMUsage+from core.model_manager import ModelInstance+from graphon.model_runtime.entities.llm_entities import LLMResult, LLMResultChunk, LLMResultChunkDelta, LLMUsagefrom graphon.model_runtime.entities.message_entities import (+ AssistantPromptMessage,DocumentPromptMessageContent,ImagePromptMessageContent,PromptMessageContentType,+ SystemPromptMessage,TextPromptMessageContent,UserPromptMessage,)@@ -110,6 +116,45 @@ class DummyResult:# ==============================+def real_runner(+ sqlite_session: Session,+ agent_records: tuple[Conversation, Message],+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,+) -> FunctionCallAgentRunner:+ """Construct the production runner, including its history, callbacks and schema lookup."""+ conversation, message = agent_records+ app_config = agent_generate_entity.app_config+ assert isinstance(app_config, AgentChatAppConfig)+ assert app_config.agent is not None+ app_config.agent.strategy = AgentEntity.Strategy.FUNCTION_CALLING+ return FunctionCallAgentRunner(+ session=sqlite_session,+ tenant_id=app_config.tenant_id,+ application_generate_entity=agent_generate_entity,+ conversation=conversation,+ app_config=app_config,+ model_config=agent_generate_entity.model_conf,+ config=app_config.agent,+ queue_manager=agent_queue_manager,+ message=message,+ user_id=agent_generate_entity.user_id,+ model_instance=ModelInstance(+ provider_model_bundle=agent_generate_entity.model_conf.provider_model_bundle,+ model=agent_generate_entity.model_conf.model,+ ),+ )+++def _tool_call(call_id: str, name: str, arguments: str) -> AssistantPromptMessage.ToolCall:+ return AssistantPromptMessage.ToolCall(+ id=call_id,+ type="function",+ function=AssistantPromptMessage.ToolCall.ToolCallFunction(name=name, arguments=arguments),+ )++@pytest.fixturedef runner(mocker: MockerFixture, sqlite_engine: Engine) -> Iterator[FunctionCallAgentRunner]:# Completely bypass BaseAgentRunner __init__ to avoid DB / Flask context@@ -194,15 +239,25 @@ def runner(mocker: MockerFixture, sqlite_engine: Engine) -> Iterator[FunctionCalclass TestToolCallChecks:- @pytest.mark.parametrize(("tool_calls", "expected"), [([], False), ([MagicMock()], True)])- def test_check_tool_calls(self, runner: FunctionCallAgentRunner, tool_calls, expected):- chunk = DummyChunk(message=DummyMessage(tool_calls=tool_calls))- assert runner.check_tool_calls(chunk) is expected-- @pytest.mark.parametrize(("tool_calls", "expected"), [([], False), ([MagicMock()], True)])- def test_check_blocking_tool_calls(self, runner: FunctionCallAgentRunner, tool_calls, expected):- result = DummyResult(message=DummyMessage(tool_calls=tool_calls))- assert runner.check_blocking_tool_calls(result) is expected+ @pytest.mark.parametrize("has_tools", [False, True])+ def test_check_tool_calls(self, real_runner: FunctionCallAgentRunner, has_tools: bool) -> None:+ chunk = LLMResultChunk(+ model="m",+ delta=LLMResultChunkDelta(+ index=0, message=AssistantPromptMessage(tool_calls=[_tool_call("1", "tool", "{}")] if has_tools else [])+ ),+ )+ assert real_runner.check_tool_calls(chunk) is has_tools++ @pytest.mark.parametrize("has_tools", [False, True])+ def test_check_blocking_tool_calls(self, real_runner: FunctionCallAgentRunner, has_tools: bool) -> None:+ result = LLMResult(+ model="m",+ prompt_messages=[],+ usage=LLMUsage.empty_usage(),+ message=AssistantPromptMessage(tool_calls=[_tool_call("1", "tool", "{}")] if has_tools else []),+ )+ assert real_runner.check_blocking_tool_calls(result) is has_tools# ==============================@@ -211,36 +266,36 @@ class TestToolCallChecks:class TestExtractToolCalls:- def test_extract_tool_calls_with_valid_json(self, runner: FunctionCallAgentRunner):- tool_call = MagicMock()- tool_call.id = "1"- tool_call.function.name = "tool"- tool_call.function.arguments = json.dumps({"a": 1})-- chunk = DummyChunk(message=DummyMessage(tool_calls=[tool_call]))- calls = runner.extract_tool_calls(chunk)+ def test_extract_tool_calls_with_valid_json(self, real_runner: FunctionCallAgentRunner) -> None:+ chunk = LLMResultChunk(+ model="m",+ delta=LLMResultChunkDelta(+ index=0, message=AssistantPromptMessage(tool_calls=[_tool_call("1", "tool", json.dumps({"a": 1}))])+ ),+ )+ calls = real_runner.extract_tool_calls(chunk)assert calls == [("1", "tool", {"a": 1})]- def test_extract_tool_calls_empty_arguments(self, runner: FunctionCallAgentRunner):- tool_call = MagicMock()- tool_call.id = "1"- tool_call.function.name = "tool"- tool_call.function.arguments = ""-- chunk = DummyChunk(message=DummyMessage(tool_calls=[tool_call]))- calls = runner.extract_tool_calls(chunk)+ def test_extract_tool_calls_empty_arguments(self, real_runner: FunctionCallAgentRunner) -> None:+ chunk = LLMResultChunk(+ model="m",+ delta=LLMResultChunkDelta(+ index=0, message=AssistantPromptMessage(tool_calls=[_tool_call("1", "tool", "")])+ ),+ )+ calls = real_runner.extract_tool_calls(chunk)assert calls == [("1", "tool", {})]- def test_extract_blocking_tool_calls(self, runner: FunctionCallAgentRunner):- tool_call = MagicMock()- tool_call.id = "2"- tool_call.function.name = "block"- tool_call.function.arguments = json.dumps({"x": 2})-- result = DummyResult(message=DummyMessage(tool_calls=[tool_call]))- calls = runner.extract_blocking_tool_calls(result)+ def test_extract_blocking_tool_calls(self, real_runner: FunctionCallAgentRunner) -> None:+ result = LLMResult(+ model="m",+ prompt_messages=[],+ usage=LLMUsage.empty_usage(),+ message=AssistantPromptMessage(tool_calls=[_tool_call("2", "block", json.dumps({"x": 2}))]),+ )+ calls = real_runner.extract_blocking_tool_calls(result)assert calls == [("2", "block", {"x": 2})]@@ -255,10 +310,10 @@ class TestInitSystemMessage:result = runner._init_system_message("system", [])assert len(result) == 1- def test_init_system_message_insert_at_start(self, runner: FunctionCallAgentRunner):- msgs = [MagicMock()]- result = runner._init_system_message("system", msgs)- assert result[0].content == "system"+ def test_init_system_message_insert_at_start(self, real_runner: FunctionCallAgentRunner) -> None:+ query = UserPromptMessage(content="query")+ result = real_runner._init_system_message("system", [query])+ assert result == [SystemPromptMessage(content="system"), query]def test_init_system_message_no_template(self, runner: FunctionCallAgentRunner):result = runner._init_system_message("", [])@@ -303,21 +358,14 @@ class TestOrganizeUserQuery:class TestClearUserPromptImageMessages:- def test_clear_text_and_image_content(self, runner: FunctionCallAgentRunner):- text = MagicMock()- text.type = "text"- text.data = "hello"-- image = MagicMock()- image.type = "image"- image.data = "img"-- user_msg = MagicMock()- user_msg.__class__.__name__ = "UserPromptMessage"- user_msg.content = [text, image]+ def test_clear_text_and_image_content(self, real_runner: FunctionCallAgentRunner) -> None:+ text = TextPromptMessageContent(data="hello")+ image = ImagePromptMessageContent(format="url", mime_type="image/png", url="https://example.test/image.png")+ user_msg = UserPromptMessage(content=[text, image])- result = runner._clear_user_prompt_image_messages([user_msg])- assert isinstance(result, list)+ result = real_runner._clear_user_prompt_image_messages([user_msg])+ assert result == [UserPromptMessage(content="hello\n[image]")]+ assert user_msg.content == [text, image]def test_clear_includes_file_placeholder(self, runner: FunctionCallAgentRunner):text = TextPromptMessageContent(data="hello")diff --git a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_config_manager.py b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_config_manager.pyindex d015294b737..9f9e151e7bd 100644--- a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_config_manager.py+++ b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_config_manager.py@@ -1,5 +1,4 @@import uuid-from types import SimpleNamespaceimport pytestfrom pytest_mock import MockerFixture@@ -7,6 +6,7 @@ from sqlalchemy.orm import Sessionfrom core.app.app_config.entities import EasyUIBasedAppModelConfigFromfrom core.app.apps.agent_chat.app_config_manager import (+ AgentChatAppConfig,AgentChatAppConfigManager,)from core.entities.agent_entities import PlanningStrategy@@ -27,7 +27,14 @@ def _app() -> App:def _config() -> AppModelConfig:- return AppModelConfig(app_id="app1")+ model = AppModelConfig(app_id="app1")+ config = model.to_dict(annotation_reply={"enabled": False})+ config["model"] = {"provider": "langgenius/openai/openai", "name": "m", "mode": "chat"}+ config["pre_prompt"] = "Help {{name}}."+ config["user_input_form"] = [{"text-input": {"variable": "name", "label": "Name", "required": True}}]+ config["external_data_tools"] = [{"enabled": True, "variable": "weather", "type": "api", "config": {}}]+ config["agent_mode"] = {"enabled": True, "strategy": "function_call", "tools": [], "prompt": None}+ return model.from_model_config_dict(config)def _conversation() -> Conversation:@@ -58,113 +65,65 @@ def _session() -> Session:class TestAgentChatAppConfigManagerGetAppConfig:- def test_get_app_config_override_config(self, mocker: MockerFixture):- app_model = _app()+ def test_get_app_config_override_config(self) -> None:app_model_config = _config()-- override_config = {"model": {"provider": "p"}}-- mocker.patch("core.app.apps.agent_chat.app_config_manager.ModelConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.PromptTemplateConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.SensitiveWordAvoidanceConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.DatasetConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.AgentConfigManager.convert")- mocker.patch.object(AgentChatAppConfigManager, "convert_features")- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.BasicVariablesConfigManager.convert",- return_value=("variables", "external"),- )- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.AgentChatAppConfig",- side_effect=lambda **kwargs: SimpleNamespace(**kwargs),- )+ override_config = app_model_config.to_dict(annotation_reply={"enabled": False})+ override_config["pre_prompt"] = "Override {{name}}."result = AgentChatAppConfigManager.get_app_config(- app_model=app_model,+ app_model=_app(),app_model_config=app_model_config,conversation=None,override_config_dict=override_config,annotation_reply=None,)+ assert isinstance(result, AgentChatAppConfig)assert result.app_model_config_dict == override_configassert result.app_model_config_from == EasyUIBasedAppModelConfigFrom.ARGS- assert result.variables == "variables"- assert result.external_data_variables == "external"+ assert result.model.provider == "langgenius/openai/openai"+ assert result.model.model == "m"+ assert result.prompt_template.simple_prompt_template == "Override {{name}}."+ assert app_model_config.pre_prompt == "Help {{name}}."+ assert len(result.variables) == 1+ assert result.variables[0].variable == "name"+ assert result.variables[0].required is True+ assert len(result.external_data_variables) == 1+ assert result.external_data_variables[0].variable == "weather"+ assert result.external_data_variables[0].type == "api"+ assert result.agent is not None+ assert result.agent.strategy.value == "function-calling"- def test_get_app_config_conversation_specific(self, mocker: MockerFixture):- app_model = _app()+ @pytest.mark.parametrize(+ ("conversation", "expected_from"),+ [+ (_conversation(), EasyUIBasedAppModelConfigFrom.CONVERSATION_SPECIFIC_CONFIG),+ (None, EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG),+ ],+ )+ def test_get_app_config_stored_config(+ self,+ conversation: Conversation | None,+ expected_from: EasyUIBasedAppModelConfigFrom,+ ) -> None:+ """None selects the latest app config; a conversation selects its supplied config."""app_model_config = _config()- annotation_reply = {"enabled": False}- conversation = _conversation()- to_dict = mocker.patch.object(- AppModelConfig,- "to_dict",- return_value={"model": {"provider": "p"}},- )-- mocker.patch("core.app.apps.agent_chat.app_config_manager.ModelConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.PromptTemplateConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.SensitiveWordAvoidanceConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.DatasetConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.AgentConfigManager.convert")- mocker.patch.object(AgentChatAppConfigManager, "convert_features")- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.BasicVariablesConfigManager.convert",- return_value=("variables", "external"),- )- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.AgentChatAppConfig",- side_effect=lambda **kwargs: SimpleNamespace(**kwargs),- )-result = AgentChatAppConfigManager.get_app_config(- app_model=app_model,+ app_model=_app(),app_model_config=app_model_config,conversation=conversation,override_config_dict=None,- annotation_reply=annotation_reply,- )-- assert result.app_model_config_dict == {"model": {"provider": "p"}}- assert result.app_model_config_from.value == "conversation-specific-config"- to_dict.assert_called_once_with(annotation_reply=annotation_reply)-- def test_get_app_config_latest_config(self, mocker: MockerFixture):- app_model = _app()- app_model_config = _config()- annotation_reply = {"enabled": False}- to_dict = mocker.patch.object(- AppModelConfig,- "to_dict",- return_value={"model": {"provider": "p"}},- )-- mocker.patch("core.app.apps.agent_chat.app_config_manager.ModelConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.PromptTemplateConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.SensitiveWordAvoidanceConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.DatasetConfigManager.convert")- mocker.patch("core.app.apps.agent_chat.app_config_manager.AgentConfigManager.convert")- mocker.patch.object(AgentChatAppConfigManager, "convert_features")- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.BasicVariablesConfigManager.convert",- return_value=("variables", "external"),- )- mocker.patch(- "core.app.apps.agent_chat.app_config_manager.AgentChatAppConfig",- side_effect=lambda **kwargs: SimpleNamespace(**kwargs),- )-- result = AgentChatAppConfigManager.get_app_config(- app_model=app_model,- app_model_config=app_model_config,- conversation=None,- override_config_dict=None,- annotation_reply=annotation_reply,+ annotation_reply={"enabled": False},)- assert result.app_model_config_from.value == "app-latest-config"- to_dict.assert_called_once_with(annotation_reply=annotation_reply)+ assert isinstance(result, AgentChatAppConfig)+ assert result.app_model_config_from == expected_from+ assert result.app_model_config_id == app_model_config.id+ assert result.app_model_config_dict == app_model_config.to_dict(annotation_reply={"enabled": False})+ assert result.prompt_template.simple_prompt_template == "Help {{name}}."+ assert result.model.model == "m"+ assert result.agent is not None+ assert result.agent.strategy.value == "function-calling"def test_get_app_config_requires_annotation_reply_without_override(self):with pytest.raises(ValueError, match="Annotation reply config is required"):diff --git a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_generator.py b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_generator.pyindex 5a16ef47c0d..a4dbee5d7c1 100644--- a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_generator.py+++ b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_generator.py@@ -1,19 +1,14 @@-import contextlibimport contextvars-import inspectimport loggingimport threading-from collections.abc import Iterator+from collections.abc import Callable, Iterable, Mappingfrom dataclasses import dataclass, field-from decimal import Decimalimport pytestfrom flask import Flaskfrom pydantic import ValidationErrorfrom sqlalchemy.orm import Session-from core.app.app_config.entities import PromptTemplateEntity-from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigfrom core.app.apps.agent_chat.app_generator import AgentChatAppGeneratorfrom core.app.apps.agent_chat.app_runner import AgentChatAppRunnerfrom core.app.apps.exc import GenerateTaskStoppedError@@ -21,12 +16,12 @@ from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueMafrom core.app.entities.app_invoke_entities import (AgentChatAppGenerateEntity,InvokeFrom,- ModelConfigWithCredentialsEntity,)+from core.app.entities.queue_entities import QueueErrorEvent+from core.app.file_access import get_current_file_access_scopefrom core.ops.ops_trace_manager import TraceQueueManagerfrom graphon.model_runtime.errors.invoke import InvokeAuthorizationErrorfrom models import Account-from models.enums import ConversationFromSourcefrom models.model import App, AppMode, AppModelConfig, Conversation, Messagefrom tests.unit_tests.config_override import apply_config_overrides@@ -49,84 +44,6 @@ class CallRecorder[T]:return self.result-class RecordingTraceQueueManager(TraceQueueManager):- """Trace manager with the real public shape and no background timer."""-- def __init__(self, app_id: str | None = None, user_id: str | None = None) -> None:- self.app_id = app_id- self.user_id = user_id---class RecordingQueueManager(MessageBasedAppQueueManager):- def __init__(self, **kwargs: object) -> None:- self.init_kwargs = kwargs- self.published_errors: list[tuple[Exception, object]] = []-- def publish_error(self, error: Exception, publish_from: object) -> None:- self.published_errors.append((error, publish_from))---class RecordingThread(threading.Thread):- def __init__(self, *, target: object, kwargs: dict[str, object]) -> None:- self.target = target- self.kwargs = kwargs- self.started = False-- def start(self) -> None:- self.started = True---@dataclass-class RecordingThreadFactory:- threads: list[RecordingThread] = field(default_factory=list)-- def __call__(self, *, target: object, kwargs: dict[str, object]) -> RecordingThread:- thread = RecordingThread(target=target, kwargs=kwargs)- self.threads.append(thread)- return thread---def _app_config() -> AgentChatAppConfig:- return AgentChatAppConfig.model_construct(- tenant_id="tenant",- app_id="app1",- app_mode=AppMode.AGENT_CHAT,- variables=[],- prompt_template=PromptTemplateEntity(- prompt_type=PromptTemplateEntity.PromptType.SIMPLE,- simple_prompt_template="You are helpful.",- ),- external_data_variables=[],- )---def _model_config() -> ModelConfigWithCredentialsEntity:- return ModelConfigWithCredentialsEntity.model_construct(provider="provider", model="model", mode="chat")---def _generate_entity() -> AgentChatAppGenerateEntity:- return AgentChatAppGenerateEntity.model_construct(- task_id="task",- app_config=_app_config(),- model_conf=_model_config(),- inputs={},- query="hello",- files=[],- user_id="user",- stream=True,- invoke_from=InvokeFrom.WEB_APP,- )---def _runner_raising(error: Exception) -> type:- class FailingRunner(AgentChatAppRunner):- def run(self, **kwargs: object) -> None:- _ = kwargs- raise error-- return FailingRunner--def _app() -> App:return App(id="app1",@@ -145,59 +62,61 @@ def _account() -> Account:return account-def _conversation() -> Conversation:- conversation = Conversation(- id="conv",- app_id="app1",- app_model_config_id=None,- model_provider=None,- override_model_configs=None,- model_id=None,- mode=AppMode.AGENT_CHAT,- name="Conversation",- inputs={},- introduction="",- system_instruction="",- system_instruction_tokens=0,- status="normal",- invoke_from=InvokeFrom.WEB_APP,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id="user",- )- return conversation---def _message() -> Message:- return Message(- id="msg",- app_id="app1",- conversation_id="conv",- inputs={},- query="hello",- message={},- message_unit_price=Decimal(0),- answer="",- answer_unit_price=Decimal(0),- total_price=Decimal(0),- currency="USD",- invoke_from=InvokeFrom.WEB_APP,- from_source=ConversationFromSource.CONSOLE,- from_end_user_id=None,- from_account_id="user",- app_mode=AppMode.AGENT_CHAT,- )+def generator(+ agent_runtime_app: Flask,+ agent_queue_manager: MessageBasedAppQueueManager,+ agent_records: tuple[Conversation, Message],+ monkeypatch: pytest.MonkeyPatch,+) -> AgentChatAppGenerator:+ assert agent_runtime_app.name+ assert agent_queue_manager is not None+ assert agent_records[0].id == "conv"+ # Keep trace configuration lookup and initialization real, but do not schedule background timers.+ monkeypatch.setattr(TraceQueueManager, "start_timer", lambda _manager: None)+ return AgentChatAppGenerator()@pytest.fixture-def generator() -> Iterator[AgentChatAppGenerator]:- app = Flask(__name__)- with app.app_context():- yield AgentChatAppGenerator()+def scheduled_threads(generator: AgentChatAppGenerator, monkeypatch: pytest.MonkeyPatch) -> list[threading.Thread]:+ """Capture OS scheduling; tests drive the real Thread.run and generator worker synchronously."""+ threads: list[threading.Thread] = []+ initialize = threading.Thread.__init__+ start = threading.Thread.start++ def initialize_thread(+ thread: threading.Thread,+ group: None = None,+ target: Callable[..., object] | None = None,+ name: str | None = None,+ args: Iterable[object] = (),+ kwargs: Mapping[str, object] | None = None,+ *,+ daemon: bool | None = None,+ ) -> None:+ initialize(thread, group=group, target=target, name=name, args=args, kwargs=kwargs, daemon=daemon)+ if target == generator._generate_worker:+ threads.append(thread)++ def defer_start(thread: threading.Thread) -> None:+ if thread not in threads:+ # Resource detectors also use threads; preserve their normal scheduling.+ start(thread)++ monkeypatch.setattr(threading.Thread, "__init__", initialize_thread)+ monkeypatch.setattr(threading.Thread, "start", defer_start)+ return threads+++def _raise_in_runner(monkeypatch: pytest.MonkeyPatch, error: Exception) -> None:+ def fail(_runner: AgentChatAppRunner, **_kwargs: object) -> None:+ raise error++ monkeypatch.setattr(AgentChatAppRunner, "run", fail)class TestAgentChatAppGeneratorGenerate:- def test_generate_rejects_blocking_mode(self, generator: AgentChatAppGenerator, sqlite_session: Session):+ def test_generate_rejects_blocking_mode(self, generator: AgentChatAppGenerator, sqlite_session: Session) -> None:app_model = _app()user = _account()with pytest.raises(ValueError):@@ -210,7 +129,7 @@ class TestAgentChatAppGeneratorGenerate:streaming=False,)- def test_generate_requires_query(self, generator: AgentChatAppGenerator, sqlite_session: Session):+ def test_generate_requires_query(self, generator: AgentChatAppGenerator, sqlite_session: Session) -> None:app_model = _app()user = _account()with pytest.raises(ValueError):@@ -220,9 +139,10 @@ class TestAgentChatAppGeneratorGenerate:user=user,args={"inputs": {}},invoke_from=InvokeFrom.WEB_APP,+ streaming=True,)- def test_generate_rejects_non_string_query(self, generator: AgentChatAppGenerator, sqlite_session: Session):+ def test_generate_rejects_non_string_query(self, generator: AgentChatAppGenerator, sqlite_session: Session) -> None:app_model = _app()user = _account()with pytest.raises(ValueError):@@ -232,6 +152,7 @@ class TestAgentChatAppGeneratorGenerate:user=user,args={"query": 123, "inputs": {}},invoke_from=InvokeFrom.WEB_APP,+ streaming=True,)def test_generate_override_requires_debugger(@@ -248,10 +169,17 @@ class TestAgentChatAppGeneratorGenerate:user=user,args={"query": "hi", "inputs": {}, "model_config": {"model": {"provider": "p"}}},invoke_from=InvokeFrom.WEB_APP,+ streaming=True,)def test_generate_success_with_debugger_override(- self, generator: AgentChatAppGenerator, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session+ self,+ generator: AgentChatAppGenerator,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_records: tuple[Conversation, Message],+ scheduled_threads: list[threading.Thread],) -> None:app_model = _app()app_model_config = AppModelConfig(app_id="app1")@@ -261,7 +189,7 @@ class TestAgentChatAppGeneratorGenerate:get_model_config = CallRecorder(app_model_config)prepare_inputs = CallRecorder({"x": 1})- init_records = CallRecorder((_conversation(), _message()))+ init_records = CallRecorder(agent_records)handle_response = CallRecorder("response")generator._get_app_model_config = get_model_config # type: ignore[method-assign]generator._prepare_user_inputs = prepare_inputs # type: ignore[method-assign]@@ -274,23 +202,25 @@ class TestAgentChatAppGeneratorGenerate:)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.AgentChatAppConfigManager.get_app_config",- CallRecorder(_app_config()),+ CallRecorder(agent_generate_entity.app_config),)monkeypatch.setattr(- "core.app.apps.agent_chat.app_generator.ModelConfigConverter.convert", CallRecorder(_model_config())+ "core.app.apps.agent_chat.app_generator.ModelConfigConverter.convert",+ CallRecorder(agent_generate_entity.model_conf),)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.FileUploadConfigManager.convert", CallRecorder(None))monkeypatch.setattr("core.app.apps.agent_chat.app_generator.ConversationService.get_conversation",- CallRecorder(_conversation()),+ CallRecorder(agent_records[0]),)- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.TraceQueueManager", RecordingTraceQueueManager)- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.MessageBasedAppQueueManager", RecordingQueueManager)+ runner_calls: list[dict[str, object]] = []++ def observe_runner(_runner: AgentChatAppRunner, **kwargs: object) -> None:+ runner_calls.append(kwargs)- thread_factory = RecordingThreadFactory()- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.threading.Thread", thread_factory)+ monkeypatch.setattr(AgentChatAppRunner, "run", observe_runner)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.AgentChatAppGenerateResponseConverter.convert",CallRecorder({"result": "ok"}),@@ -318,15 +248,36 @@ class TestAgentChatAppGeneratorGenerate:assert result == {"result": "ok"}assert get_model_config.calls[-1].kwargs["session"] is sessionassert init_records.calls[-1].kwargs["session"] is session- thread = thread_factory.threads[0]- entity = thread.kwargs["application_generate_entity"]+ assert len(scheduled_threads) == 1+ thread = scheduled_threads[0]+ assert type(thread) is threading.Thread+ parent_scope = get_current_file_access_scope()+ # The worker restores its captured context; keep that state in a separate thread context.+ contextvars.Context().run(thread.run)+ assert get_current_file_access_scope() is parent_scope+ assert len(runner_calls) == 1+ entity = runner_calls[0]["application_generate_entity"]assert isinstance(entity, AgentChatAppGenerateEntity)assert entity.extras["trace_session_id"] == "session-1"- inspect.signature(thread.target).bind(**thread.kwargs)- assert thread.started is True+ assert type(entity.trace_manager) is TraceQueueManager+ assert entity.trace_manager.trace_instance is None+ assert entity.trace_manager.app_id == "app1"+ assert type(runner_calls[0]["queue_manager"]) is MessageBasedAppQueueManager+ conversation = runner_calls[0]["conversation"]+ message = runner_calls[0]["message"]+ assert isinstance(conversation, Conversation)+ assert isinstance(message, Message)+ assert conversation.id == "conv"+ assert message.id == "msg"def test_generate_without_file_config(- self, generator: AgentChatAppGenerator, monkeypatch: pytest.MonkeyPatch, sqlite_session: Session+ self,+ generator: AgentChatAppGenerator,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_records: tuple[Conversation, Message],+ scheduled_threads: list[threading.Thread],) -> None:app_model = _app()app_model_config = AppModelConfig(app_id="app1")@@ -336,7 +287,7 @@ class TestAgentChatAppGeneratorGenerate:generator._get_app_model_config = CallRecorder(app_model_config) # type: ignore[method-assign]generator._prepare_user_inputs = CallRecorder({"x": 1}) # type: ignore[method-assign]- generator._init_generate_records = CallRecorder((_conversation(), _message())) # type: ignore[method-assign]+ generator._init_generate_records = CallRecorder(agent_records) # type: ignore[method-assign]generator._handle_response = CallRecorder("response") # type: ignore[method-assign]to_dict = CallRecorder({"model": {"provider": "p"}})@@ -347,24 +298,25 @@ class TestAgentChatAppGeneratorGenerate:"core.app.apps.agent_chat.app_generator.load_annotation_reply_config",load_annotation_reply_config,)- get_app_config = CallRecorder(_app_config())+ get_app_config = CallRecorder(agent_generate_entity.app_config)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.AgentChatAppConfigManager.get_app_config",get_app_config,)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.ModelConfigConverter.convert",- CallRecorder(_model_config()),+ CallRecorder(agent_generate_entity.model_conf),)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.FileUploadConfigManager.convert",CallRecorder(None),)- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.TraceQueueManager", RecordingTraceQueueManager)- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.MessageBasedAppQueueManager", RecordingQueueManager)+ runner_calls: list[dict[str, object]] = []- thread_factory = RecordingThreadFactory()- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.threading.Thread", thread_factory)+ def observe_runner(_runner: AgentChatAppRunner, **kwargs: object) -> None:+ runner_calls.append(kwargs)++ monkeypatch.setattr(AgentChatAppRunner, "run", observe_runner)monkeypatch.setattr("core.app.apps.agent_chat.app_generator.AgentChatAppGenerateResponseConverter.convert",@@ -387,40 +339,35 @@ class TestAgentChatAppGeneratorGenerate:assert load_annotation_reply_config.calls == [RecordedCall(args=(session, "app1"), kwargs={})]assert to_dict.calls == [RecordedCall(args=(), kwargs={"annotation_reply": annotation_reply})]assert get_app_config.calls[-1].kwargs["annotation_reply"] is annotation_reply- assert thread_factory.threads[0].started is True+ assert len(scheduled_threads) == 1+ parent_scope = get_current_file_access_scope()+ contextvars.Context().run(scheduled_threads[0].run)+ assert get_current_file_access_scope() is parent_scope+ assert len(runner_calls) == 1+ assert type(runner_calls[0]["queue_manager"]) is MessageBasedAppQueueManagerclass TestAgentChatAppGeneratorWorker:- @pytest.fixture(autouse=True)- def patch_context(self, monkeypatch: pytest.MonkeyPatch) -> None:- @contextlib.contextmanager- def ctx_manager[**P](*args: P.args, **kwargs: P.kwargs):- yield-- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.preserve_flask_contexts", ctx_manager)-def test_generate_worker_handles_generate_task_stopped(- self, generator: AgentChatAppGenerator, monkeypatch: pytest.MonkeyPatch+ self,+ generator: AgentChatAppGenerator,+ monkeypatch: pytest.MonkeyPatch,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,+ agent_runtime_app: Flask,) -> None:- queue_manager = RecordingQueueManager()- generator._get_conversation = CallRecorder(_conversation()) # type: ignore[method-assign]- generator._get_message = CallRecorder(_message()) # type: ignore[method-assign]-- monkeypatch.setattr(- "core.app.apps.agent_chat.app_generator.AgentChatAppRunner",- _runner_raising(GenerateTaskStoppedError()),- )+ _raise_in_runner(monkeypatch, GenerateTaskStoppedError())generator._generate_worker(- flask_app=Flask("worker"),+ flask_app=agent_runtime_app,context=contextvars.copy_context(),- application_generate_entity=_generate_entity(),- queue_manager=queue_manager,+ application_generate_entity=agent_generate_entity,+ queue_manager=agent_queue_manager,conversation_id="conv",message_id="msg",)- assert queue_manager.published_errors == []+ assert agent_queue_manager._q.empty()@pytest.mark.parametrize("error",@@ -436,49 +383,54 @@ class TestAgentChatAppGeneratorWorker:generator: AgentChatAppGenerator,monkeypatch: pytest.MonkeyPatch,error: Exception,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,+ agent_runtime_app: Flask,) -> None:- queue_manager = RecordingQueueManager()- generator._get_conversation = CallRecorder(_conversation()) # type: ignore[method-assign]- generator._get_message = CallRecorder(_message()) # type: ignore[method-assign]-- monkeypatch.setattr("core.app.apps.agent_chat.app_generator.AgentChatAppRunner", _runner_raising(error))+ _raise_in_runner(monkeypatch, error)generator._generate_worker(- flask_app=Flask("worker"),+ flask_app=agent_runtime_app,context=contextvars.copy_context(),- application_generate_entity=_generate_entity(),- queue_manager=queue_manager,+ application_generate_entity=agent_generate_entity,+ queue_manager=agent_queue_manager,conversation_id="conv",message_id="msg",)- assert len(queue_manager.published_errors) == 1- assert isinstance(queue_manager.published_errors[0][0], type(error))+ messages = list(agent_queue_manager.listen())+ assert len(messages) == 1+ assert isinstance(messages[0].event, QueueErrorEvent)+ assert isinstance(messages[0].event.error, type(error))+ if isinstance(error, InvokeAuthorizationError):+ assert str(messages[0].event.error) == "Incorrect API key provided"+ else:+ assert messages[0].event.error is errordef test_generate_worker_logs_value_error_when_debug(self,generator: AgentChatAppGenerator,monkeypatch: pytest.MonkeyPatch,caplog: pytest.LogCaptureFixture,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,+ agent_runtime_app: Flask,) -> None:- queue_manager = RecordingQueueManager()- generator._get_conversation = CallRecorder(_conversation()) # type: ignore[method-assign]- generator._get_message = CallRecorder(_message()) # type: ignore[method-assign]-- monkeypatch.setattr(- "core.app.apps.agent_chat.app_generator.AgentChatAppRunner", _runner_raising(ValueError("bad"))- )-+ _raise_in_runner(monkeypatch, ValueError("bad"))apply_config_overrides(monkeypatch, DEBUG=True)with caplog.at_level(logging.ERROR, logger="core.app.apps.agent_chat.app_generator"):generator._generate_worker(- flask_app=Flask("worker"),+ flask_app=agent_runtime_app,context=contextvars.copy_context(),- application_generate_entity=_generate_entity(),- queue_manager=queue_manager,+ application_generate_entity=agent_generate_entity,+ queue_manager=agent_queue_manager,conversation_id="conv",message_id="msg",)assert "Error when generating" in caplog.messages+ messages = list(agent_queue_manager.listen())+ assert len(messages) == 1+ assert isinstance(messages[0].event, QueueErrorEvent)+ assert isinstance(messages[0].event.error, ValueError)diff --git a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_runner.py b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_runner.pyindex 362503ab0de..29405e16780 100644--- a/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_runner.py+++ b/api/tests/unit_tests/core/app/apps/agent_chat/test_agent_chat_app_runner.py@@ -1,125 +1,31 @@from collections.abc import Generator, Iterator, Mapping-from datetime import datetimeimport pytest-from flask import Flask-from pytest_mock import MockerFixture-from redis import Redisfrom sqlalchemy import event, select-from sqlalchemy.engine import Enginefrom sqlalchemy.orm import Sessionfrom core.agent.cot_agent_runner import CotAgentRunnerfrom core.agent.cot_chat_agent_runner import CotChatAgentRunnerfrom core.agent.cot_completion_agent_runner import CotCompletionAgentRunner-from core.agent.entities import AgentEntity, AgentPromptEntity-from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom, ModelConfigEntity, PromptTemplateEntity+from core.agent.entities import AgentEntity+from core.agent.fc_agent_runner import FunctionCallAgentRunnerfrom core.app.apps.agent_chat.app_config_manager import AgentChatAppConfigfrom core.app.apps.agent_chat.app_runner import AgentChatAppRunnerfrom core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueManager-from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntity, InvokeFrom+from core.app.entities.app_invoke_entities import AgentChatAppGenerateEntityfrom core.app.entities.queue_entities import QueueAnnotationReplyEvent, QueueLLMChunkEvent, QueueMessageEndEvent-from core.entities.provider_entities import CustomProviderConfigurationfrom core.moderation.base import ModerationErrorfrom core.moderation.input_moderation import InputModerationfrom core.plugin.entities.plugin_daemon import PluginLLMNumTokensResponsefrom core.plugin.impl.model import PluginModelClient-from core.plugin.impl.model_runtime_factory import create_plugin_model_runtime-from extensions.ext_database import db-from extensions.ext_redis import RedisClientWrapperfrom graphon.model_runtime.entities.llm_entities import LLMMode, LLMResultChunk, LLMResultChunkDelta, LLMUsagefrom graphon.model_runtime.entities.message_entities import AssistantPromptMessagefrom graphon.model_runtime.entities.model_entities import ModelFeature, ModelPropertyKey-from graphon.model_runtime.model_providers.base.large_language_model import LargeLanguageModel-from models.enums import ConversationFromSource-from models.model import App, AppMode, Conversation, Message, MessageAgentThought, MessageAnnotation-from tests.unit_tests.core.model_fixtures import make_model_config+from models.model import App, Conversation, Message, MessageAgentThought, MessageAnnotation-PROVIDER = "langgenius/openai/openai"--def queue_manager(monkeypatch: pytest.MonkeyPatch) -> Iterator[MessageBasedAppQueueManager]:- """Use the production queue and Redis wrapper; isolate only Redis commands."""- with Redis() as client:- monkeypatch.setattr(client, "execute_command", lambda *_args, **_kwargs: None)- redis = 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",- invoke_from=InvokeFrom.SERVICE_API,- conversation_id="conv",- app_mode=AppMode.AGENT_CHAT,- message_id="msg",- )---def agent_app(sqlite_engine: Engine) -> Iterator[Flask]:- """Bind production agent-thought writes to the same SQLite database as setup reads."""- 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()---def generate_entity(monkeypatch: pytest.MonkeyPatch) -> AgentChatAppGenerateEntity:- model_config = make_model_config(provider=PROVIDER, model="m", mode=LLMMode.CHAT)- model_config.credentials = {"api_key": "token"}- model_config.model_schema.model_properties = {ModelPropertyKey.MODE: LLMMode.CHAT}- bundle = model_config.provider_model_bundle- bundle.configuration.tenant_id = "tenant"- bundle.configuration.custom_configuration.provider = CustomProviderConfiguration(- credentials=model_config.credentials- )- bundle.model_type_instance = LargeLanguageModel(- provider_schema=bundle.configuration.provider, model_runtime=create_plugin_model_runtime(tenant_id="tenant")- )- monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: model_config.model_schema)- return AgentChatAppGenerateEntity(- task_id="task",- app_config=AgentChatAppConfig(- app_id="app1",- tenant_id="tenant",- app_mode=AppMode.AGENT_CHAT,- app_model_config_from=EasyUIBasedAppModelConfigFrom.APP_LATEST_CONFIG,- app_model_config_dict={},- model=ModelConfigEntity(provider=PROVIDER, model="m", mode=LLMMode.CHAT),- prompt_template=PromptTemplateEntity(- prompt_type=PromptTemplateEntity.PromptType.SIMPLE, simple_prompt_template="Help the user."- ),- agent=AgentEntity(- provider=PROVIDER,- model="m",- strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT,- prompt=AgentPromptEntity(- first_prompt=(- "{{instruction}} {{tools}} {{tool_names}} {{historic_messages}} {{query}} {{agent_scratchpad}}"- ),- next_iteration="continue",- ),- ),- ),- model_conf=model_config,- inputs={},- query="q",- files=[],- stream=True,- user_id="user",- invoke_from=InvokeFrom.SERVICE_API,- )---def _assert_direct_output(queue_manager: MessageBasedAppQueueManager, text: str) -> None:- messages = list(queue_manager.listen())+def _assert_direct_output(agent_queue_manager: MessageBasedAppQueueManager, text: str) -> None:+ messages = list(agent_queue_manager.listen())chunks = [item.event.chunk.delta.message.content for item in messages if isinstance(item.event, QueueLLMChunkEvent)]assert all(isinstance(chunk, str) for chunk in chunks)assert "".join(chunk for chunk in chunks if isinstance(chunk, str)) == text@@ -129,61 +35,8 @@ def _assert_direct_output(queue_manager: MessageBasedAppQueueManager, text: str)@pytest.fixture-def runner(sqlite_session: Session) -> AgentChatAppRunner:- app = App(- id="app1",- tenant_id="tenant",- name="Agent chat app",- description="",- mode=AppMode.AGENT_CHAT,- enable_site=False,- enable_api=False,- )- conversation = Conversation(- id="conv",- app_id=app.id,- app_model_config_id=None,- model_provider=None,- override_model_configs=None,- model_id=None,- mode=AppMode.AGENT_CHAT,- name="Conversation",- inputs={},- introduction="",- system_instruction="",- system_instruction_tokens=0,- status="normal",- invoke_from=InvokeFrom.SERVICE_API,- from_source=ConversationFromSource.API,- from_end_user_id=None,- from_account_id="user",- )- message = Message(- id="msg",- app_id=app.id,- conversation_id=conversation.id,- inputs={},- query="q",- message={},- message_tokens=0,- message_unit_price=0,- message_price_unit=0,- answer="",- answer_tokens=0,- answer_unit_price=0,- answer_price_unit=0,- provider_response_latency=0,- total_price=0,- currency="USD",- invoke_from=InvokeFrom.SERVICE_API,- from_source=ConversationFromSource.API,- from_end_user_id=None,- from_account_id="user",- app_mode=AppMode.AGENT_CHAT,- created_at=datetime(2025, 1, 1),- )- sqlite_session.add_all([app, conversation, message])- sqlite_session.commit()+def runner(agent_records: tuple[Conversation, Message]) -> AgentChatAppRunner:+ assert agent_records[0].id == "conv"return AgentChatAppRunner()@@ -200,8 +53,8 @@ class TestAgentChatAppRunnerRun:self,runner: AgentChatAppRunner,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:app = sqlite_session.get(App, "app1")assert app is not None@@ -210,15 +63,15 @@ class TestAgentChatAppRunnerRun:conversation, message = _records(sqlite_session)with pytest.raises(ValueError, match="App not found"):- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)def test_run_moderation_error_direct_output(self,runner: AgentChatAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:def reject_input(_moderation: InputModeration, **kwargs: object) -> None:assert kwargs["query"] == "q"@@ -227,17 +80,17 @@ class TestAgentChatAppRunnerRun:monkeypatch.setattr(InputModeration, "check", reject_input)conversation, message = _records(sqlite_session)- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)- _assert_direct_output(queue_manager, "bad")+ _assert_direct_output(agent_queue_manager, "bad")def test_run_annotation_reply_short_circuits(self,runner: AgentChatAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:annotation = MessageAnnotation(app_id="app1",@@ -255,22 +108,22 @@ class TestAgentChatAppRunnerRun:monkeypatch.setattr(runner, "query_app_annotations_to_reply", query_annotation)conversation, message = _records(sqlite_session)- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)- event_message = queue_manager._q.get_nowait()+ event_message = agent_queue_manager._q.get_nowait()assert event_message is not Noneassert isinstance(event_message.event, QueueAnnotationReplyEvent)assert event_message.event.message_annotation_id == annotation.idassert sessions == [sqlite_session]- _assert_direct_output(queue_manager, "answer")+ _assert_direct_output(agent_queue_manager, "answer")def test_run_hosting_moderation_short_circuits(self,runner: AgentChatAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:def reject_hosted_input(**kwargs: object) -> bool:assert kwargs["tenant_id"] == "tenant"@@ -280,10 +133,11 @@ class TestAgentChatAppRunnerRun:monkeypatch.setattr("core.helper.moderation.check_moderation", reject_hosted_input)conversation, message = _records(sqlite_session)- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)_assert_direct_output(- queue_manager, "I apologize for any confusion, but I'm an AI assistant to be helpful, harmless, and honest."+ agent_queue_manager,+ "I apologize for any confusion, but I'm an AI assistant to be helpful, harmless, and honest.",)def test_run_model_schema_missing(@@ -291,14 +145,14 @@ class TestAgentChatAppRunnerRun:runner: AgentChatAppRunner,monkeypatch: pytest.MonkeyPatch,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:monkeypatch.setattr(PluginModelClient, "get_model_schema", lambda *_args, **_kwargs: None)conversation, message = _records(sqlite_session)with pytest.raises(ValueError, match="Model schema not found"):- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)@pytest.mark.parametrize(("mode", "expected_runner"),@@ -307,7 +161,7 @@ class TestAgentChatAppRunnerRun:(LLMMode.COMPLETION, CotCompletionAgentRunner),],)- @pytest.mark.usefixtures("agent_app")+ @pytest.mark.usefixtures("agent_runtime_app")def test_run_chain_of_thought_modes(self,runner: AgentChatAppRunner,@@ -315,13 +169,13 @@ class TestAgentChatAppRunnerRun:mode: LLMMode,expected_runner: type[CotAgentRunner],sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:- generate_entity.model_conf.mode = mode- generate_entity.model_conf.model_schema.model_properties[ModelPropertyKey.MODE] = mode- generate_entity.app_config.model.mode = mode- generate_entity.conversation_id = "conv"+ agent_generate_entity.model_conf.mode = mode+ agent_generate_entity.model_conf.model_schema.model_properties[ModelPropertyKey.MODE] = mode+ agent_generate_entity.app_config.model.mode = mode+ agent_generate_entity.conversation_id = "conv"events: list[str] = []selected_runners: list[CotAgentRunner] = []daemon_calls: list[dict[str, object]] = []@@ -366,7 +220,7 @@ class TestAgentChatAppRunnerRun:conversation, message = _records(sqlite_session)event.listen(sqlite_session, "after_commit", record_commit)try:- runner.run(generate_entity, queue_manager, conversation, message, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)finally:event.remove(sqlite_session, "after_commit", record_commit)@@ -378,7 +232,7 @@ class TestAgentChatAppRunnerRun:assert isinstance(data, dict)assert data["data"]["credentials"] == {"api_key": "token"}assert data["data"]["provider"] == "openai"- messages = list(queue_manager.listen())+ messages = list(agent_queue_manager.listen())end_events = [item.event for item in messages if isinstance(item.event, QueueMessageEndEvent)]assert len(end_events) == 1assert end_events[0].llm_result is not None@@ -391,188 +245,122 @@ class TestAgentChatAppRunnerRun:assert thoughts[0].position == 1def test_run_invalid_llm_mode_raises(- self, runner: AgentChatAppRunner, mocker: MockerFixture, sqlite_session: Session+ self,+ runner: AgentChatAppRunner,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:- app_config = mocker.MagicMock(app_id="app1", tenant_id="tenant", prompt_template=mocker.MagicMock())- app_config.agent = AgentEntity(provider="p", model="m", strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT)-- generate_entity = mocker.MagicMock(- app_config=app_config,- inputs={},- query="q",- files=[],- stream=True,- model_conf=mocker.MagicMock(- provider_model_bundle=mocker.MagicMock(),- model="m",- provider="p",- credentials={"k": "v"},- ),- conversation_id="conv",- invoke_from=mocker.MagicMock(),- user_id="user",- )-- mocker.patch.object(runner, "organize_prompt_messages", return_value=([], None))- mocker.patch.object(runner, "moderation_for_inputs", return_value=(None, {}, "q"))- mocker.patch.object(runner, "query_app_annotations_to_reply", return_value=None)- mocker.patch.object(runner, "check_hosting_moderation", return_value=False)-- model_schema = mocker.MagicMock()- model_schema.features = list[ModelFeature]()- model_schema.model_properties = {ModelPropertyKey.MODE: "invalid"}-- llm_instance = mocker.MagicMock()- llm_instance.model_type_instance.get_model_schema.return_value = model_schema- mocker.patch("core.app.apps.agent_chat.app_runner.ModelInstance", return_value=llm_instance)-+ # Simulate corrupt provider metadata without replacing the runtime or validated app config.+ agent_generate_entity.model_conf.model_schema.model_properties[ModelPropertyKey.MODE] = "invalid"conversation, message = _records(sqlite_session)+ with pytest.raises(ValueError, match="Invalid LLM mode: invalid"):+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)- with pytest.raises(ValueError):- runner.run(generate_entity, mocker.MagicMock(), conversation, message, sqlite_session)-+ @pytest.mark.parametrize("feature", [ModelFeature.TOOL_CALL, ModelFeature.MULTI_TOOL_CALL])+ @pytest.mark.parametrize("stream_tool_call", [False, True])+ @pytest.mark.usefixtures("agent_runtime_app")def test_run_function_calling_strategy_selected_by_features(- self, runner: AgentChatAppRunner, mocker: MockerFixture, sqlite_session: Session+ self,+ runner: AgentChatAppRunner,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,+ feature: ModelFeature,+ stream_tool_call: bool,) -> None:- app_config = mocker.MagicMock(app_id="app1", tenant_id="tenant", prompt_template=mocker.MagicMock())- app_config.agent = AgentEntity(provider="p", model="m", strategy=AgentEntity.Strategy.CHAIN_OF_THOUGHT)-- generate_entity = mocker.MagicMock(- app_config=app_config,- inputs={},- query="q",- files=[],- stream=True,- model_conf=mocker.MagicMock(- provider_model_bundle=mocker.MagicMock(),- model="m",- provider="p",- credentials={"k": "v"},- ),- conversation_id="conv",- invoke_from=mocker.MagicMock(),- user_id="user",- )-- mocker.patch.object(runner, "organize_prompt_messages", return_value=([], None))- mocker.patch.object(runner, "moderation_for_inputs", return_value=(None, {}, "q"))- mocker.patch.object(runner, "query_app_annotations_to_reply", return_value=None)- mocker.patch.object(runner, "check_hosting_moderation", return_value=False)-- model_schema = mocker.MagicMock()- model_schema.features = [ModelFeature.TOOL_CALL]- model_schema.model_properties = {ModelPropertyKey.MODE: LLMMode.CHAT}+ schema = agent_generate_entity.model_conf.model_schema+ schema.features = [feature, *([ModelFeature.STREAM_TOOL_CALL] if stream_tool_call else [])]+ selected: list[FunctionCallAgentRunner] = []+ requests: list[dict[str, object]] = []+ original_run = FunctionCallAgentRunner.run++ def run_agent(+ agent: FunctionCallAgentRunner, *, session: Session, message: Message, query: str, **kwargs: object+ ) -> Generator[LLMResultChunk]:+ assert not session.in_transaction()+ selected.append(agent)+ return original_run(agent, session=session, message=message, query=query, **kwargs)- llm_instance = mocker.MagicMock()- llm_instance.model_type_instance.get_model_schema.return_value = model_schema- mocker.patch("core.app.apps.agent_chat.app_runner.ModelInstance", return_value=llm_instance)+ def dispatch(_client: PluginModelClient, **kwargs: object) -> Iterator[LLMResultChunk]:+ assert not sqlite_session.in_transaction()+ assert kwargs["path"] == "plugin/tenant/dispatch/llm/invoke"+ requests.append(kwargs)+ yield LLMResultChunk(+ model="m",+ delta=LLMResultChunkDelta(+ index=0, message=AssistantPromptMessage(content="answer"), usage=LLMUsage.empty_usage()+ ),+ )+ monkeypatch.setattr(FunctionCallAgentRunner, "run", run_agent)+ monkeypatch.setattr(PluginModelClient, "_request_with_plugin_daemon_response_stream", dispatch)conversation, message = _records(sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)- runner_cls = mocker.MagicMock()- mocker.patch("core.app.apps.agent_chat.app_runner.FunctionCallAgentRunner", runner_cls)-- runner_instance = mocker.MagicMock()- runner_cls.return_value = runner_instance- runner_instance.run.return_value = list[LLMResultChunk]()- mocker.patch.object(runner, "_handle_invoke_result")-- runner.run(generate_entity, mocker.MagicMock(), conversation, message, sqlite_session)-+ app_config = agent_generate_entity.app_config+ assert isinstance(app_config, AgentChatAppConfig)+ assert app_config.agent is not Noneassert app_config.agent.strategy == AgentEntity.Strategy.FUNCTION_CALLING- runner_instance.run.assert_called_once()+ assert len(selected) == 1+ assert type(selected[0]) is FunctionCallAgentRunner+ assert len(requests) == 1+ data = requests[0]["data"]+ assert isinstance(data, dict)+ assert data["data"]["stream"] is stream_tool_call+ assert data["data"]["credentials"] == {"api_key": "token"}+ events = list(agent_queue_manager.listen())+ assert isinstance(events[-1].event, QueueMessageEndEvent)+ assert events[-1].event.llm_result is not None+ assert events[-1].event.llm_result.message.content == "answer\n"+ thoughts = sqlite_session.scalars(+ select(MessageAgentThought).where(MessageAgentThought.message_id == "msg")+ ).all()+ assert len(thoughts) == 1+ assert thoughts[0].answer == "answer"def test_run_conversation_not_found(self,runner: AgentChatAppRunner,sqlite_session: Session,- generate_entity: AgentChatAppGenerateEntity,- queue_manager: MessageBasedAppQueueManager,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:conversation_record, message_record = _records(sqlite_session)sqlite_session.delete(conversation_record)sqlite_session.commit()with pytest.raises(ValueError, match="Conversation not found"):- runner.run(generate_entity, queue_manager, conversation_record, message_record, sqlite_session)+ runner.run(agent_generate_entity, agent_queue_manager, conversation_record, message_record, sqlite_session)def test_run_message_not_found(- self, runner: AgentChatAppRunner, mocker: MockerFixture, sqlite_session: Session+ self,+ runner: AgentChatAppRunner,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:- app_config = mocker.MagicMock(app_id="app1", tenant_id="tenant", prompt_template=mocker.MagicMock())- app_config.agent = AgentEntity(provider="p", model="m", strategy=AgentEntity.Strategy.FUNCTION_CALLING)-- generate_entity = mocker.MagicMock(- app_config=app_config,- inputs={},- query="q",- files=[],- stream=True,- model_conf=mocker.MagicMock(- provider_model_bundle=mocker.MagicMock(),- model="m",- provider="p",- credentials={"k": "v"},- ),- conversation_id="conv",- invoke_from=mocker.MagicMock(),- user_id="user",- )-- conversation_record, message_record = _records(sqlite_session)- sqlite_session.delete(message_record)+ conversation, message = _records(sqlite_session)+ sqlite_session.delete(message)sqlite_session.commit()- mocker.patch.object(runner, "organize_prompt_messages", return_value=([], None))- mocker.patch.object(runner, "moderation_for_inputs", return_value=(None, {}, "q"))- mocker.patch.object(runner, "query_app_annotations_to_reply", return_value=None)- mocker.patch.object(runner, "check_hosting_moderation", return_value=False)-- with pytest.raises(ValueError):- runner.run(- generate_entity,- mocker.MagicMock(),- conversation_record,- message_record,- sqlite_session,- )+ with pytest.raises(ValueError, match="Message not found"):+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)def test_run_invalid_agent_strategy_raises(- self, runner: AgentChatAppRunner, mocker: MockerFixture, sqlite_session: Session+ self,+ runner: AgentChatAppRunner,+ monkeypatch: pytest.MonkeyPatch,+ sqlite_session: Session,+ agent_generate_entity: AgentChatAppGenerateEntity,+ agent_queue_manager: MessageBasedAppQueueManager,) -> None:- app_config = mocker.MagicMock(app_id="app1", tenant_id="tenant", prompt_template=mocker.MagicMock())- app_config.agent = mocker.MagicMock(strategy="invalid", provider="p", model="m")-- generate_entity = mocker.MagicMock(- app_config=app_config,- inputs={},- query="q",- files=[],- stream=True,- model_conf=mocker.MagicMock(- provider_model_bundle=mocker.MagicMock(),- model="m",- provider="p",- credentials={"k": "v"},- ),- conversation_id="conv",- invoke_from=mocker.MagicMock(),- user_id="user",- )-- mocker.patch.object(runner, "organize_prompt_messages", return_value=([], None))- mocker.patch.object(runner, "moderation_for_inputs", return_value=(None, {}, "q"))- mocker.patch.object(runner, "query_app_annotations_to_reply", return_value=None)- mocker.patch.object(runner, "check_hosting_moderation", return_value=False)-- model_schema = mocker.MagicMock()- model_schema.features = list[ModelFeature]()- model_schema.model_properties = {ModelPropertyKey.MODE: LLMMode.CHAT}-- llm_instance = mocker.MagicMock()- llm_instance.model_type_instance.get_model_schema.return_value = model_schema- mocker.patch("core.app.apps.agent_chat.app_runner.ModelInstance", return_value=llm_instance)-+ app_config = agent_generate_entity.app_config+ assert isinstance(app_config, AgentChatAppConfig)+ agent = app_config.agent+ assert isinstance(agent, AgentEntity)+ # Fault injection after validation covers the defensive runtime branch for corrupted state.+ monkeypatch.setattr(agent, "strategy", "invalid")conversation, message = _records(sqlite_session)-- with pytest.raises(ValueError):- runner.run(generate_entity, mocker.MagicMock(), conversation, message, sqlite_session)+ with pytest.raises(ValueError, match="Invalid agent strategy: invalid"):+ runner.run(agent_generate_entity, agent_queue_manager, conversation, message, sqlite_session)diff --git a/api/tests/unit_tests/pyrefly.toml b/api/tests/unit_tests/pyrefly.tomlindex 1e457929dd2..a7a5f66f721 100644--- a/api/tests/unit_tests/pyrefly.toml+++ b/api/tests/unit_tests/pyrefly.toml@@ -185,7 +185,6 @@ project-excludes = ["core/app/apps/agent_app/test_runtime_request_builder.py","core/app/apps/agent_app/test_session_store.py","core/app/apps/agent_chat/test_agent_chat_app_config_manager.py",- "core/app/apps/agent_chat/test_agent_chat_app_generator.py","core/app/apps/agent_chat/test_agent_chat_generate_response_converter.py","core/app/apps/chat/test_app_config_manager.py","core/app/apps/chat/test_app_generator_and_runner.py",