django-spire 0.23.7__py3-none-any.whl → 0.23.8__py3-none-any.whl

django_spire/ai/chat/tests/test_router/test_base_chat_router.py

@@ -4,6 +4,7 @@ import pytest
 
 from typing import TYPE_CHECKING
 
+from dandy.llm.request.message import MessageHistory
 from django.test import RequestFactory
 
 from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
@@ -11,7 +12,6 @@ from django_spire.ai.chat.router import BaseChatRouter
 from django_spire.core.tests.test_cases import BaseTestCase
 
 if TYPE_CHECKING:
-    from dandy.llm.request.message import MessageHistory
     from django.core.handlers.wsgi import WSGIRequest
 
 
@@ -53,7 +53,12 @@ class TestBaseChatRouter(BaseTestCase):
 
     def test_process_validates_workflow_return_type(self) -> None:
         class InvalidRouter(BaseChatRouter):
-            def workflow(self, request, user_input, message_history=None) -> str:
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> str:
                 return 'Invalid return type'
 
         router = InvalidRouter()
@@ -69,7 +74,12 @@ class TestBaseChatRouter(BaseTestCase):
 
     def test_process_handles_none_return(self) -> None:
         class NoneRouter(BaseChatRouter):
-            def workflow(self, request, user_input, message_history=None) -> None:
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> None:
                 return None
 
         router = NoneRouter()
@@ -83,12 +93,15 @@ class TestBaseChatRouter(BaseTestCase):
         assert result.text == 'I apologize, but I was unable to process your request.'
 
     def test_process_accepts_all_parameters(self) -> None:
-        from dandy.llm.request.message import MessageHistory
-
         class ParamTestRouter(BaseChatRouter):
             received_params = {}
 
-            def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> DefaultMessageIntel:
                 self.received_params = {
                     'request': request,
                     'user_input': user_input,
@@ -108,3 +121,50 @@ class TestBaseChatRouter(BaseTestCase):
         assert router.received_params['request'] == self.request
         assert router.received_params['user_input'] == 'Test input'
         assert router.received_params['message_history'] == message_history
+
+    def test_process_returns_base_message_intel_subclass(self) -> None:
+        class CustomMessageIntel(BaseMessageIntel):
+            _template: str = 'django_spire/ai/chat/message/default_message.html'
+            custom_field: str
+
+            def render_to_str(self) -> str:
+                return self.custom_field
+
+        class CustomRouter(BaseChatRouter):
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> CustomMessageIntel:
+                return CustomMessageIntel(custom_field='Custom value')
+
+        router = CustomRouter()
+        result = router.process(
+            request=self.request,
+            user_input='Hello',
+            message_history=None
+        )
+
+        assert isinstance(result, CustomMessageIntel)
+        assert result.custom_field == 'Custom value'
+
+    def test_process_with_empty_user_input(self) -> None:
+        class EmptyInputRouter(BaseChatRouter):
+            def workflow(
+                self,
+                request: WSGIRequest,
+                user_input: str,
+                message_history: MessageHistory | None = None
+            ) -> DefaultMessageIntel:
+                return DefaultMessageIntel(text=f'Received: {user_input}')
+
+        router = EmptyInputRouter()
+        result = router.process(
+            request=self.request,
+            user_input='',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Received: '

django_spire/ai/chat/tests/test_router/test_chat_workflow.py

@@ -1,7 +1,9 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 from unittest.mock import Mock, patch
 
+from dandy.llm.request.message import MessageHistory
 from django.test import RequestFactory, override_settings
 
 from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workflow
@@ -9,9 +11,17 @@ from django_spire.ai.chat.message_intel import DefaultMessageIntel
 from django_spire.ai.chat.router import BaseChatRouter
 from django_spire.core.tests.test_cases import BaseTestCase
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 class MockRouter(BaseChatRouter):
-    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> DefaultMessageIntel:
         return DefaultMessageIntel(text='Mock response')
 
 
@@ -95,8 +105,6 @@ class TestChatWorkflow(BaseTestCase):
         }
     )
     def test_workflow_passes_message_history(self) -> None:
-        from dandy.llm.request.message import MessageHistory
-
         message_history = MessageHistory()
 
         with patch('django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter.process') as mock_process:
@@ -111,3 +119,65 @@ class TestChatWorkflow(BaseTestCase):
             mock_process.assert_called_once()
             call_kwargs = mock_process.call_args[1]
             assert call_kwargs['message_history'] == message_history
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='TEST',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'TEST': 'django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter'
+        }
+    )
+    def test_workflow_passes_request(self) -> None:
+        with patch('django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter.process') as mock_process:
+            mock_process.return_value = DefaultMessageIntel(text='Response')
+
+            chat_workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            mock_process.assert_called_once()
+            call_kwargs = mock_process.call_args[1]
+            assert call_kwargs['request'] == self.request
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='TEST',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'TEST': 'django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter'
+        }
+    )
+    def test_workflow_passes_user_input(self) -> None:
+        with patch('django_spire.ai.chat.tests.test_router.test_chat_workflow.MockRouter.process') as mock_process:
+            mock_process.return_value = DefaultMessageIntel(text='Response')
+
+            chat_workflow(
+                request=self.request,
+                user_input='Test user input',
+                message_history=None
+            )
+
+            mock_process.assert_called_once()
+            call_kwargs = mock_process.call_args[1]
+            assert call_kwargs['user_input'] == 'Test user input'
+
+    @override_settings(
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={}
+    )
+    def test_workflow_uses_fallback_router_path(self) -> None:
+        with patch('django_spire.ai.chat.intelligence.workflows.chat_workflow.get_callable_from_module_string_and_validate_arguments') as mock_get_callable:
+            mock_router_class = Mock()
+            mock_router_instance = Mock()
+            mock_router_instance.process.return_value = DefaultMessageIntel(text='Fallback')
+            mock_router_class.return_value = mock_router_instance
+            mock_get_callable.return_value = mock_router_class
+
+            chat_workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            mock_get_callable.assert_called_once_with(
+                'django_spire.ai.chat.router.SpireChatRouter',
+                []
+            )

django_spire/ai/chat/tests/test_router/test_integration.py

@@ -1,23 +1,39 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 from unittest.mock import Mock, patch
 
+from dandy.llm.request.message import MessageHistory
 from django.contrib.auth.models import Permission, User
 from django.test import RequestFactory, override_settings
 
+from django_spire.ai.chat.intelligence.decoders.intent_decoder import generate_intent_decoder
 from django_spire.ai.chat.intelligence.workflows.chat_workflow import chat_workflow
 from django_spire.ai.chat.message_intel import BaseMessageIntel, DefaultMessageIntel
 from django_spire.ai.chat.router import BaseChatRouter
 from django_spire.core.tests.test_cases import BaseTestCase
 
+if TYPE_CHECKING:
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 class KnowledgeRouter(BaseChatRouter):
-    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> DefaultMessageIntel:
         return DefaultMessageIntel(text='Knowledge search result')
 
 
 class SupportRouter(BaseChatRouter):
-    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> DefaultMessageIntel:
         return DefaultMessageIntel(text='Support response')
 
 
@@ -95,8 +111,6 @@ class TestRouterIntegration(BaseTestCase):
         }
     )
     def test_intent_excluded_without_permission(self) -> None:
-        from django_spire.ai.chat.intelligence.decoders.intent_decoder import generate_intent_decoder
-
         regular_user = User.objects.create_user(username='regular', password='test')
 
         request = self.factory.get('/')
@@ -113,8 +127,6 @@ class TestRouterIntegration(BaseTestCase):
         }
     )
     def test_end_to_end_workflow(self) -> None:
-        from dandy.llm.request.message import MessageHistory
-
         message_history = MessageHistory()
         message_history.add_message(role='user', content='Previous message')
 
@@ -145,3 +157,71 @@ class TestRouterIntegration(BaseTestCase):
             )
 
             assert isinstance(result, DefaultMessageIntel)
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='KNOWLEDGE',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'KNOWLEDGE': 'django_spire.ai.chat.tests.test_router.test_integration.KnowledgeRouter',
+            'SUPPORT': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+        }
+    )
+    def test_router_selection_by_key(self) -> None:
+        result = chat_workflow(
+            request=self.request,
+            user_input='Test',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Knowledge search result'
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='SUPPORT',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'SUPPORT': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+        }
+    )
+    def test_workflow_with_none_message_history(self) -> None:
+        result = chat_workflow(
+            request=self.request,
+            user_input='Test input',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Support response'
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='SUPPORT',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'SUPPORT': 'django_spire.ai.chat.tests.test_router.test_integration.SupportRouter',
+        }
+    )
+    def test_workflow_preserves_user_input(self) -> None:
+        test_input = 'This is a specific test input'
+
+        with patch.object(SupportRouter, 'workflow', wraps=SupportRouter().workflow) as mock_workflow:
+            mock_workflow.return_value = DefaultMessageIntel(text='Response')
+
+            chat_workflow(
+                request=self.request,
+                user_input=test_input,
+                message_history=None
+            )
+
+    @override_settings(
+        DJANGO_SPIRE_AI_DEFAULT_CHAT_ROUTER='KNOWLEDGE',
+        DJANGO_SPIRE_AI_CHAT_ROUTERS={
+            'KNOWLEDGE': 'django_spire.ai.chat.tests.test_router.test_integration.KnowledgeRouter',
+        },
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={}
+    )
+    def test_workflow_without_intent_routers(self) -> None:
+        result = chat_workflow(
+            request=self.request,
+            user_input='Test',
+            message_history=None
+        )
+
+        assert isinstance(result, DefaultMessageIntel)
+        assert result.text == 'Knowledge search result'

django_spire/ai/chat/tests/test_router/test_intent_decoder.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+from typing import TYPE_CHECKING
 from unittest.mock import Mock
 
 from django.contrib.auth.models import Permission, User
@@ -10,15 +11,25 @@ from django_spire.ai.chat.message_intel import DefaultMessageIntel
 from django_spire.ai.chat.router import BaseChatRouter
 from django_spire.core.tests.test_cases import BaseTestCase
 
+if TYPE_CHECKING:
+    from dandy.llm.request.message import MessageHistory
+    from django.core.handlers.wsgi import WSGIRequest
+
 
 class TestRouter(BaseChatRouter):
-    def workflow(self, request, user_input, message_history=None) -> DefaultMessageIntel:
+    def workflow(
+        self,
+        request: WSGIRequest,
+        user_input: str,
+        message_history: MessageHistory | None = None
+    ) -> DefaultMessageIntel:
         return DefaultMessageIntel(text='Test response')
 
 
 class TestIntentDecoder(BaseTestCase):
     def setUp(self) -> None:
         super().setUp()
+
         self.factory = RequestFactory()
         self.request = self.factory.get('/')
         self.request.user = self.super_user
@@ -139,3 +150,84 @@ class TestIntentDecoder(BaseTestCase):
         assert 'First intent' in decoder.mapping
         assert 'Second intent' in decoder.mapping
         assert len(decoder.mapping) == 2
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'TEST_INTENT': {
+                'INTENT_DESCRIPTION': 'Test intent',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_mapping_keys_description(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert decoder.mapping_keys_description == "Intent of the User's Request"
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'TEST_INTENT': {
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_with_missing_intent_description(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert '' in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'NO_ROUTER': {
+                'INTENT_DESCRIPTION': 'No router intent',
+            }
+        }
+    )
+    def test_decoder_with_missing_chat_router(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert 'No router intent' not in decoder.mapping
+
+    def test_decoder_with_none_default_callable(self) -> None:
+        decoder = generate_intent_decoder(
+            request=self.request,
+            default_callable=None
+        )
+
+        assert "None of the above choices match the user's intent" not in decoder.mapping
+
+    @override_settings(
+        DJANGO_SPIRE_AI_INTENT_CHAT_ROUTERS={
+            'INTENT_A': {
+                'INTENT_DESCRIPTION': 'Intent A',
+                'REQUIRED_PERMISSION': 'auth.add_user',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            },
+            'INTENT_B': {
+                'INTENT_DESCRIPTION': 'Intent B',
+                'CHAT_ROUTER': 'django_spire.ai.chat.tests.test_router.test_intent_decoder.TestRouter',
+            }
+        }
+    )
+    def test_decoder_mixed_permission_intents(self) -> None:
+        regular_user = User.objects.create_user(username='mixed_user', password='test')
+
+        request = self.factory.get('/')
+        request.user = regular_user
+
+        decoder = generate_intent_decoder(
+            request=request,
+            default_callable=None
+        )
+
+        assert 'Intent A' not in decoder.mapping
+        assert 'Intent B' in decoder.mapping

django_spire/ai/chat/tests/test_router/test_message_intel.py

@@ -8,8 +8,8 @@ from django_spire.core.tests.test_cases import BaseTestCase
 
 class CustomMessageIntel(BaseMessageIntel):
     _template: str = 'django_spire/ai/chat/message/default_message.html'
-    text: str
     extra_data: str = 'Extra'
+    text: str
 
     def render_to_str(self) -> str:
         return f'{self.text} - {self.extra_data}'
@@ -18,6 +18,7 @@ class CustomMessageIntel(BaseMessageIntel):
 class TestMessageIntel(BaseTestCase):
     def test_default_message_intel_has_template(self) -> None:
         intel = DefaultMessageIntel(text='Test')
+
         assert intel.template == 'django_spire/ai/chat/message/default_message.html'
 
     def test_default_message_intel_render_to_str(self) -> None:
@@ -65,3 +66,61 @@ class TestMessageIntel(BaseTestCase):
 
                 def render_to_str(self) -> str:
                     return 'test'
+
+    def test_default_message_intel_model_dump(self) -> None:
+        intel = DefaultMessageIntel(text='Test text')
+        dump = intel.model_dump()
+
+        assert 'text' in dump
+        assert dump['text'] == 'Test text'
+
+    def test_custom_message_intel_default_extra_data(self) -> None:
+        intel = CustomMessageIntel(text='Test')
+
+        assert intel.extra_data == 'Extra'
+
+    def test_default_message_intel_empty_text(self) -> None:
+        intel = DefaultMessageIntel(text='')
+        result = intel.render_to_str()
+
+        assert result == ''
+
+    def test_default_message_intel_long_text(self) -> None:
+        long_text = 'A' * 10000
+        intel = DefaultMessageIntel(text=long_text)
+        result = intel.render_to_str()
+
+        assert result == long_text
+        assert len(result) == 10000
+
+    def test_default_message_intel_special_characters(self) -> None:
+        special_text = '<script>alert("xss")</script>'
+        intel = DefaultMessageIntel(text=special_text)
+        result = intel.render_to_str()
+
+        assert result == special_text
+
+    def test_default_message_intel_unicode(self) -> None:
+        unicode_text = 'Hello 世界 🌍'
+        intel = DefaultMessageIntel(text=unicode_text)
+        result = intel.render_to_str()
+
+        assert result == unicode_text
+
+    def test_render_template_to_str_with_none_context(self) -> None:
+        intel = DefaultMessageIntel(text='Test')
+        result = intel.render_template_to_str(context_data=None)
+
+        assert isinstance(result, str)
+
+    def test_render_template_to_str_with_empty_context(self) -> None:
+        intel = DefaultMessageIntel(text='Test')
+        result = intel.render_template_to_str(context_data={})
+
+        assert isinstance(result, str)
+
+    def test_custom_message_intel_override_extra_data(self) -> None:
+        intel = CustomMessageIntel(text='Test', extra_data='Override')
+
+        assert intel.extra_data == 'Override'
+        assert intel.render_to_str() == 'Test - Override'

django_spire/ai/chat/tests/test_router/test_spire_chat_router.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from unittest.mock import Mock, patch
 
+from dandy.llm.request.message import MessageHistory
 from django.test import RequestFactory, override_settings
 
 from django_spire.ai.chat.message_intel import DefaultMessageIntel
@@ -12,12 +13,14 @@ from django_spire.core.tests.test_cases import BaseTestCase
 class TestSpireChatRouter(BaseTestCase):
     def setUp(self) -> None:
         super().setUp()
+
         self.factory = RequestFactory()
         self.request = self.factory.get('/')
         self.request.user = self.super_user
 
     def test_router_can_be_instantiated(self) -> None:
         router = SpireChatRouter()
+
         assert isinstance(router, SpireChatRouter)
 
     def test_default_chat_callable_returns_message_intel(self) -> None:
@@ -90,3 +93,110 @@ class TestSpireChatRouter(BaseTestCase):
                 )
 
                 assert isinstance(result, DefaultMessageIntel)
+
+    def test_workflow_passes_message_history_to_decoder(self) -> None:
+        router = SpireChatRouter()
+        message_history = MessageHistory()
+
+        with patch('django_spire.ai.chat.router.generate_intent_decoder') as mock_decoder:
+            mock_decoder_instance = Mock()
+            mock_decoder.return_value = mock_decoder_instance
+            mock_decoder_instance.process.return_value = [
+                lambda **kwargs: DefaultMessageIntel(text='Response')
+            ]
+
+            router.workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=message_history
+            )
+
+            mock_decoder.assert_called_once()
+
+    def test_workflow_returns_message_intel(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.generate_intent_decoder') as mock_decoder:
+            mock_decoder_instance = Mock()
+            mock_decoder.return_value = mock_decoder_instance
+            mock_decoder_instance.process.return_value = [
+                lambda **kwargs: DefaultMessageIntel(text='Test Response')
+            ]
+
+            result = router.workflow(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            assert isinstance(result, DefaultMessageIntel)
+            assert result.text == 'Test Response'
+
+    @override_settings(DJANGO_SPIRE_AI_PERSONA_NAME='Custom Persona')
+    def test_default_callable_with_custom_persona(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            router._default_chat_callable(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            assert mock_bot_instance.llm_role is not None
+
+    def test_default_callable_passes_message_history(self) -> None:
+        router = SpireChatRouter()
+        message_history = MessageHistory()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            router._default_chat_callable(
+                request=self.request,
+                user_input='Hello',
+                message_history=message_history
+            )
+
+            call_kwargs = mock_bot_instance.llm.prompt_to_intel.call_args[1]
+            assert call_kwargs['message_history'] == message_history
+
+    def test_default_callable_passes_user_input(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            router._default_chat_callable(
+                request=self.request,
+                user_input='Test input',
+                message_history=None
+            )
+
+            call_kwargs = mock_bot_instance.llm.prompt_to_intel.call_args[1]
+            assert call_kwargs['prompt'] == 'Test input'
+
+    def test_default_callable_uses_default_message_intel(self) -> None:
+        router = SpireChatRouter()
+
+        with patch('django_spire.ai.chat.router.Bot') as MockBot:
+            mock_bot_instance = Mock()
+            MockBot.return_value = mock_bot_instance
+            mock_bot_instance.llm.prompt_to_intel.return_value = DefaultMessageIntel(text='Response')
+
+            router._default_chat_callable(
+                request=self.request,
+                user_input='Hello',
+                message_history=None
+            )
+
+            call_kwargs = mock_bot_instance.llm.prompt_to_intel.call_args[1]
+            assert call_kwargs['intel_class'] == DefaultMessageIntel