Skip to content

armgit / dify

Public Imported from GitHub
0

Build Agentic workflows, RAG pipelines, with rich AI model and tool support on one collaborative workspace. Deploy on cloud, VPC, or self-hosted, so teams move from prototype to production without rebuilding the stack.

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.py
new file mode 100644
index 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, message
diff --git a/api/tests/unit_tests/conftest.py b/api/tests/unit_tests/conftest.py
index 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 client
redis_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.py
index 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 event
from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session
+from core.agent.entities import AgentEntity
from core.agent.errors import AgentMaxIterationError
from core.agent.fc_agent_runner import FunctionCallAgentRunner
from core.app.app_config.entities import DatasetRetrieveConfigEntity
+from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
from 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, CreditUsageCreatedBy
from core.app.entities.queue_entities import QueueMessageFileEvent
from 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, LLMUsage
from 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.fixture
def 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[FunctionCal
class 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.py
index 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 SimpleNamespace
import pytest
from pytest_mock import MockerFixture
@@ -7,6 +6,7 @@ from sqlalchemy.orm import Session
from core.app.app_config.entities import EasyUIBasedAppModelConfigFrom
from 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_config
assert 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.py
index 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 contextlib
import contextvars
-import inspect
import logging
import threading
-from collections.abc import Iterator
+from collections.abc import Callable, Iterable, Mapping
from dataclasses import dataclass, field
-from decimal import Decimal
import pytest
from flask import Flask
from pydantic import ValidationError
from sqlalchemy.orm import Session
-from core.app.app_config.entities import PromptTemplateEntity
-from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
from core.app.apps.agent_chat.app_generator import AgentChatAppGenerator
from core.app.apps.agent_chat.app_runner import AgentChatAppRunner
from core.app.apps.exc import GenerateTaskStoppedError
@@ -21,12 +16,12 @@ from core.app.apps.message_based_app_queue_manager import MessageBasedAppQueueMa
from 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_scope
from core.ops.ops_trace_manager import TraceQueueManager
from graphon.model_runtime.errors.invoke import InvokeAuthorizationError
from models import Account
-from models.enums import ConversationFromSource
from models.model import App, AppMode, AppModelConfig, Conversation, Message
from 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 session
assert 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 MessageBasedAppQueueManager
class 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 error
def 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.py
index 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 datetime
import pytest
-from flask import Flask
-from pytest_mock import MockerFixture
-from redis import Redis
from sqlalchemy import event, select
-from sqlalchemy.engine import Engine
from sqlalchemy.orm import Session
from core.agent.cot_agent_runner import CotAgentRunner
from core.agent.cot_chat_agent_runner import CotChatAgentRunner
from 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 FunctionCallAgentRunner
from core.app.apps.agent_chat.app_config_manager import AgentChatAppConfig
from core.app.apps.agent_chat.app_runner import AgentChatAppRunner
from 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 AgentChatAppGenerateEntity
from core.app.entities.queue_entities import QueueAnnotationReplyEvent, QueueLLMChunkEvent, QueueMessageEndEvent
-from core.entities.provider_entities import CustomProviderConfiguration
from core.moderation.base import ModerationError
from core.moderation.input_moderation import InputModeration
from core.plugin.entities.plugin_daemon import PluginLLMNumTokensResponse
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, LLMResultChunk, LLMResultChunkDelta, LLMUsage
from graphon.model_runtime.entities.message_entities import AssistantPromptMessage
from 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 None
assert isinstance(event_message.event, QueueAnnotationReplyEvent)
assert event_message.event.message_annotation_id == annotation.id
assert 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) == 1
assert end_events[0].llm_result is not None
@@ -391,188 +245,122 @@ class TestAgentChatAppRunnerRun:
assert thoughts[0].position == 1
def 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 None
assert 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.toml
index 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",